死磕Spring之IoC篇 - @Bean 等註解的實現原理
阿新 • • 發佈：2021-03-09
> 該系列文章是本人在學習 Spring 的過程中總結下來的，裡面涉及到相關原始碼，可能對讀者不太友好，請結合我的原始碼註釋 [Spring 原始碼分析 GitHub 地址](https://github.com/liu844869663/spring-framework) 進行閱讀
>
> Spring 版本：5.1.14.RELEASE
>
> 開始閱讀這一系列文章之前，建議先檢視[**《深入瞭解 Spring IoC（面試題）》**](https://www.cnblogs.com/lifullmoon/p/14422101.html)這一篇文章
>
> 該系列其他文章請檢視：[**《死磕 Spring 之 IoC 篇 - 文章導讀》**](https://www.cnblogs.com/lifullmoon/p/14436372.html)
## @Bean 等註解的實現原理
通過前面的一系列文章我們瞭解到 `@Component` 註解（及其派生註解）標註的 Class 類都會被解析成 BeanDefinition（Bean 的“前身”），然後會被初始化成 Bean 物件。那麼 `@Bean` 註解不是 `@Component` 的派生註解，且用於標註方法，該註解的解析過程在前面的文章中沒有提到，那麼在 Spring 中是如何解析 `@Bean` 註解的呢？
可以先回顧一下[**《Spring 應用上下文 ApplicationContext》**](https://www.cnblogs.com/lifullmoon/p/14453083.html)文章“BeanFactory 後置處理階段”的小節中講到，在建立好 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 並註冊
> **配置類**：帶有 `@Configuration` 註解的類，如果這個類帶有 `@Component` | `@ComponentScan` | `@Import` | `@ImportSource` 註解，或者內部存在 `@Bean` 的方法都算**配置類**
### 幾個關鍵處理器的註冊
#### 處理器
關鍵的處理器：
- `ConfigurationClassPostProcessor`：處理 Spring 應用上下文中的**配置類**，解析 `@Bean` 等註解，並進行 CGLIB 提升
- `AutowiredAnnotationBeanPostProcessor`：解析 `@Autowired` 和 `@Value` 註解標註的屬性，獲取對應屬性值，進行依賴注入
- `CommonAnnotationBeanPostProcessor`：會解析 `@Resource` 註解標註的屬性，獲取對應的屬性值，進行依賴注入
- `EventListenerMethodProcessor`：解析 `@EventListener` 註解標註的方法，會將其解析成 Spring 事件監聽器並註冊
- `DefaultEventListenerFactory`：幫助 EventListenerMethodProcessor 將 `@EventListener` 註解標註的方法生成事件監聽器
#### 註冊過程
在[**《BeanDefinition 的解析過程（面向註解）》**](https://www.cnblogs.com/lifullmoon/p/14451788.html)文章中講到，如果在 XML 配置檔案中配置了 ` registerAnnotationConfigProcessors(
BeanDefinitionRegistry registry, @Nullable Object source) {
DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
if (beanFactory != null) {
if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
}
if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
}
}
Set beanDefs = new LinkedHashSet<>(8);
// 處理 Spring 應用上下文中的配置類
if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// 處理 @Autowired 以及 @Value 註解
if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// （條件啟用）處理 JSR-250 註解 @Resource，如 @PostConstruct、@PreDestroy 等
// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// Processor 物件（條件啟用）處理 JPA 註解場景
// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition();
try {
def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
AnnotationConfigUtils.class.getClassLoader()));
}
catch (ClassNotFoundException ex) {
throw new IllegalStateException(
"Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
}
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
}
// 處理標註 @EventListener 的 Spring 事件監聽方法
if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
}
// 用於 @EventListener 標註的事件監聽方法構建成 ApplicationListener 物件
if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
def.setSource(source);
beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
}
return beanDefs;
}
private static BeanDefinitionHolder registerPostProcessor(
BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {
definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
registry.registerBeanDefinition(beanName, definition);
return new BeanDefinitionHolder(definition, beanName);
}
```
整個過程就是將上面“處理器”小節中講到的幾個處理器進行註冊
### ConfigurationClassPostProcessor
`org.springframework.context.annotation.ConfigurationClassPostProcessor`，BeanDefinitionRegistryPostProcessor 處理器，解析**配置類**
#### 構造方法
```java
public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor,
PriorityOrdered, ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware {
private static final String IMPORT_REGISTRY_BEAN_NAME =
ConfigurationClassPostProcessor.class.getName() + ".importRegistry";
private SourceExtractor sourceExtractor = new PassThroughSourceExtractor();
private ProblemReporter problemReporter = new FailFastProblemReporter();
@Nullable
private Environment environment;
private ResourceLoader resourceLoader = new DefaultResourceLoader();
@Nullable
private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();
private MetadataReaderFactory metadataReaderFactory = new CachingMetadataReaderFactory();
private boolean setMetadataReaderFactoryCalled = false;
/** 已處理過的 BeanDefinitionRegistry 的 ID */
private final Set registriesPostProcessed = new HashSet<>();
/** 已處理過的 ConfigurableListableBeanFactory 的 ID */
private final Set factoriesPostProcessed = new HashSet<>();
/** 用於掃描出 ConfigurationClass 中的 BeanDefinition 並註冊 */
@Nullable
private ConfigurationClassBeanDefinitionReader reader;
private boolean localBeanNameGeneratorSet = false;
/* Using short class names as default bean names */
private BeanNameGenerator componentScanBeanNameGenerator = new AnnotationBeanNameGenerator();
}
```
實現了 BeanDefinitionRegistryPostProcessor 介面（繼承了 BeanFactoryPostProcessor 介面）
在[**《Spring 應用上下文 ApplicationContext》**](https://www.cnblogs.com/lifullmoon/p/14453083.html)文章“BeanFactory 後置處理階段”的小節可以知道，BeanDefinitionRegistryPostProcessor 優先於 BeanFactoryPostProcessor，所以我們先來看到前者的實現
#### 1. postProcessBeanDefinitionRegistry 方法
`postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry)` 方法，對 BeanDefinitionRegistry 的後置處理，其實這個入參就是 DefaultListableBeanFactory，如下：
```java
@Override
public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
int registryId = System.identityHashCode(registry);
if (this.registriesPostProcessed.contains(registryId)) {
throw new IllegalStateException(
"postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
}
if (this.factoriesPostProcessed.contains(registryId)) {
throw new IllegalStateException(
"postProcessBeanFactory already called on this post-processor against " + registry);
}
// 保證不被二次處理
this.registriesPostProcessed.add(registryId);
// 處理**配置類**
processConfigBeanDefinitions(registry);
}
```
使用 `registry` 的雜湊值作為 ID 儲存在 `registriesPostProcessed`，保證同一個 BeanDefinitionRegistry 不會被重複處理，最後呼叫 `processConfigBeanDefinitions(BeanDefinitionRegistry)` 方法
#### 2. processConfigBeanDefinitions 方法
`processConfigBeanDefinitions(BeanDefinitionRegistry)` 方法，處理**配置類**（過程有點長），如下：
```java
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
List configCandidates = new ArrayList<>();
// <1> 獲取已有的 BeanDefinition 名稱的集合
String[] candidateNames = registry.getBeanDefinitionNames();
// <2> 找出是**配置類**的 BeanDefinition 物件們
for (String beanName : candidateNames) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
// 判斷是否已經處理過，已處理則不再處理，保證不被二次處理
if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
if (logger.isDebugEnabled()) {
logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
}
// 檢查是否帶有 @Configuration 註解，設定 isFullConfigurationClass
// 或者帶有 @Component | @ComponentScan | @Import | @ImportSource | 內部存在 @Bean 的方法，設定為 isLiteConfigurationClass
// 符合上面其中一個條件都算**配置類**，需要進行處理
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
// Return immediately if no @Configuration classes were found
// <3> 沒有需要處理的**配置類**則直接 `return`
if (configCandidates.isEmpty()) {
return;
}
// Sort by previously determined @Order value, if applicable
// <4> 根據 @Order 註解進行排序
configCandidates.sort((bd1, bd2) -> {
int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
return Integer.compare(i1, i2);
});
// Detect any custom bean name generation strategy supplied through the enclosing application context
SingletonBeanRegistry sbr = null;
if (registry instanceof SingletonBeanRegistry) {
sbr = (SingletonBeanRegistry) registry;
if (!this.localBeanNameGeneratorSet) {
// 探測名稱為 org.springframework.context.annotation.internalConfigurationBeanNameGenerator 的自定義 Bean 名稱生成器
BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
if (generator != null) {
this.componentScanBeanNameGenerator = generator;
this.importBeanNameGenerator = generator;
}
}
}
if (this.environment == null) {
this.environment = new StandardEnvironment();
}
// Parse each @Configuration class
// <5> 建立一個 `ConfigurationClassParser` 物件，用於解析符合條件的**配置類**
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
Set candidates = new LinkedHashSet<>(configCandidates);
Set alreadyParsed = new HashSet<>(configCandidates.size());
do {
/**
* <5.1>
* 對所有的**配置類**進行解析，解析其內部的註解（@PropertySource、@ComponentScan、@Import、@ImportResource、@Bean）
* 每個**配置類**會生成一個 {@link ConfigurationClass} 物件
* 其中 @Bean 標註的方法轉換成 {@link BeanMethod} 物件儲存在 {@link ConfigurationClass#beanMethods} 集合中
*/
parser.parse(candidates);
/**
* <5.2>
* 對所有的 {@link ConfigurationClass} 物件進行校驗
* Class 物件不能被 final 修飾，@Bean 標註的方法不能被 private 修飾
*/
parser.validate();
// <5.3> 獲取解析出來的 ConfigurationClass 們，並移除已經處理過的物件
Set configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
configClasses.removeAll(alreadyParsed);
// Read the model and create bean definitions based on its content
/*
* <5.4>
* 建立一個 ConfigurationClassBeanDefinitionReader 物件，用於掃描出 ConfigurationClass 中的 BeanDefinition 並註冊
* 例如 @Bean 標註的方法需要註冊、@ImportResource 註解配置的資原始檔中配置的 Bean 需要註冊
*/
if (this.reader == null) {
this.reader = new ConfigurationClassBeanDefinitionReader(
registry, this.sourceExtractor, this.resourceLoader, this.environment,
this.importBeanNameGenerator, parser.getImportRegistry());
}
/*
* <5.4.1>
* 掃描所有的 ConfigurationClass，註冊相應的 BeanDefinition，主要有以下來源：
* 1. @Import 註解匯入物件
* 2. 其內部定義的帶有 @Bean 註解的方法
* 3. @ImportResource 註解匯入資源
* 4. @Import 註解匯入的 ImportBeanDefinitionRegistrar 介面的實現類可自定義實現註冊相關 BeanDefinition
*/
this.reader.loadBeanDefinitions(configClasses);
// <5.5> 將這些 ConfigurationClass 儲存至已解析的集合中
alreadyParsed.addAll(configClasses);
candidates.clear();
/*
* <6>
* 從上述過程註冊的 BeanDefinition 中，找到沒有還解析過的 BeanDefinition 們，再迴圈解析
* 例如 @Bean 標註的方法是新註冊的 BeanDefinition，也可能是一個**配置類**，但是還沒有被這裡解析過
*/
if (registry.getBeanDefinitionCount() > candidateNames.length) {
String[] newCandidateNames = registry.getBeanDefinitionNames();
Set oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
Set alreadyParsedClasses = new HashSet<>();
for (ConfigurationClass configurationClass : alreadyParsed) {
alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
}
for (String candidateName : newCandidateNames) {
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());
// 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();
}
}
```
過程如下：
1. 獲取所有的 BeanDefinition 名稱的集合
2. 找出是**配置類**的 BeanDefinition 物件們，儲存至 `configCandidates` 集合中
- 判斷是否已經處理過，已處理則不再處理，保證不被二次處理，否則
- 檢查是否帶有 `@Configuration` 註解，或者帶有 `@Component` | `@ComponentScan` | `@Import` | `@ImportSource` | 內部存在 `@Bean` 的方法，符合前面其中一個條件都算**配置類**，需要進行處理
3. 上一步沒有找到需要處理的**配置類**，則直接 `return` 返回
4. 根據 @Order 註解對 `configCandidates` 集合中的**配置類**進行排序
------
5. 建立一個 `ConfigurationClassParser` 物件，用於解析符合條件的**配置類**，會先生成 ConfigurationClass 物件儲存至其內部，然後通過 `ConfigurationClassBeanDefinitionReader` 讀取器從這些 ConfigurationClass 物件中解析出 BeanDefinition
1. **【核心】**對所有的**配置類**進行解析，呼叫 `ConfigurationClassParser#parse(Set)` 方法，解析其內部的註解（`@PropertySource`、`@ComponentScan`、`@Import`、`@ImportResource`、`@Bean`）。每個**配置類**會生成一個 `ConfigurationClass` 物件，其中 `@Bean` 標註的方法轉換成 BeanMethod 物件儲存在 ConfigurationClass.beanMethods 集合中
2. 對所有的 ConfigurationClass 物件進行校驗：Class 物件不能被 final 修飾，`@Bean` 標註的方法不能被 private 修飾
3. 獲取上面解析出來的 ConfigurationClass 們，放入 `configClasses` 集合中，並移除已經處理過的物件
4. 建立一個 `ConfigurationClassBeanDefinitionReader` 物件，呼叫其 `loadBeanDefinitions(Set)` 方法，掃描出 ConfigurationClass 中的 BeanDefinition 並註冊。例如 `@Bean` 標註的方法需要註冊、`@ImportResource` 註解配置的資原始檔中配置的 Bean 需要註冊
1. **【核心】**掃描所有的 ConfigurationClass，註冊相應的 BeanDefinition，主要有以下來源：
- `@Import` 註解匯入物件
- 其內部定義的帶有 `@Bean` 註解的方法
- `@ImportResource` 註解匯入資源
- `@Import` 註解匯入的 ImportBeanDefinitionRegistrar 介面的實現類可自定義實現註冊相關 BeanDefinition
5. 將這些 ConfigurationClass 儲存至 `alreadyParsed` 已解析的集合中
6. 從上述過程註冊的 BeanDefinition 中，找到沒有還解析過的 BeanDefinition 們，再迴圈解析。例如 `@Bean` 標註的方法是新註冊的 BeanDefinition，也可能又是一個**配置類**，但是還沒有被這裡解析過，所以需要再次掃描，如果還有未處理的**配置類**則需要進行處理
7. 清理上述解析過程中產生的元資料快取，例如通過 ASM 從 .class 檔案中獲取到的 Class 資訊，需要清理
總結：先根據**配置類**生成 ConfigurationClass 物件，然後根據該物件解析出 BeanDefinition 並註冊
> **配置類**：帶有 `@Configuration` 註解的類，如果這個類帶有 `@Component` | `@ComponentScan` | `@Import` | `@ImportSource` 註解，或者內部存在 `@Bean` 的方法都算**配置類**
上面的第 `5.1` 和 `5.4` 分別對應 ConfigurationClassParser 和 ConfigurationClassBeanDefinitionReader 兩個類，接下來會依次分析
#### 3. postProcessBeanFactory 方法
`postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory)` 方法，對 ConfigurableListableBeanFactory 的後置處理，其實這個入參就是 DefaultListableBeanFactory，和 `postProcessBeanDefinitionRegistry(BeanDefinitionRegistry)` 方法是同一個入參，如下：
```java
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
int factoryId = System.identityHashCode(beanFactory);
if (this.factoriesPostProcessed.contains(factoryId)) {
throw new IllegalStateException(
"postProcessBeanFactory already called on this post-processor against " + beanFactory);
}
this.factoriesPostProcessed.add(factoryId);
if (!this.registriesPostProcessed.contains(factoryId)) {
// BeanDefinitionRegistryPostProcessor hook apparently not supported...
// Simply call processConfigurationClasses lazily at this point then.
processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
}
// CGLIB 提升
enhanceConfigurationClasses(beanFactory);
beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
}
```
如果這個 DefaultListableBeanFactory 沒有處理過，這裡會和上面的過程一樣呼叫 `processConfigBeanDefinitions(BeanDefinitionRegistry)` 方法進行處理。接下來，會呼叫 `enhanceConfigurationClasses(ConfigurableListableBeanFactory)` 方法對 `@Configuration` 註解的**配置類**進行 CGLIB 提升，主要幫助實現 AOP 特性
#### 4. enhanceConfigurationClasses 方法
`enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory)` 方法，對 `@Configuration` 註解的**配置類**進行 CGLIB 提升，如下：
```java
public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {
Map configBeanDefs = new LinkedHashMap<>();
for (String beanName : beanFactory.getBeanDefinitionNames()) {
BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
/*
* 如果配置了 @Configuration 註解
*/
if (ConfigurationClassUtils.isFullConfigurationClass(beanDef)) {
/*
* 如果不是 AbstractBeanDefinition（Spring 內部 BeanDefinition 實現類都是它的子類），則丟擲異常
*/
if (!(beanDef instanceof AbstractBeanDefinition)) {
throw new BeanDefinitionStoreException("Cannot enhance @Configuration bean definition '" +
beanName + "' since it is not stored in an AbstractBeanDefinition subclass");
}
/*
* 如果這個 Bean 已經初始化了
*/
else if (logger.isInfoEnabled() && beanFactory.containsSingleton(beanName)) {
logger.info("Cannot enhance @Configuration bean definition '" + beanName +
"' since its singleton instance has been created too early. The typical cause " +
"is a non-static @Bean method with a BeanDefinitionRegistryPostProcessor " +
"return type: Consider declaring such methods as 'static'.");
}
configBeanDefs.put(beanName, (AbstractBeanDefinition) beanDef);
}
}
if (configBeanDefs.isEmpty()) {
// nothing to enhance -> return immediately
/*
* 沒有需要 CGLIB 提升的類則直接返回
*/
return;
}
ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();
for (Map.Entry entry : configBeanDefs.entrySet()) {
AbstractBeanDefinition beanDef = entry.getValue();
// If a @Configuration class gets proxied, always proxy the target class
beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
try {
// Set enhanced subclass of the user-specified bean class
// 通過類載入器獲取這個 BeanDefinition 的 Class 物件
Class configClass = beanDef.resolveBeanClass(this.beanClassLoader);
if (configClass != null) {
// 通過 CGLIB 建立一個子類（代理類）
Class enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);
if (configClass != enhancedClass) {
if (logger.isTraceEnabled()) {
logger.trace(String.format("Replacing bean definition '%s' existing class '%s' with " +
"enhanced class '%s'", entry.getKey(), configClass.getName(), enhancedClass.getName()));
}
// 設定該 BeanDefinition 的 Class 物件為 CGLIB 子類（代理類），用於幫助實現 AOP 特性
beanDef.setBeanClass(enhancedClass);
}
}
}
catch (Throwable ex) {
throw new IllegalStateException("Cannot load configuration class: " + beanDef.getBeanClassName(), ex);
}
}
}
```
整個過程大致就是：如果是 `@Configuration` 註解標註的類，則通過 CGLIB 建立一個子類（代理類）並設定到這個 BeanDefinition 的 `beanClass` 屬性中。這樣一來， `@Configuration` 註解標註的類就得到了 CGLIB 的提升，主要幫助實現 AOP 相關特性，這裡不做詳細展述，具體過程請期待後續的 Spring AOP 相關文章:smile:
### ConfigurationClass
`org.springframework.context.annotation.ConfigurationClass`，根據前面提到的**配置類**解析出來的物件，如下：
```java
final class ConfigurationClass {
/**
* 元資料資訊，根據通過它獲取**配置類** Class 物件的所有資訊
*/
private final AnnotationMetadata metadata;
private final Resource resource;
@Nullable
private String beanName;
/**
* 假如這個 Class 物件是通過 @Import 註解被匯入的
* 那麼這個集合儲存的就是該 @Import 註解標註的配置類，表示誰把它匯入的
*/
private final Set importedBy = new LinkedHashSet<>(1);
/**
* 帶有 @Bean 註解的方法集合
*/
private final Set beanMethods = new LinkedHashSet<>();
/**
* 需要匯入的資源集合
*/
private final Map> importedResources = new LinkedHashMap<>();
/**
* {@link Import} 註解匯入的 ImportBeanDefinitionRegistrar 型別的物件
*/
private final Map importBeanDefinitionRegistrars = new LinkedHashMap<>();
/**
* 需要跳過的 @Bean 註解的方法集合
*/
final Set skippedBeanMethods = new HashSet<>();
/**
* Create a new {@link ConfigurationClass} with the given name.
* @param metadataReader reader used to parse the underlying {@link Class}
* @param beanName must not be {@code null}
* @see ConfigurationClass#ConfigurationClass(Class, ConfigurationClass)
*/
public ConfigurationClass(MetadataReader metadataReader, String beanName) {
Assert.notNull(beanName, "Bean name must not be null");
this.metadata = metadataReader.getAnnotationMetadata();
this.resource = metadataReader.getResource();
this.beanName = beanName;
}
// ... 省略相關建構函式、getter、setter 方法
public void validate(ProblemReporter problemReporter) {
// A configuration class may not be final (CGLIB limitation)
if (getMetadata().isAnnotated(Configuration.class.getName())) {
if (getMetadata().isFinal()) {
problemReporter.error(new FinalConfigurationProblem());
}
}
for (BeanMethod beanMethod : this.beanMethods) {
beanMethod.validate(problemReporter);
}
}
@Override
public boolean equals(Object other) {
return (this == other || (other instanceof ConfigurationClass &&
getMetadata().getClassName().equals(((ConfigurationClass) other).getMetadata().getClassName())));
}
@Override
public int hashCode() {
return getMetadata().getClassName().hashCode();
}
}
```
重寫了 `equals` 方法，是同一個 Class 物件也是相等的
### ConfigurationClassParser
`org.springframework.context.annotation.ConfigurationClassParser`，解析**配置類**，生成 ConfigurationClass 物件並儲存
#### 構造方法
```java
class ConfigurationClassParser {
private static final PropertySourceFactory DEFAULT_PROPERTY_SOURCE_FACTORY = new DefaultPropertySourceFactory();
private static final Comparator DEFERRED_IMPORT_COMPARATOR =
(o1, o2) -> AnnotationAwareOrderComparator.INSTANCE.compare(o1.getImportSelector(), o2.getImportSelector());
private final MetadataReaderFactory metadataReaderFactory;
private final ProblemReporter problemReporter;
private final Environment environment;
private final ResourceLoader resourceLoader;
private final BeanDefinitionRegistry registry;
private final ComponentScanAnnotationParser componentScanParser;
private final ConditionEvaluator conditionEvaluator;
/**
* 儲存**配置類**解析出來的 ConfigurationClass 物件
*/
private final Map configurationClasses = new LinkedHashMap<>();
/**
* 儲存**配置類**的父類對應的 ConfigurationClass 物件，也就是這個配置類對應的
*/
private final Map knownSuperclasses = new HashMap<>();
private final List propertySourceNames = new ArrayList<>();
private final ImportStack importStack = new ImportStack();
private final DeferredImportSelectorHandler deferredImportSelectorHandler = new DeferredImportSelectorHandler();
public ConfigurationClassParser(MetadataReaderFactory metadataReaderFactory,
ProblemReporter problemReporter, Environment environment, ResourceLoader resourceLoader,
BeanNameGenerator componentScanBeanNameGenerator, BeanDefinitionRegistry registry) {
this.metadataReaderFactory = metadataReaderFactory;
this.problemReporter = problemReporter;
this.environment = environment;
this.resourceLoader = resourceLoader;
this.registry = registry;
this.componentScanParser = new ComponentScanAnnotationParser(
environment, resourceLoader, componentScanBeanNameGenerator, registry);
this.conditionEvaluator = new ConditionEvaluator(registry, environment, resourceLoader);
}
}
```
#### 1. parse 方法
`parse(Set configCandidates)` 方法，對這些**配置類**進行解析，如下：
```java
public void parse(Set configCandidates) {
// 遍歷所有的 BeanDefinition
for (BeanDefinitionHolder holder : configCandidates) {
BeanDefinition bd = holder.getBeanDefinition();
try {
if (bd instanceof AnnotatedBeanDefinition) {
// 解析，生成的 ConfigurationClass 物件儲存在 `configurationClasses` 集合中
parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
}
else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
// 解析，生成的 ConfigurationClass 物件儲存在 `configurationClasses` 集合中
parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
}
else {
// 解析，生成的 ConfigurationClass 物件儲存在 `configurationClasses` 集合中
parse(bd.getBeanClassName(), holder.getBeanName());
}
}
catch (BeanDefinitionStoreException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
}
}
this.deferredImportSelectorHandler.process();
}
```
遍歷這些**配置類**，呼叫 `parse(...)` 不同的過載方法進行解析，如下：
```java
protected final void parse(@Nullable String className, String beanName) throws IOException {
Assert.notNull(className, "No bean class name for configuration class bean definition");
MetadataReader reader = this.metadataReaderFactory.getMetadataReader(className);
processConfigurationClass(new ConfigurationClass(reader, beanName));
}
protected final void parse(Class clazz, String beanName) throws IOException {
processConfigurationClass(new ConfigurationClass(clazz, beanName));
}
protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
processConfigurationClass(new ConfigurationClass(metadata, beanName));
}
```
先為這個 **配置類** 建立一個 ConfigurationClass 物件，然後再呼叫 `processConfigurationClass(ConfigurationClass)` 方法進行解析
#### 2. processConfigurationClass 方法
`processConfigurationClass(ConfigurationClass configClass)` 方法，解析**配置類**，所有資訊都儲存在這個 ConfigurationClass 中，如下：
```java
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
// @Conditional 的處理，是否需要跳過
if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
return;
}
ConfigurationClass existingClass = this.configurationClasses.get(configClass);
if (existingClass != null) {
if (configClass.isImported()) {
if (existingClass.isImported()) {
existingClass.mergeImportedBy(configClass);
}
// Otherwise ignore new imported config class; existing non-imported class overrides it.
return;
}
else {
// Explicit bean definition found, probably replacing an import.
// Let's remove the old one and go with the new one.
this.configurationClasses.remove(configClass);
this.knownSuperclasses.values().removeIf(configClass::equals);
}
}
// Recursively process the configuration class and its superclass hierarchy.
// 獲取這個 ConfigurationClass 配置類的所在 Class 物件
SourceClass sourceClass = asSourceClass(configClass);
do {
// 解析 ConfigurationClass 物件，對相關注解（@PropertySource、@ComponentScan、@Import、@ImportResource、@Bean）進行解析
// 其中解析出帶有 @Bean 註解方法儲存至其中，@ImportResource 配置的資源也儲存其中
sourceClass = doProcessConfigurationClass(configClass, sourceClass);
}
// 父類迴圈解析
while (sourceClass != null);
// 將該 ConfigurationClass 配置類儲存
this.configurationClasses.put(configClass, configClass);
}
```
過程如下：
1. 會先根據 `@Conditional` 註解判斷是否需要跳過
2. 呼叫 `doProcessConfigurationClass(ConfigurationClass, SourceClass)` 方法進行解析，會遍歷父類
3. 將**配置類**對應的 ConfigurationClass 物件儲存至 `configurationClasses` 集合中
#### 3. doProcessConfigurationClass 方法
`doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)` 方法，解析**配置類**，所有資訊都儲存在這個 ConfigurationClass 中，如下：
```java
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
throws IOException {
// <1> 先處理內部成員類
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
// Recursively process any member (nested) classes first
processMemberClasses(configClass, sourceClass);
}
// Process any @PropertySource annotations
// <2> 處理 @PropertySource 註解，載入對應的資源
for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), PropertySources.class,
org.springframework.context.annotation.PropertySource.class)) {
if (this.environment instanceof ConfigurableEnvironment) {
processPropertySource(propertySource);
}
else {
logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
"]. Reason: Environment must implement ConfigurableEnvironment");
}
}
// Process any @ComponentScan annotations
// <3> 處理 @ComponentScan 註解，掃描出指定包路徑下的 BeanDefinition 們
Set componentScans = AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
if (!componentScans.isEmpty() &&
!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
for (AnnotationAttributes componentScan : componentScans) {
// The config class is annotated with @ComponentScan -> perform the scan immediately
// 底層會通過 ClassPathBeanDefinitionScanner 掃描指定的包路徑，註冊相關 BeanDefinition 們
Set scannedBeanDefinitions = this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
// Check the set of scanned definitions for any further config classes and parse recursively if needed
for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
if (bdCand == null) {
bdCand = holder.getBeanDefinition();
}
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}
// Process any @Import annotations
// <4> 處理 @Import 註解，ImportSelector 和 ImportBeanDefinitionRegistrar 型別會有相關處理
// 註解中的 Class 物件也會生成一個 ConfigurationClass 物件，再進行處理
// 這個物件不同的是其內部 `importedBy` 屬性不為空，儲存了是被誰 Import 的
processImports(configClass, sourceClass, getImports(sourceClass), true);
// Process any @ImportResource annotations
// <5> 處理 @ImportResource 註解，獲取需要匯入的資源配置資訊
AnnotationAttributes importResource = AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
if (importResource != null) {
String[] resources = importResource.getStringArray("locations");
Class readerClass = importResource.getClass("reader");
for (String resource : resources) {
String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
configClass.addImportedResource(resolvedResource, readerClass);
}
}
// Process individual @Bean methods
// <6> 解析出所有帶有 @Bean 註解的方法，通過 ASM 保證每個方法定義的順序
Set beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
// Process default methods on interfaces
// <6> 解析介面中帶有 @Bean 註解的預設方法
processInterfaces(configClass, sourceClass);
// Process superclass, if any
// <7> 如果有父類，則返回父類，再進行解析
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();
}
}
// No superclass -> processing is complete
// <8> 已經是頂部類，表示解析完成
return null;
}
```
過程大致如下：
1. 先處理內部成員類，呼叫 `processMemberClasses(...)` 方法，如果內部成員類也是**配置類**，同樣呼叫前面的 `processConfigurationClass(ConfigurationClass)`方法進行處理，這裡不展開講述
2. 處理 `@PropertySource` 註解，加載出對應的 Resource 資源，將其新增至 Environment 環境中，這裡不展開講述
3. 處理 `@ComponentScan` 註解，通過 ComponentScanAnnotationParser 掃描出指定包路徑下的 BeanDefinition 們並註冊，然後再遍歷處理，如果是**配置類**，同樣呼叫前面的 `parse(...)` 方法，這裡不展開講述
4. 處理 `@Import` 註解中的 Class 物件，呼叫 `processImports(...)` 方法，這裡不展開講述，分為下面幾種情況：
- ImportSelector 的實現類：呼叫其 `selectImports(AnnotationMetadata)` 方法獲取需要匯入的 Class 類名，再次呼叫 `processImports(...)` 方法進行處理
- ImportBeanDefinitionRegistrar 的實現類：將這個實現類儲存在 `ConfigurationClass.importBeanDefinitionRegistrars` 集合中
- 否則，為 `@Import` 註解中的 **配置類** 建立 ConfigurationClass 物件，同樣呼叫`processConfigurationClass(ConfigurationClass)`方法進行處理
5. 處理 `@ImportResource` 註解，獲取需要匯入的資源配置資訊，將這些配置資訊新增至 `ConfigurationClass.importedResources` 集合中
6. 解析出所有帶有 `@Bean` 註解的方法，底層通過 **ASM**（Java 位元組碼操作和分析框架）進行解析，然後將這些方法封裝成 BeanMethod 物件，並儲存至 `ConfigurationClass.beanMethods` 集合中，這裡不展開講述
7. 如果有父類，則迴圈進行解析
整個過程就是解析**配置類**中的各種註解，解析結果都儲存在 ConfigurationClass 中，所以說整個過程就是為**配置類**生成一個 ConfigurationClass 物件，將這些資訊生成對應的 BeanDefinition 物件並註冊到 Spring 上下文的過程還在後面，也就是下面要講的 ConfigurationClassBeanDefinitionReader 讀取器
### ConfigurationClassBeanDefinitionReader
`org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader`，**配置類**中 BeanDefinition 的讀取器，根據 ConfigurationClass 解析出 BeanDefinition 並註冊
#### 1. loadBeanDefinitions 方法
`loadBeanDefinitions(Set)` 方法，從 ConfigurationClass 中加載出 BeanDefinition，如下：
```java
public void loadBeanDefinitions(Set configurationModel) {
// 建立 @Conditional 註解的計算器
TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
// 遍歷所有的 ConfigurationClass，進行處理
for (ConfigurationClass configClass : configurationModel) {
loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
}
}
```
遍歷所有的 ConfigurationClass 物件，呼叫 `loadBeanDefinitionsForConfigurationClass(...)` 方法
#### 2. loadBeanDefinitionsForConfigurationClass 方法
`loadBeanDefinitionsForConfigurationClass(ConfigurationClass, TrackedConditionEvaluator)` 方法，從 ConfigurationClass 中加載出 BeanDefinition 並註冊，如下：
```java
private void loadBeanDefinitionsForConfigurationClass(
ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
// <1> 如果不符合 @Conditional 註解的條件，則跳過
if (trackedConditionEvaluator.shouldSkip(configClass)) {
String beanName = configClass.getBeanName();
if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
this.registry.removeBeanDefinition(beanName);
}
this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
return;
}
// <2> 如果當前 ConfigurationClass 是通過 @Import 註解被匯入的
if (configClass.isImported()) {
// <2.1> 根據該 ConfigurationClass 物件生成一個 BeanDefinition 並註冊
registerBeanDefinitionForImportedConfigurationClass(configClass);
}
// <3> 遍歷當前 ConfigurationClass 中所有的 @Bean 註解標註的方法
for (BeanMethod beanMethod : configClass.getBeanMethods()) {
// <3.1> 根據該 BeanMethod 物件生成一個 BeanDefinition 並註冊（注意這裡有無 static 修飾會有不同的配置）
loadBeanDefinitionsForBeanMethod(beanMethod);
}
// <4> 對 @ImportResource 註解配置的資源進行處理，對裡面的配置進行解析並註冊 BeanDefinition
loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
// <5> 通過 @Import 註解匯入的 ImportBeanDefinitionRegistrar 實現類往 BeanDefinitionRegistry 註冊 BeanDefinition
// Mybatis 整合 Spring 就是基於這個實現的，可檢視 Mybatis-Spring 專案中的 MapperScannerRegistrar 這個類
loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}
```
過程大致如下：
1. 如果不符合 `@Conditional` 註解的條件，則跳過
2. 如果當前 ConfigurationClass 是通過 `@Import` 註解被匯入的
1. 根據該 ConfigurationClass 物件生成一個 BeanDefinition 並註冊，呼叫 `registerBeanDefinitionForImportedConfigurationClass(ConfigurationClass)` 方法，如下：
```java
private void registerBeanDefinitionForImportedConfigurationClass(ConfigurationClass configClass) {
AnnotationMetadata metadata = configClass.getMetadata();
// 為該 ConfigurationClass 配置類建立一個 BeanDefinition 物件
AnnotatedGenericBeanDefinition configBeanDef = new AnnotatedGenericBeanDefinition(metadata);
ScopeMetadata scopeMetadata = scopeMetadataResolver.resolveScopeMetadata(configBeanDef);
configBeanDef.setScope(scopeMetadata.getScopeName());
// 生成一個 Bean 的名稱
String configBeanName = this.importBeanNameGenerator.generateBeanName(configBeanDef, this.registry);
// 設定一些配置資訊（沒有配置則會有預設值）
AnnotationConfigUtils.processCommonDefinitionAnnotations(configBeanDef, metadata);
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(configBeanDef, configBeanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
// 註冊該 BeanDefinition 物件
this.registry.registerBeanDefinition(definitionHolder.getBeanName(), definitionHolder.getBeanDefinition());
// 設定 Bean 的名稱
configClass.setBeanName(configBeanName);
}
```
根據這個類的元資訊生成一個 AnnotatedGenericBeanDefinition 物件，並註冊
3. 遍歷當前 ConfigurationClass 中所有的 `@Bean` 註解標註的方法
1. 根據該 BeanMethod 物件生成一個 BeanDefinition 並註冊（注意這裡有無 static 修飾會有不同的配置），呼叫 `loadBeanDefinitionsForBeanMethod(BeanMethod)` 方法，在後面分析
4. 對 `@ImportResource` 註解配置的資源進行處理，對裡面的配置進行解析並註冊 BeanDefinition，通過 XmlBeanDefinitionReader 對該配置檔案進行掃描，在前面的[**《BeanDefinition 的載入階段（XML 檔案）》**](https://www.cnblogs.com/lifullmoon/p/14437305.html)文章中已經分析過
5. 通過 `@Import` 註解匯入的 ImportBeanDefinitionRegistrar 實現類往 BeanDefinitionRegistry 註冊 BeanDefinition，也就是呼叫這個實現類的 `registerBeanDefinitions(AnnotationMetadata, BeanDefinitionRegistry)` 方法，自定義註冊 BeanDefinition
該過程會把 ConfigurationClass 中的資訊解析成 BeanDefinition 並註冊，其中第 `5` 步可參考 Mybatis 整合 Spring 的專案中的 MapperScannerRegistrar 類，可參考我的另一篇文章[**《精盡MyBatis原始碼分析 - MyBatis-Spring 原始碼分析》**](https://www.cnblogs.com/lifullmoon/p/14015235.html)
#### 3. loadBeanDefinitionsForBeanMethod 方法
`loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod)` 方法，將 `@Bean` 註解標註的方法解析成 BeanDefinition 並註冊，如下：
```java
private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
ConfigurationClass configClass = beanMethod.getConfigurationClass();
MethodMetadata metadata = beanMethod.getMetadata();
String methodName = metadata.getMethodName();
// Do we need to mark the bean as skipped by its condition?
// 如果不符合 @Conditional 註解的條件，則跳過
if (this.conditionEvaluator.shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN)) {
configClass.skippedBeanMethods.add(methodName);
return;
}
if (configClass.skippedBeanMethods.contains(methodName)) {
return;
}
// 獲取 @Bean 註解元資訊
AnnotationAttributes bean = AnnotationConfigUtils.attributesFor(metadata, Bean.class);
Assert.state(bean != null, "No @Bean annotation attributes");
// Consider name and any aliases
List names = new ArrayList<>(Arrays.asList(bean.getStringArray("name")));
String beanName = (!names.isEmpty() ? names.remove(0) : methodName);
// Register aliases even when overridden
for (String alias : names) {
this.registry.registerAlias(beanName, alias);
}
// Has this effectively been overridden before (e.g. via XML)?
if (isOverriddenByExistingDefinition(beanMethod, beanName)) {
if (beanName.equals(beanMethod.getConfigurationClass().getBeanName())) {
throw new BeanDefinitionStoreException(beanMethod.getConfigurationClass().getResource().getDescription(),
beanName, "Bean name derived from @Bean method '" + beanMethod.getMetadata().getMethodName() +
"' clashes with bean name for containing configuration class; please make those names unique!");
}
return;
}
// 為該 BeanMethod 建立一個 BeanDefinition 物件
ConfigurationClassBeanDefinition beanDef = new ConfigurationClassBeanDefinition(configClass, metadata);
beanDef.setResource(configClass.getResource());
beanDef.setSource(this.sourceExtractor.extractSource(metadata, configClass.getResource()));
/*
* 如果該方法被 static 修飾
* 直接設定 `beanClassName` 和 `factoryMethodName` 屬性，通過這兩者就可以建立當前方法 Bean 物件
*/
if (metadata.isStatic()) {
// static @Bean method
beanDef.setBeanClassName(configClass.getMetadata().getClassName());
beanDef.setFactoryMethodName(methodName);
}
/*
* 否則，為內部方法
* 這裡是設定 `factoryBeanName` 和 `factoryMethodName` 屬性，通過這兩者就可以建立當前 Bean 物件
* 和被 static 修飾的方法 Bean 物件不同的是，`factoryBeanName` 指定的 Bean 需要先被初始化，然後呼叫該方法建立當前方法 Bean 物件
* 而被 static 修飾可以直接通過其 Class 物件呼叫方法，無需先初始化 Bean 物件
*/
else {
// instance @Bean method
beanDef.setFactoryBeanName(configClass.getBeanName());
beanDef.setUniqueFactoryMethodName(methodName);
}
// 設定注入模式為構造器注入，因為方法可能帶有引數，需要注入
beanDef.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
beanDef.setAttribute(org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor.
SKIP_REQUIRED_CHECK_ATTRIBUTE, Boolean.TRUE);
// 設定一些配置資訊（沒有配置則會有預設值）
AnnotationConfigUtils.processCommonDefinitionAnnotations(beanDef, metadata);
// 如果配置了注入模式，則覆蓋上面的'構造器注入'
Autowire autowire = bean.getEnum("autowire");
if (autowire.isAutowire()) {
beanDef.setAutowireMode(autowire.value());
}
boolean autowireCandidate = bean.getBoolean("autowireCandidate");
if (!autowireCandidate) {
beanDef.setAutowireCandidate(false);
}
// 如果配置了 `initMethod`，則設定初始化方法名稱
String initMethodName = bean.getString("initMethod");
if (StringUtils.hasText(initMethodName)) {
beanDef.setInitMethodName(initMethodName);
}
// 如果配置了 `destroyMethod`，則設定銷燬方法名稱
String destroyMethodName = bean.getString("destroyMethod");
beanDef.setDestroyMethodName(destroyMethodName);
// Consider scoping
// 如果配置了 @Scope 註解，則進行相關配置
ScopedProxyMode proxyMode = ScopedProxyMode.NO;
AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(metadata, Scope.class);
if (attributes != null) {
beanDef.setScope(attributes.getString("value"));
proxyMode = attributes.getEnum("proxyMode");
if (proxyMode == ScopedProxyMode.DEFAULT) {
proxyMode = ScopedProxyMode.NO;
}
}
// Replace the original bean definition with the target one, if necessary
BeanDefinition beanDefToRegister = beanDef;
if (proxyMode != ScopedProxyMode.NO) {
BeanDefinitionHolder proxyDef = ScopedProxyCreator.createScopedProxy(
new BeanDefinitionHolder(beanDef, beanName), this.registry,
proxyMode == ScopedProxyMode.TARGET_CLASS);
beanDefToRegister = new ConfigurationClassBeanDefinition(
(RootBeanDefinition) proxyDef.getBeanDefinition(), configClass, metadata);
}
// 註冊該 BeanDefinition 物件
this.registry.registerBeanDefinition(beanName, beanDefToRegister);
}
```
整個過程並不複雜，大致如下：
1. 如果不符合 `@Conditional` 註解的條件，則跳過
2. 獲取 `@Bean` 註解元資訊
3. 為 `@Bean` 標註的方法（被封裝成了 BeanMethod 物件）建立一個 ConfigurationClassBeanDefinition 物件
4. 根據註解元資訊設定各種配置，例如 `autowire`（注入模式）、`initMethod`（初始化方法）、`destroyMethod`（銷燬方法），對於 `static` 修飾的方法有區別，如下：
- 靜態方法會設定 `beanClass`（Class 物件）和 `factoryMethodName`（方法名稱），可以直接呼叫 Class 物件的這個方法獲取 Bean
- 非靜態方法需要設定 `factoryBeanName`（該方法所屬 Bean 的名稱）和 `factoryMethodName`（方法名稱），需要先初始化這個所屬 Bean，才能呼叫這個方法獲取 Bean
5. 註冊這個 ConfigurationClassBeanDefinition 物件
### 總結
在 [**《Spring 應用上下文 ApplicationContext》**](https://www.cnblogs.com/lifullmoon/p/14453083.html)中有一個“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 相關特性，這裡沒有詳細展述，具體過程請期待後續的 Spring AOP 相關文章:smile:
> 至此，Spring IoC 的相關文章已全部完成，希望這一系列文章可以讓讀者對 Spring 有更加全面的認識，如有錯誤或者疑惑的地方，歡迎指正！！！共勉