Spring Boot (https://baike.baidu.com/item/Spring%20Boot?fromModule=lemma_search-box) 是由 Pivotal 团队提供的全新框架，其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程。

人们把 Spring Boot 称为搭建程序的脚手架。其最主要作用就是帮我们快速的构建庞大的 Spring 项目，并且尽可能的减少一切 XML 配置，做到开箱即用，迅速上手，让我们关注与业务而非配置。

优点

• 创建独立运行的 Spring 应用程序；
• 可嵌入 Tomcat，无需部署 war 文件；
• 简化 Maven 配置(可以继承父项目)；
• 自动配置 Spring；
• 提供生产就绪型功能，如：日志，健康检查和外部配置等；
• 不要求配置 XML；
• 非常容易和第三方框架集成起来(自动配置需要用到的一些对象)。

缺点

• 版本更新较快，可能出现较大变化；
• 因为约定大于配置，所以经常会出现一些很难解决的问题。

Spring Boot 快速入门

使用 IDEA 创建 Spring Boot 工程

pring Boot 建议使用官方提供的工具 (https://start.spring.io/) 来快速构建项目。但IDEA 自带该功能，更加方便, 但需要联网使用。

注意：官方提供的构建工具默认只能选择固定的版本，有些版本之间的差异非常大，所以如果需要选择某个版本可以自行在 pom.xml 文件中修改版本。

使用IDEA,选择创建新项目,选择spring initializer 下载地址可以使用国内阿里云镜像地址 https://start.aliyun.com/ 然后填写项目信息,选择maven project

勾选需要使用的依赖

编写 Controller 代码

@Controller
public class HelloController {

    @RequestMapping("/hello")
    @ResponseBody
    public String hello() {
        return "Hello Spring Boot";
    }
}

然后通过 main 方法启动程序，观察控制台输出内容，最后浏览器中输入 http://localhost:8080/hello 验证效果。

启动类和测试类

使用 IDEA 创建的项目会自动生成一个启动类，其实本质也是一个配置类，如下：

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

使用 IDEA 创建的项目会自动生成一个测试类，测试类贴有 @SpringBootTest 注解，可以通过通过注解属性指定加载的配置类，若没有指定，默认加载的是贴 @SpringBootApplication 注解的配置类，如下：

@SpringBootTest
class XxxApplicationTest {
    // ...
}

普通项目变更为Spring Boot项目

添加依赖

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.3.RELEASE</version>
</parent>

编写启动程序(需注意这个类的位置,需扫描到所有bean的同级目录或更上级)

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

当前项目继承的 spring-boot-starter-parent 项目有什么用？

Spring Boot 提供了一个名为 spring-boot-starter-parent 的工程，里面已经对各种常用依赖（并非全部）的版本进行了管理，我们的项目需要以这个项目为父工程，这样我们就不用操心依赖的版本问题了，需要什么依赖，直接引入坐标即可！,父项目的打包方式为pom,一般只写pom依赖关系,可以理解为这个项目就是用来统一子项目的依赖版本的

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.3.3.RELEASE</version>
</parent>

继承是 Maven 中很强大的一种功能，继承可以使得子 pom 可以获得 parent 中的部分配置（groupId，version，dependencies，build，dependencyManagement 等），可以对子 pom 进行统一的配置和依赖管理。

• parent 项目中的 dependencyManagement 标签里的声明的依赖，只具有统一版本的作用，子项目需要显式的写出来这个依赖。如果不在子项目中声明依赖，是不会从父项目中继承下来的；只有在子项目中写了该依赖项，并且没有指定具体版本，才会从父项目中继承该项，并且 version 和 scope 都读取自父 pom；另外若子项目中指定了版本号，那么会使用子项目中指定的 jar 版本。
• parent 项目中的 dependencies 里声明的依赖会被所有的子项目继承。

如何建立子项目

在当前项目右键 - new - module - 填写父项目是谁,填写子项目信息,如果是已经有了的项目想继承一个父项目则直接添加parent标签即可,参见上面

导入的依赖 spring-boot-starter-web 有什么用？

Spring Boot 非常优秀的地方在于提供了非常多以 spring-boot-starter-* 开头的开箱即用的 starter 启动器（依赖包），使得我们在开发业务代码时能够非常方便的、不需要过多关注框架的配置，而只需要关注业务即可。

Spring Boot 在配置上相比 Spring 要简单许多，其核心在于 spring-boot-starter， 在使用 Spring Boot 来搭建一个项目时，只需要引入官方提供的 starter，就可以直接使用，免去了各种配置。

官方目前已提供的常见的 Starter 如下 ：

spring-boot-starter：核心启动器，提供了自动配置，日志和 YAML 配置支持。

spring-boot-starter-aop：支持使用 Spring AOP 和 AspectJ 进行切面编程。

spring-boot-starter-freemarker：支持使用 FreeMarker 视图构建 Web 应用。

spring-boot-starter-test：支持使用 JUnit，测试 Spring Boot 应用。

spring-boot-starter-web：支持使用 Spring MVC 构建 Web 应用，包括 RESTful 应用，使用 Tomcat 作为默认的嵌入式容器。

spring-boot-starter-actuator：支持使用 Spring Boot Actuator 提供生产级别的应用程序监控和管理功能。

spring-boot-starter-logging：提供了对日志的支持，默认使用 Logback。

有关 Spring Boot Starter 命名规范，所有官方发布的 Starter 都遵循以下命名模式：spring-boot-starter-*，其中 * 指特定的应用程序代号或名称。任何第三方提供的 Starter 都不能以 spring-boot 作为前缀，应该将应用程序代号或名称作为前缀，譬如 mybatis-spring-boot-starter。

Web 启动器

这是 SpringBoot 提供的 Web 启动器，是一个快速集成 Web 模块的工具包，包含 Spring MVC，Jackson 相关的依赖，以及嵌入了 Tomcat9 服务器，默认端口 8080。

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

需要注意的是，我们并没有在这里指定版本信息。因为 Spring Boot 的父工程已经对版本进行了管理了,不然是需要写的。
这个时候，我们会发现项目中多出了大量的依赖：

这些都是 Spring Boot 根据 spring-boot-starter-web 这个依赖自动引入的，而且所有的版本都已经管理好，不会出现冲突。

打包独立运行

对于 Spring Boot 项目来说无论是普通应用还是 Web 应用，其打包方式都是 jar 即可，当然 Web 应用也能打 war 包，但是需要额外添加许多插件来运行, 如需要放到tomcat里运行，比较麻烦。

默认的 Maven 打包方式是不能正常的打包 Spring Boot 项目的，需要额外的引入打包插件，才能正常的对 Spring Boot 项目打包，以后只要拿到该 jar 包就能脱离 IDE 工具独立运行了。

<!-- 指定编译版本 -->
<properties>
    <java.version>11</java.version>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
</properties>
<!-- pom.xml 中添加插件 -->
<build>
    <plugins>
        <!-- Spring Boot 打包插件 -->
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

• 使用 maven 的 package 命令进行打包；
• 使用命令 java -jar xxx.jar --server.port=80 运行 jar 包。

Spring Boot 参数配置

参数来源

• 命令行启动项目时传入的参数，如：java -jar xxx.jar --server.port=80；
• application.properties 或者 application.yml 文件。
• 自定义配置文件, 比如自己新建 db.properties(要自己配置才会读取)

一般用的比较多的就是直接在 application.properties 或者 application.yml 配置，其次是命令行启动方式。

application.properties 语法

server.port=80
server.session-timeout=30
server.tomcat.uri-encoding=UTF-8

spring.datasource.driverClassName=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/rbac
spring.datasource.username=root 
spring.datasource.password=admin

application.yml 语法

server:  
  port: 80
  session-timeout: 30  
  tomcat.uri-encoding: UTF-8  
  
spring:  
  datasource:  
    url: jdbc:mysql://localhost:3306/crm  
    username: root  
    password: admin  
    driverClassName: com.mysql.jdbc.Driver

配置文件优先级

一个项目中可以有多个配置文件存放在不同目录中，此时他们会遵循固定的优先级来处理有冲突的属性配置，优先级由高到底，高优先级的配置会覆盖低优先级的配置。用 application.properties 文件举例子，下面文件优先级由高到低排序：

• 项目/config/application.properties
• 项目/application.properties
• 项目的 resources:config/application.properties
• 项目的 resources:application.properties

一般都在 项目的 resources:application.properties 做配置，其他方式不使用。

参数属性绑定

通过配置参数，来自定义程序的运行。一般配置参数编写在 application.properties 或者我们自定义的 properties 文件中。

参数配置在自定义的 properties

之前使用 XML 配置时，想让 Spring 知道我们指定自定义的 properties 文件，就需要如下配置：

# db.properties
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/xxx
jdbc.username=root
jdbc.password=admin

并在spring配置文件中读取这个文件

<context:property-placeholder location="classpath:db.properties" system-properties-mode="NEVER"/>

而现在使用 JavaConfig 配置，就得使用 @PropertySource + @Value 两个注解配合完成。@PropertySource 的作用就等价于上面那段 XML 配置。

/**
 *  @PropertySource：把属性配置加载到 Spring 的环境对象中
 *  @Value：从 Spring 环境对象中根据 key 读取 value
 */
@Configuration
@PropertySource("classpath:db.properties")
public class JavaConfig {
    @Value("${jdbc.driverClassName}")
    private String driverClassName;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    @Bean
    public MyDataSource dataSource() {
        MyDataSource dataSource = new MyDataSource();
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

参数配置在 application.properties

准备好 application.properties 和一个类 MyDataSource，配置如下：

# application.properties
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/crm
jdbc.username=root
jdbc.password=admin

public class MyDataSource {
    private String driverClassName;
    private String url;
    private String username;
    private String password;
    
    // 省略 toString 方法
}

使用@Value 注解绑定单个属性

@Component
public class MyDataSource {
    @Value("${jdbc.driverClassName}")
    private String driverClassName;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;

    // 省略 toString 方法
}

在配置类中给没有交给spring容器管理的类 绑定属性：

@Configuration
public class JavaConfig { 
    // @Value：从 Spring 环境对象中根据 key 读取 value
    @Value("${jdbc.driverClassName}")
    private String driverClassName;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
    
    @Bean
    public MyDataSource dataSource() {
        MyDataSource dataSource = new MyDataSource();
        dataSource.setDriverClassName(driverClassName);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

@ConfigurationProperties 绑定对象属性

使用@value注解太麻烦,如果一个对象中有多个字段,那么每个字段都要贴，我们可以在类上贴 @ConfigurationProperties 注解,注解中的属性值填一个前缀作为标识,只要配置文件中有这个前缀的属性和我们这个类中的前缀+属性名一致，即可实现自动绑定，但是注意，若是想要这个注解生效，则需要在配置类中添加 @EnableConfigurationProperties 注解；若是使用测试类加载贴有@SpringBootApplication 的配置类(这个注解内置@EnableConfigurationProperties注解)，则不需要。

@Component
@ToString
@Setter
//需要绑定属性的类
@ConfigurationProperties(prefix="jdbc")
public class MyDataSource {
    private String driverClassName;
    private String url;
    private String username;
    private String password;
    //必须要有set方法,因为是按上面注解前缀+属性名来通过set方法注入的
}

在java配置类配置如何书写

@Bean
@ConfigurationProperties("jdbc")
public MyDataSource dataSource() {
    return new MyDataSource();
}

而 application.properties配置文件中的书写方式

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/xxx
jdbc.username=root
jdbc.password=admin

@EnableConfigurationProperties 文档中解释：当 @EnableConfigurationProperties 注解应用到你的 @Configuration 时，任何贴 @ConfigurationProperties 注解的 beans 将自动被 Environment 进行属性绑定。

使用 Spring 的 Environment 对象绑定属性

当要绑定的参数过多时，直接在配置类中注入 Spring 的 Environment 对象， 这样就不需要贴上在字段或者形参上太多的 @Value 注解，相对比较简洁。

从 Environment 对象中可以获取到 application.properties 里面的参数，也可以获取到 @PropertySource 中的参数（即对配置在什么文件中没有要求）。

@Configuration
@PropertySource("classpath:db.properties")
public class JavaConfig {
    /**
     * environment：表示 Spring 的环境对象，该对象包含了加载的所有属性数据
     * 可以获取到 application.properties 里面的参数，也可以获取到 @PropertySource 中的参数,以及电脑环境数据(对应的key需要去网上查)
     * 但 application.properties 的优先级比 @PropertySource 高
     */
    @Autowired
    private Environment environment;

    @Bean
    public MyDataSource dataSource() {
        MyDataSource dataSource = new MyDataSource();
        dataSource.setDriverClassName(environment.getProperty("jdbc.driverClassName"));
        dataSource.setUrl(environment.getProperty("jdbc.url"));
        dataSource.setUsername(environment.getProperty("jdbc.username"));
        dataSource.setPassword(environment.getProperty("jdbc.password"));
        return dataSource;
    }
}

Spring Boot 自动配置原理

使用 Spring Boot 之后，做一个整合了 Spring MVC 的 Web 工程开发，变的无比简单，那些繁杂的配置都消失不见了，这是如何做到的？一切魔力的开始，都是从我们的 main 函数来的，所以我们再次来看下启动类：

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

@SpringBootApplication注解

点击进入，查看源码：

这里重点的注解有3个：

• @SpringBootConfiguration
• @EnableAutoConfiguration
• @ComponentScan

@SpringBootConfiguration注解

通过这段我们可以看出，在这个注解上面，又有一个 @Configuration 注解。通过上面的注释阅读我们知道：这个注解的作用就是声明当前类是一个配置类，然后 Spring 会自动扫描到添加了 @Configuration 的类，并且读取其中的配置信息。而 @SpringBootConfiguration 是来声明当前类是 Spring Boot 应用的配置类，项目中只能有一个。

@ComponentScan

我们的 @SpringBootApplication 注解声明的类就是 main 函数所在的启动类，因此扫描的包是该类所在包及其子包。因此，一般启动类会放在一个比较前的包目录中。

@EnableAutoConfiguration

@EnableAutoConfiguration 的作用，告诉 Spring Boot 基于你所添加的依赖，去“猜测”你想要如何配置 Spring。比如我们引入了 spring-boot-starter-web，而这个启动器中帮我们添加了 tomcat、SpringMVC 的依赖。此时自动配置就知道你是要开发一个 Web 应用，所以就帮你完成了 Web 及 Spring MVC 的默认配置了！

Spring Boot 内部对大量的第三方库或 Spring 内部库进行了默认配置，这些配置是否生效，取决于我们是否引入了对应库所需的依赖，如果有，那么默认配置就会生效。那么带来新的问题，如下：

• 这些默认配置是在哪里定义的呢？
• 为何依赖引入就会触发配置呢？

@EnableAutoConfiguration 注解中导入了一个 AutoConfigurationImportSelector 配置类，spring会创建该类对象并调用该类的方法,该类中有个 getCandidateConfigurations 方法，方法的作用是委托 SpringFactoriesLoader(工厂加载器) 去读取 jar 包中的 META-INF/spring.factories 文件，这个文件里面写了这个jar包 的所需要的配置类的全限定路径,spring会加载这些自动配置对象，包括：AOP，PropertyPlaceholder，FreeMarker，HttpMessageConverter，Jackson，DataSourceDataSourceTransactionManager，DispatcherServlet 等等。

其实在我们的项目中，已经自动引入了一个依赖：spring-boot-autoconfigure，上面说到的这些自动配置类，都来自该包。

虽然 spring.factories 文件中定义了很多配置类，但并不是所有配置类都会生效，只有符合条件的是才会创建该配置类对象并实例化其中的配置方法。

我们来看一个我们熟悉的，例如 Spring MVC，查看其自动配置类：

打开 WebMvcAutoConfiguration：

我们看到这个类上的 4 个注解：

• @Configuration：声明这个类是一个配置类

• @ConditionalOnWebApplication(type = Type.SERVLET)

ConditionalOn，翻译就是在某个条件下，此处就是满足项目的类是是 Type.SERVLET 类型

• @ConditionalOnClass({Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })

这里的条件是 OnClass，也就是满足以下类存在：Servlet、DispatcherServlet、WebMvcConfigurer。这里就是判断你是否引入了 Spring MVC相关依赖，引入依赖后该条件成立，当前类的配置才会生效！

• @ConditionalOnMissingBean(WebMvcConfigurationSupport.class)

这个条件与上面不同，OnMissingBean，是说环境中没有指定的 bean 这个才生效。其实这就是自定义配置的入口，也就是说，如果我们自己配置了一个 WebMVCConfigurationSupport 的 bean，代表容器里已经存在该 bean 了，那么这个默认配置就会失效！满足了开发者自己配置的需求

接着，我们查看 WebMvcAutoConfiguration 该类中定义了什么对象：
给我们配置了视图解析器：

WebMvcAutoConfiguration 配置类中使用了 @AutoConfigureAfter 注解，意为指定的类加载完了后，再加载本类。

@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class,
TaskExecutionAutoConfiguration.class, ValidationAutoConfiguration.class })

而 DispatcherServletAutoConfiguration 中又做了很多事情，比如配置了前端控制器

@Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
public DispatcherServlet dispatcherServlet(WebMvcProperties webMvcProperties) {
    DispatcherServlet dispatcherServlet = new DispatcherServlet();
    dispatcherServlet.setDispatchOptionsRequest(webMvcProperties.isDispatchOptionsRequest());
    dispatcherServlet.setDispatchTraceRequest(webMvcProperties.isDispatchTraceRequest());
    dispatcherServlet.setPublishEvents(webMvcProperties.isPublishRequestHandledEvents());
    dispatcherServlet.setEnableLoggingRequestDetails(webMvcProperties.isLogRequestDetails());
    return dispatcherServlet;
}

jar包配置类的参数微调原理

例如数据库的账号密码,以及项目运行端口号之类的,一般配置类会有一个与其名字对应的类(如xxxAutoConfiguration 对应xxxConfigurationProperties),该类用来封装配置类需要的属性,一般支持我们修改的都贴了@ConfigurationProperties注解,这个注解文章上面有写,用于读取我们配置文件中的指定前缀属性来填充这个类的字段,然后配置类再从中读取需要的参数

自动配置原理总结

• @SpringBootApplication 注解内部是3大注解功能的集成
  • @ComponentScan：开启组件扫描
  • @SpringBootConfiguration：作用等同于 @Configuration 注解，也是用于标记自身是一个配置类
  • @EnableAutoConfiguration：内部导入 AutoConfigurationImportSelector类，该类中有个 getCandidateConfigurations 方法，读取 jar 包中 META-INF/spring.factories 文件中配置类，再根据条件进行加载和配置，比如：AOP，PropertyPlaceholder，FreeMarker，HttpMessageConverter，Jackson，DataSourceDataSourceTransactionManager，DispatcherServlet，WebMvc 等等
• SpringApplication.run(…)的作用
  • 启动 Spring Boot 应用
  • 加载自定义的配置类，完成自动配置功能
  • 把当前项目配置到嵌入的 Tomcat 服务器
  • 启动嵌入的 Tomcat 服务器