溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章主要介紹了springboot如何自動掃描添加BeanDefinition源碼，具有一定借鑒價值，感興趣的朋友可以參考下，希望大家閱讀完這篇文章之后大有收獲，下面讓小編帶著大家一起了解一下。
1.
springboot啟動過程中，首先會收集需要加載的bean的定義，作為BeanDefinition對象，添加到BeanFactory中去。
由于BeanFactory中只有getBean之類獲取bean對象的方法，所以將將BeanDefinition添加到BeanFactory中，是通過BeanDefinitionRegistry接口的void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException;方法來完成的。
所以我們的BeanFactory的實現類如果需要具備通過beanName來返回bean對象和添加刪除BeanDefinition的能力，至少實現BeanFactory和BeanDefinitionRegistry的這兩個接口。
這里我們就來看看springboot是如何查找bean的定義，添加到BeanFactory中的。
由于我們這里只是關注查找bean對象的定義，所以這里我們這里提到的BeanFactory主要會關注BeanDefinitionRegistry這個接口。
我們本地主要分析springboot掃描加載bean的配置，和我們的代碼關系不大，所以我們的代碼就用最簡單的吧。具體代碼如下：
package com.example.bootargs;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class BootargsApplication {
public static void main(String[] args) {
SpringApplication.run(BootargsApplication.class, args);
}
}后面提到的主類統一是com.example.bootargs.BootargsApplication
2.
Springboot 查找bean的定義主要是通過ConfigurationClassPostProcessor這個類來完成的。
ConfigurationClassPostProcessor實現了BeanDefinitionRegistryPostProcessor接口。BeanDefinitionRegistryPostProcessor接口就是通過postProcessBeanDefinitionRegistry方法來給BeanDefinitionRegistry的實現類來添加bean的定義。
BeanDefinitionRegistryPostProcessor繼承了BeanFactoryPostProcessor接口，而BeanFactoryPostProcessor接口主要是用來對BeanFactory進行增強。在springboot啟動過程中首先會創建BeanFactory,再調用BeanFactoryPostProcessor對BeanFactory
進行增強，最后才會去創建bean對象。
通過BeanFactoryPostProcessor對BeanFactory進行增強，主要是通過PostProcessorRegistrationDelegate的靜態方法來完成的。在這過程中就會調用到ConfigurationClassPostProcessor這個類。
由于ConfigurationClassPostProcessor實現了BeanDefinitionRegistryPostProcessor接口，PostProcessorRegistrationDelegate就會調用ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry方法中，就會調用到processConfigBeanDefinitions方法來查找bean的定義。我們就從這里作為入口來看吧。
3.
下面我們就去看看ConfigurationClassPostProcessor的processConfigBeanDefinitions方法
/**
* Build and validate a configuration model based on the registry of
* {@link Configuration} classes.
*/
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
String[] candidateNames = registry.getBeanDefinitionNames();
//在下面的這個for循環中，會從beanFactory中已經有的bean的定義中尋找有Configuration注解的配置類。
//默認這里獲取到的只有一個包含SpringBootApplication注解的主類
for (String beanName : candidateNames) {
......
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
//如果沒有找到配置類，就直接返回
// Return immediately if no @Configuration classes were found
if (configCandidates.isEmpty()) {
return;
}
......
//在這里就通過ConfigurationClassParser去解析配置類
// Parse each @Configuration class
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");
//所有bean的定義的查找都是在這里完成的。下面我們去看看這里的parse方法
parser.parse(candidates);
......
}在ConfigurationClassParser中的parse方法中，由于我們的配置類是通過注解來定義的，所以會走AnnotatedBeanDefinition這個分支。繼續會調用到processConfigurationClass(new ConfigurationClass(metadata, beanName), DEFAULT_EXCLUSION_FILTER);這句，我們就直接進到這個processConfigurationClass方法去看吧。
protected void processConfigurationClass(ConfigurationClass configClass, Predicate<String> filter) throws IOException {
//在這里首先看配置類上是否有Conditional注解，如果有的話，就去解析處理，看看是否要跳過這個注解類
if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
return;
}
//所有解析出來的配置類都要放置到configurationClasses中,key是當前解析出來的配置類,value就是表示這個配置類是通過誰來導入的。
//如果這個配置類不是通過別的類來導入的，這時key和value就是一樣的。
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 sourceClass = asSourceClass(configClass, filter);
do {
//在這里就會進行真正的配置類的解析出來。
//注意這里是個do-while循環，處理完當前的配置類，會繼續去處理當前配置類的父類。
//如果當前類的父類類名不是java開頭,且沒有被處理過的話，就會在這個do-while循環中繼續去處理
sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
}
while (sourceClass != null);
this.configurationClasses.put(configClass, configClass);
}this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)這個的過濾主要是通過org.springframework.context.annotation.Condition接口的子類去實現matches方法完成的。
舉個例子簡單說下:
@Configuration(proxyBeanMethods = false) @ConditionalOnMissingBean(name = AbstractApplicationContext.MESSAGE_SOURCE_BEAN_NAME, search = SearchStrategy.CURRENT) @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE) @Conditional(ResourceBundleCondition.class) @EnableConfigurationProperties public class MessageSourceAutoConfiguration
上面是MessageSourceAutoConfiguration類的定義，首先會查找它上面的Conditional注解，會找到兩個注解：
@ConditionalOnMissingBean(name = AbstractApplicationContext.MESSAGE_SOURCE_BEAN_NAME, search = SearchStrategy.CURRENT)
由于這個這個注解上面有@Conditional(OnBeanCondition.class),所以會交給OnBeanCondition這個類去處理。
@Conditional(ResourceBundleCondition.class)，則會交給ResourceBundleCondition這個類去處理。
processConfigurationClass這個方法會有多個地方，主要會出現在三個地方：
就是調用parse方法的時候會調用到這個processConfigurationClass方法。
在doProcessConfigurationClass中解析當前配置類的屬性時也可能會多次調用到processConfigurationClass方法。
在this.deferredImportSelectorHandler.process()調用時也可能會調用到processConfigurationClass方法
我們這里解析的所有配置類都添加到都會調用到configurationClasses.put(configClass, configClass)方法，所以我們最終有多個類添加到configurationClasses集合中，就至少有多少次調用到processConfigurationClass方法(有Conditional注解的判斷，所以調用次數可能多于最終添加到configurationClasses集合中元素個數)
@Nullable
protected final SourceClass doProcessConfigurationClass(
ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
throws IOException {
//在這里，查看類是否有Component注解，有的話，查找當前類的內部類，進行處理
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
// Recursively process any member (nested) classes first
//這里就可能會遞歸調用到上面的processConfigurationClass方法
processMemberClasses(configClass, sourceClass, filter);
}
// Process any @PropertySource annotations
//在這里，查看類是否有PropertySources注解，有的話去解析屬性配置，添加到環境上下文中去
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
//在這里，查看類是否有ComponentScans注解，有的話，就根據這里的條件去進行目錄掃描，查找bean的定義
//由于我們當前的類上有SpringBootApplication注解，所以這里是能夠找到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
//在這里，就會去處理ComponentScans注解相關的內容。
//ComponentScans注解上有個basePackages屬性，用來指定掃描的包的名字。
//如果沒有指定basePackages屬性，就在當前類的包下及其所有子包下去查找相關的bean的定義。
//我們一般不會指定basePackages屬性，那么會在當前sourceClass類的包及其所有子包下去查找bean的定義。
//我們自己代碼中定義的controller,service,dao等等都是在這一步獲取到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
for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
if (bdCand == null) {
bdCand = holder.getBeanDefinition();
}
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
//這里也會間接調用到processConfigurationClass方法
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}
// Process any @Import annotations
//在這里，就會去處理類上的import注解。
//getImports(sourceClass)首先會獲取到import的類。
//這里會有兩個，一個是AutoConfigurationPackage上注解的AutoConfigurationPackages.Registrar.class
//另一個是EnableAutoConfiguration上的注解AutoConfigurationImportSelector.class)
//下面我們去看看processImports這個方法
//這里面也可能會調用到processConfigurationClass方法
processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
......
}doProcessConfigurationClass是真正用來處理配置類的。
在這個方法中會依次處理內部類、PropertySources注解、ComponentScans注解、Import注解、ImportResource注解、Bean注解、接口上的默認方法、繼續遞歸到它的父類。
其中：
內部類會繼續調用processConfigurationClass方法遞歸去處理
PropertySources注解解析后添加到環境上下文中
ComponentScans注解掃描到的到的類會直接被添加到beanFactory中，也會繼續調用processConfigurationClass方法遞歸去處理
Import注解會分3種情況處理：
Import的類如果實現了ImportSelector。且實現了它的子接口DeferredImportSelector,則會添加到deferredImportSelectors中，后續進行處理。如果沒有實現子接口，就遞歸調用processImports進行處理。
Import的類如果實現了ImportBeanDefinitionRegistrar。則添加到當前配置類的屬性中，進行后續處理。
不屬于上面兩種情況的話，就繼續遞歸調用processConfigurationClass進行處理。
ImportResource注解、Bean注解、接口上的默認方法這些都會解析后添加到當前配置類的屬性上，后續進行處理
對下面方法的幾個入參簡單描述下：
configClass，currentSourceClass這兩個參數直接都是指代我們包含SpringBootApplication注解的主類。
其中configClass表示當前處理的類是被誰導入的，currentSourceClass表示當前正在處理的類。這兩者一般底層是同一個資源類，但是有可能會有遞歸調用，這時兩者就可能會不同。
importCandidates是通過import注解導入的類，這里是AutoConfigurationPackages.Registrar.class和AutoConfigurationImportSelector.class importCandidates就是當前被導入的類，也就是在這里被處理的類
exclusionFilter是在ConfigurationClassParser中定義的，用來過濾java.lang.annotation.和org.springframework.stereotype.開頭的注解
checkForCircularImports表示是否檢查遞歸導入
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
boolean checkForCircularImports) {
if (importCandidates.isEmpty()) {
return;
}
//這里是錯誤檢查，檢查是否出現了遞歸
if (checkForCircularImports && isChainedImportOnStack(configClass)) {
this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
}
else {
//先將當前的配置類壓入棧
this.importStack.push(configClass);
try {
//這里，就會對import標簽導入的類進行處理
for (SourceClass candidate : importCandidates) {
//AutoConfigurationImportSelector.class類就會走下面的分支
if (candidate.isAssignable(ImportSelector.class)) {
// Candidate class is an ImportSelector -> delegate to it to determine imports
Class<?> candidateClass = candidate.loadClass();
//首先在這里創建一個AutoConfigurationImportSelector類的對象，
ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
this.environment, this.resourceLoader, this.registry);
Predicate<String> selectorFilter = selector.getExclusionFilter();
if (selectorFilter != null) {
exclusionFilter = exclusionFilter.or(selectorFilter);
}
if (selector instanceof DeferredImportSelector) {
//在這里，將當前的配置類和AutoConfigurationImportSelector的對象封裝成DeferredImportSelectorHolder對象
//添加到延遲導入的集合deferredImportSelectors中
this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
}
else {
String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);
}
}
//AutoConfigurationPackages.Registrar.class這個類就會走到這個分支中
//在這個分支中，首先創建AutoConfigurationPackages.Registrar的對象
//添加到當前配置類的importBeanDefinitionRegistrars屬性中去
else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
// Candidate class is an ImportBeanDefinitionRegistrar ->
// delegate to it to register additional bean definitions
Class<?> candidateClass = candidate.loadClass();
ImportBeanDefinitionRegistrar registrar =
ParserStrategyUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class,
this.environment, this.resourceLoader, this.registry);
configClass.addImportBeanDefinitionRegistrar(registrar, currentSourceClass.getMetadata());
}
else {
// Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
// process it as an @Configuration class
this.importStack.registerImport(
currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
}
}
}
catch (BeanDefinitionStoreException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to process import candidates for configuration class [" +
configClass.getMetadata().getClassName() + "]", ex);
}
finally {
this.importStack.pop();
}
}
}上面的import導入類處理完了，下面我們繼續回到doProcessConfigurationClass中去看剩余的部分
@Nullable
protected final SourceClass doProcessConfigurationClass(
ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
throws IOException {
......//這部分前面已經分析過了，我們就繼續看后面的吧
// 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注解的方法，添加到配置類的beanMethods屬性中
Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
// Process default methods on interfaces
//這里處理配置類實現的接口上默認方法上有Bean注解的話,也添加到beanMethods屬性中
processInterfaces(configClass, sourceClass);
// Process superclass, if any
//這里去獲取配置類的父類，如果存在父類且父類類名不是java開頭且還沒有被處理過，就會返回父類，繼續進行父類的處理。
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;
}到這里processConfigurationClass方法就整個分析完了。
下面就會走到parse方法的最后一句了。我們進去看看
public void parse(Set<BeanDefinitionHolder> configCandidates) {
......
//就會走到下面這行代碼
this.deferredImportSelectorHandler.process();
}這里主要是對延遲導入的類進行處理
public void process() {
//在上面代碼中我們分析到this.deferredImportSelectors中只有一個
//由前面的配置類和AutoConfigurationImportSelector類的對象封裝的DeferredImportSelectorHolder對象
List<DeferredImportSelectorHolder> deferredImports = this.deferredImportSelectors;
this.deferredImportSelectors = null;
try {
if (deferredImports != null) {
DeferredImportSelectorGroupingHandler handler = new DeferredImportSelectorGroupingHandler();
deferredImports.sort(DEFERRED_IMPORT_COMPARATOR);
//這里會對延遲導入的類進行分組，添加到handler中，由于我們這里只有一個對象，所以這塊的分組，我們可以不用太關注
//同時會將前面的配置類添加到handler對象的configurationClasses屬性中
deferredImports.forEach(handler::register);
//下面就會交給handler去進行處理
handler.processGroupImports();
}
}
finally {
this.deferredImportSelectors = new ArrayList<>();
}
}
}下面我們看看processGroupImports是如何處理的
public void processGroupImports() {
//這里就按分組去處理了
for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
Predicate<String> exclusionFilter = grouping.getCandidateFilter();
//這里的grouping.getImports()就回去獲取系統的配置類,我們下面去看這個getImports
grouping.getImports().forEach(entry -> {
......
}
}這里的grouping.getCandidateFilter()來自兩部分：
另一部分是來自ConfigurationClassParser定義的lambda表達式
這個是在ConfigurationClassParser類的一個靜態內部類DeferredImportSelectorGrouping中的方法
public Iterable<Group.Entry> getImports() {
//這里的deferredImports中只有一個對象，還是之前的DeferredImportSelectorHolder
for (DeferredImportSelectorHolder deferredImport : this.deferredImports) {
//這里的this.group就是之前分組的deferredImport.getImportSelector().getImportGroup();方法的返回值創建的對象
//具體就是AutoConfigurationImportSelector.AutoConfigurationGroup的對象
//下面我們先看看這個process方法
this.group.process(deferredImport.getConfigurationClass().getMetadata(),
deferredImport.getImportSelector());
}
return this.group.selectImports();
}process是在AutoConfigurationImportSelector.AutoConfigurationGroup這個類中
public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
Assert.state(deferredImportSelector instanceof AutoConfigurationImportSelector,
() -> String.format("Only %s implementations are supported, got %s",
AutoConfigurationImportSelector.class.getSimpleName(),
deferredImportSelector.getClass().getName()));
//下面這行代碼也比較重要，我們進去看看
AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)
.getAutoConfigurationEntry(annotationMetadata);
this.autoConfigurationEntries.add(autoConfigurationEntry);
for (String importClassName : autoConfigurationEntry.getConfigurations()) {
this.entries.putIfAbsent(importClassName, annotationMetadata);
}
} protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
//這里,我們就能看到設置spring.boot.enableautoconfiguration屬性去禁止導入系統配置的bean的定義
if (!isEnabled(annotationMetadata)) {
return EMPTY_ENTRY;
}
AnnotationAttributes attributes = getAttributes(annotationMetadata);
//在下面這行中，就能看到通過ClassLoader去加載META-INF/spring.factories文件，讀取內容。放置到cache中
//在當前這里,會去獲取key=org.springframework.boot.autoconfigure.EnableAutoConfiguration的所有屬性配置
List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
configurations = removeDuplicates(configurations);
Set<String> exclusions = getExclusions(annotationMetadata, attributes);
checkExcludedClasses(configurations, exclusions);
configurations.removeAll(exclusions);
//在這里獲取配置過濾類并創建對象，對上面的configuras進行過濾
//這里的配置過濾類也是從cache中獲取,key=org.springframework.boot.autoconfigure.AutoConfigurationImportFilter
configurations = getConfigurationClassFilter().filter(configurations);
//這行代碼不關鍵，我們可以不用去關注
fireAutoConfigurationImportEvents(configurations, exclusions);
//這里返回一個AutoConfigurationEntry對象
//其中configurations是過濾器能夠匹配到的配置類,exclusions在我們這里是空的
return new AutoConfigurationEntry(configurations, exclusions);
}上面代碼中getConfigurationClassFilter()獲取到的是:
是來自spring.factories文件中的org.springframework.boot.autoconfigure.AutoConfigurationImportFilter
org.springframework.boot.autoconfigure.condition.OnClassCondition
這個類主要檢查是否存在指定的類
org.springframework.boot.autoconfigure.condition.OnWebApplicationCondition
這個類主要檢查是否存在WebApplicationContext.
org.springframework.boot.autoconfigure.condition.OnBeanCondition
這個類主要檢查是否存在指定的bean
在這個過程中，在生成filter過程中,首先會通過類加載器去讀取META-INF/spring-autoconfigure-metadata.properties這些文件。
在這里，主要是通過類名.ConditionalOnBean、類名.ConditionalOnSingleCandidate、類名.ConditionalOnClass、類名.ConditionalOnWebApplication來過濾掉不符合的配置類。
具體的算法入口都在這3個類的父類FilteringSpringBootCondition的match方法，具體的實現入口分別在這3個類的getOutcomes方法中。
由于這3個類都是實現了Condition接口，因此前面分析的 processConfigurationClass方法開始的地方通過 Conditional注解過濾配置類也會用到這3個類。
從上面也可以看出springboot的按需加載主要也是通過實現Condition接口來完成的。
再回到process這個方法。
public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {
......//上面的代碼剛才已經分析過了
//在這里將上面返回的AutoConfigurationEntry對象添加到autoConfigurationEntries中
this.autoConfigurationEntries.add(autoConfigurationEntry);
for (String importClassName : autoConfigurationEntry.getConfigurations()) {
//分別將添加的配置類添加到entries這個屬性中
//importClassName是新查找到的配置類,annotationMetadata都是同一個就是我們的主類
this.entries.putIfAbsent(importClassName, annotationMetadata);
}
}在接下來的selectImports方法中，首先會對這些新添加的配置類進行排序，然后組裝成new Entry(this.entries.get(importClassName), importClassName))對象的集合。
這里需要注意的是this.entries.get(importClassName)這就是我們的主類，importClassName是我們需要添加的配置類。
這里主要是為了對當前導入的配置類和它是被誰導入的進行一個關聯(在這里，所有要導入的配置類都是由我們的主類來導入的)。
就是在后面創建ConfigurationClass對象時會使用public ConfigurationClass(MetadataReader metadataReader, @Nullable ConfigurationClass importedBy)這個構造方法。
最后在添加這些配置類到beanFactory中時通過
下面再回到processGroupImports方法
public void processGroupImports() {
for (DeferredImportSelectorGrouping grouping : this.groupings.values()) {
Predicate<String> exclusionFilter = grouping.getCandidateFilter();
//上面已經分析到grouping.getImports()返回的是Entry對象的集合
grouping.getImports().forEach(entry -> {
//entry.getMetadata()返回的還是我們之前的主類。
//這里的configurationClass也是我們之前的主類。
//這個主要是為了在processImports方法中創建的配置類為它們設置importedBy屬性
ConfigurationClass configurationClass = this.configurationClasses.get(entry.getMetadata());
try {
//這里又會調用到processImports這個方法。這個在前面已經分析過了，但是這里有一點不一樣，下面我們看看不一樣的地方
processImports(configurationClass, asSourceClass(configurationClass, exclusionFilter),
Collections.singleton(asSourceClass(entry.getImportClassName(), exclusionFilter)),
exclusionFilter, false);
}
catch (BeanDefinitionStoreException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to process import candidates for configuration class [" +
configurationClass.getMetadata().getClassName() + "]", ex);
}
});
}
}關于這個processImports方法的參數前面有描述，這里就不再說了
下面的這個方法中這時importCandidates和之前的有點不一樣，之前的是通過import注解導入的分別會走for循環的前面兩個分支，現在大概率會走到后面的else分支
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
Collection<SourceClass> importCandidates, Predicate<String> exclusionFilter,
boolean checkForCircularImports) {
this.importStack.push(configClass);
try {
for (SourceClass candidate : importCandidates) {
if (candidate.isAssignable(ImportSelector.class)) {
......
}
else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {
......
}
else {
// Candidate class not an ImportSelector or ImportBeanDefinitionRegistrar ->
// process it as an @Configuration class
//上次進入這個方法，分別走了上面的兩個分支，現在大概率會走到這個分支
//這里會將導入的類添加到imports屬性中,key是新導入的配置類,value是我們之前的主類
this.importStack.registerImport(
currentSourceClass.getMetadata(), candidate.getMetadata().getClassName());
//這里又會去處理新添加的配置類，在這里是有可能出現遞歸的，下面我們具體分析下這里的處理邏輯
processConfigurationClass(candidate.asConfigClass(configClass), exclusionFilter);
}
}
}
......
}
}在上面的processImports方法中，會處理新添加的配置類，會調用到processConfigurationClass這個方法。
到上面為止，ConfigurationClassPostProcessor的processConfigBeanDefinitions方法從parse處理的部分就全部分析完了 。
這部分主要是處理了通過主類上面的注解，將所有的配置類都添加到ConfigurationClassParser類的成員變量configurationClasses中。對于配置類上的ImportResource、Bean等等則添加配置類的對應的屬性上。
這里需要注意的是在整個整個過程中只有ComponentScans掃描到的配置類會添加到beanFactory中。
下面我們繼續看看后面的代碼。
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
......
do {
StartupStep processConfig = this.applicationStartup.start("spring.context.config-classes.parse");
parser.parse(candidates);//前面已經分析到了這里
parser.validate();
//這里就會得到所有的配置類
Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
//alreadyParsed第一次是空的，由于這個方法是do-while循環，在后面會對這個變量賦值
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());
}
//在這里就會對前面獲取的所有的配置類添加到beanFactory中
this.reader.loadBeanDefinitions(configClasses);
alreadyParsed.addAll(configClasses);
processConfig.tag("classCount", () -> String.valueOf(configClasses.size())).end();
candidates.clear();
//這里就是對比前后beanFactory中的beanDefinition數量是否有增加,如果有增加說明我們在本次do-while代碼中添加了beanFactory
//下面的邏輯主要是為了判斷當前掃描出來的配置類是否全部添加進了beanFactory中,如果有配置類還沒有被今天進去，就會循環，重新執行上面的邏輯
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);
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();
}
}上面的其他代碼都比較簡單，我們下面主要對上面的this.reader.loadBeanDefinitions(configClasses);做個簡單分析吧。
ConfigurationClassBeanDefinitionReader的方法
public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
//這個類還是用來對Conditional注解進行處理，來判斷當前配置類是否要被過濾掉
TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
for (ConfigurationClass configClass : configurationModel) {
//在這里會對每個配置類及它的屬性進行處理，封裝成beanDefinition添加到beanFactory中去
loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
}
} private void loadBeanDefinitionsForConfigurationClass(
ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
//這里就會對Conditional注解進行判斷，如果當前類是被導入的，就會去判斷導入它的類
if (trackedConditionEvaluator.shouldSkip(configClass)) {
String beanName = configClass.getBeanName();
if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
this.registry.removeBeanDefinition(beanName);
}
this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
return;
}
//如果類是被導入的，就會去對它進行處理
if (configClass.isImported()) {
registerBeanDefinitionForImportedConfigurationClass(configClass);
}
//下面就是對配置類的各種屬性進行處理
//處理方法上的bean注解
for (BeanMethod beanMethod : configClass.getBeanMethods()) {
loadBeanDefinitionsForBeanMethod(beanMethod);
}
//處理導入的資源
loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
//處理導入的ImportBeanDefinitionRegistrar
loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}在上面的代碼也可以看到，單純的配置類，如果configClass.isImported()返回false，就不會被添加到beanFactory中。也就是如果配置類不是被導入的，就不會將配置類添加到beanFactory中。
前面說過ComponentScans掃描到的類在處理過程中就被添加到了beanFactory中，其他的配置類都是在上面的方法中被添加進去的。
所有添加的類大致可以分為兩部分：
通過類上的注解，直接被添加到配置類中。這部分配置類它們的被導入類就是當前的主類。另一部分是通過主類上的@Import(AutoConfigurationImportSelector.class)注解，讀取META-INF/spring.factories文件，經過META-INF/spring-autoconfigure-metadata.properties文件過濾后被處理的類。
上面兩部分處理的時候都會進行遞歸，一層一層處理。而且所有的處理過程中也都會根據 Conditional注解進行過濾。
同時也需要注意雖然添加到beanFactory中的都是beanD,但是具體都是不一樣的。比如：
ScannedGenericBeanDefinition是通過ComponentScans注解添加的
ConfigurationClassBeanDefinition是處理方法上的bean注解添加的
AnnotatedGenericBeanDefinition是其他普通的配置類
感謝你能夠認真閱讀完這篇文章，希望小編分享的“springboot如何自動掃描添加BeanDefinition源碼”這篇文章對大家有幫助，同時也希望大家多多支持億速云，關注億速云行業資訊頻道，更多相關知識等著你來學習!
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
