Spring学习记录 Day9（Spring Boot拓展）

雨点打透心脏的1/2处 2021-11-05 21:02 285阅读 0赞

### 文章目录 ###

*  Day 9
 *  Spring Boot运行原理探究
 *   *  前言
     *  探究
     *   *  探究：pom.xml
         *  探究：启动器
         *  探究：主程序
         *  探究：@SpringBootApplication
         *  探究：@SpringBootConfiguration
         *  探究：@EnableAutoConfiguration
         *  探究：AutoConfigurationImportSelector
         *  探究：Spring.factories
 *  Run
 *   *  SpringApplication的实例化
     *  run方法的执行

# Day 9 #

2019年8月9日。  
这是我学习Spring的第九天。  
这一天，我学到了以下的知识。

# Spring Boot运行原理探究 #

## 前言 ##

之前在这篇博客中：[https://blog.csdn.net/qq\_41151659/article/details/98849882][https_blog.csdn.net_qq_41151659_article_details_98849882]  
编写的“Hello,SpringBoot!”，我们没有像以前写Spring MVC一样，写过任何的配置文件。仅仅是写了一个简单的控制类，便可以实现相等的效果，这是如何实现的呢？

## 探究 ##

### 探究：pom.xml ###

在Maven项目中，存在有一个特殊的配置文件：pom.xml。该文件保存有项目的相关配置，包括项目的信息、依赖的注入、构建的环境等。  
为了研究Spring Boot的运行原理，第一步应该就从这个文件开始。默认的pom.xml文件代码如下：

<?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.1.7.RELEASE</version>
            <relativePath/> 
        </parent>
        <groupId>com.example</groupId>
        <artifactId>demo</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <name>demo</name>
        <description>Demo project for Spring Boot</description>
    
        <properties>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>

其中，最重要的信息当属<parent.>标签中的信息。该标签类似于Java中的继承，而该项目便是继承名为spring-boot-starter-parent文件的信息，代码如下：

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

查看该文件（将光标悬停在该行上，按下ctrl+鼠标左键即可进入该文件），可以进入到spring-boot-starter-parent-2.1.7.RELEASE.pom文件中，如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70]  
从图中可以看出，该文件同样也继承了一个文件：spring-boot-dependencies。可以进入该文件查看，发现该文件正如其名：配置了多个注入依赖的信息。  
由此可知，spring-boot-starter-parent就是**真正管理Spring Boot应用里面所有依赖版本的地方，同时也是Spring Boot的版本控制中心**  
也就是说，以后需要导入依赖的时候，默认不需要再添加版本。**但是如果导入的包没有在依赖中管理，仍然需要手动配置版本**

### 探究：启动器 ###

我们继续观察pom.xml代码，可以找到从这个文件中注入的依赖，代码如下：

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

见字知意，由该段代码可以得知：

*  **springboot-boot-starter-web**：spring-boot的场景启动器
 *  springboot-boot-starter-test：测试spring-boot的场景启动器

其中，spring-boot-starter-web 还帮我们**导入了web模块正常运行所依赖的组件**；

**总结：SpringBoot将所有的功能场景都抽取出来，做成一个个的starter （启动器），只需要在项目中引入这些starter即可，所有相关的依赖都会导入进来 ， 我们要用什么功能，就导入什么样的场景启动器即可 ；**

### 探究：主程序 ###

研究完pom.xml后，我们将目光投向项目创建时默认生成的类（启动类）。这里因为创建项目时用的都是默认信息，所以该类在我的项目中的名字是DemoApplication.java（每个人的类名可能会有不同），该类代码如下：

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

其中：

*  `@SpringBootApplication`：来标注一个主程序类 ， 说明这是一个Spring Boot应用
 *  `SpringApplication.run(DemoApplication.class, args)`：用于启动Spring应用

这个表面上看起来很简单的类，竟然只用短短一行代码就可以完成Spring应用的配置以及启动，那它到底是怎么做到的呢？这就需要我们继续去探究下去。

### 探究：@SpringBootApplication ###

老办法，遇到不会的东西，就直接进入源文件查看。这里我们使用之前的方法，进入该文件查看，如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 1]  
可以看到，除了默认的四种注解（`@Target({ElementType.TYPE})`，`@Retention(RetentionPolicy.RUNTIME)`，`@Documented`，`@Inherited`）之外，还有一些自定义的注解，说明如下：

*  `@SpringBootConfiguration`：标注在某个类上，表示这个类是一个Spring Boot的配置类
 *  `@EnableAutoConfiguration`：开启自动配置功能，以前我们需要手动配置的东西，SpringBoot可以自动帮我们配置 ；该注解会告诉SpringBoot开启自动配置功能，这样自动配置才能生效；
 *  `@ComponentScan`：**这个注解在Spring中很重要**，它对应XML配置中的元素。该注解的功能就是自动扫描并加载符合条件的组件或者bean，并将这个bean定义加载到IOC容器中
 *  `@Filter`：这个注解对应着过滤器的相关配置

接下来，我们将对其中几个注解进行更深入的研究。

### 探究：@SpringBootConfiguration ###

进入该注解的源文件进行查看，可以查看到如下的信息，如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 2]  
可以看到，除了默认的注解之外， 该注解上还标识着一个自定义的注解  
`@Configuration`：在配置类上来标注这个注解，用以配置类或者配置文件。  
继续查看该注解的源代码，可以查看到如下的信息，如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 3]  
由图中可以看出，该注解上标识了一个我们在Spring中常见的注解`@component`，说明配置类也是容器中的一个组件  
至此，我们探究完了`@SpringBootConfiguration`，需要去探究另一个`@EnableAutoConfiguration`

### 探究：@EnableAutoConfiguration ###

现在回到SpringBootApplication注解中，查看这个注解，如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 4]  
`@EnableAutoConfiguration` ：开启自动配置功能  
以前我们需要配置的东西，Spring Boot可以自动帮我们配置 ； `@EnableAutoConfiguration`会告诉Spring Boot开启**自动配置**功能，这样自动配置才能生效；  
按照老办法，点击这个注释，查看该注释文件的信息，如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 5]  
`@AutoConfigurationPackage` ：自动配置包  
继续点进去，会看到一个 `@Import({Registrar.class})`，如图所示：  
![在这里插入图片描述][2019080916245742.png]  
`@import` ：Spring底层注解@import，给容器中导入一个组件，导入的组件由 \{ **Registrar.class**\} 将主配置类 【即`@SpringBootApplication`标注的类】的所在包及包下面所有子包里面的所有组件扫描到Spring容器 ；

现在回到EnableAutoConfiguration中，对其他两个注释作出说明：

*  `@Import({AutoConfigurationImportSelector.class})` ：给容器导入组件
 *  `AutoConfigurationImportSelector` ： 导入哪些组件的选择器

**它将所有需要导入的组件以全类名的方式返回 ， 这些组件就会被添加到容器中** ；

它会给容器中导入非常多的自动配置类 （xxxAutoConfiguration）, 就是给容器中导入这个场景需要的所有组件，并配置好这些组件 ；

**有了自动配置类，就免去了我们手动编写配置注入功能组件等的工作**；

为了获悉底层更多的细节，需要我们更进一步去AutoConfigurationImportSelector类中查看相应的代码

### 探究：AutoConfigurationImportSelector ###

进入AutoConfigurationImportSelector类，可以在该类中找到以下的代码：

//AutoConfigurationImportSelector中获取配置文件信息；
    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;
    }

我们将注意力投到该方法中的：

List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
             getBeanClassLoader());

这里的getSpringFactoriesLoaderFactoryClass（）方法返回的就是**我们最开始看的启动自动导入配置文件的注解类**，代码如下：

protected Class<?> getSpringFactoriesLoaderFactoryClass() { 
            return EnableAutoConfiguration.class;
        }

这就说明了这个**SpringFactoriesLoader**类与底层实现有重大联系，我们现在点进这个类查看，可以发现这个类的一个特殊变量String FACTORIES\_RESOURCE\_LOCATION，如图所示：  
![在这里插入图片描述][20190809163851421.png]  
之后，还会发现对应的方法：该方法最终会读取一个配置文件：META-INF/Spring.factories，代码如下：

public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) { 
            String factoryClassName = factoryClass.getName();
            return (List)loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
        }
    
        private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) { 
            MultiValueMap<String, String> result = (MultiValueMap)cache.get(classLoader);
            if (result != null) { 
                return result;
            } else { 
                try { 
                    Enumeration<URL> urls = classLoader != null ? classLoader.getResources("META-INF/spring.factories") : ClassLoader.getSystemResources("META-INF/spring.factories");
                    LinkedMultiValueMap result = new LinkedMultiValueMap();
    
                    while(urls.hasMoreElements()) { 
                        URL url = (URL)urls.nextElement();
                        UrlResource resource = new UrlResource(url);
                        Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                        Iterator var6 = properties.entrySet().iterator();
    
                        while(var6.hasNext()) { 
                            Entry<?, ?> entry = (Entry)var6.next();
                            String factoryClassName = ((String)entry.getKey()).trim();
                            String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                            int var10 = var9.length;
    
                            for(int var11 = 0; var11 < var10; ++var11) { 
                                String factoryName = var9[var11];
                                result.add(factoryClassName, factoryName.trim());
                            }
                        }
                    }
    
                    cache.put(classLoader, result);
                    return result;
                } catch (IOException var13) { 
                    throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
                }
            }
        }

**终于，我们找到了一切的源头：即META-INF/Spring.factories**

### 探究：Spring.factories ###

我们在项目目录下的“External Libraries”目录下可以找到这个文件，如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 6]  
通过以上的推论，我们可以得出大致的结论：

*  **SpringBoot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值，将这些值作为自动配置类导入容器 ， 自动配置类就生效 ， 帮我们进行自动配置工作；**
 *  **以前我们需要自己配置的东西 ， 自动配置类都帮我们解决了**
 *  **整个J2EE的整体解决方案和自动配置都在springboot-autoconfigure的jar包中；**

我们随意打开一个，例如WebMvcAutoConfiguration，可以看到该类具有`@Configuration`和`@Bean`注释，如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 7]

--------------------

*总结*  
所以，真正实现是从classpath中搜寻所有的META-INF/spring.factories配置文件 ，并将其中对应的 org.springframework.boot.autoconfigure. 包下的配置项通过反射实例化为对应标注了 @Configuration的JavaConfig形式的IOC容器配置类 ， 然后将这些都汇总成为一个实例并加载到IOC容器中  
*分析路线*  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 8]  
路线图：[https://www.processon.com/view/link/5d4cedc3e4b08b95b817a312\#map][https_www.processon.com_view_link_5d4cedc3e4b08b95b817a312_map]

# Run #

分析完了Spring Boot的运行原理，现在需要进一步理解Spring Boot是如何执行的，我们将目光放到默认创建出来的启动类，代码如下：

@SpringBootApplication
    public class SpringbootDemo02Application { 
    
        public static void main(String[] args) { 
            //该方法返回一个ConfigurableApplicationContext对象
            //参数一：应用入口的类 参数类：命令行参数
            SpringApplication.run(SpringbootDemo02Application.class, args);
        }
    
    }

其中，需要对`SpringApplication.run(SpringbootDemo02Application.class, args);`这个方法进行分析，而分析这个方法分为两部分：

*  SpringApplication的实例化
 *  run方法的执行

## SpringApplication的实例化 ##

需要经历以下几个步骤：

1.  推断应用的类型是普通的项目还是Web项目
2.  查找并加载所有可用初始化器 ， 设置到initializers属性中
3.  找出所有的应用程序监听器，设置到listeners属性中
4.  推断并设置main方法的定义类，找到运行的主类

对应代码如下：

public SpringApplication(ResourceLoader resourceLoader, Class... primarySources) { 
            this.sources = new LinkedHashSet();
            this.bannerMode = Mode.CONSOLE;
            this.logStartupInfo = true;
            this.addCommandLineProperties = true;
            this.addConversionService = true;
            this.headless = true;
            this.registerShutdownHook = true;
            this.additionalProfiles = new HashSet();
            this.isCustomEnvironment = false;
            this.resourceLoader = resourceLoader;
            Assert.notNull(primarySources, "PrimarySources must not be null");
            this.primarySources = new LinkedHashSet(Arrays.asList(primarySources));
            this.webApplicationType = WebApplicationType.deduceFromClasspath();
            this.setInitializers(this.getSpringFactoriesInstances(ApplicationContextInitializer.class));
            this.setListeners(this.getSpringFactoriesInstances(ApplicationListener.class));
            this.mainApplicationClass = this.deduceMainApplicationClass();
        }

## run方法的执行 ##

示意图如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 9]

[https_blog.csdn.net_qq_41151659_article_details_98849882]: https://blog.csdn.net/qq_41151659/article/details/98849882
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70]: /images/20211104/b7b9ef55b8e040ee858bc86e0a423044.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 1]: /images/20211104/ebc12bb5b0a74362b5c49211e2f4ed68.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 2]: /images/20211104/55a6a6ce109c4519aad2e460e05077ee.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 3]: /images/20211104/7bd92f515ca347cabda90f67c7b2744a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 4]: /images/20211104/a2e2993deb714a08b0d38a0ad20d93bf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 5]: /images/20211104/faca0585983947a9b862b54cf4367617.png
[2019080916245742.png]: /images/20211104/a8a6a2dbec8a46ef9e9ea9b3a181f1a1.png
[20190809163851421.png]: /images/20211104/e93638c40cd44abb8a9e5824872de1f0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 6]: /images/20211104/e518ad46c3224d84b3c000dc6060bbec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 7]: /images/20211104/65ac6faf67b748e4ac45470e9871e065.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 8]: /images/20211104/f59b35f67f9a464eb9c300d69fd20c2e.png
[https_www.processon.com_view_link_5d4cedc3e4b08b95b817a312_map]: https://www.processon.com/view/link/5d4cedc3e4b08b95b817a312#map
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMTUxNjU5_size_16_color_FFFFFF_t_70 9]: /images/20211104/3eaf314f26eb4ffb800ccc7adf94bd6f.png