Spring Boot组合集成原理浅析实战

相信大家都用过Spring组件，也对Spring AOP和Spring MVC有一定了解，笔者之前的博文:Spring AOP实践指南:

Spring MVC使用原理详解及说明:

都介绍了Spring的部分组件，笔者系列博文都是围绕Spring这个大家族来进行分享的。

一、Spring基础

1.1Spring IOC

上面的图展示是spring IOC相关的类：

BeanDefinition:容器中每一个bean都有一个相对应的BeanDefinition实例，该实例负责保存bean对象的所有必要信息，包括bean对象的class类型、是否是抽象类、构造方法和参数、其它属性等等。当客户端向容器请求相应对象时，容器就会通过这些信息为客户端返回一个完整可用的bean实例。

BeanDefinitionRegistry:抽象出bean的注册逻辑，bean对象对应的

BeanDefinition实例会在BeanDefinitionRegistry中进行注册。

BeanFactory：抽象出了bean的管理逻辑，而各个BeanFactory的实现类就具体承担了bean的注册以及管理工作

DefaultListableBeanFactory作为一个比较通用的BeanFactory实现，它同时也实现了BeanDefinitionRegistry接口，因此它就承担了Bean的注册管理工作。从图中也可以看出，BeanFactory接口中主要包含getBean、containBean、getType、getAliases等管理bean的方法，而BeanDefinitionRegistry接口则包含registerBeanDefinition、removeBeanDefinition、getBeanDefinition等注册管理BeanDefinition的方法。

其源码:

// 默认容器实现

DefaultListableBeanFactory beanRegistry = new DefaultListableBeanFactory();

// 根据业务对象构造相应的BeanDefinition

AbstractBeanDefinition definition = new RootBeanDefinition(Business.class,true);

// 将bean定义注册到容器中

beanRegistry.registerBeanDefinition(“beanName”,definition);

// 如果有多个bean，还可以指定各个bean之间的依赖关系

// ……..

// 然后可以从容器中获取这个bean的实例

// 注意：这里的beanRegistry其实实现了BeanFactory接口，所以可以强转，

// 单纯的BeanDefinitionRegistry是无法强制转换到BeanFactory类型的

BeanFactory container = (BeanFactory)beanRegistry;

Business business = (Business)container.getBean(“beanName”);

（1）IOC之容器启动阶段

这个阶段主要会进行：加载配置文件并解析，然后将解析后的数据封装为BeanDefinition实例，最后把这些保存了bean定义的BeanDefinition，注册到相应的BeanDefinitionRegistry，这样容器的启动工作就完成了。当然这个过程还包含了其他很多操作。

（2）IOC之容器实例化阶段

当某个请求通过容器的getBean方法请求某个对象，或者因为依赖关系容器需要隐式的调用getBean时，就会触发第二阶段的活动：容器会首先检查所请求的对象之前是否已经实例化完成。如果没有，则会根据注册的BeanDefinition所提供的信息实例化被请求对象，并为其注入依赖。当该对象装配完毕后，容器会立即将其返回给请求方法使用。

而在实际场景下，我们更多的使用另外一种类型的容器：ApplicationContext，它构建在BeanFactory之上，属于更高级的容器，除了具有BeanFactory的所有能力之外，还提供对事件监听机制以及国际化的支持等。它管理的bean，在容器启动时全部完成初始化和依赖注入操作。

二、Spring扩展机制

回顾Spring的生命周期:

IoC容器负责管理容器中所有bean的生命周期，而在bean生命周期的不同阶段，Spring提供了不同的扩展点来改变bean的命运

（1）BeanFactoryPostProcessor（容器启动阶段）

BeanFactory的前置处理器，允许我们在容器实例化相应对象之前，对注册到容器的BeanDefinition所保存的信息做一些额外的操作，比如修改bean定义的某些属性或者增加其他信息等。

@FunctionalInterface

public interface BeanFactoryPostProcessor {

//所有bean已经加载但是没有实例化之前

void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException;

}

（2）BeanPostProcessor（bean对象实例化阶段）

会处理容器内所有符合条件并且已经实例化后的对象

public interface BeanPostProcessor {

// 前置处理

Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;

// 后置处理

Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;

}

（3）Aware接口

其作用就是在对象实例化完成以后将Aware接口定义中规定的依赖注入到当前实例中。比如最常见的ApplicationContextAware接口，实现了这个接口的类都可以获取到一个ApplicationContext对象。当容器中每个对象的实例化过程走到BeanPostProcessor前置处理这一步时，容器会检测到之前注册到容器的ApplicationContextAwareProcessor，然后就会调用其postProcessBeforeInitialization()方法，检查并设置Aware相关依赖

2.1Spring事件监听

在服务器端，事件的监听机制更多的用于异步通知以及监控和异常处理。Java提供了实现事件监听机制的两个基础类：自定义事件类型扩展自java.util.EventObject、事件的监听器扩展自java.util.EventListener。

Spring的ApplicationContext容器内部中的所有事件类型均继承自org.springframework.context.AppliationEvent，容器中的所有监听器都实现org.springframework.context.ApplicationListener接口，并且以bean的形式注册在容器中。一旦在容器内发布ApplicationEvent及其子类型的事件，注册到容器的ApplicationListener就会对这些事件进行处理。

（1）ApplicationEvent继承自EventObject，Spring提供了一些默认的实现，比如：ContextClosedEvent表示容器在即将关闭时发布的事件类型，ContextRefreshedEvent表示容器在初始化或者刷新的时候发布的事件类型

（2）容器内部使用ApplicationListener作为事件监听器接口定义，它继承自EventListener。ApplicationContext容器在启动时，会自动识别并加载EventListener类型的bean，一旦容器内有事件发布，将通知这些注册到容器的EventListener。

（3）ApplicationContext接口继承了ApplicationEventPublisher接口，该接口提供了void publishEvent(ApplicationEvent event)方法定义，不难看出，ApplicationContext容器担当的就是事件发布者的角色ApplicationContext将事件的发布以及监听器的管理工作委托给ApplicationEventMulticaster接口的实现类。在容器启动时，会检查容器内是否存在名为applicationEventMulticaster的ApplicationEventMulticaster对象实例。如果有就使用其提供的实现，没有就默认初始化一个SimpleApplicationEventMulticaster作为实现。

三、基于Spring Boot的组合原理

3.1Spring Boot是什么

它是一个服务于spring框架的框架，能够简化配置文件，快速构建web应用，
内置tomcat，无需打包部署，直接运行。

3.2什么叫约定优于配置

maven 的目录结构

a) 默认有 resources 文件夹存放配置文件

b) 默认打包方式为 jar

spring-boot-starter-web 中默认包含 spring mvc 相关依赖以及内置的 tomcat 容器，使得构建一个 web 应用更加简单。

默认提供 application.properties/yml 文件。

默认通过 spring.profiles.active 属性来决定运行环境时读取的配置文件。

EnableAutoConfiguration 默认对于依赖的 starter 进行自动。

3.3SpringBootApplication组合注解

SpringBootApplication 本质上是由 3 个注解组成，分别是

@Configuration
@EnableAutoConfiguration
@ComponentScan
@Configuration：
在启动类里面标注了@Configuration，意味着它其实也是一个 IoC
容器的配置类

@EnableAutoConfiguration：
springboot 应用把所有符合条件的@Configuration 配置
都加载到当前 SpringBoot 创建并使用的 IoC 容器中。

@ComponentScan：
ComponentScan 默认会扫描当前 package 下的的所有加
了@Component 、@Repository、@Service、@Controller的类到 IoC 容器中；

3.4Spring Boot自动装配原理

如果是之前的spring中使用redis需要在xml定义bean,现在只需要依赖一个spring-boot-starter-data-redis的jar包,jar中定义了RedisConfiguration,当启动的时候spring会自动装载RedisConfiguration,那spring是如何知道配置类在哪里的呢?RedisConfiguration类的路径放在了classpath*META-INF/spring.factories的文件中,spring会加载这个文件中配置的configuration

（1）SpringApplication.run(AppConfig.class,args);执行流程中有refreshContext(context);这句话.

（2）refreshContext(context);内部会解析我们的配置类上的标签.实现自动装配功能的注解@EnableAutoConfiguration

（3）会解析@EnableAutoConfiguration这个注解里面的@Import引入的配置类.AutoConfigurationImportSelector

（4）AutoConfigurationImportSelector这个类中有这个方法.SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());

（5）SpringFactoriesLoader.loadFactoryNames的作用就是读取jar包中的/项目中的META-INF/spring.factories文件.

（6）spring.factories配置了要自动装配的Configuration类

3.4.1SPI机制的原理

SPI的全名为Service Provider Interface，为某个接口寻找服务实现的机制。

当服务的提供者，提供了服务接口的一种实现之后，在jar包的META-INF/services/目录里同时创建一个以服务接口命名的文件。该文件里就是实现该服务接口的具体实现类。而当外部程序装配这个模块的时候，就能通过该jar包META-INF/services/里的配置文件找到具体的实现类名，并装载实例化，完成模块的注入。通过这个约定，就不需要把服务放在代码中了，通过模块被装配的时候就可以发现服务类了。

在springboot的自动装配过程中，最终会加载META-INF/spring.factories文件，而加载的过程是由SpringFactoriesLoader加载的。从CLASSPATH下的每个Jar包中搜寻所有META-INF/spring.factories配置文件，然后将解析properties文件，找到指定名称的配置后返回。需要注意的是，其实这里不仅仅是会去ClassPath路径下查找，会扫描所有路径下的Jar包，只不过这个文件只会在Classpath下的jar包中。

通过spi技术可以自定义starter,在自定义的配置文件META-INF/spring.factories中加入实现类,依赖这个starter的项目就会扫描jar包下的配置,找到实现类进行装载实例化。

四、Spring Boot启动流程

Spring Boot应用的整个启动流程都封装在SpringApplication.run方法中，本质上其实就是在spring的基础之上做了封装，做了大量的扩张。

public ConfigurableApplicationContext run(String… args) {

StopWatch stopWatch = new StopWatch();

stopWatch.start();

ConfigurableApplicationContext context = null;

Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();

configureHeadlessProperty();

//1.通过SpringFactoriesLoader查找并加载所有的SpringApplicationRunListeners，通过调用

//starting()方法通知所有的SpringApplicationRunListeners：应用开始启动了

SpringApplicationRunListeners listeners = getRunListeners(args);

listeners.starting();

try {

//2.创建并配置当前应用将要使用的Environment

ApplicationArguments applicationArguments = new DefaultApplicationArguments(

args);

ConfigurableEnvironment environment = prepareEnvironment(listeners,

applicationArguments);

configureIgnoreBeanInfo(environment);

//3.打印banner

Banner printedBanner = printBanner(environment);

//4.根据是否是web项目，来创建不同的ApplicationContext容器

context = createApplicationContext();

//5.创建一系列FailureAnalyzer

exceptionReporters = getSpringFactoriesInstances(

SpringBootExceptionReporter.class,

new Class[] { ConfigurableApplicationContext.class }, context);

//6.初始化ApplicationContext

prepareContext(context, environment, listeners, applicationArguments,

printedBanner);

//7.调用ApplicationContext的refresh()方法,刷新容器

refreshContext(context);

//8.查找当前context中是否注册有CommandLineRunner和ApplicationRunner，如果有则遍历执行它们。

afterRefresh(context, applicationArguments);

stopWatch.stop();

if (this.logStartupInfo) {

new StartupInfoLogger(this.mainApplicationClass)

.logStarted(getApplicationLog(), stopWatch);

}

listeners.started(context);

callRunners(context, applicationArguments);

}

catch (Throwable ex) {

handleRunFailure(context, listeners, exceptionReporters, ex);

throw new IllegalStateException(ex);

}

listeners.running(context);

return context;

}

1.通过SpringFactoriesLoader查找并加载所有的SpringApplicationRunListeners，通过调用starting()方法通知所有的SpringApplicationRunListeners：应用开始启动了。（SpringApplicationRunListeners其本质上就是一个事件发布者，它在SpringBoot应用启动的不同时间点发布不同应用事件类型(ApplicationEvent)，如果有哪些事件监听者(ApplicationListener)对这些事件感兴趣，则可以接收并且处理）

看下SpringApplicationRunListeners源码：

public interface SpringApplicationRunListener {

// 运行run方法时立即调用此方法，可以用户非常早期的初始化工作

void starting();

// Environment准备好后，并且ApplicationContext创建之前调用

void environmentPrepared(ConfigurableEnvironment environment);

// ApplicationContext创建好后立即调用

void contextPrepared(ConfigurableApplicationContext context);

// ApplicationContext加载完成，在refresh之前调用

void contextLoaded(ConfigurableApplicationContext context);

// 当run方法结束之前调用

void finished(ConfigurableApplicationContext context, Throwable exception);

}

SpringApplicationRunListener只有一个实现类：EventPublishingRunListener。①处的代码只会获取到一个EventPublishingRunListener的实例，我们来看看starting()方法的内容：

public void starting() {

// 发布一个ApplicationStartedEvent

this.initialMulticaster.multicastEvent(new ApplicationStartedEvent(this.application, this.args));

}

2.创建并配置当前应用将要使用的Environment，Environment用于描述应用程序当前的运行环境，其抽象了两个方面的内容：配置文件(profile)和属性(properties)，不同的环境(eg：生产环境、预发布环境)可以使用不同的配置文件，而属性则可以从配置文件、环境变量、命令行参数等来源获取。因此，当Environment准备好后，在整个应用的任何时候，都可以从Environment中获取资源。

判断Environment是否存在，不存在就创建（如果是web项目就创建StandardServletEnvironment，否则创建StandardEnvironment）

配置Environment：配置profile以及properties

调用SpringApplicationRunListener的environmentPrepared()方法，通知事件监听者：应用的Environment已经准备好

3.打印banner（可以自定义）

4.根据是否是web项目，来创建不同的ApplicationContext容器

5.创建一系列FailureAnalyzer，创建流程依然是通过SpringFactoriesLoader获取到所有实现FailureAnalyzer接口的class，然后在创建对应的实例。FailureAnalyzer用于分析故障并提供相关诊断信息。

6.初始化ApplicationContext

将准备好的Environment设置给ApplicationContext

遍历调用所有的ApplicationContextInitializer的initialize()方法来对已经创建好的ApplicationContext进行进一步的处理

调用SpringApplicationRunListener的contextPrepared()方法，通知所有的监听者：ApplicationContext已经准备完毕

将所有的bean加载到容器中

调用SpringApplicationRunListener的contextLoaded()方法，通知所有的监听者：ApplicationContext已经装载完毕

7.调用ApplicationContext的refresh()方法,刷新容器

这里的刷新和spring中刷新原理类似，这里重点关注invokeBeanFactoryPostProcessors(beanFactory);方法，主要完成获取到所有的BeanFactoryPostProcessor来对容器做一些额外的操作，通过源可以进入到PostProcessorRegistrationDelegate类

的invokeBeanFactoryPostProcessors()方法，会获取类型为BeanDefinitionRegistryPostProcessor的beanorg.springframework.context.annotation.internalConfigurationAnnotationProcessor，对应的Class为ConfigurationClassPostProcessor。ConfigurationClassPostProcessor用于解析处理各种注解，包括：@Configuration、@ComponentScan、@Import、@PropertySource、@ImportResource、@Bean。当处理@import注解的时候，就会调用<自动配置>这一小节中的EnableAutoConfigurationImportSelector.selectImports()来完成自动配置功能

8.查找当前context中是否注册有CommandLineRunner和ApplicationRunner，如果有则 遍历执行它们。