今天，我們來分析下代碼，即：
//刷新
refresh();
這個方法做了很多事情，讓我們點開這個方法：
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
//刷新預處理，和主流程關係不大，就是保存了容器的啟動時間，啟動標誌等
prepareRefresh();
//DefaultListableBeanFactory
// Tell the subclass to refresh the internal bean factory.
//和主流程關係也不大，最終獲得了DefaultListableBeanFactory，
// DefaultListableBeanFactory實現了ConfigurableListableBeanFactory
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
//還是一些準備工作，添加了兩個後置處理器：ApplicationContextAwareProcessor，ApplicationListenerDetector
//還設置了 忽略自動裝配 和 允許自動裝配 的接口,如果不存在某個bean的時候，spring就自動註冊singleton bean
//還設置了bean表達式解析器 等
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
//這是一個空方法
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
//執行自定義的BeanFactoryProcessor和內置的BeanFactoryProcessor
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
// 註冊BeanPostProcessor
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
// 空方法
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// 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();
}
}
}
裡面有很多小方法，我們今天的目標是分析前五個小方法：
prepareRefresh
從命名來看，就知道這個方法主要做了一些刷新前的準備工作，和主流程關係不大，主要是保存了容器的啟動時間，啟動標誌等。
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory()
這個方法和主流程關係也不是很大，可以簡單的認為，就是把beanFactory取出來而已。
prepareBeanFactory
//還是一些準備工作，添加了兩個後置處理器：ApplicationContextAwareProcessor，ApplicationListenerDetector
//還設置了 忽略自動裝配 和 允許自動裝配 的接口,如果不存在某個bean的時候，spring就自動註冊singleton bean
//還設置了bean表達式解析器 等
prepareBeanFactory(beanFactory);
這代碼相比前面兩個就比較重要了，我們需要點進去好好看看，做了什麼操作:
protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// Tell the internal bean factory to use the context's class loader etc.
beanFactory.setBeanClassLoader(getClassLoader());//設置類加載器
//設置bean表達式解析器
beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
// Configure the bean factory with context callbacks.
//添加一個後置處理器：ApplicationContextAwareProcessor，此後置處理處理器實現了BeanPostProcessor接口
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
//以下接口，忽略自動裝配
beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
// BeanFactory interface not registered as resolvable type in a plain factory.
// MessageSource registered (and found for autowiring) as a bean.
//以下接口，允許自動裝配,第一個參數是自動裝配的類型，，第二個字段是自動裝配的值
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);
// Register early post-processor for detecting inner beans as ApplicationListeners.
//添加一個後置處理器：ApplicationListenerDetector，此後置處理器實現了BeanPostProcessor接口
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));
// Detect a LoadTimeWeaver and prepare for weaving, if found.
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
// Set a temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
//如果沒有註冊過bean名稱為XXX，spring就自己創建一個名稱為XXX的singleton bean
//Register default environment beans.
if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
}
if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
}
if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
}
}
首先判斷beanFactory是不是BeanDefinitionRegistry的實例，當然肯定是的，然後執行如下操作：
- 定義了一個Set，裝載BeanName，後面會根據這個Set，來判斷後置處理器是否被執行過了。
- 定義了兩個List，一個是regularPostProcessors，用來裝載BeanFactoryPostProcessor，一個是registryProcessors用來裝載BeanDefinitionRegistryPostProcessor，其中BeanDefinitionRegistryPostProcessor擴展了BeanFactoryPostProcessor。BeanDefinitionRegistryPostProcessor有兩個方法，一個是獨有的postProcessBeanDefinitionRegistry方法，一個是父類的postProcessBeanFactory方法。
- 循環傳進來的beanFactoryPostProcessors，上面已經解釋過了，一般情況下，這裡永遠都是空的，只有手動add beanFactoryPostProcessor，這裡才會有數據。我們假設beanFactoryPostProcessors有數據，進入循環，判斷postProcessor是不是BeanDefinitionRegistryPostProcessor，因為BeanDefinitionRegistryPostProcessor擴展了BeanFactoryPostProcessor，所以這裡先要判斷是不是BeanDefinitionRegistryPostProcessor，是的話，執行postProcessBeanDefinitionRegistry方法，然後把對象裝到registryProcessors裡面去，不是的話，就裝到regularPostProcessors。
- 定義了一個臨時變量：currentRegistryProcessors，用來裝載BeanDefinitionRegistryPostProcessor。
- getBeanNamesForType，顧名思義，是根據類型查到BeanNames，這裡有一點需要注意，就是去哪裡找，點開這個方法的話，就知道是循環beanDefinitionNames去找，這個方法以後也會經常看到。這裡傳了BeanDefinitionRegistryPostProcessor.class，就是找到類型為BeanDefinitionRegistryPostProcessor的後置處理器，並且賦值給postProcessorNames。一般情況下，只會找到一個，就是org.springframework.context.annotation.internalConfigurationAnnotationProcessor，也就是ConfigurationAnnotationProcessor。這個後置處理器在上一節中已經說明過了，十分重要。這裡有一個問題，為什麼我自己寫了個類，實現了BeanDefinitionRegistryPostProcessor接口，也打上了@Component註解，但是這裡沒有獲得，因為直到這一步，Spring還沒有完成掃描，掃描是在ConfigurationClassPostProcessor類中完成的，也就是下面第一個invokeBeanDefinitionRegistryPostProcessors方法。
- 循環postProcessorNames，其實也就是org.springframework.context.annotation.internalConfigurationAnnotationProcessor，判斷此後置處理器是否實現了PriorityOrdered接口（ConfigurationAnnotationProcessor也實現了PriorityOrdered接口）， 如果實現了，把它添加到currentRegistryProcessors這個臨時變量中，再放入processedBeans，代表這個後置處理已經被處理過了。當然現在還沒有處理，但是馬上就要處理了。。。
- 進行排序，PriorityOrdered是一個排序接口，如果實現了它，就說明此後置處理器是有順序的，所以需要排序。當然目前這裡只有一個後置處理器，就是ConfigurationClassPostProcessor。
- 把currentRegistryProcessors合併到registryProcessors，為什麼需要合併？因為一開始spring只會執行BeanDefinitionRegistryPostProcessor獨有的方法，而不會執行BeanDefinitionRegistryPostProcessor父類的方法，即BeanFactoryProcessor接口中的方法，所以需要把這些後置處理器放入一個集合中，後續統一執行BeanFactoryProcessor接口中的方法。當然目前這裡只有一個後置處理器，就是ConfigurationClassPostProcessor。
- 可以理解為執行currentRegistryProcessors中的ConfigurationClassPostProcessor中的postProcessBeanDefinitionRegistry方法，這就是Spring設計思想的體現了，在這裡體現的就是其中的熱插拔，插件化開發的思想。Spring中很多東西都是交給插件去處理的，這個後置處理器就相當於一個插件，如果不想用了，直接不添加就是了。這個方法特別重要，我們後面會詳細說來。
- 清空currentRegistryProcessors，因為currentRegistryProcessors是一個臨時變量，已經完成了目前的使命，所以需要清空，當然後面還會用到。
- 再次根據BeanDefinitionRegistryPostProcessor獲得BeanName，然後進行循環，看這個後置處理器是否被執行過了，如果沒有被執行過，也實現了Ordered接口的話，把此後置處理器推送到currentRegistryProcessors和processedBeans中。 這裡就可以獲得我們定義的，並且打上@Component註解的後置處理器了，因為Spring已經完成了掃描，但是這裡需要注意的是，由於ConfigurationClassPostProcessor在上面已經被執行過了，所以雖然可以通過getBeanNamesForType獲得，但是並不會加入到currentRegistryProcessors和processedBeans。
- 處理排序。
- 合併Processors，合併的理由和上面是一樣的。
- 執行我們自定義的BeanDefinitionRegistryPostProcessor。
- 清空臨時變量。
- 在上面的方法中，僅僅是執行了實現了Ordered接口的BeanDefinitionRegistryPostProcessor，這裡是執行沒有實現Ordered接口的BeanDefinitionRegistryPostProcessor。
- 上面的代碼是執行子類獨有的方法，這裡需要再把父類的方法也執行一次。
- 執行regularPostProcessors中的後置處理器的方法，需要注意的是，在一般情況下，regularPostProcessors是不會有數據的，只有在外面手動添加BeanFactoryPostProcessor，才會有數據。
- 查找實現了BeanFactoryPostProcessor的後置處理器，並且執行後置處理器中的方法。和上面的邏輯差不多，不再詳細說明。
- 獲得所有的BeanName，放入candidateNames數組。
- 循環candidateNames數組，根據beanName獲得BeanDefinition，判斷此BeanDefinition是否已經被處理過了。
- 判斷是否是配置類，如果是的話。加入到configCandidates數組，在判斷的時候，還會標記配置類屬於Full配置類，還是Lite配置類，這裡會引發一連串的知識盲點： 3.1 當我們註冊配置類的時候，可以不加@Configuration註解，直接使用@Component @ComponentScan @Import @ImportResource等註解，Spring把這種配置類稱之為Lite配置類， 如果加了@Configuration註解，就稱之為Full配置類。 3.2 如果我們註冊了Lite配置類，我們getBean這個配置類，會發現它就是原本的那個配置類，如果我們註冊了Full配置類，我們getBean這個配置類，會發現它已經不是原本那個配置類了，而是已經被cgilb代理的類了。 3.3 寫一個A類，其中有一個構造方法，打印出“你好”，再寫一個配置類，裡面有兩個被@bean註解的方法，其中一個方法new了A類，並且返回A的對象，把此方法稱之為getA，第二個方法又調用了getA方法，如果配置類是Lite配置類，會發現打印了兩次“你好”，也就是說A類被new了兩次，如果配置類是Full配置類，會發現只打印了一次“你好”，也就是說A類只被new了一次，因為這個類被cgilb代理了，方法已經被改寫。 3.4 具體的可以看我的這篇博客：juejin.im/post/5c637d… 裡面有詳細的說明。
- 如果沒有配置類直接返回。
- 處理排序。
- 解析配置類，可能是Full配置類，也有可能是Lite配置類，這個小方法是此方法的核心，稍後具體說明。
- 在第6步的時候，只是註冊了部分Bean，像 @Import @Bean等，是沒有被註冊的，這裡統一對這些進行註冊。
因為可以有多個配置類，所以需要循環處理。我們的配置類的BeanDefinition是AnnotatedBeanDefinition的實例，所以會進入第一個if：
protected final void parse(AnnotationMetadata metadata, String beanName) throws IOException {
processConfigurationClass(new ConfigurationClass(metadata, beanName));
}
protected void processConfigurationClass(ConfigurationClass configClass) 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);
do {
sourceClass = doProcessConfigurationClass(configClass, sourceClass);
}
while (sourceClass != null);
this.configurationClasses.put(configClass, configClass);
}
重點在於doProcessConfigurationClass方法，需要特別注意，最後一行代碼，會把configClass放入一個Map，會在上面第7步中用到。
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
throws IOException {
//遞歸處理內部類，一般不會寫內部類
// Recursively process any member (nested) classes first
processMemberClasses(configClass, sourceClass);
// Process any @PropertySource annotations
//處理@PropertySource註解，@PropertySource註解用來加載properties文件
for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), PropertySources.class,
org.springframework.context.annotation.PropertySource.class)) {
if (this.environment instanceof ConfigurableEnvironment) {
processPropertySource(propertySource);
} else {
logger.warn("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
"]. Reason: Environment must implement ConfigurableEnvironment");
}
}
// Process any @ComponentScan annotations
//獲得ComponentScan註解具體的內容，ComponentScan註解除了最常用的basePackage之外，還有includeFilters，excludeFilters等
Set<annotationattributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
//如果沒有打上ComponentScan，或者被@Condition條件跳過，就不再進入這個if
if (!componentScans.isEmpty() &&
!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
//循環處理componentScans
for (AnnotationAttributes componentScan : componentScans) {
// The config class is annotated with @ComponentScan -> perform the scan immediately
//componentScan就是@ComponentScan上的具體內容，sourceClass.getMetadata().getClassName()就是配置類的名稱
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)) {
//遞歸調用，因為可能組件類有被@Bean標記的方法，或者組件類本身也有ComponentScan等註解
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}
// Process any @Import annotations
//處理@Import註解
//@Import註解是spring中很重要的一個註解，Springboot大量應用這個註解
//@Import三種類，一種是Import普通類，一種是Import ImportSelector，還有一種是Import ImportBeanDefinitionRegistrar
//getImports(sourceClass)是獲得import的內容，返回的是一個set
processImports(configClass, sourceClass, getImports(sourceClass), 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);
}
}
//處理@Bean的方法，可以看到獲得了帶有@Bean的方法後，不是馬上轉換成BeanDefinition，而是先用一個set接收
// Process individual @Bean methods
Set<methodmetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
// Process default methods on interfaces
processInterfaces(configClass, sourceClass);
// Process superclass, if any
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;
}
/<methodmetadata>/<beandefinitionholder>/<annotationattributes>
- 遞歸處理內部類，一般不會使用內部類。
- 處理@PropertySource註解，@PropertySource註解用來加載properties文件。
- 獲得ComponentScan註解具體的內容，ComponentScan註解除了最常用的basePackage之外，還有includeFilters，excludeFilters等。
- 判斷有沒有被@ComponentScans標記，或者被@Condition條件帶過，如果滿足條件的話，進入if，進行如下操作： 4.1 執行掃描操作，把掃描出來的放入set，這個方法稍後再詳細說明。 4.2 循環set，判斷是否是配置類，是的話，遞歸調用parse方法，因為被掃描出來的類，還是一個配置類，有@ComponentScans註解，或者其中有被@Bean標記的方法 等等，所以需要再次被解析。
- 處理@Import註解，@Import是Spring中很重要的一個註解，正是由於它的存在，讓Spring非常靈活，不管是Spring內部，還是與Spring整合的第三方技術，都大量的運用了@Import註解，@Import有三種情況，一種是Import普通類，一種是Import ImportSelector，還有一種是Import ImportBeanDefinitionRegistrar，getImports(sourceClass)是獲得import的內容，返回的是一個set，這個方法稍後再詳細說明。
- 處理@ImportResource註解。
- 處理@Bean的方法，可以看到獲得了帶有@Bean的方法後，不是馬上轉換成BeanDefinition，而是先用一個set接收。
我們來看看到底是怎麼執行掃描的：
protected Set<beandefinitionholder> doScan(String... basePackages) {
Assert.notEmpty(basePackages, "At least one base package must be specified");
Set<beandefinitionholder> beanDefinitions = new LinkedHashSet<>();
//循環處理basePackages
for (String basePackage : basePackages) {
//根據包名找到符合條件的BeanDefinition集合
Set<beandefinition> candidates = findCandidateComponents(basePackage);
for (BeanDefinition candidate : candidates) {
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
candidate.setScope(scopeMetadata.getScopeName());
String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
//由findCandidateComponents內部可知，這裡的candidate是ScannedGenericBeanDefinition
//而ScannedGenericBeanDefinition是AbstractBeanDefinition和AnnotatedBeanDefinition的之類
//所以下面的兩個if都會進入
if (candidate instanceof AbstractBeanDefinition) {
//內部會設置默認值
postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
}
if (candidate instanceof AnnotatedBeanDefinition) {
//如果是AnnotatedBeanDefinition，還會再設置一次值
AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
}
if (checkCandidate(beanName, candidate)) {
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
definitionHolder =
AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
beanDefinitions.add(definitionHolder);
registerBeanDefinition(definitionHolder, this.registry);
}
}
}
return beanDefinitions;
}
/<beandefinition>/<beandefinitionholder>/<beandefinitionholder>因為basePackages可能有多個，所以需要循環處理，最終會進行Bean的註冊。下面再來看看findCandidateComponents方法：
public Set<beandefinition> findCandidateComponents(String basePackage) {
//spring支持component索引技術，需要引入一個組件，因為大部分情況不會引入這個組件
//所以不會進入到這個if
if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
}
else {
return scanCandidateComponents(basePackage);
}
}
/<beandefinition>Spring支持component索引技術，需要引入一個組件，大部分項目沒有引入這個組件，所以會進入scanCandidateComponents方法：
private Set<beandefinition> scanCandidateComponents(String basePackage) {
Set<beandefinition> candidates = new LinkedHashSet<>();
try {
//把 傳進來的類似 命名空間形式的字符串轉換成類似類文件地址的形式，然後在前面加上classpath*:
//即：com.xx=>classpath*:com/xx/**/*.class
String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
resolveBasePackage(basePackage) + '/' + this.resourcePattern;
//根據packageSearchPath，獲得符合要求的文件
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 元數據讀取器，解析resource，也可以理解為描述資源的數據結構
MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
//在isCandidateComponent方法內部會真正執行匹配規則
//註冊配置類自身會被排除，不會進入到這個if
if (isCandidateComponent(metadataReader)) {
ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
sbd.setResource(resource);
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;
}
/<beandefinition>/<beandefinition>- 把傳進來的類似命名空間形式的字符串轉換成類似類文件地址的形式，然後在前面加上classpath*，即：com.xx=>classpath*:com/xx/**/*.class。
- 根據packageSearchPath，獲得符合要求的文件。
- 循環符合要求的文件，進一步進行判斷。 最終會把符合要求的文件，轉換為BeanDefinition，並且返回。
直到這裡，上面說的4.1中提到的方法終於分析完畢了，讓我們再看看上面提到的第5步中的處理@Import註解方法：
//這個方法內部相當相當複雜，importCandidates是Import的內容，調用這個方法的時候，已經說過可能有三種情況
//這裡再說下，1.Import普通類，2.Import ImportSelector，3.Import ImportBeanDefinitionRegistrar
//循環importCandidates，判斷屬於哪種情況
//如果是普通類，會進到else，調用processConfigurationClass方法
//這個方法是不是很熟悉，沒錯，processImports這個方法就是在processConfigurationClass方法中被調用的
//processImports又主動調用processConfigurationClass方法，是一個遞歸調用，因為Import的普通類，也有可能被加了Import註解，@ComponentScan註解 或者其他註解，所以普通類需要再次被解析
//如果Import ImportSelector就跑到了第一個if中去，首先執行Aware接口方法，所以我們在實現ImportSelector的同時，還可以實現Aware接口
//然後判斷是不是DeferredImportSelector，DeferredImportSelector擴展了ImportSelector
//如果不是的話，調用selectImports方法，獲得全限定類名數組，在轉換成類的數組，然後再調用processImports，又特麼的是一個遞歸調用...
//可能又有三種情況，一種情況是selectImports的類是一個普通類，第二種情況是selectImports的類是一個ImportBeanDefinitionRegistrar類，第三種情況是還是一個ImportSelector類...
//所以又需要遞歸調用
//如果Import ImportBeanDefinitionRegistrar就跑到了第二個if，還是會執行Aware接口方法，這裡終於沒有遞歸了，會把數據放到ConfigurationClass中的Map<importbeandefinitionregistrar> importBeanDefinitionRegistrars中去
private void processImports(ConfigurationClass configClass, SourceClass currentSourceClass,
Collection<sourceclass> importCandidates, boolean checkForCircularImports) {
if (importCandidates.isEmpty()) {
return;
}
if (checkForCircularImports && isChainedImportOnStack(configClass)) {
this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
} else {
this.importStack.push(configClass);
try {
for (SourceClass candidate : importCandidates) {
if (candidate.isAssignable(ImportSelector.class)) {
// Candidate class is an ImportSelector -> delegate to it to determine imports
Class> candidateClass = candidate.loadClass();
ImportSelector selector = BeanUtils.instantiateClass(candidateClass, ImportSelector.class);
ParserStrategyUtils.invokeAwareMethods(
selector, this.environment, this.resourceLoader, this.registry);
if (this.deferredImportSelectors != null && selector instanceof DeferredImportSelector) {
this.deferredImportSelectors.add(
new DeferredImportSelectorHolder(configClass, (DeferredImportSelector) selector));
} else {
String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());
Collection<sourceclass> importSourceClasses = asSourceClasses(importClassNames);
processImports(configClass, currentSourceClass, importSourceClasses, false);
}
} 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 =
BeanUtils.instantiateClass(candidateClass, ImportBeanDefinitionRegistrar.class);
ParserStrategyUtils.invokeAwareMethods(
registrar, 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));
}
}
} 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();
}
}
}
/<sourceclass>/<sourceclass>/<importbeandefinitionregistrar>
這個方法大概的作用已經在註釋中已經寫明瞭，就不再重複了。
直到這裡，才把ConfigurationClassPostProcessor中的processConfigBeanDefinitions方法簡單的過了一下。
但是這還沒有結束，processConfigBeanDefinitions是BeanDefinitionRegistryPostProcessor接口中的方法，BeanDefinitionRegistryPostProcessor擴展了BeanFactoryPostProcessor，還有postProcessBeanFactory方法沒有分析，這個方法是幹嘛的，簡單的來說，就是判斷配置類是Lite配置類，還是Full配置類，如果是配置類，就會被Cglib代理，目的就是保證Bean的作用域。關於這個方法實在是比較複雜我們來做一個總結，ConfigurationClassPostProcessor中的processConfigBeanDefinitions方法十分重要，主要是完成掃描，最終註冊我們定義的Bean。
關注我：私信回覆“555”獲取往期Java高級架構資料、源碼、筆記、視頻Dubbo、Redis、Netty、zookeeper、Spring cloud、分佈式、高併發等架構技術往期架構視頻截圖
分享到:
閱讀更多 來一杯82年的Java 的文章
