上一篇我们从 run() 方法切入,分析了 Spring 容器的启动流程。今天我们拿 @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 { ......}
可以看到,@SpringBootApplication 是一个组合注解。除了最上面的几个元注解以以外,还有三个 Spring 的注解:
我们重点关注 @EnableAutoConfiguration,我们继续深入源码:
@Target(ElementType.TYPE)@Retention(RetentionPolicy.RUNTIME)@Documented@Inherited@AutoConfigurationPackage@Import(AutoConfigurationImportSelector.class)public @interface EnableAutoConfiguration { ......}
@Import 注解和 AutoConfigurationImportSelector 类是我们需要特别关注的。先剧透一下结论:自动配置的工作就是在 AutoConfigurationImportSelector 类中完成的。通过 getAutoConfigurationEntry 方法得到一个需要自动配置的列表:
protected AutoConfigurationEntry getAutoConfigurationEntry(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 = getConfigurationClassFilter().filter(configurations); fireAutoConfigurationImportEvents(configurations, exclusions); return new AutoConfigurationEntry(configurations, exclusions);}
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;}
protected Class<?> getSpringFactoriesLoaderFactoryClass() { return EnableAutoConfiguration.class;}
getCandidateConfigurations 方法会获取到 Spring 预设的自动配置列表,一共有一百多项(具体的数量不同版本可能会有差别),这个列表的名单就放在 spring-boot-autoconfigure-x.x.x.RELEASE.jar 包中的 /META-INF/spring.factories 文件中。如果我们指定了需要关闭的自动配置项,那么会通过 configurations.removeAll(exclusions) 将其从列表中移除。最后通过 filter 方法过滤掉不需要自动配置的项,最终会得到一个包含所有需要自动配置项的列表。
获取预设自动配置列表
AutoConfigurationImportSelector 类(在 getCandidateConfigurations() 方法中)通过调用 SpringFactoriesLoader 的 loadFactoryNames() 方法来读取 spring.factories 文件中的 key(org.springframework.boot.autoconfigure.EnableAutoConfiguration)来加载 Spring 预设的自动配置列表。
读取 spring.factories 文件的源码示例:
public final class SpringFactoriesLoader { // spring.factories 文件路径 public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories"; ...... public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) { ClassLoader classLoaderToUse = classLoader; if (classLoaderToUse == null) { classLoaderToUse = SpringFactoriesLoader.class.getClassLoader(); } String factoryTypeName = factoryType.getName(); // 调用真正读取 spring.factories 文件的方法 return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList()); }
private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) { ......
try { // 读取 spring.factories 文件 Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION); ...... } ...... } ......}
处理 @Import
分析完 AutoConfigurationImportSelector 类,下面来分析 @Import 注解。正是因为这个注解,ImportSelector 才能处理自动配置的逻辑。@Import 的处理逻辑是由 ConfigurationClassParser 类完成的,入口是 doProcessConfigurationClass() 方法:
class ConfigurationClassParser { ...... protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass) throws IOException {
......
// 处理 @PropertySource 注解 for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable( sourceClass.getMetadata(), PropertySources.class, org.springframework.context.annotation.PropertySource.class)) { ...... }
// 处理 @ComponentScan 注解 Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable( sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class); if (!componentScans.isEmpty() && !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) { for (AnnotationAttributes componentScan : componentScans) { Set<BeanDefinitionHolder> scannedBeanDefinitions = this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName()); ...... } }
// 处理 @Import 注解 processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
// 处理 @ImportResource 注解 AnnotationAttributes importResource = AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class); if (importResource != null) { String[] resources = importResource.getStringArray("locations"); Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader"); for (String resource : resources) { String resolvedResource = this.environment.resolveRequiredPlaceholders(resource); configClass.addImportedResource(resolvedResource, readerClass); } }
...... } ...... private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass, Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter, boolean checkForCircularImports) { ......
if (checkForCircularImports && isChainedImportOnStack(configClass)) { ...... } else { this.importStack.push(configClass); try { for (SourceClass candidate : importCandidates) { // 处理 ImportSelector if (candidate.isAssignable(ImportSelector.class)) { Class<?> candidateClass = candidate.loadClass(); ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class, this.environment, this.resourceLoader, this.registry); Predicate<String> selectorFilter = selector.getExclusionFilter(); if (selectorFilter != null) { exclusionFilter = exclusionFilter.or(selectorFilter); } if (selector instanceof DeferredImportSelector) { this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector); } else { String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata()); Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter); // 递归调用 processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false); } } else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) { ...... } else { this.importStack.registerImport( currentSourceClass.getMetadata(), candidate.getMetadata().getClassName()); processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter); } } } ...... } } }
doProcessConfigurationClass() 方法调用 processImports() 方法来处理 @Import 注解。processImports() 方法中又分情况对 @Import 注解中的值执行了不同的处理逻辑。当值为 ImportSelector.class 及其子接口/实现类(AutoConfigurationImportSelector 是 ImportSelector 的实现类 ) 时,还会通过递归再次调用自己。
这段逻辑相对比较复杂,不仅有自我递归,还有多个方法间的“串联递归”。上面代码中,进入最后一个 else 下面的 processConfigurationClass() 方法,你会看到它里面还有对 doProcessConfigurationClass() 方法的调用,这样就形成了一个调用环:doProcessConfigurationClass() -> processImports() -> processConfigurationClass() -> doProcessConfigurationClass() 。
调用链
下面是我整理的一份从 Spring 容器启动一直到自动配置功能完成的方法调用链,可以在看源码或者 Debug 的时候作为参考:
1. SpringApplication 1. run() 2. refreshContext() 3. refresh()2. AbstractApplicationContext 1. refresh() 2. invokeBeanFactoryPostProcessors()3. PostProcessorRegistrationDelegate 1. invokeBeanFactoryPostProcessors()4. ConfigurationClassPostProcessor 1. postProcessBeanDefinitionRegistry() 2. processConfigBeanDefinitions()5. ConfigurationClassParser 1. parse()6. ConfigurationClassParser.DeferredImportSelectorHandler 1. process()7. ConfigurationClassParser.DeferredImportSelectorGroupingHandler 1. processGroupImports()8. ConfigurationClassParser.DeferredImportSelectorGrouping 1. getImports()9. AutoConfigurationImportSelector.AutoConfigurationGroup 1. process()10. AutoConfigurationImportSelector 1. getAutoConfigurationEntry()
第一层级为类,其中还有几个是内部类,用“.”和主类隔开了,第二层级为该类下的方法。从上到下按顺序依次调用。
大致的调用关系就是这样,可以当做一个参考,不能保证完全严谨正确,需要注意不同版本可能有些许的出入,如果发现上述顺序有误,欢迎与我交流。
如果你在网上搜索 Spring Boot 自动配置,你会发现很多文章的入手点是 AutoConfigurationImportSelector.selectImports()。那么他的文章是基于 Spring Boot 2.1.0 之前的版本。
之所以有这样的结论是因为在 2.1.0 之后的版本中 ConfigurationClassParser.processImports() 的代码如下:
if (selector instanceof DeferredImportSelector) { this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);}else { String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata()); ......}
而 AutoConfigurationImportSelector 就是 DeferredImportSelector 的实现类,所以根本不会走 else 中的逻辑。
Spring Boot 的自动配置再一次践行了约定优于配置的原则。它的自动配置并不是一股脑的将所有预设列表全部加载进来,而是非常智能的“按需配置”。能做到这一点要归功于 @Conditional 注解和 Condition 接口。它们使得各种配置只有在符合一定的条件时才会被加载。
在讲自动配置原理的时候,我们了解到 AutoConfigurationImportSelector.getAutoConfigurationEntry() 方法中 configurations = getConfigurationClassFilter().filter(configurations) 就是用来过滤那些不符合条件配置的。
我们以 DataSourceAutoConfiguration 为例来具体分析一下,先来看一下源码:
@Configuration(proxyBeanMethods = false)@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })@ConditionalOnMissingBean(type = "io.r2dbc.spi.ConnectionFactory")@EnableConfigurationProperties(DataSourceProperties.class)@Import({ DataSourcePoolMetadataProvidersConfiguration.class, DataSourceInitializationConfiguration.InitializationSpecificCredentialsDataSourceInitializationConfiguration.class, DataSourceInitializationConfiguration.SharedCredentialsDataSourceInitializationConfiguration.class })public class DataSourceAutoConfiguration { ......}
DataSourceAutoConfiguration 通过 @ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class }) 告诉 Spring,只有当 classpath 下存在 DataSource.class 或 EmbeddedDatabaseType.class 时,DataSourceAutoConfiguration 才会被加载。
@ConditionalOnClass 是 @Conditional 的衍生注解,由 @Conditional 和 OnClassCondition 类组成,源码如下:
@Target({ ElementType.TYPE, ElementType.METHOD })@Retention(RetentionPolicy.RUNTIME)@Documented@Conditional(OnClassCondition.class)public @interface ConditionalOnClass { ......}
OnClassCondition 是一个实现了 Condition 接口的类,@ConditionalOnClass 表示 classpath 里有指定的类时加载配置。它是 @Conditional 众多衍生注解中的一个,Spring Boot 提供了一些基于 @Conditional 的衍生注解,见下表:
注解 | 说明 |
---|---|
@ConditionalOnBean | 当容器里有指定 Bean 时 |
@ConditionalOnMissingBean | 当容器里没有指定 Bean 时 |
@ConditionalOnClass | classpath 里有指定的类时 |
@ConditionalOnMissingClass | classpath 里没有指定的类时 |
@ConditionalOnExpression | 给定的 Spring Expression Language(SpEL)表达式计算结果为 true 时 |
@ConditionalOnJava | JVM 的版本匹配特定值或者一个范围时 |
@ConditionalOnJndi | 参数中给定的 JNDI 位置至少存在一个时(如果没有给参数,则要有 JNDI InitialContext) |
@ConditionalOnProperty | 指定的属性为指定的值时 |
@ConditionalOnResource | classpath 里有指定的资源时 |
@ConditionalOnWebApplication | 当前应用是 Web 应用时 |
@ConditionalOnNotWebApplication | 当前应用不是 Web 应用时 |
这些注解都是基于 @Conditional,可以覆盖到我们大多数的使用场景,如果以上情况不能满足你的需求,还可以通过自己实现 Condition 接口来完成自定义的需求。
- 完 -
更多独家精彩内容尽在我的新书《Spring Boot趣味实战课》中。
限时五折优惠,快快扫码抢购吧!
发布:刘恩惠
审核:陈歆懿
如果喜欢本文欢迎 在看丨留言丨分享至朋友圈 三连
点击阅读原文,查看本书详情!
本文分享自 博文视点Broadview 微信公众号,前往查看
如有侵权,请联系 cloudcommunity@tencent.com 删除。
本文参与 腾讯云自媒体同步曝光计划 ,欢迎热爱写作的你一起参与!