一、SpringBoot简介
1.1 原有Spring优缺点分析
1.1.1 Spring的优点分析
Spring是Java企业版（Java Enterprise Edition，JEE，也称J2EE）的轻量级代替品。无需开发重量级的Enterprise JavaBean（EJB），Spring为企业级Java开发提供了一种相对简单的方法，通过依赖注入和面向切面编程，用简单的Java对象（Plain Old Java Object，POJO）实现了EJB的功能。
1.1.2 Spring的缺点分析
虽然Spring的组件代码是轻量级的，但它的配置却是重量级的。一开始，Spring用XML配置，而且是很多XML配置。Spring 2.5引入了基于注解的组件扫描，这消除了大量针对应用程序自身组件的显式XML配置。Spring 3.0引入了基于Java的配置，这是一种类型安全的可重构配置方式，可以代替XML。
所有这些配置都代表了开发时的损耗。因为在思考Spring特性配置和解决业务问题之间需要进行思维切换，所以编写配置挤占了编写应用程序逻辑的时间。和所有框架一样，Spring实用，但与此同时它要求的回报也不少。
除此之外，项目的依赖管理也是一件耗时耗力的事情。在环境搭建时，需要分析要导入哪些库的坐标，而且还需要分析导入与之有依赖关系的其他库的坐标，一旦选错了依赖的版本，随之而来的不兼容问题就会严重阻碍项目的开发进度。
1.2 SpringBoot的概述
1.2.1 SpringBoot解决上述Spring的缺点
SpringBoot对上述Spring的缺点进行的改善和优化，基于约定优于配置的思想，可以让开发人员不必在配置与逻辑业务之间进行思维的切换，全身心的投入到逻辑业务的代码编写中，从而大大提高了开发的效率，一定程度上缩短了项目周期。
1.2.2 SpringBoot的特点
- 为基于Spring的开发提供更快的入门体验
- 开箱即用，没有代码生成，也无需XML配置。同时也可以修改默认值来满足特定的需求
- 提供了一些大型项目中常见的非功能性特性，如嵌入式服务器、安全、指标，健康检测、外部配置等
- SpringBoot不是对Spring功能上的增强，而是提供了一种快速使用Spring的方式
Spring Boot 是一套 Java 开发框架，可以快速构建基于 Spring 生态的 Java Application，实现自动配置。
二、源码解析
2.1 Spring Boot 核心配置
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.2.2.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
spring-boot-starter 是 Spring Boot 提供的场景启动器，通过 starter 导入不同场景下所需要的 jar 包，如 web、dao 等。
spring-boot-starter-{name} 是 Spring 官方提供的启动器，如 spring-boot-starter-parent，{name}-spring-boot-starter 是第三方提供的启动器，如 mybatis-spring-boot-starter。
spring-boot-starter-parent 是 Spring Boot 的父级启动器，Spring Boot 相当于一个大的组件集合，将 Spring 家族组件及第三方组件全部进行了集成，开发者只需要通过配置 spring-boot-starter 就可以将所需组件配置到项目中，直接使用，这就是开箱即用。
打开 spring-boot-starter-parent 源码，可以看到 resource 中配置了 Spring Boot 默认会读取的资源文件。
<resource>
<filtering>true</filtering>
<directory>${basedir}/src/main/resources</directory>
<includes>
<include>**/application*.yml</include>
<include>**/application*.yaml</include>
<include>**/application*.properties</include>
</includes>
</resource>
所以 Spring Boot 默认加载的配置文件是 src/main/resources 路径下名为 application 的 yml、yaml、properties 文件。
同时 spring-boot-starter-parent 中又引入了 spring-boot-dependencies 依赖。
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.2.2.RELEASE</version>
<relativePath>../../spring-boot-dependencies</relativePath>
</parent>
打开源码，如下所示。
<properties>
<activemq.version>5.15.12</activemq.version>
<antlr2.version>2.7.7</antlr2.version>
<appengine-sdk.version>1.9.79</appengine-sdk.version>
<artemis.version>2.10.1</artemis.version>
<aspectj.version>1.9.5</aspectj.version>
<assertj.version>3.13.2</assertj.version>
<atomikos.version>4.0.6</atomikos.version>
<awaitility.version>4.0.2</awaitility.version>
<bitronix.version>2.1.4</bitronix.version>
<build-helper-maven-plugin.version>3.0.0</build-helper-maven-plugin.version>
<byte-buddy.version>1.10.8</byte-buddy.version>
<caffeine.version>2.8.1</caffeine.version>
<cassandra-driver.version>3.7.2</cassandra-driver.version>
......
</properties>
从上面的spring-boot-starter-dependencies的pom.xml中我们可以发现，一部分坐标的版本、依赖管理、插件管理已经定义好，所以我们的SpringBoot工程继承spring-boot-starter-parent后已经具备版本锁定等配置了。所以起步依赖的作用就是进行依赖的传递。
2.2 Spring Boot 自动配置类
传统的 Spring 应用中，各个组件对象的管理全部交给 Spring IoC 容器，我们需要在 application.xml 中配置多个 bean，以完成组件对象的注入。
而在 Spring Boot 中，这些配置是自动注入的，并不需要开发者配置任何一个 bean，如何实现？定义一个自动配置的类，通过加载这个类来读取各种配置信息，用来替代 XML 的配置文件，这里用到两个核心注解 @Configuration 和 @Bean。
@Configuration 注解标明该类是一个配置类，@Bean 注解表示该方法返回的对象就是一个要交给 Spring IoC 容器管理的 bean 实例。
一个 @Bean 就相当于传统的 application.xml 中配置的一组 <bean/> 。
2.2.1 XML 配置方式
1、实体类。
@Data
@AllArgsConstructor
public class User {
private Integer id;
private String name;
}
2、配置文件。
<beans>
<bean id="user" class="com.musk.entity.User">
<property name="id" value="1"></property>
<property name="name" value="张三"></property>
</bean>
</beans>
3、获取 bean。
public class Test {
public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("application.xml");
User user = (User) applicationContext.getBean("user");
System.out.println(user);
}
}
2.2.2 基于配置类的方式
1、创建配置类。
@Configuration
public class MyConfiguration {
@Bean(name = "user")
public User getUser(){
return new User(1,"张三");
}
}
2、获取 Bean。
public class Test {
public static void main(String[] args) {
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfiguration.class);
User user = (User) applicationContext.getBean("user");
System.out.println(user);
}
}
2.3 Spring Boot 源码解析
Spring Boot 自动装配主要完成两件事：
1、自动装置开发者自定义的业务组件（Handler、Service、Repository 等 bean）。
2、根据开发者的设置进行自动配置（比如集成 MyBatis，自动配置 DataSource、SqlSessionFactory 等 bean）。
Spring Boot 最大的特点就是可以完成自动配置，简单讲就是之前需要开发者手动配置的各种 bean，现在 Spring Boot 全部自动完成，并且是基于 JavaConfig 的形式，即用标注了 @Configuration 的类来替代 XML，Spring Boot 最核心的注解是 @SpringBootApplication。
@SpringBootApplication 注解
该注解实际由 3 个核心注解组成：
1、@SpringBootConfiguration
2、@EnableAutoConfiguration
3、@ComponentScan
@SpringBootConfiguration 实际上还是使用了 @Configuration，Spring 官方推荐使用
@Configuration 配置类的形式来替代 XML 的配置方式，启动类标注了 @Configuration 注解之后，也就成为了 IoC 的配置类。
@ComponentScan 这个注解的功能是自动扫描并加载符合条件的组件（比如开发者自定义的业务组件，@Component 和 @Repository等），可以通过 basePackages 属性来制定扫描的范围，如果不指定，默认从 @ComponentScan 所在类的 package 向下进行扫描。
@EnableAutoConfiguration 就是完成自动配置的，会根据类路径中引入的 jar 依赖为项目自动配置，比如添加了 spring-boot-starter-web 依赖，Spring Boot 就会自动添加 Spring MVC 相关 jar，并且会自动对 Spring MVC 进行配置（DispatcherServlet、ViewResolver ）。
@EnableAutoConfiguration 是如何完成自动配置的呢？
核心注解是 @Import(EnableAutoConfigurationImportSelector.class)，具体流程如下：
1、EnableAutoConfigurationImportSelector 中返回符合条件的 @Configuration 类信息。
2、@Import 通过加载 EnableAutoConfigurationImportSelector，将所有符合条件的 @Configuration 配置都加载到当前 Spring Boot 创建并使用的 IoC 容器中。
我们通过一个例子来搞清楚 @Import 的使用。
User
package org.musk.entity;
@Data
public class User {
@Value("1")
private Integer id;
@Value("张三")
private String name;
}
MyImportSelector
public class MyImportSelector implements ImportSelector {
@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
return new String[]{"org.musk.entity.User"};
}
}
MyImportConfig
@Import(MyImportSelector.class)
public class MyImportConfig {
}
Test
public class Test {
public static void main(String[] args) {
ApplicationContext context = new AnnotationConfigApplicationContext(MyImportConfig.class);
System.out.println(context.getBean("org.southwind.entity.User"));
}
}
运行结果如图所示。
可以得出结论，Spring Boot 自动配置的类都是通过 EnableAutoConfigurationImportSelector 获取的，那么问题来了，EnableAutoConfigurationImportSelector 是如何返回 Spring Boot 所需要的 @Configuration 类呢？
这里需要使用 SpringFactoriesLoader 来完成，SpringFactoriesLoader 属于 Spring 框架私有的一种扩展方案，其主要功能就是从指定的配置文件 META-INF/spring.factories 加载配置。
它在这里的工作是通过 @EnableAutoConfiguration 的完整类名 org.springframework.boot.autoconfigure.EnableAutoConfiguration 作为 Key，在 META-INF/spring.factories 查找对应的一组 @Configuration 类。
通过这种方式，让 Spring Boot 读取到所有符合条件的 @Configuration 配置类，并通过反射机制实例化 bean 并加载到 IoC 容器中，这样就实现了自动配置。
2.4 分析 spring-boot-starter-web
按住Ctrl点击pom.xml中的spring-boot-starter-web，跳转到了spring-boot-starter-web的pom.xml，xml配置如下（只摘抄了部分重点配置）：
<?xml version="1.0" encoding="UTF-8"?>
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starters</artifactId>
<version>2.2.6.RELEASE</version>
</parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
<version>2.2.6.RELEASE</version>
<name>Spring Boot Web Starter</name>
<description>Starter for building web, including RESTful, applications using Spring
MVC. Uses Tomcat as the default embedded container</description>
<url>https://projects.spring.io/spring-boot/#/spring-boot-parent/spring-boot-starters/spring-boot-starter-web</url>
<organization>
<name>Pivotal Software, Inc.</name>
<url>https://spring.io</url>
</organization>
<licenses>
<license>
<name>Apache License, Version 2.0</name>
<url>https://www.apache.org/licenses/LICENSE-2.0</url>
</license>
</licenses>
<developers>
<developer>
<name>Pivotal</name>
<email>info@pivotal.io</email>
<organization>Pivotal Software, Inc.</organization>
<organizationUrl>https://www.spring.io</organizationUrl>
</developer>
</developers>
<scm>
<connection>scm:git:git://github.com/spring-projects/spring-boot.git</connection>
<developerConnection>scm:git:ssh://git@github.com/spring-projects/spring-boot.git</developerConnection>
<url>https://github.com/spring-projects/spring-boot</url>
</scm>
<issueManagement>
<system>Github</system>
<url>https://github.com/spring-projects/spring-boot/issues</url>
</issueManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<version>2.2.6.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-json</artifactId>
<version>2.2.6.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<version>2.2.6.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
<version>2.2.6.RELEASE</version>
<scope>compile</scope>
<exclusions>
<exclusion>
<artifactId>tomcat-embed-el</artifactId>
<groupId>org.apache.tomcat.embed</groupId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.2.5.RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.5.RELEASE</version>
<scope>compile</scope>
</dependency>
</dependencies>
</project>
从上面的spring-boot-starter-web的pom.xml中我们可以发现，spring-boot-starter-web就是将web开发要使用的spring-web、spring-webmvc等坐标进行了“打包”，这样我们的工程只要引入spring-boot-starter-web起步依赖的坐标就可以进行web开发了，同样体现了依赖传递的作用。
