Spring：基于注解、代码实现 Bean 定义/注册的 ConfigurationClassPostProcessor 的原理机制
一、问题
每接触一项新事物，我们总是因为疑惑而去探索。
从传统 xml 配置转到基于注解、代码实现 Spring Bean 定义、注册，Spring 提供了各种注解，例如 @Configuration、@Import、@ComponentScan、@Autowired，那 Spring 是怎么识别和解析这些注解的呢？可以思考下以下几个问题：
- @Configuration 注解的作用是什么，Spring 是如何解析加了 @Configuration 注解的类？
- Spring 在什么时候对 @ComponentScan、@ComponentScans 注解进行了解析？
- Spring 什么时候解析了 @Import 注解，如何解析的？
- Spring 什么时候解析了 @Bean 注解？
二、容器扩展、启动概述
Spring 的 IoC 部分被设计成可扩展的（详细可查看文档）。应用程序开发者通常不需要继承各种各样的 BeanFactory 或者 ApplicationContext 的实现类（BeanFactory和ApplicationContext都是接口）。通过插入(plug in)特殊集成接口的实现，可以无限扩展 Spring IoC 容器。这些特殊的接口有：
- BeanFactoryPostProcessors，可用于自定义配置元数据
- BeanPostProcessors，可用于自定义 Bean
基于 Spring Boot 的 Servlet应用在启动期间，会创建 AnnotationConfigServletWebServerApplicationContext 容器上下文，在其创建的成员变量中 AnnotatedBeanDefinitionReader 会通过 AnnotationConfigUtils#registerAnnotationConfigProcessors 往容器中注册一些后置处理器来完成功能的扩展，其中 ConfigurationClassPostProcessor 就完成注解、定义的 Bean 的解析和注册。
从上述结构图看出该类实现了 BeanDefinitionRegistryPostProcessor（是 BeanFactoryPostProcessor 子接口） 接口，它在容器启动阶段会被调用，实现 Bean 定义的注册操作。
- ConfigurationClassPostProcessor是一个BeanFactory的后置处理器，因此它的主要功能是参与BeanFactory的建造，在这个类中，会解析加了@Configuration的配置类，还会解析@ComponentScan、@ComponentScans注解扫描的包，以及解析@Import等注解。
- ConfigurationClassPostProcessor 实现了 BeanDefinitionRegistryPostProcessor 接口，而 BeanDefinitionRegistryPostProcessor 接口继承了 BeanFactoryPostProcessor 接口，所以 ConfigurationClassPostProcessor 中需要重写 postProcessBeanDefinitionRegistry() 方法和 postProcessBeanFactory() 方法。而ConfigurationClassPostProcessor类的作用就是通过这两个方法去实现的。
这里，简单看下容器启动、刷新过程中调用容器后置处理器的过程，容器启动详情，可以查看这里。
public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
//忽略非核心代码...
//先调用 BeanDefinitionRegistryPostProcessors
Set<String> processedBeans = new HashSet<>();
if (beanFactory instanceof BeanDefinitionRegistry) {
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor = (BeanDefinitionRegistryPostProcessor) postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
}
}
// 首先, 调用实现 PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessors，排序后，执行Bean定义的注册
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory); //排序
//调用 postProcessBeanDefinitionRegistry，ConfigurationClassPostProcessor 就会在该处加载 Bean 定义的注册
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 下一步, 调用实现 Ordered 接口的 BeanDefinitionRegistryPostProcessors
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
// 最后, 调用常规的 BeanDefinitionRegistryPostProcessors
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true,false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
}
// 接着, 调用所有后置处理器的 postProcessBeanFactory 回调接口
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
//后续与上述类似，不过是处理 BeanFactoryPostProcessor 接口，并按排序调用回调
}
通过上述流程，容器在启动时间就完成了 Bean 的解析、注册。对于 Bean 的实例、初始化，可以翻阅该篇。
三、源码分析
文章有点长，先用一张图简单描述一下执行流程。
现在直接进入 ConfigurationClassPostProcessor 的核心逻辑方法。
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
//忽略部分非核心代码...
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
//1. 获取所有 Bean 的名称
String[] candidateNames = registry.getBeanDefinitionNames();
for (String beanName : candidateNames) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {}
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
//筛选 @Configuration 的候选配置类，后续可遍历解析
// checkConfigurationClassCandidate()会判断一个是否是一个配置类,并为BeanDefinition设置属性为lite或者full。
// 在这儿为BeanDefinition设置lite和full属性值是为了后面在使用
// 如果加了@Configuration，那么对应的BeanDefinition为full;
// 如果加了@Bean,@Component,@ComponentScan,@Import,@ImportResource这些注解，则为lite。
//lite和full均表示这个BeanDefinition对应的类是一个配置类
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
// 按照 @Ordered 进行排序下
//创建配置解析类，解析每个 @Configuration 注解类
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
do {
//1. 解析配置类，
// 在此处会解析配置类上的注解(ComponentScan扫描出的类，@Import注册的类，以及@Bean方法定义的类，在这里会通过@EnableAutoConfiguration注解导入所有自动配置类)
// 注意：这一步只会将加了@Configuration注解以及通过@ComponentScan注解扫描的类才会加入到BeanDefinitionMap中
// 通过其他注解(例如@Import、@Bean)的方式，在parse()方法这一步并不会将其解析为BeanDefinition放入到BeanDefinitionMap中，而是先解析成ConfigurationClass类
// 真正放入到map中是在下面的this.reader.loadBeanDefinitions()方法中实现的
parser.parse(candidates);
parser.validate();
Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
// 创建 Bean 定义的读取类，读取 配置类中的 Bean 定义
if (this.reader == null) {
this.reader = new ConfigurationClassBeanDefinitionReader(
registry, this.sourceExtractor, this.resourceLoader, this.environment,
this.importBeanNameGenerator, parser.getImportRegistry());
}
//2. 加载配置类的 Bean 定义
// 将上一步parser解析出的ConfigurationClass类加载成BeanDefinition
// 实际上经过上一步的parse()后，解析出来的bean已经放入到BeanDefinition中了，但是由于这些bean可能会引入新的bean，
// 例如实现了ImportBeanDefinitionRegistrar或者ImportSelector接口的bean，或者bean中存在被@Bean注解的方法
// 因此需要执行一次loadBeanDefinition()，这样就会执行ImportBeanDefinitionRegistrar或者ImportSelector接口的方法或者@Bean注释的方法
this.reader.loadBeanDefinitions(configClasses);
candidates.clear();
//继续筛选出新的配置类...
}
while (!candidates.isEmpty());
// Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
}
}
通过上述两个步骤，就完成了 Bean 的解析、加载、注册。接着我们对每个步骤进行纤细的分析：
第一步，进入解析的核心逻辑方法。
parse()方法会解析配置类上的注解(ComponentScan扫描出的类，@Import注册的类，以及@Bean方法定义的类)，解析完以后(解析成ConfigurationClass类)，会将解析出的结果放入到parser的configurationClasses这个属性中(这个属性是个Map)。parse会将@Import注解要注册的类解析为BeanDefinition，但是不会把解析出来的BeanDefinition放入到BeanDefinitionMap中，真正放入到map中是在这一行代码实现的：this.reader.loadBeanDefinitions(configClasses)
public void parse(Set<BeanDefinitionHolder> configCandidates) {
//忽略部分非核心代码...
for (BeanDefinitionHolder holder : configCandidates) {
BeanDefinition bd = holder.getBeanDefinition();
// 根据BeanDefinition类型的不同，调用parse()不同的重载方法
// 实际上最终都是调用processConfigurationClass()方法
try {
if (bd instanceof AnnotatedBeanDefinition) {
parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
}
else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
}
else {
parse(bd.getBeanClassName(), holder.getBeanName());
}
}
}
// 处理延迟importSelector
this.deferredImportSelectorHandler.process();
}
protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
//忽略部分非核心代码...
// 处理配置类，由于配置类可能存在父类(若父类的全类名是以java开头的，则除外)，所有需要将configClass变成sourceClass去解析，然后返回sourceClass的父类。
// 如果此时父类为空，则不会进行while循环去解析，如果父类不为空，则会循环的去解析父类
// SourceClass的意义：简单的包装类，目的是为了以统一的方式去处理带有注解的类，不管这些类是如何加载的
// 如果无法理解，可以把它当做一个黑盒，不会影响看spring源码的主流程
SourceClass sourceClass = asSourceClass(configClass, filter);
do {
sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
}
while (sourceClass != null);
this.configurationClasses.put(configClass, configClass);
}
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter) throws IOException {
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
//1. 首先处理内部类，处理内部类时，最终还是调用doProcessConfigurationClass()方法
processMemberClasses(configClass, sourceClass, filter);
}
//2. 处理属性资源文件，加了@PropertySource注解，完成外置属性的导入
for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), PropertySources.class,
org.springframework.context.annotation.PropertySource.class)) {
if (this.environment instanceof ConfigurableEnvironment) {
processPropertySource(propertySource);
}
}
//3. 处理@ComponentScan或者@ComponentScans注解
//3.1 先找出类上的@ComponentScan和@ComponentScans注解的所有属性(例如basePackages等属性值)
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) {
// 3.2 解析@ComponentScan和 @ComponentScans 配置的扫描的包所包含的类（其扫描路径会优先以注解的配置的路径、基础类包，若为空则以应用启动类包为基础路径）
// 比如 basePackages = org.ramboy.demo, 那么在这一步会扫描出这个包及子包下的class，然后将其解析成BeanDefinition
// (BeanDefinition可以理解为等价于BeanDefinitionHolder)
Set<BeanDefinitionHolder> scannedBeanDefinitions =
this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
// 3.3 通过上一步扫描包com.tiantang.com下的类，有可能扫描出来的bean中可能也添加了ComponentScan或者ComponentScans注解.
//所以这里需要循环遍历一次，进行递归(parse)，继续解析，直到解析出的类上没有ComponentScan和ComponentScans
// (这时3.1这一步解析出componentScans为空列表，不会进入到if语句，递归终止)
for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
// 同样，这里会调用ConfigurationClassUtils.checkConfigurationClassCandidate()方法来判断类是否是一个配置类
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}
// 4.处理Import注解注册的bean，这一步只会将import注册的bean变为ConfigurationClass,不会变成BeanDefinition
// 而是在loadBeanDefinitions()方法中变成BeanDefinition，再放入到BeanDefinitionMap中
processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
// 5.处理@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);
}
}
//6. 处理加了@Bean注解的方法
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
// 处理接口中 所有 @Bean 注解的 默认方法
processInterfaces(configClass, sourceClass);
// 处理父类中 所有 @Bean 注解的
if (sourceClass.getMetadata().hasSuperClass()) {
String superclass = sourceClass.getMetadata().getSuperClassName();
if (superclass != null && !superclass.startsWith("java") && !this.knownSuperclasses.containsKey(superclass)) {
this.knownSuperclasses.put(superclass, configClass);
// Superclass found, return its annotation metadata and recurse
return sourceClass.getSuperClass();
}
}
// 没有父类，解析处理完成
return null;
}
doProcessConfigurationClass() 方法中，执行流程如下:
- 处理内部类，如果内部类也是一个配置类(判断一个类是否是一个配置类，通过 ConfigurationClassUtils.checkConfigurationClassCandidate() 可以判断)。
- 处理属性资源文件，加了@PropertySource注解。
- 首先解析出类上的@ComponentScan和@ComponentScans注解，然后根据配置的扫描包路径，利用ASM技术(ASM技术是一种操作字节码的技术，有兴趣的朋友可以去网上了解下)扫描出所有需要交给Spring管理的类，由于扫描出的类中可能也被加了@ComponentScan和@ComponentScans注解，因此需要进行递归解析，直到所有加了这两个注解的类被解析完成。
- 处理@Import注解。通过@Import注解，有三种方式可以将一个Bean注册到Spring容器中。
- 处理@ImportResource注解，解析配置文件。
- 处理加了@Bean注解的方法。
- 通过processInterfaces()处理接口的默认方法，从JDK8开始，接口中的方法可以有自己的默认实现，因此，如果这个接口中的方法也加了@Bean注解，也需要被解析。(很少用)
- 解析父类，如果被解析的配置类继承了某个类，那么配置类的父类也会被进行解析doProcessConfigurationClass()(父类是JDK内置的类例外，即全类名以java开头的)。
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass, Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter, boolean checkForCircularImports) {
//忽略部分非核心代码...
if (importCandidates.isEmpty()) {
return;
}
if (checkForCircularImports && isChainedImportOnStack(configClass)) {
this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
}
else {
this.importStack.push(configClass);
try {
for (SourceClass candidate : importCandidates) {
if (candidate.isAssignable(ImportSelector.class)) {
// 候选类是 ImportSelector ，委托给它进行导入
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 {
//获取所有导入的名称，封装成 SourceClass，进行导入
String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
}
}
else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
// 候选类是 ImportBeanDefinitionRegistrar ，委托给它注册 Bean 的定义
Class<?> candidateClass = candidate.loadClass();
ImportBeanDefinitionRegistrar registrar =
ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
this.environment, this.resourceLoader, this.registry);
configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
}
else {
// 候选类非 ImportSelector or ImportBeanDefinitionRegistrar，处理成 @Configuration 配置类
this.importStack.registerImport(
currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
}
}
}
finally {
this.importStack.pop();
}
}
}
第二步，将通过@Import、@Bean等注解方式注册的类解析成BeanDefinition，然后注册到BeanDefinitionMap中。
public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
for (ConfigurationClass configClass : configurationModel) {
// 循环调用loadBeanDefinitionsForConfigurationClass()
loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
}
}
private void loadBeanDefinitionsForConfigurationClass(
ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
//忽略非核心代码...
// 如果一个bean是通过@Import(ImportSelector)的方式添加到容器中的，那么此时configClass.isImported()返回的是true
// 而且configClass的importedBy属性里面存储的是ConfigurationClass就是将bean导入的类
if (configClass.isImported()) {
registerBeanDefinitionForImportedConfigurationClass(configClass);
}
// 判断当前的bean中是否含有@Bean注解的方法，如果有，需要把这些方法产生的bean放入到BeanDefinitionMap当中
for (BeanMethod beanMethod : configClass.getBeanMethods()) {
loadBeanDefinitionsForBeanMethod(beanMethod);
}
loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
// 如果bean上存在@Import注解，且import的是一个实现了ImportBeanDefinitionRegistrar接口，
// 则执行ImportBeanDefinitionRegistrar的registerBeanDefinitions()方法
loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}
四、总结
-
本文主要分析了 ConfigurationClassPostProcessor 类的作用，由于该类实现了 BeanFactoryPostProcessor 接口和 BeanDefinitionRegistryPostProcessor 接口，所以会重写 postProcessBeanDefinitionRegistry() 方法和 postProcessBeanFactory() 方法。
-
在postProcessBeanDefinitionRegistry()方法中解析了加了Configuration注解的类，同时解析出 @ComponentScan 和 @ComponentScans 扫描出的Bean，也会解析出加了 @Bean 注解的方法所注册的Bean，以及通过 @Import 注解注册的Bean和 @ImportResource 注解导入的配置文件中配置的Bean。在 postProcessBeanDefinitionRegistry() 方法中，通过源码分析了两个十分重要的方法:ConfigurationClassParser.parse()和this.reader.loadBeanDefinitions()