死磕Spring之IoC篇 - BeanDefinition 的解析過程（面向註解）

月圓吖發表於2021-02-26

該系列文章是本人在學習 Spring 的過程中總結下來的，裡面涉及到相關原始碼，可能對讀者不太友好，請結合我的原始碼註釋 Spring 原始碼分析 GitHub 地址進行閱讀

Spring 版本：5.1.14.RELEASE

開始閱讀這一系列文章之前，建議先檢視《深入瞭解 Spring IoC（面試題）》這一篇文章

該系列其他文章請檢視：《死磕 Spring 之 IoC 篇 - 文章導讀》

BeanDefinition 的解析過程（面向註解）

前面的幾篇文章對 Spring 解析 XML 檔案生成 BeanDefinition 並註冊的過程進行了較為詳細的分析，這種定義 Bean 的方式是面向資源（XML）的方式。面向註解定義 Bean 的方式 Spring 的處理過程又是如何進行的？本文將會分析 Spring 是如何將 @Component 註解或其派生註解 標註的 Class 類解析成 BeanDefinition（Bean 的“前身”）並註冊。

在上一篇 《解析自定義標籤（XML 檔案）》文章中提到了處理 <context:component-scan /> 標籤的過程中，底層藉助於 ClassPathBeanDefinitionScanner 掃描器，去掃描指定路徑下符合條件的 BeanDefinition 們，這個類就是處理 @Component 註解定義 Bean 的底層實現。關於 @ComponentScan 註解的原理也是基於這個掃描器來實現的，我們先來看看這個掃描器的處理過程。

類圖

死磕Spring之IoC篇 - BeanDefinition 的解析過程（面向註解）

ClassPathBeanDefinitionScanner

org.springframework.context.annotation.ClassPathBeanDefinitionScanner，繼承 ClassPathScanningCandidateComponentProvider，classpath 下 BeanDefinition 的掃描器，支援設定過濾器

預設有三個過濾器： @Component 註解的過濾器，Java EE 6 的 javax.annotation.ManagedBean 註解過濾器，JSR-330 的 javax.inject.Named 註解過濾器，這裡我們重點關注第一個過濾器

建構函式

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

屬性不多，建構函式都會進入最下面這個構造方法，主要呼叫了兩個方法，如下：

呼叫父類的 registerDefaultFilters() 方法，註冊幾個預設的過濾器，方法如下：

protected void registerDefaultFilters() {
    // 新增 @Component 註解的過濾器（具有層次性），@Component 的派生註解都符合條件
    this.includeFilters.add(new AnnotationTypeFilter(Component.class));
    ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
    try {
        this.includeFilters.add(new AnnotationTypeFilter(
                ((Class<? extends Annotation>) 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<? extends Annotation>) 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 註解過濾器

呼叫父類的 setResourceLoader(@Nullable ResourceLoader resourceLoader) 方法，設定資源載入物件並嘗試載入出 CandidateComponentsIndex 物件，方法如下：

@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 並註冊，方法如下：

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

過程如下：

獲取掃描前的 BeanDefinition 數量
進行掃描，將過濾出來的所有的 .class 檔案生成對應的 BeanDefinition 並註冊，呼叫 doScan(String... basePackages) 方法
如果 includeAnnotationConfig 為 true（預設），則註冊幾個關於註解的 PostProcessor 處理器（關鍵），在其他地方也會註冊，內部會進行判斷，已註冊的處理器不會再註冊，記住這個 AnnotationConfigUtils 類
返回本次掃描註冊的 BeanDefinition 數量

2. doScan 方法

doScan(String... basePackages) 方法，掃描出包路徑下符合條件 BeanDefinition 並註冊，方法如下：

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
    Assert.notEmpty(basePackages, "At least one base package must be specified");
    // <1> 定義個 Set 集合 `beanDefinitions`，用於儲存本次掃描成功註冊的 BeanDefinition 們
    Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
    for (String basePackage : basePackages) { // 遍歷需要掃描的包名
        // <2> 【核心】掃描包路徑，通過 ASM（Java 位元組碼的操作和分析框架）解析出所有符合條件的 BeanDefinition
        Set<BeanDefinition> 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;
}

過程如下：

定義個 Set 集合 beanDefinitions，用於儲存本次掃描成功註冊的 BeanDefinition 們
【核心】掃描包路徑，通過 ASM（Java 位元組碼的操作和分析框架）解析出所有符合條件的 BeanDefinition，呼叫父類的 findCandidateComponents(String basePackage) 方法
對第 2 步解析出來的 BeanDefinition 依次處理，並註冊
1. 解析出 @Scope 註解的元資訊並設定
2. 獲取或者生成一個的名稱 beanName
3. 設定相關屬性的預設值
4. 根據這個類的相關注解設定屬性值（存在則會覆蓋預設值）
5. 檢查 beanName 是否已存在，已存在但是不相容則會丟擲異常
6. 將 BeanDefinition 封裝成 BeanDefinitionHolder 物件，這裡多了一個 beanName
7. 如果代理模式是 TARGET_CLASS，則再建立一個 BeanDefinition 代理物件（重新設定了相關屬性），原始 BeanDefinition 已註冊
8. 新增至 beanDefinitions 集合
9. 註冊該 BeanDefinition
返回 beanDefinitions（已註冊的 BeanDefinition 集合）

第 2 步是這個掃描過程的核心步驟，在父類 ClassPathScanningCandidateComponentProvider 中進行分析，接下來的處理過程不復雜，獲取相關屬性進行配置

第 7 步建立代理物件，和 AOP 相關，感興趣的可自行檢視

ClassPathScanningCandidateComponentProvider

org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider，classpath 下掃描符合條件的 BeanDefinition

建構函式

public class ClassPathScanningCandidateComponentProvider implements EnvironmentCapable, ResourceLoaderAware {

	static final String DEFAULT_RESOURCE_PATTERN = "**/*.class";
	private String resourcePattern = DEFAULT_RESOURCE_PATTERN;

	/** 包含過濾器 */
	private final List<TypeFilter> includeFilters = new LinkedList<>();
	/** 排除過濾器 */
	private final List<TypeFilter> 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 的載入器，程式碼如下：

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<ClassLoader, CandidateComponentsIndex> 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<URL> urls = classLoader.getResources(COMPONENTS_RESOURCE_LOCATION);
			if (!urls.hasMoreElements()) {
				return null;
			}
			// 載入所有 `META-INF/spring.components` 檔案的內容
			List<Properties> 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 物件

整過過程不復雜，如下：

根據 spring.index.ignore 變數判斷是否需要忽略本次載入過程，預設為 false
獲取所有的 META-INF/spring.components 檔案
載入出所有 META-INF/spring.components 檔案的內容，並生成多個 key-value
內容不為空則建立對應的 CandidateComponentsIndex 物件返回

例如 META-INF/spring.components 檔案這樣配置：

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 物件如下所示：

3. findCandidateComponents 方法

findCandidateComponents(String basePackage) 方法，解析出包路徑下所有符合條件的 BeanDefinition，方法如下：

public Set<BeanDefinition> 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，方法如下：

private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
    // <1> 定義 `candidates` 用於儲存符合條件的 BeanDefinition
    Set<BeanDefinition> 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;
}

過程如下：

定義 candidates 用於儲存符合條件的 BeanDefinition
根據包名生成一個掃描的路徑，例如 classpath*:包路徑/**/*.class
掃描到包路徑下所有的 .class 檔案
開始對第 3 步掃描到的所有 .class 檔案（需可讀）進行處理，符合條件的類名會解析出一個 ScannedGenericBeanDefinition
1. 根據這個類名找到 .class 檔案，通過 ASM（Java 位元組碼操作和分析框架）獲取這個類的所有資訊，生成 metadataReader 物件。這個物件其中包含 ClassMetadata 類元資訊和 AnnotationMetadata 註解元資訊，也就是說根據 .class 檔案就獲取到了這個類的元資訊，而不是在 JVM 執行時通過 Class 物件進行操作，提高效能
2. 根據所有的過濾器判斷這個類是否符合條件（例如必須標註 @Component 註解或其派生註解）
3. 如果符合條件，則建立一個 ScannedGenericBeanDefinition 物件，來源和源物件都是這個 .class 檔案資源
4. 再次判斷這個類是否符合條件（不是內部類並且是一個具體類），具體類：不是介面也不是抽象類，如果是抽象類則需要帶有 @Lookup 註解
5. 符合條件，則新增至 candidates 集合
返回 candidates 集合

關於 ASM 的實現本文不進行探討，感興趣的可自行研究

4. addCandidateComponentsFromIndex 方法

addCandidateComponentsFromIndex(CandidateComponentsIndex index, String basePackage) 方法，根據 META-INF/spring.components 檔案，獲取帶有 @Indexed 註解的類名，然後解析出符合條件的 BeanDefinition，方法如下：

private Set<BeanDefinition> addCandidateComponentsFromIndex(CandidateComponentsIndex index, String basePackage) {
    // <1> 定義 `candidates` 用於儲存符合條件的 BeanDefinition
    Set<BeanDefinition> candidates = new LinkedHashSet<>();
    try {
        Set<String> 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;
}

過程如下：

定義 candidates 用於儲存符合條件的 BeanDefinition
根據過濾器從所有 META-INF/spring.components 檔案中獲取所有符合條件的類名稱
1. 獲取過濾註解（或類）的名稱（例如 org.springframework.stereotype.Component）
2. 獲取註解（或類）對應的條目，並過濾出 basePackage 包名下的條目（類的名稱）
開始對第 2 步過濾出來類名進行處理，符合條件的類名會解析出一個 AnnotatedGenericBeanDefinition
1. 根據這個類名找到 .class 檔案，通過 ASM（Java 位元組碼操作和分析框架）獲取這個類的所有資訊，生成 metadataReader 物件。這個物件其中包含 ClassMetadata 類元資訊和 AnnotationMetadata 註解元資訊，也就是說根據 .class 檔案就獲取到了這個類的元資訊，而不是在 JVM 執行時通過 Class 物件進行操作，提高效能
2. 根據所有的過濾器判斷這個類是否符合條件（例如必須標註 @Component 註解或其派生註解）
3. 如果符合條件，則建立一個 AnnotatedGenericBeanDefinition 物件
4. 再次判斷這個類是否符合條件（不是內部類並且是一個具體類），具體類：不是介面也不是抽象類，如果是抽象類則需要帶有 @Lookup 註解
5. 符合條件，則新增至 candidates 集合
返回 candidates 集合

該過程不會去掃描到所有的 .class 檔案，而是從 META-INF/spring.components 檔案中讀取，知道了類名稱也就知道了 .class 檔案的路徑，然後可以通過 ASM 進行操作了。Spring 5.0 開始新增的一個 @Indexed 註解（新特性），目的為了提高效能。

總結

本文面向註解（@Component 註解或其派生註解）定義的 Bean，Spring 是如何將他們解析成 BeanDefinition（Bean 的“前身”）並註冊的，大致過程如下：

ClassPathBeanDefinitionScanner 會去掃描到包路徑下所有的 .class 檔案
通過 ASM（Java 位元組碼操作和分析框架）獲取 .class 對應類的所有元資訊
根據元資訊判斷是否符合條件（帶有 @Component 註解或其派生註解），符合條件則根據這個類的元資訊生成一個 BeanDefinition 進行註冊

關於上面的第 1 步效能損耗不少，Spring 5.0 開始新增的一個 @Indexed 註解（新特性），@Indexed 派生註解（例如 @Component）或 @Indexed 註解的類可以定義在 META-INF/spring.components 檔案中，Spring 會直接從檔案中讀取，找到符合條件的類名稱，也就找到了 .class 檔案。這樣一來對於上面第 1 步來說在效能上得到了提升，目前還沒見到這種方式，畢竟還要再檔案中定義類名，感覺太複雜了，啟動過程慢就慢點?

到這裡，對於通過 面向資源（XML、Properties）、面向註解 兩種定義 Bean 的方式，Spring 將定義的資訊轉換成 BeanDefinition（Bean 的“前身”）的過程差不多都分析了。我們接下來研究一下 Bean 的生命週期，BeanDefinition 是如何變成 Bean 的。

本文你是否還有疑惑，@Bean 註解定義的 Bean 怎麼沒有解析成 BeanDefinition 呢？別急，在後續的文章會進行分析

死磕Spring之IoC篇 - BeanDefinition 的解析階段（XML 檔案）
2021-02-24
SpringBeanXML
死磕Spring之IoC篇 - Bean 的建立過程
2021-03-01
SpringBean
死磕Spring之IoC篇 - BeanDefinition 的載入階段（XML 檔案）
2021-02-23
SpringBeanXML
死磕Spring之IoC篇 - @Bean 等註解的實現原理
2021-03-09
SpringBean
死磕Spring之IoC篇 - @Autowired 等註解的實現原理
2021-03-08
Spring
死磕Spring之IoC篇 - 深入瞭解Spring IoC（面試題）
2021-02-20
Spring面試題
死磕Spring之IoC篇 - Bean 的“前身”
2021-02-23
SpringBean
死磕Spring之IoC篇 - 解析自定義標籤（XML 檔案）
2021-02-25
SpringXML
死磕Spring之IoC篇 - 開啟 Bean 的載入
2021-03-01
SpringBean
死磕Spring之IoC篇 - 除錯環境的搭建
2021-02-22
Spring除錯
死磕Spring之IoC篇 - Bean 的屬性填充階段
2021-03-05
SpringBean
死磕Spring之IoC篇 - Bean 的例項化階段
2021-03-02
SpringBean
死磕Spring之AOP篇 - Spring AOP註解驅動與XML配置
2021-04-23
SpringXML
死磕Spring之IoC篇 - Spring 應用上下文 ApplicationContext
2021-03-09
SpringAPPContext
Spring原始碼之IOC（一）BeanDefinition原始碼解析
2018-12-04
Spring原始碼Bean
死磕Spring之IoC篇 - 單例 Bean 的迴圈依賴處理
2021-03-04
Spring單例Bean
死磕Spring之AOP篇 - Spring 事務詳解
2021-05-12
Spring
深入Spring之IOC之載入BeanDefinition
2020-05-18
SpringBean
死磕Spring之AOP篇 - Spring AOP總覽
2021-04-16
Spring
死磕Spring之AOP篇 - Spring AOP常見面試題
2021-04-14
Spring面試題
Spring IoC Context啟動過程解析
2016-06-21
SpringContext
spring-IOC容器原始碼分析（二）BeanDefinition註冊流程
2018-11-19
Spring原始碼Bean
死磕Spring之AOP篇 - Spring AOP自動代理（一）入口
2021-04-19
Spring
Spring原始碼之預設標籤解析及BeanDefinition註冊
2022-04-08
Spring原始碼Bean
死磕 java集合之終結篇
2019-05-04
Java
Spring原始碼解讀(1)-IOC容器BeanDefinition的載入
2019-05-06
Spring原始碼Bean
死磕 java魔法類之Unsafe解析
2019-05-05
Java
死磕Spring之AOP篇 - Spring AOP自動代理（三）建立代理物件
2021-04-21
Spring物件
死磕Spring之AOP篇 - Spring AOP兩種代理物件的攔截處理
2021-04-22
Spring物件
spring原始碼解析之AnnotationConfigWebApplicationContext#loadBeanDefinitions()方法載入BeanDefinition過程
2020-10-13
Spring原始碼WebAPPContextBean
Spring IOC容器-註解的方式
2016-05-09
Spring
Spring進階案例之註解和IoC案例
2020-07-30
Spring
Spring IoC 公共註解詳解
2020-07-08
Spring
死磕 java同步系列之AQS終篇（面試）
2019-06-23
JavaAQS面試
Spring 原始碼閱讀（二）IoC 容器初始化以及 BeanFactory 建立和 BeanDefinition 載入過程
2024-04-22
Spring原始碼Bean
Spring基於註解的IoC配置
2018-09-20
Spring
spring原始碼解析之IOC容器（二）------載入和註冊
2019-06-24
Spring原始碼
死磕Spring之AOP篇 - Spring AOP自動代理（二）篩選合適的通知器
2021-04-20
Spring

死磕Spring之IoC篇 - BeanDefinition 的解析過程（面向註解）

BeanDefinition 的解析過程（面向註解）

類圖

ClassPathBeanDefinitionScanner

建構函式

1. scan 方法

2. doScan 方法

ClassPathScanningCandidateComponentProvider

建構函式

CandidateComponentsIndexLoader

3. findCandidateComponents 方法

4. scanCandidateComponents 方法

4. addCandidateComponentsFromIndex 方法

總結

相關文章