死磕Spring之IoC篇 - BeanDefinition 的解析過程（面向註解）
阿新 • • 發佈：2021-02-26
> 該系列文章是本人在學習 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)
## BeanDefinition 的解析過程（面向註解）
前面的幾篇文章對 Spring 解析 XML 檔案生成 BeanDefinition 並註冊的過程進行了較為詳細的分析，這種定義 Bean 的方式是**面向資源（XML）**的方式。**面向註解**定義 Bean 的方式 Spring 的處理過程又是如何進行的？本文將會分析 Spring 是如何將 `@Component 註解或其派生註解` 標註的 Class 類解析成 BeanDefinition（Bean 的“前身”）並註冊。
在上一篇 [**《解析自定義標籤（XML 檔案）》**](https://www.cnblogs.com/lifullmoon/p/14449414.html)文章中提到了處理 `
### ClassPathBeanDefinitionScanner
`org.springframework.context.annotation.ClassPathBeanDefinitionScanner`，繼承 ClassPathScanningCandidateComponentProvider，classpath 下 BeanDefinition 的掃描器，支援設定過濾器
預設有三個過濾器： `@Component` 註解的過濾器，Java EE 6 的 `javax.annotation.ManagedBean` 註解過濾器，JSR-330 的 `javax.inject.Named` 註解過濾器，這裡我們重點關注第一個過濾器
#### 建構函式
```java
public class ClassPathBeanDefinitionScanner extends ClassPathScanningCandidateComponentProvider {
/** BeanDefinition 註冊中心 DefaultListableBeanFactory */
private final BeanDefinitionRegistry registry;
/** BeanDefinition 的預設配置 */
private BeanDefinitionDefaults beanDefinitionDefaults = new BeanDefinitionDefaults();
@Nullable
private String[] autowireCandidatePatterns;
/** Bean 的名稱生成器 */
private BeanNameGenerator beanNameGenerator = new AnnotationBeanNameGenerator();
private ScopeMetadataResolver scopeMetadataResolver = new AnnotationScopeMetadataResolver();
/** 是否註冊幾個關於註解的 PostProcessor 處理器 */
private boolean includeAnnotationConfig = true;
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
this(registry, true);
}
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
this(registry, useDefaultFilters, getOrCreateEnvironment(registry));
}
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
Environment environment) {
this(registry, useDefaultFilters, environment,
(registry instanceof ResourceLoader ? (ResourceLoader) registry : null));
}
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
Environment environment, @Nullable ResourceLoader resourceLoader) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
this.registry = registry;
if (useDefaultFilters) {
// 註冊預設的過濾器，@Component 註解的過濾器（具有層次性）
registerDefaultFilters();
}
setEnvironment(environment);
// 設定資源載入物件，會嘗試加載出 CandidateComponentsIndex 物件（儲存 `META-INF/spring.components` 檔案中的內容，不存在該物件為 `null`）
setResourceLoader(resourceLoader);
}
}
```
屬性不多，建構函式都會進入最下面這個構造方法，主要呼叫了兩個方法，如下：
1. 呼叫父類的 `registerDefaultFilters()` 方法，註冊幾個預設的過濾器，方法如下：
```java
protected void registerDefaultFilters() {
// 新增 @Component 註解的過濾器（具有層次性），@Component 的派生註解都符合條件
this.includeFilters.add(new AnnotationTypeFilter(Component.class));
ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
try {
this.includeFilters.add(new AnnotationTypeFilter(
((Class) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
logger.trace("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
}
catch (ClassNotFoundException ex) {
// JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
}
try {
this.includeFilters.add(new AnnotationTypeFilter(
((Class) ClassUtils.forName("javax.inject.Named", cl)), false));
logger.trace("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
}
catch (ClassNotFoundException ex) {
// JSR-330 API not available - simply skip.
}
}
```
新增 `@Component` 註解的過濾器（具有層次性），`@Component` 的派生註解都符合條件
也會新增 Java EE 6 的 `javax.annotation.ManagedBean` 註解過濾器，JSR-330 的 `javax.inject.Named` 註解過濾器
2. 呼叫父類的 `setResourceLoader(@Nullable ResourceLoader resourceLoader)` 方法，設定資源載入物件並嘗試加載出 CandidateComponentsIndex 物件，方法如下：
```java
@Override
public void setResourceLoader(@Nullable ResourceLoader resourceLoader) {
this.resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader);
this.metadataReaderFactory = new CachingMetadataReaderFactory(resourceLoader);
// 獲取所有 `META-INF/spring.components` 檔案中的內容
this.componentsIndex = CandidateComponentsIndexLoader.loadIndex(this.resourcePatternResolver.getClassLoader());
}
```
這裡有個關鍵的步驟，加載出 CandidateComponentsIndex 物件，嘗試去獲取所有 `META-INF/spring.components` 檔案中的內容，後續進行分析
#### 1. scan 方法
`scan(String... basePackages)` 方法，掃描出包路徑下符合條件 BeanDefinition 並註冊，方法如下：
```java
public int scan(String... basePackages) {
// <1> 獲取掃描前的 BeanDefinition 數量
int beanCountAtScanStart = this.registry.getBeanDefinitionCount();
// <2> 進行掃描，將過濾出來的所有的 .class 檔案生成對應的 BeanDefinition 並註冊
doScan(basePackages);
// Register annotation config processors, if necessary.
// <3> 如果 `includeAnnotationConfig` 為 `true`（預設），則註冊幾個關於註解的 PostProcessor 處理器（關鍵）
// 在其他地方也會註冊，內部會進行判斷，已註冊的處理器不會再註冊
if (this.includeAnnotationConfig) {
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
// <4> 返回本次掃描註冊的 BeanDefinition 數量
return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
}
```
過程如下：
1. 獲取掃描前的 BeanDefinition 數量
2. 進行掃描，將過濾出來的所有的 .class 檔案生成對應的 BeanDefinition 並註冊，呼叫 `doScan(String... basePackages)` 方法
3. 如果 `includeAnnotationConfig` 為 `true`（預設），則註冊幾個關於註解的 PostProcessor 處理器（關鍵），在其他地方也會註冊，內部會進行判斷，已註冊的處理器不會再註冊，記住這個 **AnnotationConfigUtils** 類
4. 返回本次掃描註冊的 BeanDefinition 數量
#### 2. doScan 方法
`doScan(String... basePackages)` 方法，掃描出包路徑下符合條件 BeanDefinition 並註冊，方法如下：
```java
protected Set doScan(String... basePackages) {
Assert.notEmpty(basePackages, "At least one base package must be specified");
// <1> 定義個 Set 集合 `beanDefinitions`，用於儲存本次掃描成功註冊的 BeanDefinition 們
Set beanDefinitions = new LinkedHashSet<>();
for (String basePackage : basePackages) { // 遍歷需要掃描的包名
// <2> 【核心】掃描包路徑，通過 ASM（Java 位元組碼的操作和分析框架）解析出所有符合條件的 BeanDefinition
Set candidates = findCandidateComponents(basePackage);
// <3> 對第 `2` 步解析出來的 BeanDefinition 依次處理，並註冊
for (BeanDefinition candidate : candidates) {
// <3.1> 解析出 @Scope 註解的元資訊並設定
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
// <3.2> 獲取或者生成一個的名稱 `beanName`
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
// <3.3> 設定相關屬性的預設值
if (candidate instanceof AbstractBeanDefinition) {
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
// <3.4> 根據這個類的相關注解設定屬性值（存在則會覆蓋預設值）
if (candidate instanceof AnnotatedBeanDefinition) {
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
// <3.5> 檢查 beanName 是否已存在，已存在但是不相容則會丟擲異常
if (checkCandidate(beanName, candidate)) {
// <3.6> 將 BeanDefinition 封裝成 BeanDefinitionHolder 物件，這裡多了一個 `beanName`
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
// <3.7> 如果代理模式是 `TARGET_CLASS`，則再建立一個 BeanDefinition 代理物件（重新設定了相關屬性），原始 BeanDefinition 已註冊
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
// <3.8> 新增至 `beanDefinitions` 集合
beanDefinitions.add(definitionHolder);
// <3.9> 註冊該 BeanDefinition
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
// <4> 返回 `beanDefinitions`（已註冊的 BeanDefinition 集合）
return beanDefinitions;
}
```
過程如下：
1. 定義個 Set 集合 `beanDefinitions`，用於儲存本次掃描成功註冊的 BeanDefinition 們
2. **【核心】**掃描包路徑，通過 ASM（Java 位元組碼的操作和分析框架）解析出所有符合條件的 BeanDefinition，呼叫父類的 `findCandidateComponents(String basePackage)` 方法
3. 對第 `2` 步解析出來的 BeanDefinition 依次處理，並註冊
1. 解析出 @Scope 註解的元資訊並設定
2. 獲取或者生成一個的名稱 `beanName`
3. 設定相關屬性的預設值
4. 根據這個類的相關注解設定屬性值（存在則會覆蓋預設值）
5. 檢查 `beanName` 是否已存在，已存在但是不相容則會丟擲異常
6. 將 BeanDefinition 封裝成 BeanDefinitionHolder 物件，這裡多了一個 `beanName`
7. 如果代理模式是 `TARGET_CLASS`，則再建立一個 BeanDefinition 代理物件（重新設定了相關屬性），原始 BeanDefinition 已註冊
8. 新增至 `beanDefinitions` 集合
9. 註冊該 BeanDefinition
4. 返回 `beanDefinitions`（已註冊的 BeanDefinition 集合）
第 `2` 步是這個掃描過程的核心步驟，在父類 **ClassPathScanningCandidateComponentProvider** 中進行分析，接下來的處理過程不復雜，獲取相關屬性進行配置
第 `7` 步建立代理物件，和 AOP 相關，感興趣的可自行檢視
### ClassPathScanningCandidateComponentProvider
`org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider`，classpath 下掃描符合條件的 BeanDefinition
#### 建構函式
```java
public class ClassPathScanningCandidateComponentProvider implements EnvironmentCapable, ResourceLoaderAware {
static final String DEFAULT_RESOURCE_PATTERN = "**/*.class";
private String resourcePattern = DEFAULT_RESOURCE_PATTERN;
/** 包含過濾器 */
private final List includeFilters = new LinkedList<>();
/** 排除過濾器 */
private final List excludeFilters = new LinkedList<>();
@Nullable
private Environment environment;
/** {@link Condition} 註解計算器 */
@Nullable
private ConditionEvaluator conditionEvaluator;
/** 資源載入器，預設 PathMatchingResourcePatternResolver */
@Nullable
private ResourcePatternResolver resourcePatternResolver;
/** MetadataReader 工廠 */
@Nullable
private MetadataReaderFactory metadataReaderFactory;
/** 所有 `META-INF/spring.components` 檔案的內容 */
@Nullable
private CandidateComponentsIndex componentsIndex;
protected ClassPathScanningCandidateComponentProvider() {
}
public ClassPathScanningCandidateComponentProvider(boolean useDefaultFilters) {
this(useDefaultFilters, new StandardEnvironment());
}
public ClassPathScanningCandidateComponentProvider(boolean useDefaultFilters, Environment environment) {
if (useDefaultFilters) {
registerDefaultFilters();
}
setEnvironment(environment);
setResourceLoader(null);
}
@Override
public void setResourceLoader(@Nullable ResourceLoader resourceLoader) {
this.resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader);
this.metadataReaderFactory = new CachingMetadataReaderFactory(resourceLoader);
// 獲取所有 `META-INF/spring.components` 檔案中的內容
this.componentsIndex = CandidateComponentsIndexLoader.loadIndex(this.resourcePatternResolver.getClassLoader());
}
}
```
建構函式在上一小節的 ClassPathBeanDefinitionScanner 的建構函式中都已經講過了
我們來看到 `componentsIndex` 屬性，呼叫 `CandidateComponentsIndexLoader#loadIndex(@Nullable ClassLoader classLoader)` 方法生成的
#### CandidateComponentsIndexLoader
`org.springframework.context.index.CandidateComponentsIndexLoader`，CandidateComponentsIndexLoader 的載入器，程式碼如下：
```java
public final class CandidateComponentsIndexLoader {
public static final String COMPONENTS_RESOURCE_LOCATION = "META-INF/spring.components";
public static final String IGNORE_INDEX = "spring.index.ignore";
private static final boolean shouldIgnoreIndex = SpringProperties.getFlag(IGNORE_INDEX);
private static final Log logger = LogFactory.getLog(CandidateComponentsIndexLoader.class);
/** CandidateComponentsIndex 的快取，與 ClassLoader 對應 */
private static final ConcurrentMap cache = new ConcurrentReferenceHashMap<>();
private CandidateComponentsIndexLoader() {
}
@Nullable
public static CandidateComponentsIndex loadIndex(@Nullable ClassLoader classLoader) {
ClassLoader classLoaderToUse = classLoader;
if (classLoaderToUse == null) {
classLoaderToUse = CandidateComponentsIndexLoader.class.getClassLoader();
}
// 獲取所有 `META-INF/spring.components` 檔案中的內容
return cache.computeIfAbsent(classLoaderToUse, CandidateComponentsIndexLoader::doLoadIndex);
}
@Nullable
private static CandidateComponentsIndex doLoadIndex(ClassLoader classLoader) {
// 是否忽略 Index 的提升，通過配置 `spring.index.ignore` 變數，預設為 `false`
if (shouldIgnoreIndex) {
return null;
}
try {
// 獲取所有的 `META-INF/spring.components` 檔案
Enumeration urls = classLoader.getResources(COMPONENTS_RESOURCE_LOCATION);
if (!urls.hasMoreElements()) {
return null;
}
// 載入所有 `META-INF/spring.components` 檔案的內容
List result = new ArrayList<>();
while (urls.hasMoreElements()) {
URL url = urls.nextElement();
Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
result.add(properties);
}
if (logger.isDebugEnabled()) {
logger.debug("Loaded " + result.size() + "] index(es)");
}
// 總共配置多少個 component 元件
int totalCount = result.stream().mapToInt(Properties::size).sum();
// 如果配置了 component 元件，則封裝成 CandidateComponentsIndex 物件並返回
return (totalCount > 0 ? new CandidateComponentsIndex(result) : null);
}
catch (IOException ex) {
throw new IllegalStateException("Unable to load indexes from location [" +
COMPONENTS_RESOURCE_LOCATION + "]", ex);
}
}
}
```
CandidateComponentsIndexLoader 被 `final` 修飾，也不允許例項化，提供 `loadIndex(@Nullable ClassLoader classLoader)` 靜態方法，獲取所有 `META-INF/spring.components` 檔案中的內容，存在檔案幷包含內容則建立對應的 CandidateComponentsIndex 物件
整過過程不復雜，如下：
1. 根據 `spring.index.ignore` 變數判斷是否需要忽略本次載入過程，預設為 `false`
2. 獲取所有的 `META-INF/spring.components` 檔案
3. 加載出所有 `META-INF/spring.components` 檔案的內容，並生成多個 key-value
4. 內容不為空則建立對應的 CandidateComponentsIndex 物件返回
例如 `META-INF/spring.components` 檔案這樣配置：
```properties
example.scannable.AutowiredQualifierFooService=example.scannable.FooService
example.scannable.DefaultNamedComponent=org.springframework.stereotype.Component
example.scannable.NamedComponent=org.springframework.stereotype.Component
example.scannable.FooService=example.scannable.FooService
example.scannable.FooServiceImpl=org.springframework.stereotype.Component,example.scannable.FooService
example.scannable.ScopedProxyTestBean=example.scannable.FooService
example.scannable.StubFooDao=org.springframework.stereotype.Component
example.scannable.NamedStubDao=org.springframework.stereotype.Component
example.scannable.ServiceInvocationCounter=org.springframework.stereotype.Component
example.scannable.sub.BarComponent=org.springframework.stereotype.Component
```
生成的 CandidateComponentsIndex 物件如下所示：
findCandidateComponents(String basePackage) {
/*
* 2. 掃描包路徑，通過 ASM（Java 位元組碼的操作和分析框架）解析出符合條件的 AnnotatedGenericBeanDefinition 們，並返回
* 說明：
* 針對 `1` 解析過程中去掃描指定路徑下的 .class 檔案的效能問題，從 Spring 5.0 開始新增了一個 @Indexed 註解（新特性），
* @Component 註解上面就添加了 @Indexed 註解
*
* 這裡不會去掃描指定路徑下的 .class 檔案，而是讀取所有 `META-INF/spring.components` 檔案中符合條件的類名，
* 直接新增 .class 字尾就是編譯檔案，而不要去掃描
*
* 沒在哪看見這樣使用過，可以參考 ClassPathScanningCandidateComponentProviderTest#customAnnotationTypeIncludeFilterWithIndex 測試方法
*/
if (this.componentsIndex != null // `componentsIndex` 不為空，存在 `META-INF/spring.components` 檔案並且解析出資料則會建立
&& indexSupportsIncludeFilters()) // `includeFilter` 過濾器的元素（註解或類）必須標註 @Indexed 註解
{
return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
}
else {
/*
* 1. 掃描包路徑，通過 ASM（Java 位元組碼的操作和分析框架）解析出符合條件的 ScannedGenericBeanDefinition 們，並返回
* 首先需要去掃描指定路徑下所有的 .class 檔案，該過程對於效能有不少的損耗
* 然後通過 ASM 根據 .class 檔案可以獲取到這個類的所有元資訊，也就可以解析出對應的 BeanDefinition 物件
*/
return scanCandidateComponents(basePackage);
}
}
```
這個方法的實現有兩種方式，都是基於 **ASM**（Java 位元組碼的操作和分析框架）實現的，預設情況下都是第 `1` 種，分別如下：
- `1`，呼叫 `scanCandidateComponents(String basePackage)` 方法，**預設**
掃描包路徑，通過 **ASM**（Java 位元組碼的操作和分析框架）解析出符合條件的 ScannedGenericBeanDefinition 們，並返回。首先需要去掃描指定路徑下所有的 .class 檔案，該過程對於效能有不少的損耗；然後通過 **ASM** 根據 .class 檔案可以獲取到這個類的所有元資訊，也就可以解析出對應的 BeanDefinition 物件
- `2`，`componentsIndex` 不為空，也就是說是通過 `META-INF/spring.components` 檔案配置的 Bean，並且定義 Bean 的註解必須標註 `@Index` 註解，則呼叫 `addCandidateComponentsFromIndex(CandidateComponentsIndex index, String basePackage)` 方法進行解析
掃描包路徑，通過 **ASM**（Java 位元組碼的操作和分析框架）解析出符合條件的 AnnotatedGenericBeanDefinition 們，並返回。針對 `1` 解析過程中去掃描指定路徑下的 .class 檔案的效能問題，從 Spring 5.0 開始新增了一個 `@Index` 註解（新特性），@Component 註解上面就添加了 @Index 註解；這裡不會去掃描指定路徑下的 .class 檔案，而是讀取所有 `META-INF/spring.components` 檔案中符合條件的類名，直接新增 .class 字尾就是編譯檔案，而不要去掃描，提高效能。
> ASM 是一個 Java 位元組碼操控框架。它能被用來動態生成類或者增強既有類的功能。ASM 可以直接產生二進位制 class 檔案，也可以在類被載入入 Java 虛擬機器之前動態改變類行為。Java Class 被儲存在嚴格格式定義的 .class 檔案裡，這些類檔案擁有足夠的元資料來解析類中的所有元素：類名稱、方法、屬性以及 Java 位元組碼（指令）。ASM 從類檔案中讀入資訊後，能夠改變類行為，分析類資訊，甚至能夠根據使用者要求生成新類。
Spring 在很多地方都使用到了 **ASM**
#### 4. scanCandidateComponents 方法
`scanCandidateComponents(String basePackage)` 方法，解析出包路徑下所有符合條件的 BeanDefinition，方法如下：
```java
private Set scanCandidateComponents(String basePackage) {
// <1> 定義 `candidates` 用於儲存符合條件的 BeanDefinition
Set candidates = new LinkedHashSet<>();
try {
// <2> 根據包名生成一個掃描的路徑，例如 `classpath*:包路徑/**/*.class`
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + '/' + this.resourcePattern;
// <3> 掃描到包路徑下所有的 .class 檔案
Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
boolean traceEnabled = logger.isTraceEnabled();
boolean debugEnabled = logger.isDebugEnabled();
// <4> 開始對第 `3` 步掃描到的所有 .class 檔案（需可讀）進行處理，符合條件的類名會解析出一個 ScannedGenericBeanDefinition
for (Resource resource : resources) {
if (resource.isReadable()) { // 檔案資源可讀
try {
// <4.1> 根據這個類名找到 `.class` 檔案，通過 ASM（Java 位元組碼操作和分析框架）獲取這個類的所有資訊
// `metadataReader` 物件中包含 ClassMetadata 類元資訊和 AnnotationMetadata 註解元資訊
// 也就是說根據 `.class` 檔案就獲取到了這個類的元資訊，而不是在 JVM 執行時通過 Class 物件進行操作，提高效能
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
// <4.2> 根據所有的過濾器判斷這個類是否符合條件（例如必須標註 @Component 註解或其派生註解）
if (isCandidateComponent(metadataReader)) {
// <4.3> 如果符合條件，則建立一個 ScannedGenericBeanDefinition 物件
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
// 來源和源物件都是這個 .class 檔案資源
sbd.setResource(resource);
sbd.setSource(resource);
/*
* <4.4> 再次判斷這個類是否符合條件（不是內部類並且是一個具體類）
* 具體類：不是介面也不是抽象類，如果是抽象類則需要帶有 @Lookup 註解
*/
if (isCandidateComponent(sbd)) {
// <4.5> 符合條件，則新增至 `candidates` 集合
candidates.add(sbd);
}
}
} catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to read candidate component class: " + resource, ex);
}
}
}
} catch (IOException ex) {
throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
}
// <5> 返回 `candidates` 集合
return candidates;
}
```
過程如下：
1. 定義 `candidates` 用於儲存符合條件的 BeanDefinition
2. 根據包名生成一個掃描的路徑，例如 `classpath*:包路徑/**/*.class`
3. 掃描到包路徑下所有的 .class 檔案
4. 開始對第 `3` 步掃描到的所有 .class 檔案（需可讀）進行處理，符合條件的類名會解析出一個 ScannedGenericBeanDefinition
1. 根據這個類名找到 `.class` 檔案，通過 **ASM**（Java 位元組碼操作和分析框架）獲取這個類的所有資訊，生成 `metadataReader` 物件。這個物件其中包含 ClassMetadata 類元資訊和 AnnotationMetadata 註解元資訊，也就是說根據 `.class` 檔案就獲取到了這個類的元資訊，而不是在 JVM 執行時通過 Class 物件進行操作，提高效能
2. 根據所有的過濾器判斷這個類是否符合條件（例如必須標註 @Component 註解或其派生註解）
3. 如果符合條件，則建立一個 ScannedGenericBeanDefinition 物件，來源和源物件都是這個 .class 檔案資源
4. 再次判斷這個類是否符合條件（不是內部類並且是一個具體類），具體類：不是介面也不是抽象類，如果是抽象類則需要帶有 @Lookup 註解
5. 符合條件，則新增至 `candidates` 集合
5. 返回 `candidates` 集合
關於 ASM 的實現本文不進行探討，感興趣的可自行研究
#### 4. addCandidateComponentsFromIndex 方法
`addCandidateComponentsFromIndex(CandidateComponentsIndex index, String basePackage)` 方法，根據 `META-INF/spring.components` 檔案，獲取帶有 @Indexed 註解的類名，然後解析出符合條件的 BeanDefinition，方法如下：
```java
private Set addCandidateComponentsFromIndex(CandidateComponentsIndex index, String basePackage) {
// <1> 定義 `candidates` 用於儲存符合條件的 BeanDefinition
Set candidates = new LinkedHashSet<>();
try {
Set types = new HashSet<>();
// <2> 根據過濾器從所有 `META-INF/spring.components` 檔案中獲取所有符合條件的**類名稱**
for (TypeFilter filter : this.includeFilters) {
// <2.1> 獲取過濾註解（或類）的名稱（例如 `org.springframework.stereotype.Component`）
String stereotype = extractStereotype(filter);
if (stereotype == null) {
throw new IllegalArgumentException("Failed to extract stereotype from " + filter);
}
// <2.2> 獲取註解（或類）對應的條目，並過濾出 `basePackage` 包名下的條目（類的名稱）
types.addAll(index.getCandidateTypes(basePackage, stereotype));
}
boolean traceEnabled = logger.isTraceEnabled();
boolean debugEnabled = logger.isDebugEnabled();
// <3> 開始對第 `2` 步過濾出來類名進行處理，符合條件的類名會解析出一個 AnnotatedGenericBeanDefinition
for (String type : types) {
// <3.1> 根據這個類名找到 `.class` 檔案，通過 ASM（Java 位元組碼操作和分析框架）獲取這個類的所有資訊
// `metadataReader` 物件中包含 ClassMetadata 類元資訊和 AnnotationMetadata 註解元資訊
// 也就是說根據 `.class` 檔案就獲取到了這個類的元資訊，而不是在 JVM 執行時通過 Class 物件進行操作，提高效能
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(type);
// <3.2> 根據所有的過濾器判斷這個類是否符合條件（例如必須標註 @Component 註解或其派生註解）
if (isCandidateComponent(metadataReader)) {
// <3.3> 如果符合條件，則建立一個 AnnotatedGenericBeanDefinition 物件
AnnotatedGenericBeanDefinition sbd = new AnnotatedGenericBeanDefinition(
metadataReader.getAnnotationMetadata());
/*
* <3.4> 再次判斷這個類是否符合條件（不是內部類並且是一個具體類）
* 具體類：不是介面也不是抽象類，如果是抽象類則需要帶有 @Lookup 註解
*/
if (isCandidateComponent(sbd)) {
// <3.5> 符合條件，則新增至 `candidates` 集合
candidates.add(sbd);
}
}
}
} catch (IOException ex) {
throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
}
// <4> 返回 `candidates` 集合
return candidates;
}
```
過程如下：
1. 定義 `candidates` 用於儲存符合條件的 BeanDefinition
2. 根據過濾器從所有 `META-INF/spring.components` 檔案中獲取所有符合條件的**類名稱**
1. 獲取過濾註解（或類）的名稱（例如 `org.springframework.stereotype.Component`）
2. 獲取註解（或類）對應的條目，並過濾出 `basePackage` 包名下的條目（類的名稱）
3. 開始對第 `2` 步過濾出來類名進行處理，符合條件的類名會解析出一個 AnnotatedGenericBeanDefinition
1. 根據這個類名找到 `.class` 檔案，通過 **ASM**（Java 位元組碼操作和分析框架）獲取這個類的所有資訊，生成 `metadataReader` 物件。這個物件其中包含 ClassMetadata 類元資訊和 AnnotationMetadata 註解元資訊，也就是說根據 `.class` 檔案就獲取到了這個類的元資訊，而不是在 JVM 執行時通過 Class 物件進行操作，提高效能
2. 根據所有的過濾器判斷這個類是否符合條件（例如必須標註 @Component 註解或其派生註解）
3. 如果符合條件，則建立一個 AnnotatedGenericBeanDefinition 物件
4. 再次判斷這個類是否符合條件（不是內部類並且是一個具體類），具體類：不是介面也不是抽象類，如果是抽象類則需要帶有 @Lookup 註解
5. 符合條件，則新增至 `candidates` 集合
4. 返回 `candidates` 集合
該過程不會去掃描到所有的 .class 檔案，而是從 `META-INF/spring.components` 檔案中讀取，知道了類名稱也就知道了 .class 檔案的路徑，然後可以通過 ASM 進行操作了。Spring 5.0 開始新增的一個 @Indexed 註解（新特性），目的為了提高效能。
### 總結
本文面向註解（`@Component 註解或其派生註解`）定義的 Bean，Spring 是如何將他們解析成 BeanDefinition（Bean 的“前身”）並註冊的，大致過程如下：
1. ClassPathBeanDefinitionScanner 會去掃描到包路徑下所有的 .class 檔案
2. 通過 **ASM**（Java 位元組碼操作和分析框架）獲取 .class 對應類的所有元資訊
3. 根據元資訊判斷是否符合條件（帶有 `@Component 註解或其派生註解`），符合條件則根據這個類的元資訊生成一個 BeanDefinition 進行註冊
關於上面的第 `1` 步效能損耗不少，Spring 5.0 開始新增的一個 @Indexed 註解（新特性），@Indexed 派生註解（例如 @Component）或 @Indexed 註解的類可以定義在 `META-INF/spring.components` 檔案中，Spring 會直接從檔案中讀取，找到符合條件的類名稱，也就找到了 .class 檔案。這樣一來對於上面第 `1` 步來說在效能上得到了提升，目前還沒見到這種方式，畢竟 還要再檔案中定義類名，感覺太複雜了，啟動過程慢就慢點:smile:
到這裡，對於通過 **面向資源（XML、Properties）**、**面向註解** 兩種定義 Bean 的方式，Spring 將定義的資訊轉換成 BeanDefinition（Bean 的“前身”）的過程差不多都分析了。我們接下來研究一下 Bean 的生命週期，BeanDefinition 是如何變成 Bean 的。
> 本文你是否還有疑惑，@Bean 註解定義的 Bean 怎麼沒有解析成 BeanDefinition 呢？別急，在後續的文章會進
### ClassPathBeanDefinitionScanner
`org.springframework.context.annotation.ClassPathBeanDefinitionScanner`，繼承 ClassPathScanningCandidateComponentProvider，classpath 下 BeanDefinition 的掃描器，支援設定過濾器
預設有三個過濾器： `@Component` 註解的過濾器，Java EE 6 的 `javax.annotation.ManagedBean` 註解過濾器，JSR-330 的 `javax.inject.Named` 註解過濾器，這裡我們重點關注第一個過濾器
#### 建構函式
```java
public class ClassPathBeanDefinitionScanner extends ClassPathScanningCandidateComponentProvider {
/** BeanDefinition 註冊中心 DefaultListableBeanFactory */
private final BeanDefinitionRegistry registry;
/** BeanDefinition 的預設配置 */
private BeanDefinitionDefaults beanDefinitionDefaults = new BeanDefinitionDefaults();
@Nullable
private String[] autowireCandidatePatterns;
/** Bean 的名稱生成器 */
private BeanNameGenerator beanNameGenerator = new AnnotationBeanNameGenerator();
private ScopeMetadataResolver scopeMetadataResolver = new AnnotationScopeMetadataResolver();
/** 是否註冊幾個關於註解的 PostProcessor 處理器 */
private boolean includeAnnotationConfig = true;
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry) {
this(registry, true);
}
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters) {
this(registry, useDefaultFilters, getOrCreateEnvironment(registry));
}
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
Environment environment) {
this(registry, useDefaultFilters, environment,
(registry instanceof ResourceLoader ? (ResourceLoader) registry : null));
}
public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
Environment environment, @Nullable ResourceLoader resourceLoader) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
this.registry = registry;
if (useDefaultFilters) {
// 註冊預設的過濾器，@Component 註解的過濾器（具有層次性）
registerDefaultFilters();
}
setEnvironment(environment);
// 設定資源載入物件，會嘗試加載出 CandidateComponentsIndex 物件（儲存 `META-INF/spring.components` 檔案中的內容，不存在該物件為 `null`）
setResourceLoader(resourceLoader);
}
}
```
屬性不多，建構函式都會進入最下面這個構造方法，主要呼叫了兩個方法，如下：
1. 呼叫父類的 `registerDefaultFilters()` 方法，註冊幾個預設的過濾器，方法如下：
```java
protected void registerDefaultFilters() {
// 新增 @Component 註解的過濾器（具有層次性），@Component 的派生註解都符合條件
this.includeFilters.add(new AnnotationTypeFilter(Component.class));
ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
try {
this.includeFilters.add(new AnnotationTypeFilter(
((Class) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
logger.trace("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
}
catch (ClassNotFoundException ex) {
// JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
}
try {
this.includeFilters.add(new AnnotationTypeFilter(
((Class) ClassUtils.forName("javax.inject.Named", cl)), false));
logger.trace("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
}
catch (ClassNotFoundException ex) {
// JSR-330 API not available - simply skip.
}
}
```
新增 `@Component` 註解的過濾器（具有層次性），`@Component` 的派生註解都符合條件
也會新增 Java EE 6 的 `javax.annotation.ManagedBean` 註解過濾器，JSR-330 的 `javax.inject.Named` 註解過濾器
2. 呼叫父類的 `setResourceLoader(@Nullable ResourceLoader resourceLoader)` 方法，設定資源載入物件並嘗試加載出 CandidateComponentsIndex 物件，方法如下：
```java
@Override
public void setResourceLoader(@Nullable ResourceLoader resourceLoader) {
this.resourcePatternResolver = ResourcePatternUtils.getResourcePatternResolver(resourceLoader);
this.metadataReaderFactory = new CachingMetadataReaderFactory(resourceLoader);
// 獲取所有 `META-INF/spring.components` 檔案中的內容
this.componentsIndex = CandidateComponentsIndexLoader.loadIndex(this.resourcePatternResolver.getClassLoader());
}
```
這裡有個關鍵的步驟，加載出 CandidateComponentsIndex 物件，嘗試去獲取所有 `META-INF/spring.components` 檔案中的內容，後續進行分析
#### 1. scan 方法
`scan(String... basePackages)` 方法，掃描出包路徑下符合條件 BeanDefinition 並註冊，方法如下：
```java
public int scan(String... basePackages) {
// <1> 獲取掃描前的 BeanDefinition 數量
int beanCountAtScanStart = this.registry.getBeanDefinitionCount();
// <2> 進行掃描，將過濾出來的所有的 .class 檔案生成對應的 BeanDefinition 並註冊
doScan(basePackages);
// Register annotation config processors, if necessary.
// <3> 如果 `includeAnnotationConfig` 為 `true`（預設），則註冊幾個關於註解的 PostProcessor 處理器（關鍵）
// 在其他地方也會註冊，內部會進行判斷，已註冊的處理器不會再註冊
if (this.includeAnnotationConfig) {
AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);
}
// <4> 返回本次掃描註冊的 BeanDefinition 數量
return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);
}
```
過程如下：
1. 獲取掃描前的 BeanDefinition 數量
2. 進行掃描，將過濾出來的所有的 .class 檔案生成對應的 BeanDefinition 並註冊，呼叫 `doScan(String... basePackages)` 方法
3. 如果 `includeAnnotationConfig` 為 `true`（預設），則註冊幾個關於註解的 PostProcessor 處理器（關鍵），在其他地方也會註冊，內部會進行判斷，已註冊的處理器不會再註冊，記住這個 **AnnotationConfigUtils** 類
4. 返回本次掃描註冊的 BeanDefinition 數量
#### 2. doScan 方法
`doScan(String... basePackages)` 方法，掃描出包路徑下符合條件 BeanDefinition 並註冊，方法如下：
```java
protected Set