精华内容
下载资源
问答
  • springboot框架相关技术的案例项目及使用springboot框架时的需注意点 项目介绍 SpringBoot集成框架各种实用的组件技术点以及一些框架重要技术点的项目案例的实现,纯属个人技术积累和框架学习,有缺漏之处请指出。 ...
  • springboot-learning-2:springboot框架相关技术的案例项目及使用springboot框架时的需注意点(随后springboot-learning-1仓库)
  • 基于SpringBoot框架应用开发技术的分析与研究.pdf
  • SpringBoot框架

    千次阅读 多人点赞 2021-05-28 20:38:55
    一、SpringBoot框架 1、SpringBoot介绍 SpringBoot是Spring家族体系中一员。 Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can “just run”. We take...

    一、SpringBoot框架

    1、SpringBoot介绍

    SpringBoot是Spring家族体系中一员。

    在这里插入图片描述

    Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can “just run”.

    We take an opinionated view of the Spring platform and third-party libraries so you can get started with minimum fuss. Most Spring Boot applications need minimal Spring configuration.

    使用Spring Boot可以轻松地创建独立的,基于生产级别的基于Spring的应用程序,您可以“运行”它们。

    我们对Spring平台和第三方库持固执己见的观点,因此您可以以最小的麻烦开始使用。大多数Spring Boot应用程序需要最少的Spring配置。

    总结:SpringBoot框架可以快速的去构建企业级的项目环境(整合各种jar包、处理各种冲突、项目进行打包、快速发布、几乎进行零配置就可完成一个项目运行等等)

    2、SpringBoot特征

    Create stand-alone Spring applications

    Embed Tomcat, Jetty or Undertow directly (no need to deploy WAR files)

    Provide opinionated ‘starter’ dependencies to simplify your build configuration

    Automatically configure Spring and 3rd party libraries whenever possible

    Provide production-ready features such as metrics, health checks, and externalized configuration

    Absolutely no code generation and no requirement for XML configuration

    • 创建独立的Spring应用程序
    • 直接嵌入Tomcat,Jetty或Undertow(无需部署WAR文件)
    • 提供自以为是的“入门”依赖项以简化构建配置
    • 尽可能自动配置Spring和3rd Party库
    • 提供可用于生产的功能,例如指标,运行状况检查和外部化配置
    • 完全没有代码生成,也不需要XML配置

    在这里插入图片描述

    3、SpringBoot好处

    Java项目一直以来都有一个严重的问题:

    • 基于xml的配置臃肿,而且不利于团队协作开发。框架的很多核心的配置,其实都是固定的,完全以简化掉。
    • 项目可以会依赖大量的第三方的jar包,jar包之间难免会出现版本冲突现象。

    而SpringBoot框架就是解决这些问题。可以让项目几乎完成自动化配置,不需要编写任何的xml文件,同时不用去关心jar包之间的冲突等问题。

    很方便的与第三方的一些技术整合:redis、mongoDB、MQ、freemark等等。

    二、SpringBoot入门

    1、搭建SpringBoot的环境

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    2、添加依赖完成简单测试

    2.1、关于maven的父子工程

    maven构建项目的环境的时候有三种方式:

    • jar方式:普通的java项目,打包之后是一个jar包。可以将这个jar包发给别人使用。
    • war方式:JavaWEB项目,需要web容器(tomcat)运行,项目打包之后war包。会用到servlet、jsp等技术
    • pom方式:它用在项目构建的过程中,用于进行多个子项目的共性内容管理。但是任何最终完成的项目要么是jar、要么是war。pom方式构建的项目一般都会是项目的父项目。而最终编写功能的jar或war项目会去继承pom方式的项目。

    在这里插入图片描述

    POM方式的项目中:存放的整个项目中最共性和通用的一些模块。主要是用来管理整个项目的jar包(依赖)。

    2.2、SpringBoot的依赖

    SpringBoot本身就是一个项目,由Spring官方提供,并且这个项目是以pom方式提供的,其中管理的JavaEE开发中所能用到的几乎所有的依赖,以及服务器。

    Spring Boot 2.3.0.RELEASE需要Java 8,并且与Java 14(包括)兼容。 还需要Spring Framework 5.2.6.RELEASE或更高版本。

    Build ToolVersion
    Maven3.3+
    Gradle6 (6.3 or later). 5.6.x is also supported but in a deprecated form

    Spring Boot supports the following embedded servlet containers:

    NameServlet Version
    Tomcat 9.04.0
    Jetty 9.43.1
    Undertow 2.04.0

    You can also deploy Spring Boot applications to any Servlet 3.1+ compatible container.

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.neusoft.springboot</groupId>
        <artifactId>springboot-demo</artifactId>
        <version>1.0-SNAPSHOT</version>
        <packaging>jar</packaging>
    
        <!--
            导入SpringBoot的项目依赖,SpringBoot是一个pom工程,
            在我们的项目中需要去继承pom工程
    
            如果一个项目是pom方式,那么在别的项目要使用的话,需要通过parent标签来引用这个这项目
        -->
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.3.0.RELEASE</version>
        </parent>
    
        <dependencies>
            <!-- 需要使用SpringMVC, -->
            <!-- spring-boot-starter-web -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
        </dependencies>
    </project>
    

    2.3、导入springMVC的启动器

        <!-- 需要使用SpringMVC, -->
        <!-- spring-boot-starter-web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    

    2.4、编写SpringBoot启动类

    @SpringBootApplication
    public class SpringBootDemo {
        public static void main(String[] args) {
            SpringApplication.run(SpringBootDemo.class , args);
        }
    }
    

    2.5、编写Controller

    @RestController
    @RequestMapping("/demo")
    public class DemoController {
    
        @RequestMapping("/abc")
        public String demo(){
            System.out.println("请求被接受到了.......");
            return "hello world";
        }
    }
    
    

    2.6、启动测试

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    上面这些操作没有任何的xml、tomcat的配置,已经可以完成一个简单的请求和响应的处理,主要是因为在SpringBoot已经为我们做了大量的配置:

    在这里插入图片描述

    在SpringBoot,已经将SpringMVC的核心对象DispatcherServlet自动配置完成。

    在这里插入图片描述

    在这里插入图片描述

    三、关于SpringBoot的一些配置

    1、父工程配置

    在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    在顶层的父工程中配置了大量的依赖和第三方jar包的版本管理

    <properties>
      <log4j2.version>2.13.2</log4j2.version>
      <logback.version>1.2.3</logback.version>
      <lombok.version>1.18.12</lombok.version>
      <mockito.version>3.3.3</mockito.version>
      <mongodb.version>4.0.3</mongodb.version>
      <mssql-jdbc.version>7.4.1.jre8</mssql-jdbc.version>
      <mysql.version>8.0.20</mysql.version>
      <spring-boot.version>2.3.0.RELEASE</spring-boot.version>
      <servlet-api.version>4.0.1</servlet-api.version>
      <slf4j.version>1.7.30</slf4j.version>
      <spring-framework.version>5.2.6.RELEASE</spring-framework.version>
      还有大量的版本管理配置.................
    </properties>
    

    在maven的项目中,如果一个项目只是管理依赖,而整个项目不真正完成任何的业务逻辑的代码,也就是这个项目中不需要真正去使用任何的类(依赖)。这时使用dependencyManagement来管理所有的依赖,当子工程继承当前这个项目之后,在子工程的pom文件中去使用dependencies来引用已经被父工程管理的依赖即可。

    <dependencies>
        <!-- 需要使用SpringMVC, -->
        <!-- spring-boot-starter-web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>
    

    如果父工程中管理的版本不适合当前子工程使用,这时子工程到导入依赖的时候,可以重新指定版本。

    2、SpringBoot的基础配置

    SpringBoot框架不提倡使用xml进行项目的配置,过去可能根据SpringMVC、Spring、Mybatis框架,都需要进行一些框架的核心基础配置,以下是Spring框架中的部分配置

    <!-- 开启spring的扫描包和注解 -->
    <context:annotation-config />
    <context:component-scan base-package="com.neusoft" />
    
    <!-- 加载数据库的参数文件 -->
    <context:property-placeholder location="classpath:jdbc.properties" />
    
    <!-- 配置数据库连接池 -->
    <bean class="com.alibaba.druid.pool.DruidDataSource" id="dataSource">
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
        <property name="driverClassName" value="${jdbc.driver}" />
    </bean>
    

    SpringBoot不提倡使用xml配置,但是有些参数还是必须配置的。SpringBoot提供自己的一些配置方式:

    2.1、在resources目录下进行配置

    SpringBoot自己的配置文件默认有两种风格:1、properties;2、yml或yaml

    在这里插入图片描述

    SpringBoot的核心配置文件的名称是固定的,必须是application,并且扩展名只能是.properties或者.yaml.yml

    2.2、SpringBoot读取配置方式

    假设编写连接数据库的参数配置:

    jdbc.username=root
    jdbc.password=root
    jdbc.url=jdbc:mysql://127.0.0.1:3306/mybatis
    jdbc.driver=com.mysql.jdbc.Driver
    

    导入mysql和driud的依赖

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.27</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.22</version>
    </dependency>
    

    SpringBoot允许我们在程序中读取一些自己的配置数据的。只是不建议采用xml配置。可以类代替xml的配置,然后在类中定义相关的属性和方法,最终得到想要的对象即可。

    // @Configuration 当前的类是个配置类
    @Configuration
    // @PropertySource 关联外部的文件
    @PropertySource("classpath:jdbc.properties")
    public class JDBCConfig {
        @Value("${jdbc.username}")
        private String username ;
        @Value("${jdbc.password}")
        private String password;
        @Value("${jdbc.url}")
        private String url;
        @Value("${jdbc.driver}")
        private String driver;
    
        // 最终需要得到连接池,并且交给Spring管理
        // 在SpringBoot中,如果方法返回的对象需要Spring管理,只需要在方法上添加@Bean注解
        @Bean
        public DataSource getDataSource(){
            // 创建阿里巴巴的数据库连接池
            DruidDataSource dataSource = new DruidDataSource();
            // 设置连接数据库的相关参数
            dataSource.setUsername(this.username);
            dataSource.setPassword(this.password);
            dataSource.setUrl(this.url);
            dataSource.setDriverClassName(this.driver);
            return dataSource;
        }
    }
    

    编写代码测试

    @RequestMapping("/jdbc")
    public DataSource demo2(){
        System.out.println(dataSource);
        return dataSource;
    }
    

    测试结果:

    在这里插入图片描述

    在这里插入图片描述

    2.3、SpringBoot读取中定义配置第二种方式

    2.3.1、配置关联的参数

    在这里插入图片描述

    /*
     @ConfigurationProperties 注解等价于下面三个何在一起的效果
       @Configuration
       @PropertySource("classpath:jdbc.properties")   // 需要将四个参数配置到springboot自己的文件中
       @Value("${jdbc.username}")
    
     使用@ConfigurationProperties  注解的时候,需要使用prefix指定配置文件中的前缀
     在类中的属性需要提供对应的get和set方法,属性名一定要和配置文件中的前缀后面的内容相同
     这时SpringBoot就会自动的将参数配置到对象中。
     */
    @ConfigurationProperties(prefix = "jdbc")
    @Data
    public class JDBCData {
        private String username ;
        private String password;
        private String url;
        private String driver;
    }
    
    

    2.3.2、配置bean对象

    @Configuration // 这是一个配置类
    // 需要关联到设置参数的对象
    @EnableConfigurationProperties(value = JDBCData.class)
    public class DataSourceConfig {
    
        @Bean // 返回对象交给Spring管理
        public DataSource getDataSource( JDBCData jdbcData ){
            // 创建阿里巴巴的数据库连接池
            DruidDataSource dataSource = new DruidDataSource();
            // 设置连接数据库的相关参数
            dataSource.setUsername(jdbcData.getUsername());
            dataSource.setPassword(jdbcData.getPassword());
            dataSource.setUrl(jdbcData.getUrl());
            dataSource.setDriverClassName(jdbcData.getDriver());
            return dataSource;
        }
    }
    

    四、SpringBoot的核心启动类

    1、SpringBootApplication注解

    在这里插入图片描述

    当搭建SpringBoot项目的时候,一般采用普通的Java项目,然后通过main作为整个项目的入口。在main方法所在的类上需要使用SpringBootApplication注解来标注当前的类是SpringBoot项目的核心启动入口类。

    在使用SpringBootApplication注解的方法中,使用main方法,作为程序入口,其中需要使用SpringApplication类中的静态的run方法来让程序运行。

    查阅SpringBootApplication的注解源码:

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @SpringBootConfiguration
    @EnableAutoConfiguration
    @ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
    		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
    public @interface SpringBootApplication {
        // 注解中的内容省略
    }
    

    在SpringBootApplication注解上,又有三个重要的注解:

    @SpringBootConfiguration
    @EnableAutoConfiguration
    @ComponentScan

    在去查阅@SpringBootConfiguration注解的作用:

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Configuration
    public @interface SpringBootConfiguration {
    }
    
    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Component
    public @interface Configuration {
    }
    

    @SpringBootConfiguration:这个注解来标注某个类是一个SpringBoot的配置类,同时需要将这个类交给Spring管理。

    在这里插入图片描述

    2、EnableAutoConfiguration注解

    EnableAutoConfiguration:主要功能开启自动配置的

    @Target(ElementType.TYPE)
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Inherited
    @AutoConfigurationPackage
    @Import(AutoConfigurationImportSelector.class)
    public @interface EnableAutoConfiguration {
        
    }
    

    在这里插入图片描述

    SpringBootApplication注解:第二层含义,自动导入相关的配置(通过隐藏的@AutoConfigurationPackage注解完成,同时在导入的时候需要使用选择器(AutoConfigurationImportSelector)选择性的导入相关的包,主要依赖的是自己项目中的pom引用的starter。

    3、ComponentScan注解

    ComponentScan注解:相当于配置的Spring的扫描包。让SpringBoot在启动的都扫描哪些包下的类。与在Spring的核心配置文件中配置的下面内容等价:

    <!-- 开启spring的扫描包和注解 -->
    <context:annotation-config />
    <context:component-scan base-package="com.neusoft" />
    

    在这里插入图片描述

    其实我们在SpringBoot的项目中,并没有明确的去指定让SpringBoot扫描哪些包,将来交给Spring管理。

    只是在核心启动类上使用的了@SpringBootApplication注解(1、配置类;2、自动导入;3、配置扫描包)。

    在这里插入图片描述

    注意:SpringBoot的核心启动类,建议书写在所有类的公共包下(放在包层级级别较浅的位置下)。

    因为在SpringBoot的核心启动类上会使用@SpringBootApplication,这是虽然没有手动指定Spring的扫描包的名称,这时默认扫描的是当前SpringBoot的核心启动类所在的包,以及子包下的所有内容。

    以后创建的包的时候:

    ​ com.neusoft:放SpringBoot的核心启动类

    ​ com.neusoft.web:

    ​ com.neusoft.service:

    ​ com.neusoft.service.impl:

    ​ com.neusoft.dao(mapper|repository):

    ​ com.neusoft.utils:

    ​ com.neusoft.pojo:

    4、自动配置的启动器starter

    在这里插入图片描述

    在SpringBoot的自动配置的jar包中:

    # Auto Configure
    org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
    org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
    org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
    org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
    org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
    org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
    org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
    org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
    org.springframework.boot.autoconfigure.context.LifecycleAutoConfiguration,\
    org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
    org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
    org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
    org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.cassandra.CassandraReactiveRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.couchbase.CouchbaseReactiveRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveElasticsearchRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.elasticsearch.ReactiveElasticsearchRestClientAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.jdbc.JdbcRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.mongo.MongoReactiveDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.mongo.MongoReactiveRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.r2dbc.R2dbcDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.r2dbc.R2dbcRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.r2dbc.R2dbcTransactionManagerAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.redis.RedisReactiveAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration,\
    org.springframework.boot.autoconfigure.elasticsearch.ElasticsearchRestClientAutoConfiguration,\
    org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,\
    org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,\
    org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration,\
    org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration,\
    org.springframework.boot.autoconfigure.h2.H2ConsoleAutoConfiguration,\
    org.springframework.boot.autoconfigure.hateoas.HypermediaAutoConfiguration,\
    org.springframework.boot.autoconfigure.hazelcast.HazelcastAutoConfiguration,\
    org.springframework.boot.autoconfigure.hazelcast.HazelcastJpaDependencyAutoConfiguration,\
    org.springframework.boot.autoconfigure.http.HttpMessageConvertersAutoConfiguration,\
    org.springframework.boot.autoconfigure.http.codec.CodecsAutoConfiguration,\
    org.springframework.boot.autoconfigure.influx.InfluxDbAutoConfiguration,\
    org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration,\
    org.springframework.boot.autoconfigure.integration.IntegrationAutoConfiguration,\
    org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration,\
    org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
    org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,\
    org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration,\
    org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration,\
    org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,\
    org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration,\
    org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration,\
    org.springframework.boot.autoconfigure.jms.JndiConnectionFactoryAutoConfiguration,\
    org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration,\
    org.springframework.boot.autoconfigure.jms.artemis.ArtemisAutoConfiguration,\
    org.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration,\
    org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration,\
    org.springframework.boot.autoconfigure.jsonb.JsonbAutoConfiguration,\
    org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration,\
    org.springframework.boot.autoconfigure.availability.ApplicationAvailabilityAutoConfiguration,\
    org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration,\
    org.springframework.boot.autoconfigure.ldap.LdapAutoConfiguration,\
    org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration,\
    org.springframework.boot.autoconfigure.mail.MailSenderAutoConfiguration,\
    org.springframework.boot.autoconfigure.mail.MailSenderValidatorAutoConfiguration,\
    org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration,\
    org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\
    org.springframework.boot.autoconfigure.mongo.MongoReactiveAutoConfiguration,\
    org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration,\
    org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\
    org.springframework.boot.autoconfigure.quartz.QuartzAutoConfiguration,\
    org.springframework.boot.autoconfigure.r2dbc.R2dbcAutoConfiguration,\
    org.springframework.boot.autoconfigure.rsocket.RSocketMessagingAutoConfiguration,\
    org.springframework.boot.autoconfigure.rsocket.RSocketRequesterAutoConfiguration,\
    org.springframework.boot.autoconfigure.rsocket.RSocketServerAutoConfiguration,\
    org.springframework.boot.autoconfigure.rsocket.RSocketStrategiesAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.servlet.UserDetailsServiceAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.servlet.SecurityFilterAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.reactive.ReactiveSecurityAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.reactive.ReactiveUserDetailsServiceAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.rsocket.RSocketSecurityAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.saml2.Saml2RelyingPartyAutoConfiguration,\
    org.springframework.boot.autoconfigure.sendgrid.SendGridAutoConfiguration,\
    org.springframework.boot.autoconfigure.session.SessionAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.oauth2.client.servlet.OAuth2ClientAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.oauth2.client.reactive.ReactiveOAuth2ClientAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.oauth2.resource.servlet.OAuth2ResourceServerAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.oauth2.resource.reactive.ReactiveOAuth2ResourceServerAutoConfiguration,\
    org.springframework.boot.autoconfigure.solr.SolrAutoConfiguration,\
    org.springframework.boot.autoconfigure.task.TaskExecutionAutoConfiguration,\
    org.springframework.boot.autoconfigure.task.TaskSchedulingAutoConfiguration,\
    org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration,\
    org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration,\
    org.springframework.boot.autoconfigure.transaction.jta.JtaAutoConfiguration,\
    org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.client.RestTemplateAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.embedded.EmbeddedWebServerFactoryCustomizerAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.reactive.HttpHandlerAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.reactive.ReactiveWebServerFactoryAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.reactive.WebFluxAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.reactive.error.ErrorWebFluxAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.reactive.function.client.ClientHttpConnectorAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.reactive.function.client.WebClientAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.ServletWebServerFactoryAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.error.ErrorMvcAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.HttpEncodingAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.MultipartAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.servlet.WebMvcAutoConfiguration,\
    org.springframework.boot.autoconfigure.websocket.reactive.WebSocketReactiveAutoConfiguration,\
    org.springframework.boot.autoconfigure.websocket.servlet.WebSocketServletAutoConfiguration,\
    org.springframework.boot.autoconfigure.websocket.servlet.WebSocketMessagingAutoConfiguration,\
    org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration,\
    org.springframework.boot.autoconfigure.webservices.client.WebServiceTemplateAutoConfiguration
    

    在SpringBoot的自动配置中spring.factories已经编写大量可以自动完成配置的类。但是这些不是说在项目启动的时候就全部配置,是要根据项目导入的starter来决定最后这些自动配置中哪些生效,哪些失效。

    What’s in a name
    All official starters follow a similar naming pattern; spring-boot-starter-*, where * is a
    particular type of application. This naming structure is intended to help when you need to find a
    starter. The Maven integration in many IDEs lets you search dependencies by name. For example,
    with the appropriate Eclipse or STS plugin installed, you can press ctrl-space in the POM editor
    and type “spring-boot-starter” for a complete list.
    As explained in the “Creating Your Own Starter” section, third party starters should not start
    with spring-boot, as it is reserved for official Spring Boot artifacts. Rather, a third-party
    starter typically starts with the name of the project. For example, a third-party starter project
    called thirdpartyproject would typically be named thirdpartyproject-spring-boot-
    starter.

    五、SpringBoot实践

    1、SpringBoot整合SSM

    在这里插入图片描述

    导入依赖:

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.3.0.RELEASE</version>
        </parent>
    
        <groupId>com.neusoft.edu</groupId>
        <artifactId>ssm-edu</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <dependencies>
            <!-- springmvc的启动器 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <!-- mybatis启动器 -->
            <dependency>
                <groupId>org.mybatis.spring.boot</groupId>
                <artifactId>mybatis-spring-boot-starter</artifactId>
                <version>2.1.3</version>
            </dependency>
            <!-- 通用mapper启动器 -->
            <dependency>
                <groupId>tk.mybatis</groupId>
                <artifactId>mapper-spring-boot-starter</artifactId>
                <version>2.1.5</version>
            </dependency>
            <!--pagehelper-->
            <dependency>
                <groupId>com.github.pagehelper</groupId>
                <artifactId>pagehelper-spring-boot-starter</artifactId>
                <version>1.2.13</version>
            </dependency>
    
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.27</version>
            </dependency>
            <dependency>
                <groupId>com.alibaba</groupId>
                <artifactId>druid</artifactId>
                <version>1.1.22</version>
            </dependency>
        </dependencies>
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    </project>
    

    编写启动类:

    @SpringBootApplication
    public class EduAPP {
        public static void main(String[] args) {
            SpringApplication.run(EduAPP.class ,args);
        }
    }
    

    启动程序报错:

    在这里插入图片描述

    因为SpringBoot项目中引入数据库和orm框架(mybatis),这时SpringBoot会自动读取连接数据库的初始化4个参数,而项目根本没有做任何的配置。启动肯定报错。

    需要配置SpringBoot的核心配置文件:

    server:
      port: 80
      servlet:
        context-path: "/edu"
    spring:
      application:
        name: edu
      datasource:
        url: jdbc:mysql://127.0.0.1:3306/ssm-demo
        data-username: root
        data-password: root
        driver-class-name: com.mysql.jdbc.Driver
    

    2、SpringBoot处理静态的资源文件

    SpringBoot默认要求项目中的所有的静态资源(html、css、js、图片、视频、音频等等文件)需要放在固定的位置,默认在ResourceProperties类中有相关的说明:

    在这里插入图片描述

    展开全文
  • springboot框架相关技术的案例项目及使用springboot框架时的需注意点(接着springboot-learning-2仓库) 项目介绍 SpringBoot整合框架各种实用的组件技术点以及一些框架重要技术点的项目案例的实现,纯属个人技术...
  • springboot框架

    2019-10-08 19:49:49
    在Spring框架这个大家族中,产生了很多衍生框架,比如 Spring、SpringMvc框架等,Spring的核心内容在于控制反转(IOC)和依赖注入(DI),所谓控制反转并非是一种技术,而是一种思想,在操作方面是指在spring配置文件中...

    1、SpringBoot是什么?

       在Spring框架这个大家族中,产生了很多衍生框架,比如 Spring、SpringMvc框架等,Spring的核心内容在于控制反转(IOC)和依赖注入(DI),所谓控制反转并非是一种技术,而是一种思想,在操作方面是指在spring配置文件中创建<bean>,依赖注入即为由spring容器为应用程序的某个对象提供资源,比如 引用对象、常量数据等。

       SpringBoot是一个框架,一种全新的编程规范,他的产生简化了框架的使用,所谓简化是指简化了Spring众多框架中所需的大量且繁琐的配置文件,所以 SpringBoot是一个服务于框架的框架,服务范围是简化配置文件。

    2、SpringBoot可以做什么?

      最明显的特点是,让文件配置变的相当简单、让应用部署变的简单(SpringBoot内置服务器,并装备启动类代码),可以快速开启一个Web容器进行开发。

    3、SpringBoot工程的使用特点

      (1)一个简单的SpringBoot工程是不需要在pom.xml手动添加什么配置的,如果与其他技术合用 比如postMan(文档在线自动生成、开发功能测试的一套工具)、Swagger(文档在线自动生成、开发功能测试的一套工具),则需要在pom.xml中添加依赖,由程序自动加载依赖jar包等配置文件。

      (2)我们之前在利用SSM或者SSH开发的时候,在resources中储存各种对应框架的配置文件,而现在我们只需要一个配置文件即可,配置内容也大体有 服务器端口号、数据库连接的地址、用户名、密码。这样,虽然简单 但在一定问题上而言,这也是极不安全的,将所有配置,放在一个文件里,是很危险的,但对于一般项目而言并不会有太大影响。

       (3)在SpringBoot创建时会自动创建Bootdemo1Application启动类,代表着本工程项目和服务器的启动加载,在springBoot中是内含服务器的,所以不需手动配置Tomact,但注意端口号冲突问题。

    4、关于SpringBoot各种层之间的注解问题

       (1)推荐到此博客查询关于springboot的注解详情 https://www.cnblogs.com/woms/p/5754200.html

     

    展开全文
  • springBoot框架

    2018-12-03 20:15:49
    一、springboot的入门程序 1、开发环境 如果创建springboot工程必须使用maven、Gradle maven jdk1.8以上。 springboot2.0 2、需求 请求url响应json。 3、springboot开发步骤 1)创建一个maven工程,打包方式jar包。 ...

    一、springboot的入门程序
    1、开发环境
    如果创建springboot工程必须使用maven、Gradle
    maven
    jdk1.8以上。
    springboot2.0
    2、需求
    请求url响应json。
    3、springboot开发步骤
    1)创建一个maven工程,打包方式jar包。
    2)需要继承springboot-starter-parent工程。
    3)做web工程添加一个spring-boot-starter-web(起步依赖)
    4)编写Controller
    5)编写启动类,其中有main方法。
    要求启动类应该在所有类的父包中
    启动类上需要添加@SpringBootApplication注解。
    代表是springboot工程。包含一个包扫描器。
    springboot工程中自带服务器。

    二、springboot深度体验
    1、要求数据从数据库中获得
    使用SpringDataJpa做持久化框架。

    1)只需要添加springdatajpa的起步依赖即可。	
    2)mysql数据库驱动
    3)在配置文件中配置数据库连接。
    	application.properties
    

    2、springboot工程中添加页面
    可以使用jsp,在springboot中不推荐使用jsp。
    需要把工程打包方式改为war
    需要把tomcat的jar包剥离
    打成war包,部署到tomcat下。
    可以使用模板技术:
    freemarker(推荐使用)
    velocity(不推荐使用)
    Thymeleaf

    	把freemarker的起步依赖添加到工程。
    
    	模板文件保存在resources/templates目录下,且扩展名必须是ftl。
    静态资源的访问:
    	要求把静态资源放到resources/static目录下。静态资源的根目录。
    

    三、入门小结
    1、工程搭建
    需要继承spring-boot-starter-parent工程
    2、使用其他框架
    添加对应的起步依赖。
    3、创建引导类
    其中有main方法。
    引导类上@SpringBootApplication注解。
    4、推荐使用模板技术做页面。
    四、springboot的配置文件
    没有xml配置文件。
    只有一个application.properties
    可以对各个框架做个性化配置。
    可以配置的东西很多,可以在官方文档找到。

    在springboot中还支持yml(yaml)格式:
    	key:
    		sub-key1: value
    		sub-key2: value
    
    可以直接使用@Value注解取属性的值。使用方法跟properties相同。
    还可以使用@ConfigurationProperties注解取
    

    五、springboot整合常用框架
    1、整合mybatis
    1)添加mybatis的起步依赖。
    2)在配置文件中配置数据库的连接信息。和使用springdatajpa通用。
    3)定义pojo类、定义接口、映射文件。
    4)单独配置mybatis的包扫描器。

    2、springboot整合junit
    1)添加起步依赖
    2)创建一个测试类。
    @RunWith(SpringRunner.class)
    //设置引导类
    @SpringBootTest(class=MyApplication.class)
    3)把需要测试的对象直接注入到测试类中。
    4)使用@Test标注测试类

    3、springboot整合redis
    1)添加springdataRedis的起步依赖。
    2)在配置文件中配置redis的ip及端口号。
    3)在代码中直接使用RedisTemplate
    4、springboot整合SpringDataElasticSearch
    1)添加起步依赖
    2)在配置文件中配置ES集群的信息。
    3)在代码中直接使用ElasticSearchTemplate对象
    4)自定义Entity,dao,继承ElasticSearchRepository接口。

    当springboot同时整合redis和es时会发生冲突。
    需要添加一个jvm参数:
    	-Des.set.netty.runtime.available.processors=false
    

    六、使用springboot的技巧
    1、事务管理
    1)在springboot中推荐使用注解形式。在需要开启事务的方法上添加@Transactional注解。
    2)需要在引导类上添加
    @EnableTransactionManagement
    2、工程部署
    1)向maven工程中添加以插件。


    org.springframework.boot
    spring-boot-maven-plugin


    2)使用maven的打包命令打包。
    mvn package

    打包之后是一个肥包fat-jar
    
    展开全文
  • 开源项目结合了springboot框架+thymeleaf模板引擎+layui前端框架+数据库+redis等技术
  • SpringBoot框架的搭建

    千次阅读 2020-01-13 13:33:03
    SpringBoot框架的搭建

    **

    SpringBoot框架的搭建

    **

    个人 简介

    你好! 很高兴你能阅读到这篇文章,这是我第一次使用 博客 做分享。我是做Java全栈开发的,个人学习能力差,目前有4年开发经验,但是个人能力感觉还是很差,不会的东西还是太多,看到各位大神的各类神贴,收益颇多。近期做了个SpringBoot项目,SpringBoot的火热程度,我就不做过多阐述了,说说自己的感受,以及提供个人搭建SpringBoot框架的踩坑系列,望大家以我为鉴,避免各种踩坑,如有大神看到文章的不足,或是缺陷,请您留言,不甚感激。

    开发工具

    以下是本次开发使用到的工具:

    1. SpringBoot ,项目采用SpringBoot快速搭建;
    2. 使用IDEA开发,maven管理;
    3. 前端用的是,Thymeleaf 模板,layUI,Bootstrap;
    4. Apache Shiro 安全框架;
    5. Mybatis 做持久层。

    本文介绍

    本分类是个系列片,将讲述的非常详细,每个字码都是作者,一个一个敲上去的,本文档是踩坑系列第一集,项目框架的搭建。Springboot框架的搭建,据本人了解有3中方式,spring官网提供页面下载的方式,IDEA创建,Eclipse STS工具创建。之前本人一直使用的Eclipse或者MyEclipse,一直感觉Eclipse或MyEclipse,是Java开发神器,然而,,,在一次项目开发过程中,我们的项目有多个迭代版本的,线上正式版(2.0版本,1.0版本是ssm版的,项目升级使用SpringBoot),测试服务版本,本地开发版本,由于同一个项目,在Eclipse中切换效果体验太差,于是更换开发工具-IDEA,使用IDEA之后,瞬间感觉到了,版本之间的切换是个多么爽的的事情,项目经理再也不用担心,我们会改错版本,导致项目版本紊乱。。。所以本人推荐使用IDEA,在本人的踩坑系列中,IDEA将作为第一开发工具。废话有点多了,干点正事吧。。。

    特殊说明:
    先来个简单的,本文档只适合初次接触的SpringBoot的,不会搭建SpringBoot框架的,更高级的将逐步推出,不喜勿喷

    IEDA创建SpringBoot框架

    1.首先打开你的IDEA,File - New - Project…
    在这里插入图片描述
    2.操作完,会显示以下弹窗。。。
    在这里插入图片描述
    3.选择Spring Initializr - 选择自己的JDK - Next
    在这里插入图片描述

    4.填写项目的基本信息,大家以个人喜好填写,然后Next
    在这里插入图片描述

    5.此处可以选择一些初始化的配置
    在这里插入图片描述

    6.本文是SpringBoot框架的搭建,因此只阐述简单的搭建,此处我只选择了web。
    在这里插入图片描述

    7.显示项目名称,可以修改,项目存储目录,可以修改,建议修改,Finish,结束,项目自己会加载,所需jar包
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    以上就是IDEA搭建SpringBoot框架项目全部过程,自此SpringBoot框架搭建完成。但是咱们是技术人员,每做一部操作都要去测试,接下来咱们就是测试咱们这个框架是否可行,是否能用。。。

    SpringBoot框架,测试

    1.首先测试,当前项目是否能跑起来,是否报错,我们运行项目的启动类,打开项目的启动类,鼠标右键单击Run…
    在这里插入图片描述
    2.查看控制台,出现Started DemoApplication in 1.32 seconds (JVM running for 3.37),证明项目启动成功,并且项目自动帮我使用8080端口。
    在这里插入图片描述
    3.为了验证我们的项目是否真的搭建成功,我们写个测试类,测试下,首先我将在我们的项目里面创建个包,写个controller类,在页面输出万古不变的:Hello World!
    在这里插入图片描述
    在这里插入图片描述
    4.重新启动服务,访问咱们的/hello接口,测试页面是否有输出,谷歌浏览器访问:http://localhost:8080/hello
    在这里插入图片描述

    5.由此,咱们的项目搭建成功,正常访问。

    本文档适合新接触SpringBoot的小白,文章内容由作者亲自书写,已入门或者大神级别,勿喷!



                        您的支持,是我创作的动力,感谢您的支持!!!

    在这里插入图片描述

    展开全文
  • springboot框架学习积累—SpringBoot支持的视图技术 1.支持的视图技术 2.Thymeleaf常用标签 是一种Springboot使用的页面模板技术 <!DOCTYPE html> <...link rel="stylesheet" type="text/cs
  • springboot框架简介

    2019-10-09 21:27:15
    springboot简介 1、简化spring,springmvc配置文件 2、可以快速启动一个web容器 3、可以快速正合第三方框架技术
  • springboot框架图解

    万次阅读 多人点赞 2018-10-21 11:12:35
    springboot容器启动流程: 其中最重要的: 运行机制为: springboot事件驱动:详情见:springboot事件驱动与观察者模式(http://www.cnblogs.com/dennyzhangdd/p/8343229.html) springboot启动流程图: ...
  • SpringBoot基础框架,集成了通过CXF发布WebService技术,包括服务器端和客户端,直接可运行
  • SpringBoot之为什么需要使用SpringBoot框架 SpringBoot基本框架介绍:  SpringBoot 是一个快速开发的框架, 封装了Maven常用依赖、能够快速的整合第三方框架;简化XML配置,全部采用注解形式,内置Tomcat、Jetty、...
  • SpringBoot框架介绍

    2021-03-13 23:22:42
    所有的技术框架的发展似乎都遵循了一条主线规律:从一个复杂应用场景 衍生 一种规范框架,人们只需要进行各种配置而不需要自己去实现它,这时候强大的配置功能成了优点;发展到一定程度之后,人们根据实际生产应用...
  • SpringBoot 框架入门

    2020-07-28 14:07:35
    要说近两年比较火的企业级开发框架是什么,那非 SpringBoot 莫属,这是一个非常优秀的开源框架,可能这里有的小伙伴就会有疑问了,现在那么多优秀的开源框架,为什么 SpringBoot 一出现就非常火呢?其实它那么受欢迎...
  • Springboot框架简介

    千次阅读 多人点赞 2020-11-20 00:26:07
    1.1.什么是SpringBoot SpringBoot是Spring项目中的一个子工程,与我们所熟知的Spring-framework 同属于spring的产品: 我们可以看到下面的一段介绍: Takes an opinionated view of building production-ready ...
  • 这是自己搭建的一个连接了Oracle的springboot 框架,里面搭建好了前端和后端的架构,前端使用了layer bootstrap,jQuery 等技术
  • 初次认识SpringBoot框架

    2017-11-20 14:49:03
    一:SpringBoot框架的简介1)SpringBoot的产生Spring Boot是由Pivotal团队提供的全新框架,其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置,从而使开发人员不再需要...
  • 最近写了一篇SpringCloud整合Dubbo的技术贴,本篇内容有点类似,Dubbo本身就是微服务框架,整合SpringBoot之后,可以吸收SpringBoot框架的自动装配功能; Dubbo集成SpringBoot框架的目的,是为了实现Springcloud...
  • Springboot框架项目核心文档(概要设计说明书、接口详细设计、数据库设计、需求说明书);Springboot框架项目核心文档(概要设计说明书、接口详细设计、数据库设计、需求说明书)
  • springboot框架 目录结构

    万次阅读 多人点赞 2019-03-29 22:50:55
    springboot 提供了一个解决方案吧,可以先不关心如何配置,可以快速的启动开发,进行业务逻辑编写,各种需要的技术,加入 starter 就配置好了,直接使用,可以说追求开箱即用的效果吧 AJAX 是与服务器交换数据并...
  • 项目介绍:这是一个基于SpringBoot框架开发的博客发布系统。该系统有两个角色,一个角色是普通用户,另一个角色是管理员。普通用户可以浏览或评论这个网站里大家发表的博客,然后也可以在这个网站上发布自己的博客。...
  • SpringBoot框架之概述与原理浅析

    千次阅读 2020-02-07 12:12:28
    在上一篇博客 SpringBoot框架之创建第一个项目(两种方式)演示了如何创建SpringBoot项目,在此篇博客将对上述过程的作用、SpringBoot实现原理进行简单的分析。 一、SpringBoot框架概述 1、什么是SpringBoot Spring ...
  • ❝ 要说近两年比较火的企业级开发框架是什么,那非 SpringBoot 莫属,这是一个非常优秀的开源框架,可能这里有的小伙伴就会有疑问了,现在那么多优秀的开源框架,为什么 SpringBoot 一出现就非常火呢?其实它那么受...
  • 课程目标:通过本课程的学习,全面掌握Spring Boot开发框架技术,并在实际项目开发中得心应手使用Spring Boot框架,提升自身的技术能力与价值。 适用人群:有一定的Java Web开发基础。 课程概述:Spring Boot是...
  • Idea搭建springboot框架教程

    千次阅读 2019-09-03 10:09:45
    目前较为主流的SpringBoot框架进行服务端搭建,后续跟进小程序开发教程。以下纯为一些个人开发日记(大神勿喷)。 一、开发工具及环境: Idea(Ultimate):https://www.jetbrains.com/idea/download/#sect...
  • 基于SpringBoot框架企业级应用系统开发全面实战,包含视频和源码,课程配套ppt,和文档
  • 基于java(springboot框架)的新闻管理系统 开题报告+界面

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 53,370
精华内容 21,348
关键字:

springboot框架技术

spring 订阅