前言：
對於Spring創建Bean的方式我相信大家 並不陌生，絕大數同學其實都知道Spring最初就是通過xml的方式去初始化Bean並完成依賴注入的工作，但是在Spring3.0之后，在spring framework模塊中提供了了@Confirguration這個注解，並通過搭配@Bean等注解，可以完全不依賴xml配置，在運行時完成Bean的創建和初始化工作。
@Configuration注解的簡單實用(demo)
package com.vipbbo.selfdemo.spring.configuration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class CustomBeanConfig {
/**
* @Bean注解聲明了一個bean，bean名稱默認為方法名 beanImpl
* @return
*/
@Bean
IBean beanImpl(){
return new BeanImpl();
}
}
interface IBean{
}
class BeanImpl implements IBean{
}
注意：默認情況下Bean的名稱和方法名稱相同，也可以通過name屬性來進行修改指定
比如：
@Bean(name = "customName")
@Configuratio注解的分析
首先我們先上述案例點擊@Configuration注解看一下源碼，如下：
- 看源碼(
Configuration.java)
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
@AliasFor(annotation = Component.class)
String value() default "";
Boolean proxyBeanMethods() default true;
}
- 源碼分析
我們看到源碼里面，@Configuration標記了@Component元注解，因此可以被@ComponentScan掃描並處理，在Spring容器初始化時Configuration類會被注冊到Bean容器中，最后還會被實例化。
使用@Autowired、@Inject注解
因為@Configuration本身也是一個@Component，因此配置類本身也會被注冊到應用上下文，並且也可以使用IOC的@Autowired、@Inject等注解來注入所需的Bean，我們來修改一下之前的Demo，如下：
@Configuration
public class CustomBeanConfig {
@Autowired
private Environment environment;
/**
* 、 @Bean注解聲明了一個bean，bean名稱默認為方法名 beanImpl
* @return
*/
@Bean
IBean beanImpl(){
return new BeanImpl();
}
}
@ComponentScan注解的使用
配置類也可以自己添加注解@ComponentScan，來顯示掃描需使用的組件。
@Configuration使用@Component進行元注解，因此@Configuration類也可以被組件掃描到(特別是使用XML元素)
例如：
@Configuration
@ComponentScan("com.vipbbo")
public class CustomBeanConfig {
// 略......
}
注解@Controller @Service @Repository @Component
-
@Controller : 表明標識的"類"是一個Controller，也就是控制器，可以把它理解為MVC模式下的Controller角色。這個注解是一個特殊的@Component，允許實現類通過類路徑的掃描掃描到。它通常與@RequestMapping 注解一起使用。
-
@Service： 表明這個帶注解的類是一個"Service"，也就是服務層，可以把它理解為MVC 模式中的Service層這個角色，這個注解也是一個特殊的@Component，允許實現類通過類路徑的掃描掃描到
-
@Repository： 表明這個注解的類是一個"Repository",團隊實現了JavaEE 模式中像是作為"Data Access Object" 可能作為DAO來使用，當與 PersistenceExceptionTranslationPostProcessor 結合使用時，這樣注釋的類有資格獲得Spring轉換的目的。這個注解也是@Component 的一個特殊實現，允許實現類能夠被自動掃描到
-
@Component: 表明這個注釋的類是一個組件，當使用基於注釋的配置和類路徑掃描時，這些類被視為自動檢測的候選者
-
看源碼
// @Controller
@Target({
ElementType.TYPE
}
)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Controller {
@AliasFor(annotation = Component.class)
String value() default "";
}
// @Service
@Target({
ElementType.TYPE
}
)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Service {
@AliasFor(annotation = Component.class)
String value() default "";
}
// @Repository
@Target({
ElementType.TYPE
}
)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Repository {
@AliasFor(annotation = Component.class)
String value() default "";
}
// @Component
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Indexed
public @interface Component {
String value() default "";
}
- 源碼分析
我們可以看到@Controller，@Service，@Repository這三個注解上面都有@Component這個注解；也就是說，上面四個注解標記的類都能夠通過@ComponentScan掃描到，上面四個注解最大的區別就是使用的場景和語義不一樣，比如你定義一個Service類想要被Spring管理，你應該把它定義為@Service而不是@Controller因為我們從語義上講，@Service更像是一個服務的類，而不是一個控制器的類，@Component通常被稱作組件，它可以標記任何你沒有嚴格予以說明的類，比如說是一個配置類，它不屬於MVC的任何一層，這個時候你更習慣把它定義為@Component。
@Controller，@Service，@Repository的注解上都有@Component，所以這三個注解都可以用@Component進行替換
同@Import注解組合使用
新建一個配置類，例如數據庫配置類：
@Configuration
public class DatabaseConfig {
@Bean
public DataSource dataSource(){
return new DataSource(){
...
};
}
}
然后再CustomBeanConfig中使用@Import來導入配置
@Configuration
@ComponentScan("com.vipbbo")
@Component
@Import(DatabaseConfig.class)
public class CustomBeanConfig {
/**
* 注入的bean在DatabaseConfig.class中定義
*/
@Autowired
private DataSource dataSource;
}
最后執行：
ApplicationContext context = new AnnotationConfigApplicationContext(CustomBeanConfig.class);
DatabaseConfig dataSourceConfig = context.getBean(DatabaseConfig.class);
執行過后你就會發現只注冊了CustomBeanConfig.class，容器自動會把@Import指向的配置類初始化。
同@Profile注解組合使用
在配置類可以聲明@Profile注解，僅當滿足profile條件時，才會處理配置類，也可以將@Profile注解加載配置類中的每一個@Bean來實現更細粒度的條件控制。如下：
@Configuration
@Profile("develop")
public class DatabaseConfig {
@Bean
public DataSource dataSource(){
return new DataSource(){
// ...
};
}
}
@Profile注解也接受稍復雜的環境表達式，支持 ** &、** |、 !** 三種符號來表達與、或、非的關系。**
上面的Bean僅會在 “develop” 環境同時被激活時才注冊。
嵌套使用@Configuration
在配置類中可以創建靜態內部類，並添加@Configuration注解，這樣上下文只需要注冊最外面的配置類，內部的配置類會自動被加載。這樣做就省略了@Import，因為本身就在配置類內部，無需在特別指定了。比如：
@Configuration
public class CustomBeanConfig {
@Configuration
public static class DatabaseConfig{
@Bean
DataSource dataSource(){
return new DataSource() {
...
};
}
}
}
注意注意注意注意！！！！！！！！！！
任何嵌套的@Configuration都必須是static的。
@Lazy初始化
默認情況下，配置類中的Bean都隨着上下文被初始化，可以在配置類中添加@Lazy注解來延遲初始化，當然也可以在每個@Bean注解上添加，來實現更細粒度的控制。
@Configuration
@Lazy
public class CustomConfig {
@Bean
CustomBean appBean(){
return new AppBean();
}
}
配置類約束
- 配置類必須為顯式聲明的類，而不能通過工廠類方法返回實例，運行時類增強。
- 配置類不允許標記為
final。 - 配置類必須全局可見(不允許定義在方法本地內部類中)。
- 嵌套配置類必須聲明為
static內部類。 - @Bean方法不可以在創建新的配置類(所有實例都當作Bean處理，不解析相關配置注解)
@Configuration源碼
ApplicationContext的refresh方法
在之前的一篇文章spring源碼閱讀一中寫過，Spring容器啟動時，即ApplicationContext接口實現類的對象實例執行refresh方法時，在Bean初始化完成之前，有一個擴展點，用來操作BeanFactory，來擴展對應的功能，比如往BeanFactory中注冊的BeanDefinition，我們回顧一下Application的refresh函數：
- 看源碼(
AbstractApplicationContext.java)
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
// Prepare this context for refreshing.
// 1.准備刷新的上下文 環境
prepareRefresh();
// 2.初始化beanFactory 並進行xml文件讀取
//ClassPathXmlApplicationContext 包含着beanFactory所提供的一切特征，在這一步會將復用
//BeanFactory中的配置文件讀取解析及其他功能，這一步之后
// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 3.對beanFactory的各種功能進行填充 、BeanFactory的預准備工作
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
try {
// 4.子類覆蓋方法做額外處理 (具體的見 AbstractRefreshableWebApplicationContext 類中)
/*
BeanFactory的預准備工作（BeanFactory進行一些設置）
* spring 之所以強大，為世人所推崇，除了它功能上為大家提供便利外，還因為它很好的架構，開放式的架構讓使用它的程序員根據業務需要
* 擴展已經存在的功能，
* 這種開放式的設計spring隨處可見，例如在本例中提供了空的函數實現postProcessBeanFactory 方便程序猿在業務上做進一步擴展 */
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
/* 5.激活beanFactory的處理器 （Bean的后置處理器）
* ===========詳解=========
* BeanFactoryPostProcessor 接口和 BeanFactoryProcessor 類似，都可以對bean定義(配置元數據)進行處理，也就是說SpringIOC允許
* BeanFactoryPostProcessor 在容器實際實例化任何其他的bean之前來讀取配置元數據，並可能修改它，也可以配置多個BeanFactoryPostProcessor
* ，可以通過order屬性來控制BeanFactoryPostProcessor的執行順序(注意：此屬性必須當BeanFactoryPostProcessor實現了Ordered
* 接口時才可以賒賬)，因此在實現BeanFactoryPostProcessor時應該考慮實現Ordered接口
* 如果想改變實現的bean實例(例如從配置源數據創建的對象)，那最好使用BeanPostProcessor，同樣的BeanFactoryPostProcessor，
* 的作用域范圍是容器級別的，它只是和你鎖使用的容器有關。如果你在容器中定義了一個BeanFactoryPostProcessor，它僅僅對此容器的
* bean進行后置處理，BeanFactoryPostProcessor不會對定義在另外一個容器的bean進行后置處理，即使兩個容器都在同一個層次上。
* 在spring中存在對BeanFactoryPostProcessor的典型應用，如：PropertyPlaceholderConfigure
* */
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// 6.注冊攔截Bean創建的Bean攔截器（Bean的后置處理器,攔截Bean的創建），這里只是注冊，真正調用的時候 是在getBean
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
beanPostProcess.end();
// 7.為上下文處理Message源，國際化處理 即不同語言的消息體
// Initialize message source for this context.
initMessageSource();
// 8.初始化應用消息廣播器 也就是事件派發器，並放入 ApplicationEventMulticaster 中
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// 9.留給子類來初始化它的Bean 給子容器（子類），子類重寫這個方法，在容器刷新的時候可以自定義邏輯
// Initialize other special beans in specific context subclasses.
onRefresh();
// 10.在所有注冊的Bean中查找Listener Bean 注冊到廣播器中
// Check for listener beans and register them.
registerListeners();
// 初始化剩下的單實例(非惰性的)
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// 最后一步完成刷新過程，通知生命周期處理器lifecycleProcessor刷新過程，同時發出 ContentRefreshEvent 通知別人
// Last step: publish corresponding event.
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
contextRefresh.end();
}
}
}
- 源碼分析
看這一行代碼invokeBeanFactoryPostProcessors(beanFactory);，在這里初始化BeanFactory后，會激活各種BeanFactory處理器，我們來看看invokeBeanFactoryPostProcessors這個方法。
- 看源碼(
PostProcessorRegistrationDelegate.java)
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// 1、首先調用 BeanDefinitionRegistryPostProcessors
// Invoke BeanDefinitionRegistryPostProcessors first, if any.
Set<String> processedBeans = new HashSet<>();
// beanFactory是 BeanDefinitionRegistry 類型
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
// 定義BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
// 定義BeanDefinitionRegistryPostProcessor集合
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
// 循環手動注冊的 beanFactoryPostProcessors
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
/* 如果是BeanDefinitionRegistryPostProcessor的實例話,
* 則調用其 postProcessBeanDefinitionRegistry 方法,對bean進行注冊操作
*/
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
// 否則則將其當做普通的BeanFactoryPostProcessor處理,直接加入regularPostProcessors集合,以備后續處理 else {
regularPostProcessors.add(postProcessor);
}
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
// Separate between BeanDefinitionRegistryPostProcessors that implement
// PriorityOrdered, Ordered, and the rest.
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
// 首先調用實現了 PriorityOrdered (有限排序接口)的
// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
// 排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 加入registryProcessors集合
registryProcessors.addAll(currentRegistryProcessors);
// 調用所有實現了PriorityOrdered的的BeanDefinitionRegistryPostProcessors的postProcessBeanDefinitionRegistry方法,注冊bean
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
// 清空currentRegistryProcessors,以備下次使用
currentRegistryProcessors.clear();
// 其次,調用實現了Ordered(普通排序接口)的BeanDefinitionRegistryPostProcessors
// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
// 排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 加入registryProcessors集合
registryProcessors.addAll(currentRegistryProcessors);
// 調用所有實現了PriorityOrdered的的BeanDefinitionRegistryPostProcessors的postProcessBeanDefinitionRegistry方法,注冊bean
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
// 清空currentRegistryProcessors,以備下次使用
currentRegistryProcessors.clear();
// 最后,調用其他的BeanDefinitionRegistryPostProcessors
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
Boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
// 排序
sortPostProcessors(currentRegistryProcessors, beanFactory);
// 加入registryProcessors集合
registryProcessors.addAll(currentRegistryProcessors);
// 調用其他的 BeanDefinitionRegistryProcessors 的 postProcessorBeanDefinitionRegistry 方法
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
// 清空currentRegistryProcessors集合 以供下次使用
currentRegistryProcessors.clear();
}
/* 現在調用所有的 BeanDefinitionRegistryPostProcessor (包括手動注冊和配置文件注冊) 和
* 和 BeanFactoryPostProcessor(只有手動注冊)的回調函數 -> postProcessBeanFactory
*/
// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
// 2.如果不是BeanDefinitionRegistry的實例，那么直接調用其他回調函數即可 -->postProcessBeanFactory else {
// Invoke factory processors registered with the context instance.
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
// 上面的代碼已經處理完了所有的 BeanDefinitionRegistryPostProcessor 和 手動注冊的 BeanFactoryPostProcessor
// 接下來要處理通過配置文件注冊的 BeanFactoryPostProcessor
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
// 首先獲取所有的BeanFactoryPostProcessor (注意：這里獲取的集合會包含 BeanDefinitionRegistryPostProcessors)
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
// 這里 將實現了 PriorityOrdered Ordered的處理器和其他處理器區分開來，分別進行處理
// PriorityOrdered有序處理器
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// Ordered有序處理器
List<String> orderedPostProcessorNames = new ArrayList<>();
// 無序處理器
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
// 判斷processedBeans是否包含當前處理器(processedBeans中的處理器已經處理過的 也就是上邊第一步已經處理過的)，如果包含則不做處理
// skip - already processed in first phase above
}
// 加入到PriorityOrdered有序處理器集合 else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
// 加入到Ordered有序處理器集合 else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
// 加入到無序處理器集合 else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// 首先調用實現了 PriorityOrdered 接口的處理器
// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 其次 調用了 Ordered 接口的處理器
// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// 最后 調用了無序處理器
// Finally, invoke all other BeanFactoryPostProcessors.
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
// 循環遍歷 BeanFactoryPostProcessor 中的 postProcessBeanFactory 方法
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// 清理元數據
// Clear cached merged bean definitions since the post-processors might have
// modified the original metadata, e.g. replacing placeholders in values...
beanFactory.clearMetadataCache();
}
- 源碼分析
我們着重看看一下registryProcessor.postProcessBeanDefinitionRegistry(registry);這行代碼，然后看一下其實現類如圖所示:
然后我們看一下ConfigurationClassPostProcessor這個類里面的postProcessBeanDefinitionRegistry方法
- 看源碼(
ConfigurationClassPostProcessor.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);
// 解析Java類配置bean
processConfigBeanDefinitions(registry);
}
繼續查看解析Java類配置Bean的方法processConfigBeanDefinition(registry)
- 看源碼(
ConfigurationClassPostProcessor.java)
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
// 所有已經注冊的Bean
String[] candidateNames = registry.getBeanDefinitionNames();
// 清楚Bean定義信息
for (String beanName : candidateNames) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
if (logger.isDebugEnabled()) {
logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
}
// 1. 如果當前Bean是JavaBean配置類(含有@Configuration注解的類)， 則加入到集合 configCandidates 中 else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
// Return immediately if no @Configuration classes were found
// 沒有 @Configuration 注解的類直接退出
if (configCandidates.isEmpty()) {
return;
}
// Sort by previously determined @Order value, if applicable
// 多個Java 配置類 按 @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) {
BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
AnnotationConfigUtils.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
// 初始化一個 ConfigurationClassParser 解析器 ，可以解析 @Configuration 配置類
ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
do {
StartupStep processConfig = this.applicationStartup.start("spring.context.config-classes.parse");
// 2. 解析Java配置類
parser.parse(candidates);
// 主要校驗配置類不能使用 final 修飾符修飾 (CGLIB代理是生成一個子類，因此原先的類不能使用final修飾)
parser.validate();
// 排除已處理過的配置類
Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
configClasses.removeAll(alreadyParsed);
// Read the model and create bean definitions based on its content
if (this.reader == null) {
this.reader = new ConfigurationClassBeanDefinitionReader(
registry, this.sourceExtractor, this.resourceLoader, this.environment,
this.importBeanNameGenerator, parser.getImportRegistry());
}
// 3. 加載Bean 定義信息，主要實現將 @Bean @Configuration @Import @ImportResource 注冊為Bean
this.reader.loadBeanDefinitions(configClasses);
alreadyParsed.addAll(configClasses);
processConfig.tag("classCount", () -> String.valueOf(configClasses.size())).end();
// 清空已處理的配置類
candidates.clear();
// 再次獲取容器中Bean定義數量，如果大於之前獲取的Bean定義數量，則說明有新的Bean注冊到容器中，需要再次解析
if (registry.getBeanDefinitionCount() > candidateNames.length) {
String[] newCandidateNames = registry.getBeanDefinitionNames();
Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
Set<String> 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);
// 新注冊的Bean如果也是@Configuration配置類，則添加數據等待解析
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.
((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
}
}
- 源碼解析
processConfigBeanDefinitions這個方法大體可以划分為三個階段：
- 階段一：從容器中獲取和Configuration有關系的BeanDefinition
- 以該BeanDefinition為起點，進行解析操作，得到解析結果集
- 將解析到的結果集加載到容器中，即構造成一個BeanDefinition放到容器中待初始化
1. 判斷類是否與@Configuration有關
在上面第一步中，有@Configuration注解的會加入到集合當中，這個判斷是在ConfigurationClassUtils.checkConfigurationClassCandidate當中實現的。
看源碼之前先看一下
ConfigturationClassUtils.java類中的一下代碼，在下面的代碼分析中都有用到。
private static final Set<String> candidateIndicators = new HashSet<>(8);
static {
candidateIndicators.add(Component.class.getName());
candidateIndicators.add(ComponentScan.class.getName());
candidateIndicators.add(Import.class.getName());
candidateIndicators.add(ImportResource.class.getName());
}
- 看源碼(
ConfigurationClassUtils.java)
public static Boolean checkConfigurationClassCandidate(
BeanDefinition beanDef, MetadataReaderFactory metadataReaderFactory) {
String className = beanDef.getBeanClassName();
if (className == null || beanDef.getFactoryMethodName() != null) {
return false;
}
// 獲取注解元數據信息
AnnotationMetadata metadata;
if (beanDef instanceof AnnotatedBeanDefinition &&
className.equals(((AnnotatedBeanDefinition) beanDef).getMetadata().getClassName())) {
// Can reuse the pre-parsed metadata from the given BeanDefinition...
metadata = ((AnnotatedBeanDefinition) beanDef).getMetadata();
} else if (beanDef instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) beanDef).hasBeanClass()) {
// Check already loaded Class if present...
// since we possibly can't even load the class file for this Class.
Class<?> beanClass = ((AbstractBeanDefinition) beanDef).getBeanClass();
if (BeanFactoryPostProcessor.class.isAssignableFrom(beanClass) ||
BeanPostProcessor.class.isAssignableFrom(beanClass) ||
AopInfrastructureBean.class.isAssignableFrom(beanClass) ||
EventListenerFactory.class.isAssignableFrom(beanClass)) {
return false;
}
metadata = AnnotationMetadata.introspect(beanClass);
} else {
try {
MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(className);
metadata = metadataReader.getAnnotationMetadata();
}
catch (IOException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Could not find class file for introspecting configuration annotations: " +
className, ex);
}
return false;
}
}
// 注意這個方法 下面后進行一個匹配 看看是不是指定的注解 比如 @Configuration
Map<String, Object> config = metadata.getAnnotationAttributes(Configuration.class.getName());
// 查找當前注解是否與 @Configuration 相關
// 該方法還會判斷該注解上的注解是否有 @Configuration 一直往上尋找 因為有的注解是復合注解
if (config != null && !Boolean.FALSE.equals(config.get("proxyBeanMethods"))) {
beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);
}
// 查找當前注解上是否有 @ComponentScan、@Component、@Import、@ImportResource 注解
// 如果沒有則查找Bean注解，同上，一直往上查找 else if (config != null || isConfigurationCandidate(metadata)) {
beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE);
} else {
return false;
}
// It's a full or lite configuration candidate... Let's determine the order value, if any.
Integer order = getOrder(metadata);
if (order != null) {
beanDef.setAttribute(ORDER_ATTRIBUTE, order);
}
return true;
}
繼續看一下這里面的isConfigurationCandidate這個方法
- 看源碼(
ConfigurationClassUtils.java)
public static Boolean isConfigurationCandidate(AnnotationMetadata metadata) {
// Do not consider an interface or an annotation...
if (metadata.isInterface()) {
return false;
}
// Any of the typical annotations found?
for (String indicator : candidateIndicators) {
if (metadata.isAnnotated(indicator)) {
return true;
}
}
// Finally, let's look for @Bean methods...
return hasBeanMethods(metadata);
}
繼續查看這個方法里面的hasBeanMethods方法：
- 看源碼(``)
static Boolean hasBeanMethods(AnnotationMetadata metadata) {
try {
return metadata.hasAnnotatedMethods(Bean.class.getName());
}
catch (Throwable ex) {
if (logger.isDebugEnabled()) {
logger.debug("Failed to introspect @Bean methods on class [" + metadata.getClassName() + "]: " + ex);
}
return false;
}
}
2. 解析Java配置類parse.parse(candidates)
parse.parse(candidates)方法最終調用processConfigurationClass方法來處理@Configuratin配置類，ConfigurationClassParser.procesConfigurationClass()方法代碼如下：
- 看源碼(
ConfigurationClassParser.java)
protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
// 判斷是否需要解析
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.
// ** 真正解析配置類 **
SourceClass sourceClass = asSourceClass(configClass, filter);
do {
sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
}
while (sourceClass != null);
// 再次添加到到集合中
this.configurationClasses.put(configClass, configClass);
}
- 源碼解析
看上面代碼中的真正解析配置類的那行代碼sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);doProcessConfigurationClass方法主要是從配置類中解析所有Bean，包括處理內部類，父類以及各種注解ConfigurationClassParse.doProcessConfigurationClass()解析邏輯如下：
- 看源碼(
ConfigurationClassParser.java)
@Nullable
protected final SourceClass doProcessConfigurationClass(
ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
throws IOException {
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
// Recursively process any member (nested) classes first
// 遞歸處理任何成員（嵌套）類
processMemberClasses(configClass, sourceClass, filter);
}
// Process any @PropertySource annotations
// 處理@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
// 處理@ComponentScan
//獲取@ComponentScan注解信息
Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
if (!componentScans.isEmpty() &&
!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
for (AnnotationAttributes componentScan : componentScans) {
// The config class is annotated with @ComponentScan -> perform the scan immediately
// 按@CmponentScan注解掃描bean
Set<BeanDefinitionHolder> scannedBeanDefinitions =
this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
// Check the set of scanned definitions for any further config classes and parse recursively if needed
// 遍歷掃描出的bean定義是否是配置類bean
for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
if (bdCand == null) {
bdCand = holder.getBeanDefinition();
}
// 如果掃描出的bean定義是配置類（含有@COnfiguration）,則繼續調用parse方法，內部再次調用doProcessConfigurationClas(),遞歸解析
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}
// Process any @Import annotations
//處理@Import注解
processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
// Process any @ImportResource annotations
// 處理@ImportResource注解
AnnotationAttributes importResource =
AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
if (importResource != null) {
String[] resources = importResource.getStringArray("locations");
Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
for (String resource : resources) {
String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
configClass.addImportedResource(resolvedResource, readerClass);
}
}
// Process individual @Bean methods
// 處理@Bean注解
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
// 將解析出的所有@Bean注解方法添加到configClass配置類信息中
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
// Process default methods on interfaces
// 處理接口中所有添加@Bean注解的方法，內部通過遍歷所有接口，解析得到@Bean注解方法，並添加到configClass配置類信息中
processInterfaces(configClass, sourceClass);
// Process superclass, if any
// 如果有父類，則返回父類，遞歸執行doProcessConfigurationClass()解析父類
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
return null;
}
接下來說一下很重要的兩個注解，@Bean、@ComponentScan的實現過程。在上面的doProcessConfigurationClass方法里
@ComponentScan注解解析過程
//獲取@ComponentScan注解信息
Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
@ComponentScan注解解析，從上面的代碼可以看出@ComponentScan注解解析通過調用ComponentScanAnnotationParser的parse方法完成，而parse()方法內部處理了一些scanner屬性(過濾設置)和basePackages包名處理，最終通過調用ClassPathBeanDefinitionScanner.doScan方法實現掃描工作。
先來看一下ComponentScanAnnotationParser的parse方法
- 看源碼(
ComponentScanAnnotationParser.java)
public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
Boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
BeanUtils.instantiateClass(generatorClass));
ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
scanner.setScopedProxyMode(scopedProxyMode);
} else {
Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");
scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));
}
scanner.setResourcePattern(componentScan.getString("resourcePattern"));
for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
for (TypeFilter typeFilter : typeFiltersFor(filter)) {
scanner.addIncludeFilter(typeFilter);
}
}
for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
for (TypeFilter typeFilter : typeFiltersFor(filter)) {
scanner.addExcludeFilter(typeFilter);
}
}
Boolean lazyInit = componentScan.getBoolean("lazyInit");
if (lazyInit) {
scanner.getBeanDefinitionDefaults().setLazyInit(true);
}
Set<String> basePackages = new LinkedHashSet<>();
String[] basePackagesArray = componentScan.getStringArray("basePackages");
for (String pkg : basePackagesArray) {
String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
Collections.addAll(basePackages, tokenized);
}
for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
basePackages.add(ClassUtils.getPackageName(clazz));
}
if (basePackages.isEmpty()) {
basePackages.add(ClassUtils.getPackageName(declaringClass));
}
scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
@Override
protected Boolean matchClassName(String className) {
return declaringClass.equals(className);
}
}
);
return scanner.doScan(StringUtils.toStringArray(basePackages));
}
注意上面最后一行代碼 scanner.doScan(StringUtils.toStringArray(basePackages));
doScan掃描basePackages下所有bean.
- 看源碼(
ClassPathBeanDedefinitionScanner.java)
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
Assert.notEmpty(basePackages, "At least one base package must be specified");
Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
for (String basePackage : basePackages) {
// 根據 basePackage 加載包下所有Java文件，並掃描出所有Bean組件
Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
// 遍歷 beanDefinition
for (BeanDefinition candidate : candidates) {
// 解析作用域 Scope
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
if (candidate instanceof AbstractBeanDefinition) {
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
// 通過注解解析到 candidate 結構中，主要是處理 Lazy primary DependsOn Role Description 這五個注解
if (candidate instanceof AnnotatedBeanDefinition) {
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
// 檢查當前 Bean 是否已注冊，不存在則注冊
if (checkCandidate(beanName, candidate)) {
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
definitionHolder =
AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
// 注冊到IOC 容器中，主要是一些 @Component 組件，@Bean方法並沒有在此處注冊，BeanName和BeanDefinition鍵值對
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}
上面掃掃描出所有Bean組件的方法findCandidateComponents具體實現是在ClassPathScanningCandidateComponentProvider的scanCandidateComponents方法里面；如下：
- 看源碼(
ClassPathScaningcandidateCommponentProvider.java)
private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
Set<BeanDefinition> candidates = new LinkedHashSet<>();
try {
// @ComponentScan("com.sl.springlearning.extension")
// 包路徑處理：packageSearchPath = classpath*:com/sl/springlearning/extension/**/*.class
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + '/' + this.resourcePattern;
// 獲取當前包下所有的class文件
Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
Boolean traceEnabled = logger.isTraceEnabled();
Boolean debugEnabled = logger.isDebugEnabled();
for (Resource resource : resources) {
if (traceEnabled) {
logger.trace("Scanning " + resource);
}
if (resource.isReadable()) {
try {
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
// 按照scanner過濾器過濾，比如配置類本身將被過濾掉，沒有@Component等組件注解的類將過濾掉
// 包含@Component注解的組件將創建BeanDefinition
if (isCandidateComponent(metadataReader)) {
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setSource(resource);
if (isCandidateComponent(sbd)) {
if (debugEnabled) {
logger.debug("Identified candidate component class: " + resource);
}
candidates.add(sbd);
} else {
if (debugEnabled) {
logger.debug("Ignored because not a concrete top-level class: " + resource);
}
}
} else {
if (traceEnabled) {
logger.trace("Ignored because not matching any filter: " + resource);
}
}
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to read candidate component class: " + resource, ex);
}
} else {
if (traceEnabled) {
logger.trace("Ignored because not readable: " + resource);
}
}
}
}
catch (IOException ex) {
throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
}
return candidates;
}
@Bean注解解析過程
繼續回到ConfigutationClassParser.java中的doProcessConfigurationClass這個方法里的對@Bean注解的解析。Set
- 看源碼(
ConfigurationClaSSParser.java)
private Set<MethodMetadata> retrieveBeanMethodMetadata(SourceClass sourceClass) {
AnnotationMetadata original = sourceClass.getMetadata();
// 獲取所有 @Bean 注解的方法
Set<MethodMetadata> beanMethods = original.getAnnotatedMethods(Bean.class.getName());
// 如果配置類中有多個@Bean注解的方法，則排序
if (beanMethods.size() > 1 && original instanceof StandardAnnotationMetadata) {
// Try reading the class file via ASM for deterministic declaration order...
// Unfortunately, the JVM's standard reflection returns methods in arbitrary
// order, even between different runs of the same application on the same JVM.
try {
AnnotationMetadata asm =
this.metadataReaderFactory.getMetadataReader(original.getClassName()).getAnnotationMetadata();
Set<MethodMetadata> asmMethods = asm.getAnnotatedMethods(Bean.class.getName());
if (asmMethods.size() >= beanMethods.size()) {
Set<MethodMetadata> selectedMethods = new LinkedHashSet<>(asmMethods.size());
for (MethodMetadata asmMethod : asmMethods) {
for (MethodMetadata beanMethod : beanMethods) {
if (beanMethod.getMethodName().equals(asmMethod.getMethodName())) {
selectedMethods.add(beanMethod);
break;
}
}
}
if (selectedMethods.size() == beanMethods.size()) {
// All reflection-detected methods found in ASM method set -> proceed
beanMethods = selectedMethods;
}
}
}
catch (IOException ex) {
logger.debug("Failed to read class file via ASM for determining @Bean method order", ex);
// No worries, let's continue with the reflection metadata we started with...
}
}
return beanMethods;
}
- 源碼分析
從retrieveBeanMethodMetadata方法可以看到的是只是實現了@Bean方法的解析，但並未將實現Bean實例的創建。
3. 加載Bean定義信息this.reader.loadBeanDefinitions(configClasses)
繼續回到ConfigurationClassPostProcessor類的processConfigBeanDefinitions方法，當調用完praser方法后，能得到一批ConfigurationClass集合，但是這時候只是獲取到，而容器中還沒有對應的注冊信息，那么接下來就是對這批集合進行注冊處理。
this.reader.loadBeanDefinitions(configClasses);這行代碼就是進行注冊處理。
- 看源碼(
ConfigurationClassBeanDefinitionReader.java)
public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
for (ConfigurationClass configClass : configurationModel) {
loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
}
}
- 源碼分析
ConfigurationClassBeanDefinitionReader.loadBeanDefinitions()方法的功能就是將之前解析出的configClasses配置類信息中所有配置相關的信息添加到Spring的Bean定義。主要是配置類中的@Bean注解方法，配置類@ImportResource和@Import(實現ImportBeanDefinitionRegistrar接口方式)的Bean注冊
繼續查看loadBeanDefinitionsForConfigurationClass方法
- 看源碼(
ConfigurationClassBeanDefinitionReader.java)
private void loadBeanDefinitionsForConfigurationClass(
ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
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;
}
// 與@Import注解相關
if (configClass.isImported()) {
registerBeanDefinitionForImportedConfigurationClass(configClass);
}
// 將@Bean方法注冊為bean
for (BeanMethod beanMethod : configClass.getBeanMethods()) {
loadBeanDefinitionsForBeanMethod(beanMethod);
}
// 將configClass中中ImportResource指定的資源注冊為bean
loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
// 將configClass中ImportedRegistrar注冊為bean
loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}
繼續查看將@Bean方法注冊為Bean的方法：loadBeanDefinitionsForBeanMethod
- 看源碼(
ConfigurationClassBeanDefinitionReader.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?
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
// 獲取@Bean注解是否有name屬性，如：（@Bean(name="myBean")）
List<String> names = new ArrayList<>(Arrays.asList(bean.getStringArray("name")));
// 默認Bean的方法和名稱相同，但是如果設置了name，就獲取name作為BeanName
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, beanName);
beanDef.setSource(this.sourceExtractor.extractSource(metadata, configClass.getResource()));
// 設置工廠方法，
// 后去的Bean實例化，getBean的時候，會判斷BeanMethod是否存在FactoryMethod，如果存在就使用反射調用工廠方法，返回工廠方法的對象
if (metadata.isStatic()) {
// static @Bean method
if (configClass.getMetadata() instanceof StandardAnnotationMetadata) {
beanDef.setBeanClass(((StandardAnnotationMetadata) configClass.getMetadata()).getIntrospectedClass());
} else {
beanDef.setBeanClassName(configClass.getMetadata().getClassName());
}
beanDef.setUniqueFactoryMethodName(methodName);
} else {
// instance @Bean method
beanDef.setFactoryBeanName(configClass.getBeanName());
beanDef.setUniqueFactoryMethodName(methodName);
}
if (metadata instanceof StandardMethodMetadata) {
beanDef.setResolvedFactoryMethod(((StandardMethodMetadata) metadata).getIntrospectedMethod());
}
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);
}
String initMethodName = bean.getString("initMethod");
if (StringUtils.hasText(initMethodName)) {
beanDef.setInitMethodName(initMethodName);
}
String destroyMethodName = bean.getString("destroyMethod");
beanDef.setDestroyMethodName(destroyMethodName);
// Consider scoping
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, beanName);
}
if (logger.isTraceEnabled()) {
logger.trace(String.format("Registering bean definition for @Bean method %s.%s()",
configClass.getMetadata().getClassName(), beanName));
}
this.registry.registerBeanDefinition(beanName, beanDefToRegister);
}
- 源碼解析
上面的代碼比較多，主要看注釋的核心部分，其目的主要是構造了BeanDefinition，然后注冊進容器，而BeanDefinition的一些屬性則是由注解中獲取的；
另外，可以看到@Bean的方式構造的BeanDefinition的時候，與普通的不同，這種方式是會設置工廠方法去初始化，也就是說，咱們自定義的CustomConfig類型的appBean方法會被Spring當成一個工廠方法，也就是說這種方式與下列的初始化方式原理類似：
<bean id="customConfig" class="com.vipbbo.selfdemo.spring.configuration.CustomConfig"/>
<bean id="appBean" factory-bean="customConfig" factory-method="appBean"></bean>
總結
處理邏輯理了一遍之后，看ConfigurationClassPostProcessor處理器解析@Configuration配置類主要過程：
- Spring容器初始化時注冊默認后置處理器ConfigurationClassPostProcessor
- Spring容器初始化執行refresh()方法中調用ConfigurationClassPostProcessor
- ConfigurationClassPostProcessor處理器借助ConfigurationClassParser完成配置類解析
- ConfigurationClassParser配置內解析過程中完成嵌套的MemberClass、@PropertySource注解、@ComponentScan注解(掃描package下的所有Class並進行迭代解析，主要是@Component組件解析及注冊)、@ImportResource、@Bean等處理
- 完成@Bean注冊，@ImportResource指定bean的注冊以及@Import(實現ImportBeanDefinitionRegistrar接口方式)的Bean注冊
- 有@Bean注解的方法在解析的時候作為iConfigurantionClass的一個屬性，最后還是會轉換成BeanDefinition進行處理，而實例化的時候會作為一個工廠方法進行Bean的創建
整理不易，如果對你有所幫助歡迎點贊關注
微信搜索【碼上遇見你】獲取更多精彩內容