SpringBoot原理发现（一）

说明：

本系列基于SpringBoot 2.2.9.RELEASE 版本，对SpringBoot的原理进行分析，一共分为四节：

SpringBoot原理发现（一）：创建Hello World，对pom依赖以及@SpringBootApplication注解进行分析

SpringBoot原理发现（二）：分析SpringBoot自动配置原理

SpringBoot原理发现（三）：通过主配置类main方法分析SpringBoot启动配置原理

SpringBoot原理发现（四）：了解SpringBoot启动中的几个重要回调机制

Hello World

创建Hello World，主启动类如下：

@SpringBootApplication
public class DemoApplication {

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

    @RestController
    public class HelloController{

        @GetMapping("/")
        public String helloWorld(){
            return "hello world";
        }
    }
}

1. POM文件

　1.1 父POM

<!-- 当前项目pom -->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.9.RELEASE</version>
    <relativePath/>
</parent>

<!-- spring-boot-starter-parent 的父pom -->
<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-dependencies</artifactId>
  <version>2.2.9.RELEASE</version>
  <relativePath>../../spring-boot-dependencies</relativePath>
</parent>

　　可以看出当前项目pom中的parent 依赖了 spring-boot-dependencies，而spring-boot-dependencies中管理的就是SpringBoot应用里面的所有依赖版本。（如果其中没包含，需要自定义在父pom中进行依赖）

<!-- spring-boot-dependencies 部分代码 -->
<properties>
    <activemq.version>5.15.13</activemq.version>
    <antlr2.version>2.7.7</antlr2.version>
    <appengine-sdk.version>1.9.81</appengine-sdk.version>
    <artemis.version>2.10.1</artemis.version>
    <aspectj.version>1.9.6</aspectj.version>
    <assertj.version>3.13.2</assertj.version>
    <atomikos.version>4.0.6</atomikos.version>
    <awaitility.version>4.0.3</awaitility.version>
    <bitronix.version>2.1.4</bitronix.version>
    
　　.......

　1.2  启动器

　   SpringBoot将所有的功能场景都抽取成一个个的starter，只需要依赖某个starter，便有了相关依赖信息及功能，这样的starter称之为场景启动器。

　　可以通过点击官网进行查看包含哪些starter，如下图：

　　

　　如开发web应用，只需要引入spring-boot-starter-web便有了web模块的相关功能

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

    ......

　　spring-boot-starter-web：管理了web模块需要引用的依赖文件，如下图：

<!-- spring-boot-starter-web.pom部分依赖-->
<dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter</artifactId>
      <version>2.2.9.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-json</artifactId>
      <version>2.2.9.RELEASE</version>
      <scope>compile</scope>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-tomcat</artifactId>
      <version>2.2.9.RELEASE</version>
      <scope>compile</scope>
    </dependency>

2.主程序分析

@SpringBootApplication
public class DemoApplication {

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

    @RestController
    public class HelloController{

        @GetMapping("/")
        public String helloWorld(){
            return "hello world";
        }
    }
}

　　2.1 @SpringBootApplication

　　　该注解标注在某个类上，说明这个类是SpringBoot的主配置类，SpringBoot应用应该使用这个类的main方法进行启动。

　　　进入该注解，可以看到@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 {

　　　2. 1.1 @SpringBootConfiguration

　　　　SpringBoot的配置类。进去会发现其实就是一个Spring的配置类@Configuration，而@Configuration其实就是一个组件@Component。

　　　　@SpringBootConfiguration是SpringBoot提供的，而@Configuration是Spring提供的

　　　　代码如下：

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

.....

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

　 2 .2 @EnableAutoConfiguration

　　　　作用：开启自动配置功能

　　　　所谓开启自动配置：以前需要提供各种配置文件，如包扫描等，现在使用@EnableAutoConfiguration标注，SpringBoot就会开启自动配置功能。

　　　　点开这个注解，会发现它同样是组合注解，如下：

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

　　  2.2.1 @AutoConfigurationPackage

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {

}

@Import(AutoConfigurationPackages.Registrar.class)：向容器中导入一个组件，组件由@Import后面传入的类指定

AutoConfigurationPackages.Registrar.class 关键代码如下：

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {

        @Override
        public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
            register(registry, new PackageImport(metadata).getPackageName());
        }

　　通过debug可以查看该注解是标注是在主启动类上，获取主启动类所在的包位置路径，将该路径下面的所有包扫描注入到容器中。类似spring配置文件xml中 <context:component-scan base-package="xx.yyy" />功能。

@AutoConfigurationPackage 其实就是自动获取主配置类下面的所有包并扫描注入进IOC容器中。

　　  2.2.2 @Import(AutoConfigurationImportSelector.class)

　　　　同样是往IOC容器中导入AutoConfigurationImportSelector.class中指定的组件。

　　　　AutoConfigurationImportSelector主要代码：

protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
            AnnotationMetadata annotationMetadata) {
        if (!isEnabled(annotationMetadata)) {
            return EMPTY_ENTRY;
        }
        AnnotationAttributes attributes = getAttributes(annotationMetadata);
        List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
        configurations = removeDuplicates(configurations);
        Set<String> exclusions = getExclusions(annotationMetadata, attributes);
        checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        configurations = filter(configurations, autoConfigurationMetadata);
        fireAutoConfigurationImportEvents(configurations, exclusions);
        return new AutoConfigurationEntry(configurations, exclusions);
    }

　　通过debug可以看出，它会返回各种XXXAutoConfiguration。而有了这些XXXAutoConfiguration，就不需要我们在手动去编写相关场景的注入功能组件等工作，如下图：

这些XXXAutoConfiguration又是从何而来呢？

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
                getBeanClassLoader());
        Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you "
                + "are using a custom packaging, make sure that file is correct.");
        return configurations;
    }

SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),getBeanClassLoader())
 第一个参数：EnableAutoConfiguration.class
 第二个参数：ClassLoader

进入loadFactoryNames方法，SpringBoot会扫描类路径下的META-INF/spring.factories 文件中定义的数据，并返回第一个参数EnableAutoConfiguration指定的值，并将这些值作为自动配置类导入到容器中，
 在后续该方法会经常出现，用于扫描spring.factories中定义的值，如下图：

　　

# 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.cloud.CloudServiceConnectorsAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\

......

　　至此基本上可以看出SpringBoot是如何进行加载且工作的。说到底spring的配置文件一个也没少，只是SpringBoot底层将我们的配置文件进行自动配置到容器中了，少了手动编写大量的组件配置。