Spring源碼解析之ConfigurationClassPostProcessor（三）

在上一章筆者介紹了ConfigurationClassParser.doProcessConfigurationClass(...)方法，在這個方法里調用了processImports(...)方法處理配置類的@Import注解，getImports(sourceClass)能從一個配置類上獲取@Import注解配置的所有類形成一個集合，如果集合不為空則會在下面代碼的<1>處開始遍歷處理。

如果一個類是ImportSelector接口的實現類，會進入<2>處的分支，並在<3>處創建實現類的實例，在<4>處調用實例的selectImports(...)方法獲取配置類列表，之后在<5>處以遞歸的方式調用doProcessConfigurationClass(...)將獲取到的配置類傳入。

如果一個類是ImportBeanDefinitionRegistrar接口的實現類，則會進入<6>處的分支，這里依舊生成一個實現類的實例，只是這里不立馬回調該接口的方法，而是暫存在配置類中，待從ConfigurationClassParser.processImports(...)逐層返回到ConfigurationClassPostProcessor.processConfigBeanDefinitions(...)的do-while循環后會執行ImportBeanDefinitionRegistrar實例的回調方法。

如果一個類僅僅是平平無奇的配置類，即不是ImportSelector的實現類，也不是ImportBeanDefinitionRegistrar的實現類，則會進入<7>處的分支，這里會將配置類傳給processConfigurationClass(...)方法，這里我們也可以認為是遞歸調用，這個方法筆者之前講過，會將配置類上的@ComponentScans、@ComponentScan注解指定的類路徑解析出來，根據類路徑掃描BeanDefinition，再判斷掃描出來的類是否有資格成為配置類，如果可以的話會再進一步解析。

class ConfigurationClassParser {
	……
	protected final SourceClass doProcessConfigurationClass(
			ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
			throws IOException {
		……
		processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
		……
	}
	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 {
				for (SourceClass candidate : importCandidates) {//<1>
					if (candidate.isAssignable(ImportSelector.class)) {//<2>
						// Candidate class is an ImportSelector -> delegate to it to determine imports
						Class<?> candidateClass = candidate.loadClass();
						ImportSelector selector = ParserStrategyUtils.instantiateClass(candidateClass, ImportSelector.class,
								this.environment, this.resourceLoader, this.registry);//<3>
						Predicate<String> selectorFilter = selector.getExclusionFilter();
						if (selectorFilter != null) {
							exclusionFilter = exclusionFilter.or(selectorFilter);
						}
						if (selector instanceof DeferredImportSelector) {
							this.deferredImportSelectorHandler.handle(configClass, (DeferredImportSelector) selector);
						}
						else {
							String[] importClassNames = selector.selectImports(currentSourceClass.getMetadata());//<4>
							Collection<SourceClass> importSourceClasses = asSourceClasses(importClassNames, exclusionFilter);
							processImports(configClass, currentSourceClass, importSourceClasses, exclusionFilter, false);//<5>
						}
					}
					else if (candidate.isAssignable(ImportBeanDefinitionRegistrar.class)) {//<6>
						// 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 {//<7>
						// 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();
			}
		}
	}
	……
}

　　

那么我們來總結一下ConfigurationClassParser.processImports(...)完成的工作，這個方法主要用於處理配置類上的@Import注解，@Import注解允許我們引入多個配置類，在這個方法會遍歷處理這些配置類，如果配置類是ImportSelector的實現類，執行實現類的回調方法能立馬拿到待引入的配置類列表，我們可以遞歸調用processImports(...)方法將拿到的配置類列表傳入，在這個方法會處理來自上層傳入的配置類。如果配置類是ImportBeanDefinitionRegistrar接口的實現類，這里僅僅是實例化這個類的實例並暫存到配置類，並不立即調用實現類的回調方法，因為spring不能肯定開發者會往傳入的registrar對象注冊多少個配置類，甚至有的開發者一個都不會注冊。如果一個類不是ImportSelector或ImportBeanDefinitionRegistrar接口的實現類，會調用processConfigurationClass(...)方法將配置類傳入，我們可以認為這里是遞歸調用，因為processConfigurationClass(...)方法最終會執行到processImports(...)方法。processConfigurationClass(...)方法會解析配置類指定的類路徑，並將可以成為BeanDefinition的類注冊進spring容器，在嘗試將掃描出來的類作為配置類進行解析。

在了解ConfigurationClassParser.parse(...)方法完成的工作后，我們來整體過一下ConfigurationClassPostProcessor.processConfigBeanDefinitions(...)方法，這個方法在最開始的時候會獲取spring容器所有的beanName，遍歷這些beanName拿到開發者傳給容器的配置類，因為開發者可能傳入多個配置類，所以這里會行程一個配置類列表，如果列表為空則退出該方法，如果列表不為空，則對列表中的配置類進行排序。

在對配置類列表排序完畢后，會進入一個do-while循環解析配置類。解析配置類是一項非常復雜的工作，解析配置類的時候不但會掃描配置類指定的類路徑，還會嘗試將掃描出來的BeanDefinition當做一個配置類再次進行解析，如果掃描出來的BeanDefinition可以作為配置類會再次進行二次解析，這里又會重復之前所說的解析工作，在解析完畢后，才會處理@Import注解。

在了解完spring是如何解析配置類后，我們來再來整體過下ConfigurationClassPostProcessor.processConfigBeanDefinitions(...)的邏輯，在<1>處會先用candidateNames這個數組存放spring容器目前所有的beanName。

candidateNames有以下兩點作用：

1. spring會在<2>處先根據candidateNames中存放的beanName過濾出可以成為配置類的的BeanDefinition。
2. candidateNames可以用於判斷解析配置類時是否有新的BeanDefinition被注冊進spring容器，可以認為candidateNames是解析配置類前的快照，如果解析完配置類后發現spring容器的BeanDefinition數量大於快照中beanName的數量，表示在解析的時候有引入新的BeanDefinition。

在<2>處完成遍歷后會將配置類的BeanDefinition和beanName包裝成一個BeanDefinitionHolder對象存進configCandidates列表，之后再<3>處會根據configCandidates列表生成一個配置類集合candidates，<4>處同樣會根據配置類的長度生成一個集合alreadyParsed，這個集合會存放已經解析的配置類。

之后會進入一個do-while循環，在循環中會解析、校驗配置類。<5>處會獲取所有解析出來的配置類，這里筆者所說的不單單是我們平常用@Configuration注解標記的配置類，在解析方法里會把類路徑下描到的BeanDefinition嘗試作為配置類進行解析，所以<5>處的方法還會將類路徑下可以作為配置類的BeanDefinition返回。我們可以在配置類上用@Import注解引入一個ImportBeanDefinitionRegistrar實現類，也可以用@ImportResource注解引入一個XML配置文件，ImportBeanDefinitionRegistrar實現類和XML文件在解析的時候會暫存在配置類中，等到從解析方法回到do-while循環時就會在<7>處配置類中暫存的ImportBeanDefinitionRegistrar實例和XML文件，這里可能會向spring容器注冊新的BeanDefinition。

在執行完<7>處的代碼后，配置類才算完全被解析，在<8>會將已經被完全解析的配置類存放進alreadyParsed集合，同時我們往回看，每次執行do-while循環時，<5>處總會把目前獲取到的配置類返回，configClasses可能存在已經被完全解析的配置類，所以在<6>處會把已經完全解析的配置類移除，<7>處僅處理目前需要處理尚未回調ImportBeanDefinitionRegistrar接口的實例和XML文件。

在<8>處將完全處理完畢的配置類放到alreadyParsed集合后，會清空candidates集合，如果在<9>處判斷目前spring容器擁有的BeanDefinition數量大於解析配置類前beanName的數量，會進入分支<9>看看是否有需要再解析的配置類，如果有配置類添加到candidates集合則開啟新的一輪的循環。如果<9>處判斷解析完配置類后spring容器的BeanDefinition數量等於原先解析前beanName的數量，則candidates集合為空退出do-while循環。

那么在分支<9>中又是如何判斷是否應該往candidates集合添加新的配置類呢？在分支<9>內會先把spring容器目前所有的beanName存放到newCandidateNames這個數組中，oldCandidateNames用於存放解析前的beanName，alreadyParsedClasses用於存放解析后的所有配置類。之后會在<10>處遍歷spring容器目前所有的beanName，如果beanName在oldCandidateNames集合中，表示其BeanDefinition在本次循環或之前的循環已經被解析，這里不會進入<11>處的分支。如果beanName不在oldCandidateNames集合中，那么這個beanName對應的BeanDefinition有可能是在解析時注冊進spring容器，也可能是解析配置類完畢后在<7>處注冊進spring容器的，如果是在解析時引入，那么alreadyParsedClasses會包含這個配置類，這里不會進入<12>處的分支。如果是在<7>處處理暫存在配置類的ImportBeanDefinitionRegistrar實例和XML文件，那么alreadyParsedClasses不會包含BeanDefinition對應的類，這里只要ConfigurationClassUtils.checkConfigurationClassCandidate(...)判斷BeanDefinition對應的類是配置類就會把BeanDefinition和beanName包裝成BeanDefinitionHolder對象存進candidates。最后在<13>處將spring目前所有的beanName存進數組candidateNames，作為下一輪循環解析前的快照。如果下一輪循環在<9>處判斷spring容器中的BeanDefinition數量等於上一輪的快照數量，就會退出循環。另外進入了<9>處的分支並不意味着一定會有下個循環，do-while退出循環的條件是candidates為空，只要新引入的BeanDefinition都是解析出來的配置類，或者新引入的BeanDefinition都不是配置類，則不會進入分支<12>，則candidates為空，會退出do-while循環。

public class ConfigurationClassPostProcessor implements BeanDefinitionRegistryPostProcessor,
		PriorityOrdered, ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware {
	……
	public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
		List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
		String[] candidateNames = registry.getBeanDefinitionNames();//<1>

		for (String beanName : candidateNames) {//<2>
			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);
				}
			}
			else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
				configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
			}
		}
		……
		// 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);//<3>
		Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());//<4>
		do {
			parser.parse(candidates);
			parser.validate();

			Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());//<5>
			configClasses.removeAll(alreadyParsed);//<6>

			// 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());
			}
			this.reader.loadBeanDefinitions(configClasses);//<7>
			alreadyParsed.addAll(configClasses);//<8>

			candidates.clear();
			if (registry.getBeanDefinitionCount() > candidateNames.length) {//<9>
				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) {//<10>
					if (!oldCandidateNames.contains(candidateName)) {//<11>
						BeanDefinition bd = registry.getBeanDefinition(candidateName);
						if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
								!alreadyParsedClasses.contains(bd.getBeanClassName())) {//<12>
							candidates.add(new BeanDefinitionHolder(bd, candidateName));
						}
					}
				}
				candidateNames = newCandidateNames;//<13>
			}
		}
		while (!candidates.isEmpty());
		……
	}
	……
}

　　

至此，我們了解在執行ConfigurationClassPostProcessor.processConfigBeanDefinitions(...)的時候是如何完成掃描類路徑，筆者再介紹在上面的方法是如何完成配置類的校驗，如何執行配置類中暫存的ImportBeanDefinitionRegistrar實例引入新的BeanDefinition，就結束本章對ConfigurationClassPostProcessor的介紹。

首先我們來看配置類是如何完成校驗的，在執行ConfigurationClassParser.validate()方法的時候會遍歷已經獲取到的所有配置類ConfigurationClass.validate(...)方法，在配置類校驗的時候，會檢查如果配置類是full模式（有標記@Configuration注解且proxyBeanMethods為true），這個full模式的配置類是否有使用fina修飾符，如果是full模式的配置類，那么類中是否有同時使用了@Bean注解和fina修飾符的方法？之所以做這樣的校驗：是因為一個full模式的配置類是要使用cglib技術代理的，如果配置類本身使用了final修飾符是無法被繼承的，則不能通過校驗。如果full模式的配置類有用@Bean注解標記的方法，方法本身也使用了final修飾符，這個方法是不能被重寫的，就不允許通過校驗。

但如果大家將@Configuration、@Bean和final修飾符搭配使用，會發現java會出現編譯錯誤，既然連編譯這關都過不了，為何還要校驗呢？spring這里是防止編譯出來的字節碼被篡改，有人特意在編譯后的full模式配置類字節碼加上final修飾符，在在這個方法里再次對配置類進行校驗。

class ConfigurationClassParser {
	……
	public void validate() {
		for (ConfigurationClass configClass : this.configurationClasses.keySet()) {
			configClass.validate(this.problemReporter);
		}
	}
	……
}

final class ConfigurationClass {
	……
	public void validate(ProblemReporter problemReporter) {
		// A configuration class may not be final (CGLIB limitation) unless it declares proxyBeanMethods=false
		Map<String, Object> attributes = this.metadata.getAnnotationAttributes(Configuration.class.getName());
		if (attributes != null && (Boolean) attributes.get("proxyBeanMethods")) {
			if (this.metadata.isFinal()) {//校驗full模式的配置類是否使用final修飾符
				problemReporter.error(new FinalConfigurationProblem());
			}
			for (BeanMethod beanMethod : this.beanMethods) {//校驗full模式配置類的方法
				beanMethod.validate(problemReporter);
			}
		}
	}
	……
}

final class BeanMethod extends ConfigurationMethod {
	……
	public void validate(ProblemReporter problemReporter) {
		if (getMetadata().isStatic()) {
			// static @Bean methods have no constraints to validate -> return immediately
			return;
		}

		if (this.configurationClass.getMetadata().isAnnotated(Configuration.class.getName())) {
			if (!getMetadata().isOverridable()) {//校驗方法是否允許被重寫
				// instance @Bean methods within @Configuration classes must be overridable to accommodate CGLIB
				problemReporter.error(new NonOverridableMethodError());
			}
		}
	}
	……
}

　　

最后，我們來了解下ConfigurationClassBeanDefinitionReader.loadBeanDefinitions(...)是如何在解析完配置類后，又從配置類加載新的BeanDefinition到spring容器里。這個方法會調用loadBeanDefinitionsForConfigurationClass(...)方法遍歷傳入的配置類，在代碼<1>處會遍歷配置類中加了@Bean注解的方法，這里會調用loadBeanDefinitionsForBeanMethod(...)將@Bean方法包裝成一個BeanDefinition注冊進spring容器，因為我們知道spring會根據@Bean方法實例化一個bean對象，而BeanDefinition是生產bean對象的原料。

在根據@Bean方法生成BeanDefinition時，會先在<2>處獲取方法名，然后在<3>處獲取bean對象的別名，並在<4>處建立beanName和別名的映射。之后會在<5>處根據配置類、元數據和方法名創建一個ConfigurationClassBeanDefinition對象，創建bean對象的方法是否是靜態決定了控制流是進入<6>處還是<7>處的分支。如果是用靜態方法來創建bean對象，在<6>處就設置靜態方法對應的類以及方法名。如果是實例方法創建bean對象則進入<7>處的分支，在<7>處的分支會設置可以創建當前bean對象的工廠beanName，即配置類的beanName，再設置創建bean對象的方法名。

在<8>處會設置@Bean方法的BeanDefinition的默認自動裝配模型為AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR，但@Bean注解默認的自動裝配模型為Autowire.NO，在<9>處會獲取@Bean注解配置的自動裝配模型並存放到BeanDefinition。在<10>處會獲取@Bean注解設置的是否自動參與候選，默認為true。之后在<11>處獲取初始化方法，在<12>處獲取銷毀方法，如果這兩個字段有設置的話。最后在<13>處將beanName和BeanDefinition的映射注冊進spring容器中。這里我們又看到一個BeanDefinition的實現類型。

在<1>處的方法遍歷完所有的beanMethod將其BeanDefinition注冊進spring容器后，會分別在<14>和<15>處處理暫存在配置類的XML配置文件和ImportBeanDefinitionRegistrar實例。在<15>處loadBeanDefinitionsFromRegistrars(...)方法的實現我們也看到在這個方法內會遍歷配置類中所有的ImportBeanDefinitionRegistrar實例，回調其registerBeanDefinitions(...)方法，在這個方法中開發者可以向spring容器注冊新的BeanDefinition。

class ConfigurationClassBeanDefinitionReader {
	……
	public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
		TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
		for (ConfigurationClass configClass : configurationModel) {
			loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
		}
	}
	private void loadBeanDefinitionsForConfigurationClass(
			ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
		……
		for (BeanMethod beanMethod : configClass.getBeanMethods()) {//<1>
			loadBeanDefinitionsForBeanMethod(beanMethod);
		}

		loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());//<14>
		loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());//<15>
	}
	……
	private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
		ConfigurationClass configClass = beanMethod.getConfigurationClass();
		MethodMetadata metadata = beanMethod.getMetadata();
		String methodName = metadata.getMethodName();//<2>
		……
		AnnotationAttributes bean = AnnotationConfigUtils.attributesFor(metadata, Bean.class);
		Assert.state(bean != null, "No @Bean annotation attributes");

		// Consider name and any aliases
		List<String> names = new ArrayList<>(Arrays.asList(bean.getStringArray("name")));//<3>
		String beanName = (!names.isEmpty() ? names.remove(0) : methodName);

		// Register aliases even when overridden
		for (String alias : names) {//<4>
			this.registry.registerAlias(beanName, alias);
		}

		……
		ConfigurationClassBeanDefinition beanDef = new ConfigurationClassBeanDefinition(configClass, metadata, beanName);//<5>
		beanDef.setSource(this.sourceExtractor.extractSource(metadata, configClass.getResource()));

		if (metadata.isStatic()) {//<6>
			// static @Bean method
			if (configClass.getMetadata() instanceof StandardAnnotationMetadata) {
				beanDef.setBeanClass(((StandardAnnotationMetadata) configClass.getMetadata()).getIntrospectedClass());
			}
			else {
				beanDef.setBeanClassName(configClass.getMetadata().getClassName());
			}
			beanDef.setUniqueFactoryMethodName(methodName);
		}
		else {//<7>
			// instance @Bean method
			beanDef.setFactoryBeanName(configClass.getBeanName());
			beanDef.setUniqueFactoryMethodName(methodName);
		}

		if (metadata instanceof StandardMethodMetadata) {
			beanDef.setResolvedFactoryMethod(((StandardMethodMetadata) metadata).getIntrospectedMethod());
		}

		beanDef.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);//<8>
		beanDef.setAttribute(org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor.
				SKIP_REQUIRED_CHECK_ATTRIBUTE, Boolean.TRUE);

		AnnotationConfigUtils.processCommonDefinitionAnnotations(beanDef, metadata);

		Autowire autowire = bean.getEnum("autowire");//<9>
		if (autowire.isAutowire()) {
			beanDef.setAutowireMode(autowire.value());
		}

		boolean autowireCandidate = bean.getBoolean("autowireCandidate");//<10>
		if (!autowireCandidate) {
			beanDef.setAutowireCandidate(false);
		}

		String initMethodName = bean.getString("initMethod");//<11>
		if (StringUtils.hasText(initMethodName)) {
			beanDef.setInitMethodName(initMethodName);
		}

		String destroyMethodName = bean.getString("destroyMethod");//<12>
		beanDef.setDestroyMethodName(destroyMethodName);
		……
		BeanDefinition beanDefToRegister = beanDef;
		……
		this.registry.registerBeanDefinition(beanName, beanDefToRegister);//<13>
	}
	……
	private void loadBeanDefinitionsFromRegistrars(Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> registrars) {
		registrars.forEach((registrar, metadata) ->
				registrar.registerBeanDefinitions(metadata, this.registry, this.importBeanNameGenerator));
	}
	……
}