SpringIOC之@Bean 等注解的实现原理

最新推荐文章于 2024-01-04 16:19:15 发布

Coder_Boy_

最新推荐文章于 2024-01-04 16:19:15 发布

阅读量1.3k

点赞数

分类专栏： Spring实战 Java技术架构师文章标签： spring java 后端 Powered by 金山文档

本文链接：https://blog.csdn.net/Coder_Boy_/article/details/128895722

版权

Java技术架构师同时被 2 个专栏收录

33 篇文章 1 订阅

订阅专栏

Spring实战

32 篇文章 8 订阅

订阅专栏

概述

我们了解到 @Component 注解（及其派生注解）标注的 Class 类都会被解析成 BeanDefinition（Bean 的“前身”）然后实例化为早期Bean，再进行Bean的属性注入，最后会被初始化成完整Bean对象(如果需要代理则会创建Bean代理对象)。

而@Bean 注解不是 @Component 的派生注解，且用于标注方法，使用方法名作为BeanName，返回值作为Bean，那么

Spring 中是如何解析 @Bean 注解的呢？

我们知道在Spring应用上下文ApplicationContext启动的时候，会调用其实现类AbstractApplicationContext的refresh()

在创建好 BeanFactory 后会调用所有的 BeanFactoryPostProcessor 处理器对其进行后置处理。@Bean 注解就是在这个过程被解析的，解析过程大致就是遍历所有的 BeanDefinition，如果其内部包含 @Bean 标注的注解，则会将该方法解析出一个 BeanDefinition 对象并注册。当然，除了 @Bean 注解外，例如 @ComponentScan、@Import、@ImportResource、@PropertySource 注解都是在该过程中进行解析的。那么接下来将分析整个的解析过程，入口在 ConfigurationClassPostProcessor 这个处理器中。

主要涉及以下几个类：

org.springframework.context.annotation.ConfigurationClassPostProcessor，处理 Spring 应用上下文中的配置类，解析 @Bean 等注解，并进行 CGLIB 提升

org.springframework.context.annotation.ConfigurationClass，根据前面提到的配置类解析出来的对象，包含各种注解的信息，例如 @Bean、@Import

org.springframework.context.annotation.ConfigurationClassParser，解析配置类，生成 ConfigurationClass 对象并保存

org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader，配置类中 BeanDefinition 的读取器，根据 ConfigurationClass 解析出 BeanDefinition 并注册

几个对象的关联关系

ConfigurationClassPostProcessor中会使用

ConfigurationClassParser来解析配置注解或配置文件生成ConfigurationClass 对象并保存

ConfigurationClassBeanDefinitionReader读取所有的ConfigurationClass 对象解析出BeanDefinition 后注册到IOC

配置类：带有 @Configuration 注解的类，如果这个类带有 @Component | @ComponentScan | @Import | @ImportSource 注解，或者内部存在 @Bean 的方法都算配置类

举例如下

关键处理器的注册

处理器

关键的处理器：

ConfigurationClassPostProcessor：处理 Spring 应用上下文中的配置类，解析 @Bean 等注解，并进行 CGLIB 提升

AutowiredAnnotationBeanPostProcessor：解析 @Autowired 和 @Value 注解标注的属性，获取对应属性值，进行依赖注入

CommonAnnotationBeanPostProcessor：会解析 @Resource 注解标注的属性，获取对应的属性值，进行依赖注入

EventListenerMethodProcessor：解析 @EventListener 注解标注的方法，会将其解析成 Spring 事件监听器并注册

DefaultEventListenerFactory：帮助 EventListenerMethodProcessor 将 @EventListener 注解标注的方法生成事件监听器

注册过程

如果在 XML 配置文件中配置了 <context:component-scan /> 标签，会通过 ClassPathBeanDefinitionScanner 扫描器进行解析；注解配置的 Spring 应用上下文也会通过 ClassPathBeanDefinitionScanner 扫描器进行扫描。

在 ClassPathBeanDefinitionScanner 的扫描过程中会调用 AnnotationConfigUtils#registerAnnotationConfigProcessors(BeanDefinitionRegistry) 方法

再来看到 AnnotationConfigUtils 的这个方法，如下：

整个过程就是将上面“处理器”小节中讲到的几个处理器进行注册

开始这个处理器的解析

ConfigurationClassPostProcessor

实现了 BeanDefinitionRegistryPostProcessor 接口（继承了 BeanFactoryPostProcessor 接口）

关于BeanDefinitionRegistryPostProcessor几点说明

BeanDefinitionRegistryPostProcessor 优先于 BeanFactoryPostProcessor执行

先看BeanFactoryPostProcessor后看BeanDefinitionRegistryPostProcessor

postProcessBeanDefinitionRegistry 方法

对 BeanDefinitionRegistry 的后置处理，其实这个入参就是 DefaultListableBeanFactory，如下：

使用 registry 的哈希值作为 ID 保存在 registriesPostProcessed，保证同一个 BeanDefinitionRegistry 不会被重复处理，最后调用 processConfigBeanDefinitions(BeanDefinitionRegistry) 方法

processConfigBeanDefinitions 方法

processConfigBeanDefinitions(BeanDefinitionRegistry) 方法，处理配置类

最后做些清理工作

// 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());
        }

        if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
            // Clear cache in externally provided MetadataReaderFactory; this is a no-op
            // for a shared cache since it'll be cleared by the ApplicationContext.
            // <7> 清理上述解析过程中产生的元数据缓存
            ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
        }

总体过程如下：

获取所有的 BeanDefinition 名称的集合

找出是配置类的 BeanDefinition 对象们，保存至 configCandidates 集合中

判断是否已经处理过，已处理则不再处理，保证不被二次处理，否则

检查是否带有 @Configuration 注解，或者带有 @Component | @ComponentScan | @Import | @ImportSource | 内部存在 @Bean 的方法，符合前面其中一个条件都算配置类，需要进行处理

上一步没有找到需要处理的配置类，则直接 return 返回

根据 @Order 注解对 configCandidates 集合中的配置类进行排序

创建一个 ConfigurationClassParser 对象，用于解析符合条件的配置类，会先生成 ConfigurationClass 对象保存至其内部，然后通过 ConfigurationClassBeanDefinitionReader 读取器从这些 ConfigurationClass 对象中解析出 BeanDefinition

【核心】对所有的配置类进行解析，调用 ConfigurationClassParser#parse(Set<BeanDefinitionHolder>) 方法，解析其内部的注解（@PropertySource、@ComponentScan、@Import、@ImportResource、@Bean）。每个配置类会生成一个 ConfigurationClass 对象，其中 @Bean 标注的方法转换成 BeanMethod 对象保存在 ConfigurationClass.beanMethods 集合中

对所有的 ConfigurationClass 对象进行校验：Class 对象不能被 final 修饰（后面会用CGLIB代理的），@Bean 标注的方法不能被 private 修饰

获取上面解析出来的 ConfigurationClass 们，放入 configClasses 集合中，并移除已经处理过的对象

创建一个 ConfigurationClassBeanDefinitionReader 对象，调用其 loadBeanDefinitions(Set<ConfigurationClass>) 方法，扫描出 ConfigurationClass 中的 BeanDefinition 并注册。例如 @Bean 标注的方法需要注册、@ImportResource 注解配置的资源文件中配置的 Bean 需要注册

【核心】扫描所有的 ConfigurationClass，注册相应的 BeanDefinition，主要有以下来源：

@Import 注解导入对象

其内部定义的带有 @Bean 注解的方法

@ImportResource 注解导入资源

@Import 注解导入的 ImportBeanDefinitionRegistrar 接口的实现类可自定义实现注册相关 BeanDefinition

将这些 ConfigurationClass 保存至 alreadyParsed 已解析的集合中

从上述过程注册的 BeanDefinition 中，找到没有还解析过的 BeanDefinition 们，再循环解析。例如 @Bean 标注的方法是新注册的 BeanDefinition，也可能又是一个配置类，但是还没有被这里解析过，所以需要再次扫描，如果还有未处理的配置类则需要进行处理

清理上述解析过程中产生的元数据缓存，例如通过 ASM 从 .class 文件中获取到的 Class 信息，需要清理

总结：先根据配置类生成 ConfigurationClass 对象，然后根据该对象解析出 BeanDefinition 并注册

配置类：带有 @Configuration 注解的类，如果这个类带有 @Component | @ComponentScan | @Import | @ImportSource 注解，或者内部存在 @Bean 的方法都算配置类

上面的第 5.1 和 5.4 分别对应 ConfigurationClassParser 和 ConfigurationClassBeanDefinitionReader 两个类，接下来会依次分析

postProcessBeanFactory 方法

postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) 方法，对 ConfigurableListableBeanFactory 的后置处理，其实这个入参就是 DefaultListableBeanFactory，和 postProcessBeanDefinitionRegistry(BeanDefinitionRegistry) 方法是同一个入参，如下：

enhanceConfigurationClasses 方法

enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) 方法，对 @Configuration 注解的配置类进行 CGLIB 提升，如下：

整个过程大致就是：如果是 @Configuration 注解标注的类，则通过 CGLIB 创建一个子类（代理类）并设置到这个 BeanDefinition 的 beanClass 属性中。这样一来， @Configuration 注解标注的类就得到了 CGLIB 的提升，主要帮助实现 AOP 相关特性

ConfigurationClass

org.springframework.context.annotation.ConfigurationClass，根据前面提到的配置类解析出来的对象

ConfigurationClassParser

org.springframework.context.annotation.ConfigurationClassParser，解析配置类，生成 ConfigurationClass 对象并保存

parse 方法

parse(Set<BeanDefinitionHolder> configCandidates) 方法，对这些配置类进行解析，如下：

遍历这些配置类，调用 parse(...) 不同的重载方法进行解析，如下：

processConfigurationClass 方法

processConfigurationClass(ConfigurationClass configClass) 方法，解析配置类，所有信息都保存在这个 ConfigurationClass 中，如下：

doProcessConfigurationClass 方法

doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass) 方法，解析配置类，所有信息都保存在这个 ConfigurationClass 中，如下：

主要过程大致如下：

先处理内部成员类，调用 processMemberClasses(...) 方法，如果内部成员类也是配置类，同样调用前面的 processConfigurationClass(ConfigurationClass)方法进行处理

处理 @PropertySource 注解，加载出对应的 Resource 资源，将其添加至 Environment 环境中，

处理 @ComponentScan 注解，通过 ComponentScanAnnotationParser 扫描出指定包路径下的 BeanDefinition 们并注册，然后再遍历处理，如果是配置类，同样调用前面的 parse(...) 方法

处理 @Import 注解中的 Class 对象，调用 processImports(...) 方法，分为下面几种情况：

ImportSelector 的实现类：调用其 selectImports(AnnotationMetadata) 方法获取需要导入的 Class 类名，再次调用 processImports(...) 方法进行处理

ImportBeanDefinitionRegistrar 的实现类：将这个实现类保存在 ConfigurationClass.importBeanDefinitionRegistrars 集合中

否则，为 @Import 注解中的配置类创建 ConfigurationClass 对象，同样调用processConfigurationClass(ConfigurationClass)方法进行处理

处理 @ImportResource 注解，获取需要导入的资源配置信息，将这些配置信息添加至 ConfigurationClass.importedResources 集合中

解析出所有带有 @Bean 注解的方法，底层通过 ASM（Java 字节码操作和分析框架）进行解析，然后将这些方法封装成 BeanMethod 对象，并保存至 ConfigurationClass.beanMethods 集合中，

如果有父类，则循环进行解析

整个过程就是解析配置类中的各种注解，解析结果都保存在 ConfigurationClass 中，所以说整个过程就是为配置类生成一个 ConfigurationClass 对象，将这些信息生成对应的 BeanDefinition 对象并注册到 Spring 上下文的过程还在后面，也就是下面要讲的 ConfigurationClassBeanDefinitionReader 读取器

ConfigurationClassBeanDefinitionReader

org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader，配置类中 BeanDefinition 的读取器，根据 ConfigurationClass 解析出 BeanDefinition 并注册

loadBeanDefinitions 方法

loadBeanDefinitions(Set<ConfigurationClass>) 方法，从 ConfigurationClass 中加载出 BeanDefinition，如下：

遍历所有的 ConfigurationClass 对象，调用 loadBeanDefinitionsForConfigurationClass(...) 方法

loadBeanDefinitionsForConfigurationClass 方法

loadBeanDefinitionsForConfigurationClass(ConfigurationClass, TrackedConditionEvaluator) 方法，从 ConfigurationClass 中加载出 BeanDefinition 并注册，如下：

过程大致如下：

如果不符合 @Conditional 注解的条件，则跳过

如果当前 ConfigurationClass 是通过 @Import 注解被导入的

根据该 ConfigurationClass 对象生成一个 BeanDefinition 并注册，调用

根据这个类的元信息生成一个 AnnotatedGenericBeanDefinition 对象，并注册

遍历当前 ConfigurationClass 中所有的 @Bean 注解标注的方法

根据该 BeanMethod 对象生成一个 BeanDefinition 并注册（注意这里有无 static 修饰会有不同的配置），调用 loadBeanDefinitionsForBeanMethod(BeanMethod) 方法，在后面分析

对 @ImportResource 注解配置的资源进行处理，对里面的配置进行解析并注册 BeanDefinition，通过 XmlBeanDefinitionReader 对该配置文件进行扫描（xml 、properties）

通过 @Import 注解导入的 ImportBeanDefinitionRegistrar 实现类往 BeanDefinitionRegistry 注册 BeanDefinition，也就是调用这个实现类的 registerBeanDefinitions(AnnotationMetadata, BeanDefinitionRegistry) 方法，实现自定义注册 BeanDefinition

该过程会把 ConfigurationClass 中的信息解析成 BeanDefinition 并注册，其中第 5 步可参考 Mybatis 集成 Spring 的项目中的 MapperScannerRegistrar 类

loadBeanDefinitionsForBeanMethod 方法

loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) 方法，将 @Bean 注解标注的方法解析成 BeanDefinition 并注册，如下：

全文总结：

“BeanFactory 后置处理阶段”，在创建好 DefaultListableBeanFactory 后会调用所有的 BeanDefinitionRegistryPostProcessor 和 BeanFactoryPostProcessor 对其进行处理，前者优先。

Spring 应用上下文中的 ConfigurationClassPostProcessor 就是一个 BeanDefinitionRegistryPostProcessor 处理器，它会对所有的配置类（包括其内部成员类）进行处理，会做以下事情：

加载 @PropertySource 注解配置的资源到 Environment 环境中

扫描 @ComponentScan 注解指定路径下的 BeanDefinition 们，如果也是配置类，会进行同样的处理过程

解析出 @Import 注解配置的配置类，解析成 AnnotatedGenericBeanDefinition 并注册；其中配置的是 ImportSelector 实现类，则调用其selectImports(AnnotationMetadata) 方法获取配置类；如果配置的是 ImportBeanDefinitionRegistrar 实现类，则调用其registerBeanDefinitions(AnnotationMetadata, BeanDefinitionRegistry) 方法，实现自定义注册 BeanDefinition

解析 @ImportResource 注解，加载配置的 XML 文件，解析出 BeanDefinition 们

将这些配置类中 @Bean 注解的方法解析成 ConfigurationClassBeanDefinition 并注册

配置类：带有 @Configuration 注解的类，如果这个类带有 @Component | @ComponentScan | @Import | @ImportSource 注解，或者内部存在 @Bean 的方法都算配置类

如果是 @Configuration 注解标注的类，还会进行 CGLIB 提升，主要帮助实现 AOP 相关特性

@configuration 中的@bean方法实例化和 xml配置方式的`factory-method` 工厂方法，

创建一个实例对象原理一一致

Coder_Boy_

关注

0
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
SpringIOC之@Bean 等注解的实现原理

我们了解到@Component注解（及其派生注解）标注的 Class 类都会被解析成 BeanDefinition（Bean 的“前身”）然后实例化为早期Bean，再进行Bean的属性注入，最后会被初始化成完整Bean对象(如果需要代理则会创建Bean代理对象)。而@Bean注解不是@Component的派生注解，且用于标注方法，使用方法名作为BeanName，返回值作为Bean，那么Spring 中是如何解析@Bean注解的呢？
复制链接

扫一扫