Zhuoli's Blog上篇文章我们介绍了通过xml配置文件来解析Bean配置的过程，本篇文章我们来看另一种解析Bean配置的方式，@Configuration配置类。在Spring应用中，为了使用@Configuration配置类，如果使用xml启动ApplicationContext，我们一般会在xml配置文件中加上如下一行配置：
<context:component-scan base-package="com.zhuoli.service.spring.explore.config"/>以告诉Spring容器Config配置类的位置，Spring在启动时会自动解析base-package包中该包下的@Configuration配置类。在解析的过程中，如果配置类中存在@Bean声明的方法，该方法会被解析成BeanDefinition并注册到BeanFactory。这样就算跟xml配置文件Bean解析的过程拉平了，BeanDefinition解析之后的流程就是统一的了。
1. @Configuration使用示例
package com.zhuoli.service.spring.explore.config;
public class TestBeanA {
private String testName;
public void setTestName(String testName) {
this.testName = testName;
}
public String getTestName() {
return testName;
}
}package com.zhuoli.service.spring.explore.config;
public class TestBeanB {
private String testName;
public void setTestName(String testName) {
this.testName = testName;
}
public String getTestName() {
return testName;
}
}package com.zhuoli.service.spring.explore.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class MyConfiguration {
@Bean
public TestBeanA configTestBeanA(){
TestBeanA testBeanA = new TestBeanA();
testBeanA.setTestName("configTestBeanA");
return testBeanA;
}
@Bean
public TestBeanB configTestBeanB() {
TestBeanB testBeanB = new TestBeanB();
testBeanB.setTestName("configTestBeanB");
return testBeanB;
}
}<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.1.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<context:component-scan base-package="com.zhuoli.service.spring.explore.config"/>
<bean id="testBeanA" class="com.zhuoli.service.spring.explore.config.TestBeanA">
<property name="testName" value="xmlTestBeanA"/>
</bean>
<bean id="testBeanB" class="com.zhuoli.service.spring.explore.config.TestBeanB">
<property name="testName" value="xmlTestBeanB"/>
</bean>
</beans>这里分别通过配置类和xml配置文件配置了TestBeanA、TestBeanB的bean，下面通过xml启动Spring：
public class SpringConfigTest {
public static void main(String[] args) {
AbstractApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:spring-config.xml");
TestBeanA xmlTestBeanA = (TestBeanA) applicationContext.getBean("testBeanA");
TestBeanA configTestBeanA = (TestBeanA) applicationContext.getBean("configTestBeanA");
TestBeanB xmlTestBeanB = (TestBeanB) applicationContext.getBean("testBeanB");
TestBeanB configTestBeanB = (TestBeanB) applicationContext.getBean("configTestBeanB");
System.out.println(xmlTestBeanA.getTestName());
System.out.println(configTestBeanA.getTestName());
System.out.println(xmlTestBeanB.getTestName());
System.out.println(configTestBeanB.getTestName());
applicationContext.close();
}
}运行结果：
xmlTestBeanA
configTestBeanA
xmlTestBeanB
configTestBeanB可以得出结论，@Configuration配置类和xml配置文件同时生效了。这里我们也可以做个试验，把xml配置文件的<component-scan>去除，看一下@Configuration配置类中配置的configTestBeanA和configTestBeanB是否还能拿到，结论是否定的，至于原因，我们再后面的源码解读部分再揭晓。
2. @Configuration源码解读
跟@Configuration配置类解析相关的类有三个ConfigurationClassPostProcessor、ConfigurationClassParser和ConfigurationClassBeanDefinitionReader。
- ConfigurationClassPostProcessor：该类是BeanDefinitionRegistryPostProcessor/BeanFactoryPostProcessor，按照之前文章的介绍，该类的postProcessBeanDefinitionRegistry方法会在Bean实例化之前调用invokeBeanFactoryPostProcessors方法中调用
- ConfigurationClassParser：该类用于解析@Configuration注解的配置类，生成一组ConfigurationClass对象
- ConfigurationClassBeanDefinitionReader：该类用于解析ConfigurationClassParser生成的ConfigurationClass对象，加载并注册BeanDefinition
2.1 ConfigurationClassPostProcessor
该类是BeanDefinitionRegistryPostProcessor/BeanFactoryPostProcessor，我们之前介绍过，在Spring Context加载一个核心方法
org.springframework.context.support.AbstractApplicationContext#refresh中调用了一个方法invokeBeanFactoryPostProcessors用于执行BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法，和BeanFactoryPostProcessor的postProcessBeanFactory方法。而@Configuration配置类中声明的Bean就是在postProcessBeanDefinitionRegistry方法中完成解析和注册的。
2.1.1 postProcessBeanDefinitionRegistry
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);
processConfigBeanDefinitions(registry);
}核心代码是最后的调用的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 (String beanName : candidateNames) {
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
if (logger.isDebugEnabled()) {
logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
}
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
// 1. 将所有的@Configuration配置类添加到List configCandidates中
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
// Return immediately if no @Configuration classes were found
if (configCandidates.isEmpty()) {
return;
}
// Sort by previously determined @Order value, if applicable
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(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
// 2. 解析每一个@Configuration配置类，生成ConfigurationClass对象
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 {
parser.parse(candidates);
parser.validate();
// parser.getConfigurationClasses()获取所有通过@Configuration配置类解析得到的ConfigurationClass对象
Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
configClasses.removeAll(alreadyParsed);
// Read the model and create bean definitions based on its content
// 3. 初始化ConfigurationClassBeanDefinitionReader，用于从ConfigurationClass对象中解析并注册Bean
if (this.reader == null) {
this.reader = new ConfigurationClassBeanDefinitionReader(
registry, this.sourceExtractor, this.resourceLoader, this.environment,
this.importBeanNameGenerator, parser.getImportRegistry());
}
// 4. loadBeanDefinitions解析并注册BeanDefinition
this.reader.loadBeanDefinitions(configClasses);
alreadyParsed.addAll(configClasses);
// 5. 清空已解析的@Configuration BeanDefinitionHolder
candidates.clear();
// 6. 经过一轮do循环,现在容器中Bean定义数量超过了该次循环开始时的容器内Bean定义数量，
// 说明在该次循环中发现并注册了更多的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);
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();
}
}上述代码的核心就是2、3、4，后面在介绍ConfigurationClassParser和ConfigurationClassBeanDefinitionReader时再分别介绍。总的来说，通过该方法，完成了将@Configuration配置类中声明的Bean解析并注册到注册中心，这一步跟xml文件的解析和注册是一致的。
2.1.2 postProcessBeanFactory
/**
* Prepare the Configuration classes for servicing bean requests at runtime
* by replacing them with CGLIB-enhanced subclasses.
*/
@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
int factoryId = System.identityHashCode(beanFactory);
if (this.factoriesPostProcessed.contains(factoryId)) {
throw new IllegalStateException(
"postProcessBeanFactory already called on this post-processor against " + beanFactory);
}
this.factoriesPostProcessed.add(factoryId);
if (!this.registriesPostProcessed.contains(factoryId)) {
// BeanDefinitionRegistryPostProcessor hook apparently not supported...
// Simply call processConfigurationClasses lazily at this point then.
processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
}
// 1. 对容器中的配置类做增强
enhanceConfigurationClasses(beanFactory);
// 2. 向容器中增加一个ImportAwareBeanPostProcessor(如果所增加组件已经存在会先将其删除然后重新添加)
beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
}2.1.3 ConfigurationClassPostProcessor何时引入的
最开始的示例中，我们并没有在xml配置文件中显式声明一个ConfigurationClassPostProcessor的Bean，但是在该BeanFactoryPostProcessor却生效了，也就是说肯定有地方替我们声明了该Bean，这也是阅读代码过程中困扰了我很久的地方。这里在仅介绍通过xml配置文件的方式启动Spring，该BeanFactoryPostProcessor是如何引入的。通过配置类启动Spring的方式该BeanFactoryPostProcessor的引入区别比较大，我们在后面介绍通过配置类启动Spring时再介绍。
通过观察发现，我们在xml配置文件中添加了这么一行配置：
<context:component-scan base-package="com.zhuoli.service.spring.explore.config"/>来告诉Spring容器，需要扫描的配置类的位置，就是在解析<context:component-scan/> xml配置时，完成了ConfigurationClassPostProcessor的注册。除了<context:component-scan/>，<context:annotation-config/>解析的过程也可以完成ConfigurationClassPostProcessor的注册。执行链路如下：
2.2 ConfigurationClassParser
在上述postProcessBeanDefinitionRegistry方法中，声明了ConfigurationClassParser对象，并调用了该类的parse方法。ConfigurationClassParser用于解析@Configuration配置类，并解析配置类的注解，比如@PropertySource、 @ComponentScan、@Import、@ImportResource，以及配置类中使用@Bean注解的方法。
这里需要注意的是，对@ComponentScan的解析跟其他内容解析有所不同，ConfigurationClassParser中会通过ComponentScanAnnotationParser扫描指定包下的Bean定义，并将其注册到BeanFactory。对于配置类而言，ConfigurationClassParser仅仅是将其解析为ConfigurationClass对象，交给调用方ConfigurationClassPostProcessor使用（后续会通过ConfigurationClassBeanDefinitionReader从ConfigurationClass中加载BeanDefinition）。
它的解析过程会通过一组种子配置类(base-package指定的)，从这些种子配置类开始分析所有关联的配置类，分析过程主要是递归分析配置类的注解@Import，配置类内部嵌套类，找出其中所有的配置类，然后返回这组配置类对应的ConfigurationClass对象。
2.2.1 org.springframework.context.annotation.ConfigurationClassParser#parse(java.util.Set)
/**
* configCandidates : 外部指定需要被分析的一组候选配置类BeanDefinitionHolder
* 这些配置类BeanDefinitionHolder是在ComponentScanBeanDefinitionParser中得到的
**/
public void parse(Set<BeanDefinitionHolder> configCandidates) {
for (BeanDefinitionHolder holder : configCandidates) {
BeanDefinition bd = holder.getBeanDefinition();
try {
// 根据BeanDefinition类型走不同的分支
// 最终都会调用processConfigurationClass方法，解析注解类
if (bd instanceof AnnotatedBeanDefinition) {
parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
}
else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
}
else {
parse(bd.getBeanClassName(), holder.getBeanName());
}
}
catch (BeanDefinitionStoreException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
}
}
this.deferredImportSelectorHandler.process();
}2.2.2 org.springframework.context.annotation.ConfigurationClassParser#processConfigurationClass
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);
// 1. 如果配置类已经解析过
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);
}
}
// 2. 解析配置类
SourceClass sourceClass = asSourceClass(configClass, filter);
do {
// 从当前配置类configClass开始向上沿着类继承结构逐层执行doProcessConfigurationClass,
// 直到遇到的父类是由Java提供的类结束循环
sourceClass = doProcessConfigurationClass(configClass, sourceClass, filter);
}
while (sourceClass != null);
// 3. 将解析结果configClass放到Map configurationClasses
this.configurationClasses.put(configClass, configClass);
}2.2.3 doProcessConfigurationClass
/**
* @return annotation metadata of superclass, {@code null} if none found or previously processed
*/
protected AnnotationMetadata doProcessConfigurationClass(ConfigurationClass configClass, AnnotationMetadata metadata) throws IOException {
// recursively process any member (nested) classes first
// 1. 首先递归处理嵌套类
processMemberClasses(metadata);
// process any @PropertySource annotations
// 2. 处理配置类@PropertySource注解
AnnotationAttributes propertySource = MetadataUtils.attributesFor(metadata,
org.springframework.context.annotation.PropertySource.class);
if (propertySource != null) {
processPropertySource(propertySource);
}
// process any @ComponentScan annotations
// 3. 处理配置类@ComponentScan注解
AnnotationAttributes componentScan = MetadataUtils.attributesFor(metadata, ComponentScan.class);
if (componentScan != null) {
// the config class is annotated with @ComponentScan -> perform the scan immediately
// 通过ComponentScanAnnotationParser将@ComponentScan注解指定包下的Bean解析为BeanDefinition并注册到BeanFactory
Set<BeanDefinitionHolder> scannedBeanDefinitions =
this.componentScanParser.parse(componentScan, metadata.getClassName());
// check the set of scanned definitions for any further config classes and parse recursively if necessary
for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
// 检查ComponentScanAnnotationParser扫描得到的BeanDefinition是有有配置类，如果有配置类，调用parse方法对配置类进行解析
if (ConfigurationClassUtils.checkConfigurationClassCandidate(holder.getBeanDefinition(), this.metadataReaderFactory)) {
this.parse(holder.getBeanDefinition().getBeanClassName(), holder.getBeanName());
}
}
}
// process any @Import annotations
// 4. 处理配置类@Import注解
// collectImports()方法，它会搜集metadata所有的@Import注解的value值，并递归访问@Import
Set<Object> imports = new LinkedHashSet<Object>();
Set<Object> visited = new LinkedHashSet<Object>();
collectImports(metadata, imports, visited);
if (!imports.isEmpty()) {
processImport(configClass, metadata, imports, true);
}
// process any @ImportResource annotations
// 5. 处理配置类@ImportResource注解
if (metadata.isAnnotated(ImportResource.class.getName())) {
AnnotationAttributes importResource = MetadataUtils.attributesFor(metadata, ImportResource.class);
String[] resources = importResource.getStringArray("value");
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
// 6. 处理配置类中带有@Bean注解的方法
Set<MethodMetadata> beanMethods = metadata.getAnnotatedMethods(Bean.class.getName());
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
// process superclass, if any
// 7. 如果父类superclass存在，并且不是`java`包中的类，并且尚未处理处理，则才返回它以便外层循环继续
if (metadata.hasSuperClass()) {
String superclass = metadata.getSuperClassName();
if (!superclass.startsWith("java") && !this.knownSuperclasses.containsKey(superclass)) {
this.knownSuperclasses.put(superclass, configClass);
// superclass found, return its annotation metadata and recurse
if (metadata instanceof StandardAnnotationMetadata) {
Class<?> clazz = ((StandardAnnotationMetadata) metadata).getIntrospectedClass();
return new StandardAnnotationMetadata(clazz.getSuperclass(), true);
}
else {
MetadataReader reader = this.metadataReaderFactory.getMetadataReader(superclass);
return reader.getAnnotationMetadata();
}
}
}
// no superclass, processing is complete
// 8. 没找到需要处理的父类，返回null告诉外层循环结束
return null;
}通过调用ConfigurationClassParser类的parse方法，完成了配置类到ConfigurationClass对象的转换，并存储在ConfigurationClassParser类的成员变量configurationClasses中。ConfigurationClass类定义如下所示，调用方ConfigurationClassPostProcessor会实例化一个ConfigurationClassBeanDefinitionReader对象，解析并注册configurationClasses中每一个ConfigurationClass中定义的Bean（在ConfigurationClass中指beanMethods）。通过ConfigurationClassPostProcessor完成了@Configuration配置类的解析。
2.3 ConfigurationClassBeanDefinitionReader
上面讲到，通过ConfigurationClassPostProcessor#processConfigBeanDefinitions方法中调用ConfigurationClassParser#parse(java.util.Set)方法，我们得到了一个ConfigurationClass的List。然后在processConfigBeanDefinitions方法中，会通过ConfigurationClassBeanDefinitionReader对ConfigurationClass进行解析。如下：
2.3.1 loadBeanDefinitions
public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
// 遍历配置类，解析并注册bean
for (ConfigurationClass configClass : configurationModel) {
loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
}
}2.3.2 loadBeanDefinitionsForConfigurationClass
/**
* 从指定的一个配置类ConfigurationClass中提取bean定义信息并注册bean定义到bean容器 :
* 1. 配置类本身要注册为bean定义
* 2. 配置类中的@Bean注解方法要注册为配置类
*/
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机制被导入进来的配置类，将它本身作为一个bean定义注册到容器
if (configClass.isImported()) {
registerBeanDefinitionForImportedConfigurationClass(configClass);
}
// 配置类里面@Bean注解的方法作为bean定义注册到容器
for (BeanMethod beanMethod : configClass.getBeanMethods()) {
loadBeanDefinitionsForBeanMethod(beanMethod);
}
// 从配置类导入的文件中获取bean定义信息并注册到容器
// 从xml或者groovy bean定义文件解析并注册bean
loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
// 从导入的ImportBeanDefinitionRegistrar中获取bean定义信息并注册到容器
loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}2.3.3 loadBeanDefinitionsForBeanMethod
/**
* 解析配置类中@Bean注解的配置类方法作为bean定义，并注册到bean容器
*/
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;
}
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")));
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;
}
ConfigurationClassBeanDefinition beanDef = new ConfigurationClassBeanDefinition(configClass, metadata);
beanDef.setResource(configClass.getResource());
beanDef.setSource(this.sourceExtractor.extractSource(metadata, configClass.getResource()));
if (metadata.isStatic()) {
// static @Bean method
beanDef.setBeanClassName(configClass.getMetadata().getClassName());
beanDef.setFactoryMethodName(methodName);
}
else {
// instance @Bean method
beanDef.setFactoryBeanName(configClass.getBeanName());
beanDef.setUniqueFactoryMethodName(methodName);
}
beanDef.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
beanDef.setAttribute(RequiredAnnotationBeanPostProcessor.SKIP_REQUIRED_CHECK_ATTRIBUTE, Boolean.TRUE);
AnnotationConfigUtils.processCommonDefinitionAnnotations(beanDef, metadata);
Autowire autowire = bean.getEnum("autowire");
if (autowire.isAutowire()) {
beanDef.setAutowireMode(autowire.value());
}
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);
}
if (logger.isDebugEnabled()) {
logger.debug(String.format("Registering bean definition for @Bean method %s.%s()",
configClass.getMetadata().getClassName(), beanName));
}
this.registry.registerBeanDefinition(beanName, beanDefToRegister);
}2.3.4 loadBeanDefinitionsFromImportedResources
/**
* 从xml或者groovy bean定义文件解析并注册bean
*/
private void loadBeanDefinitionsFromImportedResources(
Map<String, Class<? extends BeanDefinitionReader>> importedResources) {
Map<Class<?>, BeanDefinitionReader> readerInstanceCache = new HashMap<>();
importedResources.forEach((resource, readerClass) -> {
// Default reader selection necessary?
if (BeanDefinitionReader.class == readerClass) {
if (StringUtils.endsWithIgnoreCase(resource, ".groovy")) {
// 如果是groovy bean定义文件采用GroovyBeanDefinitionReader读取类解析
readerClass = GroovyBeanDefinitionReader.class;
}
else {
// 如果是xml bean定义文件采用XmlBeanDefinitionReader读取类解析
readerClass = XmlBeanDefinitionReader.class;
}
}
BeanDefinitionReader reader = readerInstanceCache.get(readerClass);
if (reader == null) {
try {
// Instantiate the specified BeanDefinitionReader
reader = readerClass.getConstructor(BeanDefinitionRegistry.class).newInstance(this.registry);
// Delegate the current ResourceLoader to it if possible
if (reader instanceof AbstractBeanDefinitionReader) {
AbstractBeanDefinitionReader abdr = ((AbstractBeanDefinitionReader) reader);
abdr.setResourceLoader(this.resourceLoader);
abdr.setEnvironment(this.environment);
}
readerInstanceCache.put(readerClass, reader);
}
catch (Throwable ex) {
throw new IllegalStateException(
"Could not instantiate BeanDefinitionReader class [" + readerClass.getName() + "]");
}
}
// TODO SPR-6310: qualify relative path locations as done in AbstractContextLoader.modifyLocations
// 从导入的xml或者groovy文件中读取bean定义并注册到bean容器
reader.loadBeanDefinitions(resource);
});
}2.3.5 loadBeanDefinitionsFromRegistrars
/**
* 对配置类中所有通过@Import导入的ImportBeanDefinitionRegistrar类，遍历调用registerBeanDefinitions方法注册bean
*/
private void loadBeanDefinitionsFromRegistrars(Map<ImportBeanDefinitionRegistrar, AnnotationMetadata> registrars) {
registrars.forEach((registrar, metadata) ->
registrar.registerBeanDefinitions(metadata, this.registry));
}以上就是通过xml启动的Spring容器，如何完成对@Configuration注解的配置类中定义的Bean的解析和注册过程。接下来的文章，我们会来介绍一下，通过配置类启动的spring容器，如何完成Bean的解析和注册的。
参考链接：
1. Spring BeanDefinitionRegistryPostProcessor : ConfigurationClassPostProcessor
2. Spring 工具类 ConfigurationClassParser 分析得到配置类
3. Spring 工具 ConfigurationClassBeanDefinitionReader 注册配置类中的bean定义