Spring源碼核心篇整體欄目

---

內容	鏈接地址
【一】Spring的bean的生命周期	https://zhenghuisheng.blog.csdn.net/article/details/143441012
【二】深入理解spring的依賴注入和屬性填充	https://zhenghuisheng.blog.csdn.net/article/details/143854482
【三】精通spring的aop的底層原理和源碼實現	https://zhenghuisheng.blog.csdn.net/article/details/144012934
【四】spring中refresh刷新機制的流程和實現	https://zhenghuisheng.blog.csdn.net/article/details/144118337
【五】spring中循環依賴的解決和底層實現	https://zhenghuisheng.blog.csdn.net/article/details/144132213
【六】spring中事務的底層實現與執行流程	https://zhenghuisheng.blog.csdn.net/article/details/144178500
【七】spring中事物傳播機制的流程和原理	https://zhenghuisheng.blog.csdn.net/article/details/144178500
【八】spring中配置類底層原理和源碼實現	https://zhenghuisheng.blog.csdn.net/article/details/148657333

---

如需轉載，請附上鏈接:https://blog.csdn.net/zhenghuishengq/article/details/148657333

一. 深入理解spring配置類實現原理

在spring中，內部存在一些配置類，配置注解，在我們使用這些注解的時候，可以手動的將一些配置類加載到spring容器中，類似與比較常規的 @Configuration 注解等，除了這個注解之外，spring內部也提供了多個這種注解，接下來從spring源碼中，來分析這些配置類以及配置注解

在spring源碼中，會解析配置類，校驗是否配置類的入口如下，通過下面這個方法來判斷該

ConfigurationClassUtils.checkConfigurationClassCandidate(...)

1，配置類方法入口checkConfigurationClassCandidate

其方法詳情如下，主要是通過獲取類上面的注解，然后通過注解來判斷該類是不是配置類

首先會判斷這個類上面是不是加了這個 @Configuration 注解

AnnotationMetadata metadata;
// 校驗是不是加了 @Configuration 注解
if (isFullConfigurationCandidate(metadata)) {//如果加了，那么給這個注解上面加一個標記beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);
}
public static boolean isFullConfigurationCandidate(AnnotationMetadata metadata) {return metadata.isAnnotated(Configuration.class.getName());
}

接下來根據源碼繼續往下走，上面是一個full重的配置類，接下來會判斷一些lite配置類，即一些比較輕的配置類

else if (isLiteConfigurationCandidate(metadata)) {beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE);
}

這個lite輕的配置類的具體實現如下，首先會判斷要加載的類上面的注解包不包括在 candidateIndicators 集合列表中， 這個set集合中包括的主要注解如下：Component、ComponentScan、Import、ImportResource 這四個，除了這幾個之外，下面還會判斷內部是否有 @Bean 注解

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

也就是說，只要類上面有 以下注解，那么spring就會將這些類掃描并解析成一個配置類

• @Configuration
• @Bean
• @Component
• @ComponentScan
• @Import
• @ImportResource

2，解析配置類doProcessConfigurationClass

在refresh方法中，會有一個 invokeBeanFactoryPostProcessors 方法，在內部就會調用到這個 doProcessConfigurationClass 真正的去解析這個配置類的方法。接下來直接看源碼，看看內部到底是如何解析的。

2.1. @PropertySource 解析

首先第一步是解析帶有這個 PropertySource 注解的實體類，這個注解就是用于處理 Properties 配置文件的，將配置文件中的內容加載到spring容器內部

for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(sourceClass.getMetadata(), PropertySources.class,org.springframework.context.annotation.PropertySource.class)) {if (this.environment instanceof ConfigurableEnvironment) {processPropertySource(propertySource);}
}

2.2. @ComponentScan 解析

接下來解析的是這個 ComponentScan 注解，ComponentScan說白了就是對 @Component注解的掃描，判斷類上面是否有這個 @Component注解，在前面講解bean的生命周期的時候重點的講解過。

for (AnnotationAttributes componentScan : componentScans) {//把我們掃描出來的類變為bean定義的集合 真正的解析Set<BeanDefinitionHolder> scannedBeanDefinitions =this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());//循環處理我們包掃描出來的bean定義for (BeanDefinitionHolder holder : scannedBeanDefinitions) {BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();if (bdCand == null) {bdCand = holder.getBeanDefinition();}//判斷當前掃描出來的bean定義是不是一個配置類,若是的話 直接進行遞歸解析if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {//遞歸解析 因為@Component算是lite配置類parse(bdCand.getBeanClassName(), holder.getBeanName());}}
}

首先會將這些掃描到的類解析成一個 BeanDefinition，判斷是否存在includeFilters中，excludeFilters中，然后判斷是否@Lazy @DependsOn等注解，最后將這些屬性全部注冊到beanDefinition中返回

this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName())

最后又會判斷這個類屬不屬于配置類，屬于的話再次遞歸解析，判斷這個類可不可能存在父類也需要解析成配置類等，直到返回null跳出遞歸

if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {//遞歸解析 因為@Component算是lite配置類parse(bdCand.getBeanClassName(), holder.getBeanName());
}

2.3. @Import 解析

接下來就是處理Import的注解，這個部分的解析相對繞一些。首先會調用這個 getImports 方法獲取全部帶有Import的類

processImports(configClass, sourceClass, getImports(sourceClass), true);

然后遍歷這些獲取的Import實例，里面會有三個分支，校驗這些加了Import的類上面是否是單純的加了這個注解，還是同時實現了別的接口，要對相關實現的接口做不同的判斷

for (SourceClass candidate : importCandidates) {...
}

• 1，首先是先看只有單純加了Import的配置類，spring會直接將這種配置類進行解析注冊

else {// 當做配置類再解析，注意這里會標記：importedBy，  表示這是Import的配置的類// 再執行之前的processConfigurationClass()方法 ，this.importStack.registerImport(currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());processConfigurationClass(candidate.asConfigClass(configClass));
}		

• 2，隨后是判斷這個加了Import注解的類，同時實現了 ImportSelector 接口，如果是的話，那么會先實例化一個 ImportSelector 組件，然后通過遞歸的方式，將一個ImportSelector組件解析成上面多個 Import 組件，最后又調用這個 processImports 方法，將解析成多個的import組件走上面的這個else邏輯

if (candidate.isAssignable(ImportSelector.class)) {// Candidate class is an ImportSelector -> delegate to it to determine importsClass<?> candidateClass = candidate.loadClass();//實例化我們的SelectImport組件ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);//調用相關的aware方法ParserStrategyUtils.invokeAwareMethods(selector, this.environment, this.resourceLoader, this.registry);//判斷是不是延時的DeferredImportSelectors，是這個類型 不進行處理if (this.deferredImportSelectors != null && selector instanceof DeferredImportSelector) {this.deferredImportSelectors.add(new DeferredImportSelectorHolder(configClass, (DeferredImportSelector) selector));}else {//不是延時的//調用selector的selectImportsString[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());// 所以遞歸解析-- 直到成普通組件Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames);processImports(configClass, currentSourceClass, importSourceClasses, false);}
}

• 3，最后再看這個加了Import注解，同時也實現了 ImportBeanDefinitionRegistrar 接口的方法，他和上面這個實現 ImportSelector 的方式不同，不會解析轉成多個Import，而是作為一個屬性加入到 ConfigurationClass配置類中

else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {Class<?> candidateClass = candidate.loadClass();//實例話我們的ImportBeanDefinitionRegistrar對象ImportBeanDefinitionRegistrar registrar =BeanUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class);ParserStrategyUtils.invokeAwareMethods(registrar, this.environment, this.resourceLoader, this.registry);//保存我們的ImportBeanDefinitionRegistrar對象 currentSourceClass=所在配置類configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
}

2.4. @ ImportResource 解析

接下來就是處理這個 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);}
}

其核心就在于下面這句，用于獲取本地的一些環境變量或者一些屬性，比如獲取一些 xml 文件中的一些配置屬性等，然后將內容讀取到配置文件

String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);

最后也是作為一個屬性加入到 ConfigurationClass 配置文件中，和上面實現這個 ImportBeanDefinitionRegistrar 接口的一樣，目前只是將這些屬性加入到配置文件中，還有生成具體的beanDefinition

configClass.addImportedResource(resolvedResource, readerClass);

2.5. @Bean 解析

接下來就是接下這個 @Bean注解，這里也比較簡單，就是在類中獲取全部帶有 @Bean的注解，然后去遍歷這些元數據，然后將這些打包成一個 BeanMethod實體，加入到ConfigurationClass配置文件中

// 獲取全部帶有 @Bean的方法
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}

除了在類中獲取 @Bean 注解之外，他還有一個在接口中獲取該注解的解析。比如有的接口的default方法中加了這個注解進行注入，但其實現和在類中找一致，也是將這些打包成BeanMethod實體類，加入到配置文件中

processInterfaces(configClass, sourceClass);private void processInterfaces(ConfigurationClass configClass, SourceClass sourceClass) throws IOException {for (SourceClass ifc : sourceClass.getInterfaces()) {Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(ifc);for (MethodMetadata methodMetadata : beanMethods) {if (!methodMetadata.isAbstract()) {// A default method or other concrete method on a Java 8+ interface...configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));}}processInterfaces(configClass, ifc);}
}

2.6. @父類解析

最后就剩一個父類解析，因為很多地方涉及到遞歸解析，判斷父類是否也是一個配置類，因此需要在此處進行處理

遞歸直到沒有父類需要解析，那么就會返回一個null，前面的while需要通過這個返回的null跳出遞歸，可以參考源碼實現。

// 處理配置類的父類的 ，循環再解析
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 recursereturn sourceClass.getSuperClass();}
}
// 沒有父類解析完成
return null;

3，注冊配置類的beanDefinition

上面PropertySource 、ComponentScan 、Import 都注冊成了對應的beanDefinition，而@Bean、@ImportResource 注解目前只是封裝成了實體加載到了配置類中，還沒有進行注冊到對應beanDefinition中，那么繼續看源碼，底層是如何將后面加到配置類的幾個注冊成bean定義的

還是得回到 processConfigBeanDefinitions 中，查看這個@Bean和實現了這個 ImportBeanDefinitionRegistrar 的 @Import方法時如何解析成BeanDefinition的，這塊內容在前面講解bean的生命周期的時候詳細的講過，這個也是前面的一個流程

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {// 此處才把@Bean的方法和@Import 注冊到BeanDefinitionMap中this.reader.loadBeanDefinitions(configClasses);
}

接下來直接查看這個 loadBeanDefinitions 方法，里面也沒做特別的事情，就是一個循環

public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();//注冊我們的配置類到容器中for (ConfigurationClass configClass : configurationModel) {loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);}
}

接下來重點查看這個 loadBeanDefinitionsForConfigurationClass 方法，在這個方法中，對@Import、@Bean、@ImportResources、@ImportBeanDefinition 注解進行解析，然后生成對應的beanDefinition

3.1. @Import注解生成BeanDefinition

首先會判斷這個配置類是不是導入進來的

if (configClass.isImported()) {registerBeanDefinitionForImportedConfigurationClass(configClass);
}

如果這個類是通過Import導入進來的，那么會調用這個 registerBeanDefinitionForImportedConfigurationClass 方法來將這個類注冊成 BeanDefinition，會設置一些元數據信息，bean定義，作用域等，最后通過注冊的方式將這個實體類注冊成一個BeanDefinition

3.2. @Bean注解生成BeanDefinition

隨后會判斷這個配置類上面是不是通過@Bean的方式注入進來的，如果是通過@Bean方式注入進來的，前面已經將@Bean的配置類包裝成了 BeanMethod 實體類，因此只需要遍歷這個配置類中的 BeanMethods實體類集合即可

//是不是通過我們的@bean導入進來的組件
for (BeanMethod beanMethod : configClass.getBeanMethods()) {loadBeanDefinitionsForBeanMethod(beanMethod);
}

這個解析會相對復雜點，里面設計多重校驗，最后注冊成BeanDefinition

private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {//設計大量的校驗`...// 最后注冊成BeanDefinition中this.registry.registerBeanDefinition(beanName, beanDefToRegister);
}

3.3. @ImportResources注解生成BeanDefinition

隨后判斷是不是importResources注解注入進來的

private void loadBeanDefinitionsFromImportedResources(){...
}

主要是加載一些grovvy配置文件或者xml文件，然后將這些配置文件設置到環境變量中

最后將這個配置文件通過reader讀取的方式加載到配置文件中

reader.loadBeanDefinitions(resource);