给你一份Spring Boot核心知识清单①-2
Posted
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了给你一份Spring Boot核心知识清单①-2相关的知识,希望对你有一定的参考价值。
由于博客字数限制,不允许发大于20w个字符的文章,所以需要分成两篇,接上文
五、出神入化:揭秘自动配置原理
典型的Spring Boot应用的启动类一般均位于 src/main/java
根路径下,比如 MoonApplication
类:
@SpringBootApplication public class MoonApplication { public static void main(String[] args) { SpringApplication.run(MoonApplication.class, args); } }
其中 @SpringBootApplication
开启组件扫描和自动配置,而 SpringApplication.run
则负责启动引导应用程序。 @SpringBootApplication
是一个复合 Annotation
,它将三个有用的注解组合在一起:
@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 { // ...... }
@SpringBootConfiguration
就是 @Configuration
,它是Spring框架的注解,标明该类是一个 JavaConfig
配置类。而 @ComponentScan
启用组件扫描,前文已经详细讲解过,这里着重关注 @EnableAutoConfiguration
。
@EnableAutoConfiguration
注解表示开启Spring Boot自动配置功能,Spring Boot会根据应用的依赖、自定义的bean、classpath下有没有某个类 等等因素来猜测你需要的bean,然后注册到IOC容器中。那 @EnableAutoConfiguration
是如何推算出你的需求?首先看下它的定义:
@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @AutoConfigurationPackage @Import(EnableAutoConfigurationImportSelector.class) public @interface EnableAutoConfiguration { // ...... }
你的关注点应该在 @Import(EnableAutoConfigurationImportSelector.class)
上了,前文说过, @Import
注解用于导入类,并将这个类作为一个bean的定义注册到容器中,这里它将把 EnableAutoConfigurationImportSelector
作为bean注入到容器中,而这个类会将所有符合条件的@Configuration配置都加载到容器中,看看它的代码:
public String[] selectImports(AnnotationMetadata annotationMetadata) { // 省略了大部分代码,保留一句核心代码 // 注意:SpringBoot最近版本中,这句代码被封装在一个单独的方法中 // SpringFactoriesLoader相关知识请参考前文 List<String> factories = new ArrayList<String>(new LinkedHashSet<String>( SpringFactoriesLoader.loadFactoryNames(EnableAutoConfiguration.class, this.beanClassLoader))); }
这个类会扫描所有的jar包,将所有符合条件的@Configuration配置类注入的容器中,何为符合条件,看看 META-INF/spring.factories
的文件内容:
// 来自 org.springframework.boot.autoconfigure下的META-INF/spring.factories // 配置的key = EnableAutoConfiguration,与代码中一致 org.springframework.boot.autoconfigure.EnableAutoConfiguration=org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration.....
以 DataSourceAutoConfiguration
为例,看看Spring Boot是如何自动配置的:
@Configuration @ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class }) @EnableConfigurationProperties(DataSourceProperties.class) @Import({ Registrar.class, DataSourcePoolMetadataProvidersConfiguration.class }) public class DataSourceAutoConfiguration { }
分别说一说:
@ConditionalOnClass({DataSource.class,EmbeddedDatabaseType.class})
:当Classpath中存在DataSource或者EmbeddedDatabaseType类时才启用这个配置,否则这个配置将被忽略。@EnableConfigurationProperties(DataSourceProperties.class)
:将DataSource的默认配置类注入到IOC容器中,DataSourceproperties定义为:
// 提供对datasource配置信息的支持,所有的配置前缀为:spring.datasource @ConfigurationProperties(prefix = "spring.datasource") public class DataSourceProperties { private ClassLoader classLoader; private Environment environment; private String name = "testdb"; ...... }
@Import({Registrar.class,DataSourcePoolMetadataProvidersConfiguration.class})
:导入其他额外的配置,就以DataSourcePoolMetadataProvidersConfiguration
为例吧。
@Configuration public class DataSourcePoolMetadataProvidersConfiguration { @Configuration @ConditionalOnClass(org.apache.tomcat.jdbc.pool.DataSource.class) static class TomcatDataSourcePoolMetadataProviderConfiguration { @Bean public DataSourcePoolMetadataProvider tomcatPoolDataSourceMetadataProvider() { ..... } } ...... }
DataSourcePoolMetadataProvidersConfiguration是数据库连接池提供者的一个配置类,即Classpath中存在 org.apache.tomcat.jdbc.pool.DataSource.class
,则使用tomcat-jdbc连接池,如果Classpath中存在 HikariDataSource.class
则使用Hikari连接池。
这里仅描述了DataSourceAutoConfiguration的冰山一角,但足以说明Spring Boot如何利用条件话配置来实现自动配置的。回顾一下, @EnableAutoConfiguration
中导入了EnableAutoConfigurationImportSelector类,而这个类的 selectImports()
通过SpringFactoriesLoader得到了大量的配置类,而每一个配置类则根据条件化配置来做出决策,以实现自动配置。
整个流程很清晰,但漏了一个大问题: EnableAutoConfigurationImportSelector.selectImports()
是何时执行的?其实这个方法会在容器启动过程中执行: AbstractApplicationContext.refresh()
,更多的细节在下一小节中说明。
六、启动引导:Spring Boot应用启动的秘密
6.1 SpringApplication初始化
SpringBoot整个启动流程分为两个步骤:初始化一个SpringApplication对象、执行该对象的run方法。看下SpringApplication的初始化流程,SpringApplication的构造方法中调用initialize(Object[] sources)方法,其代码如下:
private void initialize(Object[] sources) { if (sources != null && sources.length > 0) { this.sources.addAll(Arrays.asList(sources)); } // 判断是否是Web项目 this.webEnvironment = deduceWebEnvironment(); setInitializers((Collection) getSpringFactoriesInstances(ApplicationContextInitializer.class)); setListeners((Collection) getSpringFactoriesInstances(ApplicationListener.class)); // 找到入口类 this.mainApplicationClass = deduceMainApplicationClass(); }
初始化流程中最重要的就是通过SpringFactoriesLoader找到 spring.factories
文件中配置的 ApplicationContextInitializer
和 ApplicationListener
两个接口的实现类名称,以便后期构造相应的实例。 ApplicationContextInitializer
的主要目的是在 ConfigurableApplicationContext
做refresh之前,对ConfigurableApplicationContext实例做进一步的设置或处理。ConfigurableApplicationContext继承自ApplicationContext,其主要提供了对ApplicationContext进行设置的能力。
实现一个ApplicationContextInitializer非常简单,因为它只有一个方法,但大多数情况下我们没有必要自定义一个ApplicationContextInitializer,即便是Spring Boot框架,它默认也只是注册了两个实现,毕竟Spring的容器已经非常成熟和稳定,你没有必要来改变它。
而 ApplicationListener
的目的就没什么好说的了,它是Spring框架对Java事件监听机制的一种框架实现,具体内容在前文Spring事件监听机制这个小节有详细讲解。这里主要说说,如果你想为Spring Boot应用添加监听器,该如何实现?
Spring Boot提供两种方式来添加自定义监听器:
通过
SpringApplication.addListeners(ApplicationListener<?>...listeners)
或者SpringApplication.setListeners(Collection<?extendsApplicationListener<?>>listeners)
两个方法来添加一个或者多个自定义监听器既然SpringApplication的初始化流程中已经从
spring.factories
中获取到ApplicationListener
的实现类,那么我们直接在自己的jar包的META-INF/spring.factories
文件中新增配置即可:
org.springframework.context.ApplicationListener=cn.moondev.listeners.xxxxListener\
关于SpringApplication的初始化,我们就说这么多。
6.2 Spring Boot启动流程
Spring Boot应用的整个启动流程都封装在SpringApplication.run方法中,其整个流程真的是太长太长了,但本质上就是在Spring容器启动的基础上做了大量的扩展,按照这个思路来看看源码:
public ConfigurableApplicationContext run(String... args) { StopWatch stopWatch = new StopWatch(); stopWatch.start(); ConfigurableApplicationContext context = null; FailureAnalyzers analyzers = null; configureHeadlessProperty(); // ① SpringApplicationRunListeners listeners = getRunListeners(args); listeners.starting(); try { // ② ApplicationArguments applicationArguments = new DefaultApplicationArguments(args); ConfigurableEnvironment environment = prepareEnvironment(listeners,applicationArguments); // ③ Banner printedBanner = printBanner(environment); // ④ context = createApplicationContext(); // ⑤ analyzers = new FailureAnalyzers(context); // ⑥ prepareContext(context, environment, listeners, applicationArguments,printedBanner); // ⑦ refreshContext(context); // ⑧ afterRefresh(context, applicationArguments); // ⑨ listeners.finished(context, null); stopWatch.stop(); return context; } catch (Throwable ex) { handleRunFailure(context, listeners, analyzers, ex); throw new IllegalStateException(ex); } }
① 通过SpringFactoriesLoader查找并加载所有的 SpringApplicationRunListeners
,通过调用starting()方法通知所有的SpringApplicationRunListeners:应用开始启动了。SpringApplicationRunListeners其本质上就是一个事件发布者,它在SpringBoot应用启动的不同时间点发布不同应用事件类型(ApplicationEvent),如果有哪些事件监听者(ApplicationListener)对这些事件感兴趣,则可以接收并且处理。还记得初始化流程中,SpringApplication加载了一系列ApplicationListener吗?这个启动流程中没有发现有发布事件的代码,其实都已经在SpringApplicationRunListeners这儿实现了。
简单的分析一下其实现流程,首先看下SpringApplicationRunListener的源码:
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)); }
顺着这个逻辑,你可以在②处的 prepareEnvironment()
方法的源码中找到 listeners.environmentPrepared(environment);
即SpringApplicationRunListener接口的第二个方法,那不出你所料, environmentPrepared()
又发布了另外一个事件 ApplicationEnvironmentPreparedEvent
。接下来会发生什么,就不用我多说了吧。
② 创建并配置当前应用将要使用的 Environment
,Environment用于描述应用程序当前的运行环境,其抽象了两个方面的内容:配置文件(profile)和属性(properties),开发经验丰富的同学对这两个东西一定不会陌生:不同的环境(eg:生产环境、预发布环境)可以使用不同的配置文件,而属性则可以从配置文件、环境变量、命令行参数等来源获取。因此,当Environment准备好后,在整个应用的任何时候,都可以从Environment中获取资源。
总结起来,②处的两句代码,主要完成以下几件事:
判断Environment是否存在,不存在就创建(如果是web项目就创建
StandardServletEnvironment
,否则创建StandardEnvironment
)配置Environment:配置profile以及properties
调用SpringApplicationRunListener的
environmentPrepared()
方法,通知事件监听者:应用的Environment已经准备好
③、SpringBoot应用在启动时会输出这样的东西:
. ____ _ __ _ _ /\\ / ___‘_ __ _ _(_)_ __ __ _ \ \ \ ( ( )\___ | ‘_ | ‘_| | ‘_ \/ _` | \ \ \ \\/ ___)| |_)| | | | | || (_| | ) ) ) ) ‘ |____| .__|_| |_|_| |_\__, | / / / / =========|_|==============|___/=/_/_/_/ :: Spring Boot :: (v1.5.6.RELEASE)
如果想把这个东西改成自己的涂鸦,你可以研究以下Banner的实现,这个任务就留给你们吧。
④、根据是否是web项目,来创建不同的ApplicationContext容器。
⑤、创建一系列 FailureAnalyzer
,创建流程依然是通过SpringFactoriesLoader获取到所有实现FailureAnalyzer接口的class,然后在创建对应的实例。FailureAnalyzer用于分析故障并提供相关诊断信息。
⑥、初始化ApplicationContext,主要完成以下工作:
将准备好的Environment设置给ApplicationContext
遍历调用所有的ApplicationContextInitializer的
initialize()
方法来对已经创建好的ApplicationContext进行进一步的处理调用SpringApplicationRunListener的
contextPrepared()
方法,通知所有的监听者:ApplicationContext已经准备完毕将所有的bean加载到容器中
调用SpringApplicationRunListener的
contextLoaded()
方法,通知所有的监听者:ApplicationContext已经装载完毕
⑦、调用ApplicationContext的 refresh()
方法,完成IoC容器可用的最后一道工序。从名字上理解为刷新容器,那何为刷新?就是插手容器的启动,联系一下第一小节的内容。那如何刷新呢?且看下面代码:
// 摘自refresh()方法中一句代码 invokeBeanFactoryPostProcessors(beanFactory);
看看这个方法的实现:
protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) { PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors()); ...... }
获取到所有的 BeanFactoryPostProcessor
来对容器做一些额外的操作。BeanFactoryPostProcessor允许我们在容器实例化相应对象之前,对注册到容器的BeanDefinition所保存的信息做一些额外的操作。这里的getBeanFactoryPostProcessors()方法可以获取到3个Processor:
ConfigurationWarningsApplicationContextInitializer$ConfigurationWarningsPostProcessor SharedMetadataReaderFactoryContextInitializer$CachingMetadataReaderFactoryPostProcessor ConfigFileApplicationListener$PropertySourceOrderingPostProcessor
不是有那么多BeanFactoryPostProcessor的实现类,为什么这儿只有这3个?因为在初始化流程获取到的各种ApplicationContextInitializer和ApplicationListener中,只有上文3个做了类似于如下操作:
public void initialize(ConfigurableApplicationContext context) { context.addBeanFactoryPostProcessor(new ConfigurationWarningsPostProcessor(getChecks())); }
然后你就可以进入到 PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors()
方法了,这个方法除了会遍历上面的3个BeanFactoryPostProcessor处理外,还会获取类型为 BeanDefinitionRegistryPostProcessor
的bean: org.springframework.context.annotation.internalConfigurationAnnotationProcessor
,对应的Class为 ConfigurationClassPostProcessor
。 ConfigurationClassPostProcessor
用于解析处理各种注解,包括:@Configuration、@ComponentScan、@Import、@PropertySource、@ImportResource、@Bean。当处理 @import
注解的时候,就会调用<自动配置>这一小节中的 EnableAutoConfigurationImportSelector.selectImports()
来完成自动配置功能。其他的这里不再多讲,如果你有兴趣,可以查阅参考资料6。
⑧、查找当前context中是否注册有CommandLineRunner和ApplicationRunner,如果有则遍历执行它们。
⑨、执行所有SpringApplicationRunListener的finished()方法。
这就是Spring Boot的整个启动流程,其核心就是在Spring容器初始化并启动的基础上加入各种扩展点,这些扩展点包括:ApplicationContextInitializer、ApplicationListener以及各种BeanFactoryPostProcessor等等。你对整个流程的细节不必太过关注,甚至没弄明白也没有关系,你只要理解这些扩展点是在何时如何工作的,能让它们为你所用即可。
整个启动流程确实非常复杂,可以查询参考资料中的部分章节和内容,对照着源码,多看看,我想最终你都能弄清楚的。言而总之,Spring才是核心,理解清楚Spring容器的启动流程,那Spring Boot启动流程就不在话下了。
参考资料
[1] 王福强 著;SpringBoot揭秘:快速构建微服务体系; 机械工业出版社, 2016
[2] 王福强 著;Spring揭秘; 人民邮件出版社, 2009
[3] Craig Walls 著;丁雪丰 译;Spring Boot实战;中国工信出版集团 人民邮电出版社,2016
[4] 深入探讨 Java 类加载器
[6] spring boot实战:Spring boot Bean加载源码分析
本文出自 “迷失的月亮” 博客,请务必保留此出处http://luecsc.blog.51cto.com/2219432/1964057
以上是关于给你一份Spring Boot核心知识清单①-2的主要内容,如果未能解决你的问题,请参考以下文章
干货!没学过 Spring Boot ?送你一份超详细的知识清单