《Spring源码深度解析 郝佳 第2版》容器的基本实现与XML文件的加载
《Spring源码深度解析 郝佳 第2版》XML标签的解析
《Spring源码深度解析 郝佳 第2版》bean的加载、循环依赖的解决
《Spring源码深度解析 郝佳 第2版》ApplicationContext
《Spring源码深度解析 郝佳 第2版》AOP
《Spring源码深度解析 郝佳 第2版》JDBC、MyBatis原理
SpringBoot是为了简化新Spring应用的初始化搭建以及开发过程。该框架使用了特定的方式来进行配置，主要特点
写简单的栗子，基本步骤
spring-boot-dependencies进而引入spring-boot-autoconfigure<?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>
<groupId>org.example</groupId>
<artifactId>study-springboot-mystarter</artifactId>
<version>1.0-SNAPSHOT</version>
<!-- Starter导入自己的依赖-->
<!-- 自动配置的依赖-->
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-autoconfigure</artifactId>
</dependency>
</dependencies>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.0.1.RELEASE</version>
<type>pom</type>
<scope>import</scope>
</dependency>
</dependencies>
</dependencyManagement>
</project>
package service;
public interface HelloService {
public void sayHello();
}
package service.impl;
import org.springframework.stereotype.Component;
import service.HelloService;
@Component
public class HelloServiceImpl implements HelloService {
public void sayHello() {
System.out.println("你好呀！");
}
}
package config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration // 声明当前类是等同于xml的配置类
@ComponentScan({"service.impl"}) // 扫描包路径配置
public class HelloServiceAutoConfiguration {
}
其实不在Starter中写 @ComponentScan，在Spring主服务模块是可以扫外部包的，但是有时候主服务扫描外部引入的Starter的全部包或者不知道需要扫哪些包，会很麻烦，耦合度较高，现在直接在Starter中的spring.factories指定特定的包即可，符合单一职责
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
config.HelloServiceAutoConfiguration
往期博客分析过run方法，参考 《Spring源码深度解析 郝佳 第2版》ApplicationContext
// ConfigurableApplicationContext
public ConfigurableApplicationContext run(String... args) {
// 1. 计时器
StopWatch stopWatch = new StopWatch();
stopWatch.start();
// 2. 容器
ConfigurableApplicationContext context = null;
Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
this.configureHeadlessProperty();
SpringApplicationRunListeners listeners = this.getRunListeners(args);
listeners.starting();
Collection exceptionReporters;
try {
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
// 3.准备环境，根据webApplicationType 准备上下文环境
// webApplicationType 是在构造函数时根据ClassPath下内容设置的
ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
this.configureIgnoreBeanInfo(environment);
Banner printedBanner = this.printBanner(environment);
// 4. 创建容器,根据webApplicationType给contextClass赋值，然后初始化对应上下文容器
context = this.createApplicationContext();
exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
// 5. 准备容器相关
this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
// 6. 刷新容器，这里委托ConfigurableApplicationContext接口的refesh(),
// 真实调用的是AbstractApplicationContext.refresh(),也就是上面分析的部分
this.refreshContext(context);
this.afterRefresh(context, applicationArguments);
stopWatch.stop();
if (this.logStartupInfo) {
(new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
}
listeners.started(context);
this.callRunners(context, applicationArguments);
} catch (Throwable var10) {
this.handleRunFailure(context, var10, exceptionReporters, listeners);
throw new IllegalStateException(var10);
}
try {
listeners.running(context);
return context;
} catch (Throwable var9) {
this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
throw new IllegalStateException(var9);
}
}
其中关键步骤
该步骤就是实例化一个ApplicationContext，需要根据webApplicationType的值来判断初始化，而webApplicationType是在SpringApplication构造函数时根据ClassPath下内容设置的，这也是后面启动Tomcat的关键地方
private Class<? extends ConfigurableApplicationContext> applicationContextClass;
protected ConfigurableApplicationContext createApplicationContext() {
Class<?> contextClass = this.applicationContextClass;
if (contextClass == null) {
try {
switch(this.webApplicationType) {
// 有web的默认上下文
case SERVLET:
contextClass = Class.forName("org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext");
break;
case REACTIVE:
contextClass = Class.forName("org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext");
break;
// 没有web的默认上下文
default:
contextClass = Class.forName("org.springframework.context.annotation.AnnotationConfigApplicationContext");
}
} catch (ClassNotFoundException var3) {
throw new IllegalStateException("Unable create a default ApplicationContext, please specify an ApplicationContextClass", var3);
}
}
return (ConfigurableApplicationContext)BeanUtils.instantiateClass(contextClass);
}
研究Starter到底是怎么启动的？分析入口需要是@SpringBootApplication注解
package org.springframework.boot.autoconfigure;
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration // 标注当前为配置类，相当于xml
@EnableAutoConfiguration // 自动装配全局开关
// 包扫描
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {
@AliasFor(annotation = EnableAutoConfiguration.class)
Class<?>[] exclude() default {};
@AliasFor(annotation = EnableAutoConfiguration.class)
String[] excludeName() default {};
@AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
String[] scanBasePackages() default {};
@AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
Class<?>[] scanBasePackageClasses() default {};
@AliasFor(annotation = ComponentScan.class, attribute = "nameGenerator")
Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;
@AliasFor(annotation = Configuration.class)
boolean proxyBeanMethods() default true;
}
然后接着分析@EnableAutoConfiguration ，它是自动装配全局开关，想要使用Starter你得首先需要导入它啊，其实也就是将Starter中暴露的bean放到Spring中，这个过程是自动的，因此导入Starter之后可以直接@Autowired注入
他的原理就是 @Import(AutoConfigurationImportSelector.class) ，导入了AutoConfigurationImportSelector类，实现Starter自动化导入
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class) // 导入了一个AutoConfigurationImportSelector
public @interface EnableAutoConfiguration {
String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
Class<?>[] exclude() default {};
String[] excludeName() default {};
}
自动配置类位置从该Starter的spring.factories中获得，可能获取到的并不一定要自动装配，如根本没有引入对应的Starter
因此依靠selectImports自动化导入内部的自动配置类
// AutoConfigurationImportSelector
@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
// 1. 是否需要自动导入，也就是是否开启全局开关
if (!isEnabled(annotationMetadata)) {
return NO_IMPORTS;
}
// 2. 读取spring.factories的自动配置类，封装到 AutoConfigurationEntry
AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}
// AutoConfigurationImportSelector
protected boolean isEnabled(AnnotationMetadata metadata) {
if (getClass() == AutoConfigurationImportSelector.class) {
return getEnvironment().getProperty(EnableAutoConfiguration.ENABLED_OVERRIDE_PROPERTY, Boolean.class, true);
}
return true;
}
找出spring.factories中全部的自动配置类全路径名，包含主服务模块的和引入Starter的，但是主模块中会有可能根本没有引入对应的Starter对应的自动配置类路径，哪如何处理？等会分析…。然就封装到AutoConfigurationEntry中的List<String> configurations，以便后续通过自动配置类上的@ComponentScan注册各个Starter暴露的bean
读取的时机则是在SpringBoot启动的时候完成，具体原理就是使用了Spring的BeanDefinitionRegistryPostProcessor拓展点实现了ConfigurationClassPostProcessor从而实现一系列拓展，后面再分析启动时加载spring.factories的原理逻辑。
// AutoConfigurationImportSelector
protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
// 1. 不需要自动装配Starter
if (!isEnabled(annotationMetadata)) {
return EMPTY_ENTRY;
}
// 2. 获取所有注解类
AnnotationAttributes attributes = getAttributes(annotationMetadata);
// 3. 需要导入的Starter的自动配置类，
// 以便后面获取里面配置的@ComponentScan扫描各个Starter中暴露的bean
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);
}
// 3. 需要导入的Starter的自动配置类，以便后面获取里面配置的@ComponentScan扫描各个Starter中暴露的bean
// AutoConfigurationImportSelector
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
// 3.1 委托 SpringFactoriesLoader 读取Starter的spring.factpries
List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),
getBeanClassLoader());
// Starter必须指定spring.factories，否则报错提示
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;
}
// // 3.1 委托 SpringFactoriesLoader 读取Starter的spring.factpries
// SpringFactoriesLoader
public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
String factoryTypeName = factoryType.getName();
// loadSpringFactories方法返回一个map
// 包含spring.factories里面配置的自动各个Starter的自动配置类
return (List)
loadSpringFactories(classLoader)
.getOrDefault(factoryTypeName, Collections.emptyList());
}
委托方法loadSpringFactories读取加载spring.factories
// SpringFactoriesLoader
// 读取spring.factories内容到map
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 {
// 读取 META-INF/spring.factories
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 factoryTypeName = ((String)entry.getKey()).trim();
String[] var9 = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
int var10 = var9.length;
for(int var11 = 0; var11 < var10; ++var11) {
String factoryImplementationName = var9[var11];
result.add(factoryTypeName, factoryImplementationName.trim());
}
}
}
cache.put(classLoader, result);
return result;
} catch (IOException var13) {
throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var13);
}
}
}
可以debug查看AutoConfigurationEntry看到
那么Spring在启动的时候如何加载spring.factories呢？结合往期博客对启动run方法的分析
ConfigurationClassPostProcessor类作为Spring的拓展点，是SpringBoot一系列功能的基础入口。
// ConfigurationClassPostProcessor
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
// 需要注册的BeanDefinitionHolder
List<BeanDefinitionHolder> configCandidates = new ArrayList();
// 需要注册的全路径名
String[] candidateNames = registry.getBeanDefinitionNames();
String[] var4 = candidateNames;
int var5 = candidateNames.length;
for(int var6 = 0; var6 < var5; ++var6) {
String beanName = var4[var6];
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
// 该配置类已经注册
if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
if (this.logger.isDebugEnabled()) {
this.logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
} else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
// 将全路径名转为BeanDefinitionHolder，保存到configCandidates
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
// 需要注册的configCandidates不为空
if (!configCandidates.isEmpty()) {
// 排序
configCandidates.sort((bd1, bd2) -> {
int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
return Integer.compare(i1, i2);
});
SingletonBeanRegistry sbr = null;
// 单例注册器
if (registry instanceof SingletonBeanRegistry) {
sbr = (SingletonBeanRegistry)registry;
if (!this.localBeanNameGeneratorSet) {
BeanNameGenerator generator = (BeanNameGenerator)sbr.getSingleton("org.springframework.context.annotation.internalConfigurationBeanNameGenerator");
if (generator != null) {
this.componentScanBeanNameGenerator = generator;
this.importBeanNameGenerator = generator;
}
}
}
if (this.environment == null) {
this.environment = new StandardEnvironment();
}
// 接下来就是进入 ConfigurationClassParser 实例的parse方法
ConfigurationClassParser parser = new ConfigurationClassParser(this.metadataReaderFactory, this.problemReporter, this.environment, this.resourceLoader, this.componentScanBeanNameGenerator, registry);
// 待注册的 BeanDefinitionHolder
Set<BeanDefinitionHolder> candidates = new LinkedHashSet(configCandidates);
HashSet alreadyParsed = new HashSet(configCandidates.size());
do {
// 1. 完成解析，内部完成selectImports的调用和processImports的调用
parser.parse(candidates);
parser.validate();
Set<ConfigurationClass> configClasses = new LinkedHashSet(parser.getConfigurationClasses());
configClasses.removeAll(alreadyParsed);
if (this.reader == null) {
this.reader = new ConfigurationClassBeanDefinitionReader(registry, this.sourceExtractor, this.resourceLoader, this.environment, this.importBeanNameGenerator, parser.getImportRegistry());
}
// 2. 完成注册
this.reader.loadBeanDefinitions(configClasses);
alreadyParsed.addAll(configClasses);
candidates.clear();
if (registry.getBeanDefinitionCount() > candidateNames.length) {
String[] newCandidateNames = registry.getBeanDefinitionNames();
Set<String> oldCandidateNames = new HashSet(Arrays.asList(candidateNames));
Set<String> alreadyParsedClasses = new HashSet();
Iterator var12 = alreadyParsed.iterator();
while(var12.hasNext()) {
ConfigurationClass configurationClass = (ConfigurationClass)var12.next();
alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
}
String[] var23 = newCandidateNames;
int var24 = newCandidateNames.length;
for(int var14 = 0; var14 < var24; ++var14) {
String candidateName = var23[var14];
if (!oldCandidateNames.contains(candidateName)) {
BeanDefinition bd = registry.getBeanDefinition(candidateName);
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) && !alreadyParsedClasses.contains(bd.getBeanClassName())) {
candidates.add(new BeanDefinitionHolder(bd, candidateName));
}
}
}
candidateNames = newCandidateNames;
}
} while(!candidates.isEmpty());
if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
}
if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
((CachingMetadataReaderFactory)this.metadataReaderFactory).clearCache();
}
}
}
总结：在ApplicationContext的refresh方法中，会调用invokeBeanFactoryPostProcessors激活相应的处理器，具体的方法就是在postProcessBeanDefinitionRegistry方法内部一系列逻辑委托ConfigurationClassPostProcessor的processConfigBeanDefinitions拿到了spring.factories的自动配置类全路径名，然后封装为BeanDefinitionHolder，然后下面进行
前面分析完了ConfigurationClassPostProcessor的postConfigBeanDefinitions方法，接下来就是分析ConfigurationClassParser类的parse方法，也就是这里先后调用selectImports和proceImports方法
// ConfigurationClassParser
public void parse(Set<BeanDefinitionHolder> configCandidates) {
Iterator var2 = configCandidates.iterator();
while(var2.hasNext()) {
BeanDefinitionHolder holder = (BeanDefinitionHolder)var2.next();
// 拿到BeanDefinition
BeanDefinition bd = holder.getBeanDefinition();
try {
// BeanDefinition的类型，三种
// 以此种为例，注解配置的自动配置类
if (bd instanceof AnnotatedBeanDefinition) {
this.parse(((AnnotatedBeanDefinition)bd).getMetadata(), holder.getBeanName());
}
else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition)bd).hasBeanClass()) {
this.parse(((AbstractBeanDefinition)bd).getBeanClass(), holder.getBeanName());
}
else {
this.parse(bd.getBeanClassName(), holder.getBeanName());
}
} catch (BeanDefinitionStoreException var6) {
throw var6;
} catch (Throwable var7) {
throw new BeanDefinitionStoreException("Failed to parse configuration class [" + bd.getBeanClassName() + "]", var7);
}
}
// 最后调用
this.deferredImportSelectorHandler.process();
}
// 委托
public void process() {
List<ConfigurationClassParser.DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
this.deferredImportSelectors = null;
try {
if (deferredImports != null) {
ConfigurationClassParser.DeferredImportSelectorGroupingHandler handler = ConfigurationClassParser.this.new DeferredImportSelectorGroupingHandler();
deferredImports.sort(ConfigurationClassParser.DEFERRED_IMPORT_COMPARATOR);
deferredImports.forEach(handler::register);
// 委托
handler.processGroupImports();
}
} finally {
this.deferredImportSelectors = new ArrayList();
}
}
// 委托
public void processGroupImports() {
Iterator var1 = this.groupings.values().iterator();
while(var1.hasNext()) {
ConfigurationClassParser.DeferredImportSelectorGrouping grouping = (ConfigurationClassParser.DeferredImportSelectorGrouping)var1.next();
Predicate<String> exclusionFilter = grouping.getCandidateFilter();
grouping.getImports().forEach((entry) -> {
ConfigurationClass configurationClass = (ConfigurationClass)this.configurationClasses.get(entry.getMetadata());
try {
// 进入processImports
ConfigurationClassParser.this.processImports(configurationClass, ConfigurationClassParser.this.asSourceClass(configurationClass, exclusionFilter), Collections.singleton(ConfigurationClassParser.this.asSourceClass(entry.getImportClassName(), exclusionFilter)), exclusionFilter, false);
} catch (BeanDefinitionStoreException var5) {
throw var5;
} catch (Throwable var6) {
throw new BeanDefinitionStoreException("Failed to process import candidates for configuration class [" + configurationClass.getMetadata().getClassName() + "]", var6);
}
});
}
}
processImports方法处理spring.factories中的自动配置类首先就是就是需要加载自动配置类，这个时候AutoConfigurationImportSelector的selectImports方法就要发挥作用了
他返回的自动配置类需要进一步解析，因为可能对应@Import、@Bean、@ComponentScan多种类型，进一步解析递归调用processImports方法
private void processImports(ConfigurationClass configClass, ConfigurationClassParser.SourceClass currentSourceClass, Collection<ConfigurationClassParser.SourceClass> importCandidates, Predicate<String> exclusionFilter, boolean checkForCircularImports) {
if (!importCandidates.isEmpty()) {
if (checkForCircularImports && this.isChainedImportOnStack(configClass)) {
this.problemReporter.error(new ConfigurationClassParser.CircularImportProblem(configClass, this.importStack));
} else {
this.importStack.push(configClass);
try {
Iterator var6 = importCandidates.iterator();
while(var6.hasNext()) {
ConfigurationClassParser.SourceClass candidate = (ConfigurationClassParser.SourceClass)var6.next();
Class candidateClass;
// 1. 要先对 XxxImportSelector类处理，调用它的selectImports、processImports方法
if (candidate.isAssignable(ImportSelector.class)) {
candidateClass = candidate.loadClass();
ImportSelector selector = (ImportSelector)ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class, this.environment, this.resourceLoader, this.registry);
Predicate<String> selectorFilter = selector.getExclusionFilter();
if (selectorFilter != null) {
exclusionFilter = exclusionFilter.or(selectorFilter);
}
// DeferredImportSelector
if (selector instanceof DeferredImportSelector) {
this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector)selector);
} else {
// 1.1 slelectImports方法
String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
Collection<ConfigurationClassParser.SourceClass> importSourceClasses = this.asSourceClasses(importClassNames, exclusionFilter);
// 1.2 processImports方法
this.processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
}
}
// 2. 对XxxImportBeanDefinitionRegistrar类处理
else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
candidateClass = candidate.loadClass();
ImportBeanDefinitionRegistrar registrar = (ImportBeanDefinitionRegistrar)ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class, this.environment, this.resourceLoader, this.registry);
configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
}
// 3. 一般配置类处理
else {
this.importStack.registerImport(currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
// 如@Bean、@ComponentScan等类
this.processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
}
}
} catch (BeanDefinitionStoreException var17) {
throw var17;
} catch (Throwable var18) {
throw new BeanDefinitionStoreException("Failed to process import candidates for configuration class [" + configClass.getMetadata().getClassName() + "]", var18);
} finally {
this.importStack.pop();
}
}
}
}
// 自动配置类解析前置处理
protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
// 这里 shouldSkip 是 @Conditional 注解实现原理的时机，下面会说明
// 即不满足@Conditional注解的话，就不会再进行下面selectImports、processImports等
if (!this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
ConfigurationClass existingClass = (ConfigurationClass)this.configurationClasses.get(configClass);
if (existingClass != null) {
if (configClass.isImported()) {
if (existingClass.isImported()) {
existingClass.mergeImportedBy(configClass);
}
return;
}
this.configurationClasses.remove(configClass);
this.knownSuperclasses.values().removeIf(configClass::equals);
}
ConfigurationClassParser.SourceClass sourceClass = this.asSourceClass(configClass, filter);
do {
// 真正的解析
sourceClass = this.doProcessConfigurationClass(configClass, sourceClass, filter);
} while(sourceClass != null);
this.configurationClasses.put(configClass, configClass);
}
}
其中对于@ComponentScan的注册，有可能需要递归的完成，其中注册核心逻辑就是在processImports—>processConfigurationClass—>doProcessConfigurationClass方法
@Nullable
protected final ConfigurationClassParser.SourceClass doProcessConfigurationClass(ConfigurationClass configClass, ConfigurationClassParser.SourceClass sourceClass, Predicate<String> filter) throws IOException {
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
this.processMemberClasses(configClass, sourceClass, filter);
}
// 1. 处理 @PropertySources 注解
Iterator var4 = AnnotationConfigUtils.attributesForRepeatable(sourceClass.getMetadata(), PropertySources.class, PropertySource.class).iterator();
AnnotationAttributes importResource;
while(var4.hasNext()) {
importResource = (AnnotationAttributes)var4.next();
if (this.environment instanceof ConfigurableEnvironment) {
this.processPropertySource(importResource);
} else {
this.logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() + "]. Reason: Environment must implement ConfigurableEnvironment");
}
}
// 2. 处理 @ComponentScan 注解
Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
if (!componentScans.isEmpty() && !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
Iterator var14 = componentScans.iterator();
while(var14.hasNext()) {
AnnotationAttributes componentScan = (AnnotationAttributes)var14.next();
// 解析全路径
Set<BeanDefinitionHolder> scannedBeanDefinitions = this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
Iterator var8 = scannedBeanDefinitions.iterator();
while(var8.hasNext()) {
BeanDefinitionHolder holder = (BeanDefinitionHolder)var8.next();
BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
if (bdCand == null) {
bdCand = holder.getBeanDefinition();
}
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
// 递归调用
this.parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}
this.processImports(configClass, sourceClass, this.getImports(sourceClass), filter, true);
// 3. 处理 @ImportSource 注解
importResource = AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
if (importResource != null) {
String[] resources = importResource.getStringArray("locations");
Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
String[] var20 = resources;
int var22 = resources.length;
for(int var23 = 0; var23 < var22; ++var23) {
String resource = var20[var23];
String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
configClass.addImportedResource(resolvedResource, readerClass);
}
}
// 4. @Bean的Methods处理
Set<MethodMetadata> beanMethods = this.retrieveBeanMethodMetadata(sourceClass);
Iterator var18 = beanMethods.iterator();
while(var18.hasNext()) {
MethodMetadata methodMetadata = (MethodMetadata)var18.next();
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
// 5. 处理接口中的默认方法，在JDK9之后，接口中可以包含default修饰的包含方法体的方法
this.processInterfaces(configClass, sourceClass);
if (sourceClass.getMetadata().hasSuperClass()) {
String superclass = sourceClass.getMetadata().getSuperClassName();
if (superclass != null && !superclass.startsWith("java") && !this.knownSuperclasses.containsKey(superclass)) {
this.knownSuperclasses.put(superclass, configClass);
return sourceClass.getSuperClass();
}
}
return null;
}
最终对于@ComponentScan的扫描是委托于ClassPathBeanDefinitionScanner来实现的，他通过字节码扫描效率会比反射机制要高很多。
它的作用：它是Spring提供的一个更通用的基于条件的bean的创建，通过使用@Conditional注解，会根据满足的某一个特定条件创建一个特定的bean。如一个JAR包中包含多个bean，这多个bean之间存在先后创建的依赖关系，因此可以使用@Conditional注解完成自动配置。或者是配置自动装配的开关。
它的原理：分析注解@ConditionalOnProperty 原理，首先需要判断哪里调用了这个注解，发现是OnPropertyConditional类，查看他的方法，内部只有一个public的方法是getMatchOutcome，得知是由这个方法完成核心逻辑的
// OnPropertyConditional
// 将是否匹配的条件疯转到 ConditionOutcome 中，内部包含成员变量match 为true、false
@Override
public ConditionOutcome getMatchOutcome(ConditionContext context, AnnotatedTypeMetadata metadata) {
// 扫描出 @ConditionalOnProperty 注解的信息
List<AnnotationAttributes> allAnnotationAttributes = annotationAttributesFromMultiValueMap(
metadata.getAllAnnotationAttributes(ConditionalOnProperty.class.getName()));
// 不匹配的配置类，不需要自动装配
List<ConditionMessage> noMatch = new ArrayList<>();
// 匹配的配置类，需要自动装配
List<ConditionMessage> match = new ArrayList<>();
for (AnnotationAttributes annotationAttributes : allAnnotationAttributes) {
// 核心的验证逻辑
ConditionOutcome outcome = determineOutcome(annotationAttributes, context.getEnvironment());
// 加入对应的结果
(outcome.isMatch() ? match : noMatch).add(outcome.getConditionMessage());
}
if (!noMatch.isEmpty()) {
return ConditionOutcome.noMatch(ConditionMessage.of(noMatch));
}
return ConditionOutcome.match(ConditionMessage.of(match));
}
// 核心的验证逻辑 determineOutcome
private ConditionOutcome determineOutcome(AnnotationAttributes annotationAttributes, PropertyResolver resolver) {
Spec spec = new Spec(annotationAttributes);
// 处理不匹配的两种情况
// 1. missProperties对应属性缺失
List<String> missingProperties = new ArrayList<>();
// 2. nonMatchingProperties对应不匹配
List<String> nonMatchingProperties = new ArrayList<>();
// 这两个结果的填充,内部使用PropertyResolver来验证
spec.collectProperties(resolver, missingProperties, nonMatchingProperties);
if (!missingProperties.isEmpty()) {
return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnProperty.class, spec)
.didNotFind("property", "properties").items(Style.QUOTE, missingProperties));
}
if (!nonMatchingProperties.isEmpty()) {
return ConditionOutcome.noMatch(ConditionMessage.forCondition(ConditionalOnProperty.class, spec)
.found("different value in property", "different value in properties")
.items(Style.QUOTE, nonMatchingProperties));
}
return ConditionOutcome
.match(ConditionMessage.forCondition(ConditionalOnProperty.class, spec).because("matched"));
}
结合前面processImports方法调用的流程，在processConfigurationClass步骤中主要逻辑就是对即将解析的注解做预处理
// 自动配置类解析前置处理
protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
// 这里 shouldSkip 是 @Conditional 注解实现原理的时机
// 即不满足@Conditional注解的话，就不会再进行下面selectImports、processImports等
if (!this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
ConfigurationClass existingClass = (ConfigurationClass)this.configurationClasses.get(configClass);
if (existingClass != null) {
if (configClass.isImported()) {
if (existingClass.isImported()) {
existingClass.mergeImportedBy(configClass);
}
return;
}
this.configurationClasses.remove(configClass);
this.knownSuperclasses.values().removeIf(configClass::equals);
}
ConfigurationClassParser.SourceClass sourceClass = this.asSourceClass(configClass, filter);
do {
// 真正的解析
sourceClass = this.doProcessConfigurationClass(configClass, sourceClass, filter);
} while(sourceClass != null);
this.configurationClasses.put(configClass, configClass);
}
}
分析shouldSkip方法，这个方法关键地方
public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
if (metadata != null && metadata.isAnnotated(Conditional.class.getName())) {
if (phase == null) {
return metadata instanceof AnnotationMetadata && ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata)metadata) ? this.shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION) : this.shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
} else {
List<Condition> conditions = new ArrayList();
// 1. 获取所有的condition
Iterator var4 = this.getConditionClasses(metadata).iterator();
while(var4.hasNext()) {
String[] conditionClasses = (String[])var4.next();
String[] var6 = conditionClasses;
int var7 = conditionClasses.length;
for(int var8 = 0; var8 < var7; ++var8) {
String conditionClass = var6[var8];
Condition condition = this.getCondition(conditionClass, this.context.getClassLoader());
conditions.add(condition);
}
}
AnnotationAwareOrderComparator.sort(conditions);
var4 = conditions.iterator();
Condition condition;
ConfigurationPhase requiredPhase;
do {
do {
if (!var4.hasNext()) {
return false;
}
condition = (Condition)var4.next();
requiredPhase = null;
if (condition instanceof ConfigurationCondition) {
requiredPhase = ((ConfigurationCondition)condition).getConfigurationPhase();
}
} while(requiredPhase != null && requiredPhase != phase);
// 2. condition匹配
} while(condition.matches(this.context, metadata));
return true;
}
} else {
return false;
}
}
SpringBoot会读取properties文件的原理就是通过PropertyResolver来实现的，如我们使用@Value来读取properties文件中的内容也是此原理
我们以@Value注解来分析，看看那个类调用了Value.class，发现是QualifierAnnotationAutowireCandidateResolver类
debug查看解析完properties中的值后，是怎么填充到属性中的？发现在BeanFactory接口中有resloveDependcy方法，该方法主要是依赖查找，对于@Value类型的依赖则是需要读取properties文件，参考：https://www.cnblogs.com/binarylei/p/12337145.html
发现获取Value表达式属性之后，会进入DefaultListableBeanFactory类的resloveEmbeddedValue方法
// AbstractBeanFactoy
@Nullable
public String resolveEmbeddedValue(@Nullable String value) {
if (value == null) {
return null;
} else {
String result = value;
Iterator var3 = this.embeddedValueResolvers.iterator();
do {
if (!var3.hasNext()) {
return result;
}
StringValueResolver resolver = (StringValueResolver)var3.next();
// 交给了 resolveStringValue
result = resolver.resolveStringValue(result);
} while(result != null);
return null;
}
}
该方法内部委托resolveStringValue实现properties文件的读取解析，他的作用时机切入点是在PropertySourcePlaceholderConfigurer类，它实现了BeanFactoryPostProcess
而StringValueResolver初始化就是在PropertySourcePlaceholderConfigurer的postProcessBeanFactory方法中，分析这个方法