spring源码：@Bean注解解析
目的
在前面的自动扫描bean原理这篇文章中，主要说的是spring是如何将@ComponentScan注解声明的包下，加了@Component注解的业务类扫描到spring容器中的；在这篇文章中，没有说明一个知识点，在这里说明一下：
spring将业务类转换为BeanDefinition的方式有三种
- @ComponentScan注解+@Component注解
- @Bean
- @Import注解，引入ImportBeanDefinitionRegistrar和ImportSelector的实现类
这是我目前通过源码学习，总结出来的，当然，也有可能不全，后面学习到了 再来这里补充
本文，就是要说明第二种对业务bean进行转换beanDefinition的源码解析，我不确定自己能不能把这个知识点讲解清楚，试一下吧
源码
这个gif是我们今天要说的源码，前面的调用逻辑，这里其实就是要调用到
org.springframework.context.annotation.ConfigurationClassPostProcessor#postProcessBeanDefinitionRegistry
这个方法的逻辑；该方法是什么时候执行到的，为什么要执行这个方法，我在上篇博客中有写到；这里我们只关心@Bean的处理逻辑：
我们来看上个gif最后调用的方法
org.springframework.context.annotation.ConfigurationClassParser#parse(java.util.Set<org.springframework.beans.factory.config.BeanDefinitionHolder>)
public void parse(Set<BeanDefinitionHolder> configCandidates) {
this.deferredImportSelectors = new LinkedList<>();
for (BeanDefinitionHolder holder : configCandidates) {
BeanDefinition bd = holder.getBeanDefinition();
try {
/**
* 根据beanDefinition的不同来做不同的处理
* 如果bean是配置类(加了@Configuration注解的配置类)，那这里就会走下面的第一个分支的判断条件
* 因为在将配置类放到beanDefinitionMap中的时候，是将配置类声明为了AnnotatedGenericBeanDefinition类型的
*/
if (bd instanceof AnnotatedBeanDefinition) {
/**
* 如果将bean存入到beanDefinitionMap第四步
*
* 在这里注入的只是普通的bean，普通的bean 就是指加了@Component注解的bean
* 何为不普通的bean？ @Bean 各种beanFactoryPostProcessor获取到的bean不在这里注入 但是是在这里解析 只是不是在这里put到BeanDefinitionMap中的
*/
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());
}
}
}
processDeferredImportSelectors();
}
这里会根据beanDefinition的不同类型，来进行不同的处理；由于这里的configCandidates是配置类，所以是AnnotatedBeanDefinition，因为在前面调用AnnotationConfigApplicationContext构造方法的时候，会把配置类注入到BeanDefinitionMap中，创建的是AnnotatedGenericBeanDefinition类型的
在parse()方法中，会执行以下的调用链，中间的一些细节，我们暂时不做解析，我们来看doProcessConfigurationClass()方法
org.springframework.context.annotation.ConfigurationClassParser#parse(org.springframework.core.type.AnnotationMetadata, java.lang.String)
org.springframework.context.annotation.ConfigurationClassParser#processConfigurationClass
org.springframework.context.annotation.ConfigurationClassParser#doProcessConfigurationClass
@Nullable
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
throws IOException {
// Process any @ComponentScan annotations
/**
* 序号1：
* 判断类中是否加了@ComponentScan注解
* 从matedata 里面拿出@ComponentScan注解的属性信息，在后面的方法中，从这个属性里面获取到value,也就是要扫描的包进行注入
*/
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
/**
* 如果将bean存入到beanDefinitionMap第6步
*
* 扫描所有的普通类
* 当这个方法执行完之后，将配置类上@ComponentScan要注入的bean已经注入到map中了
* 但是如果配置类有@Import的话，是在下面processImports()完成的
*
* 这里是获取到当前配置类下的所有的要扫描的包路径信息
*/
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
//检查扫描出来的类中师傅还有configuration
for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
if (bdCand == null) {
bdCand = holder.getBeanDefinition();
}
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}
// Process any @Import annotations
/**
* 序号2：
* 处理 import注解
*
* 这里处理import是要判断我们的类当中是否有@Import注解，如果有，把import注解的值拿出来(就是import的那个类)
* getImports(sourceClass)方法会获取到当前配置类上import注解注入的所有class
*
* 比如：@Import(XXXX.class),那么这里把XXXX.class拿去解析
* 在解析的过程中，会进行递归调用；
* 也就是说会再次调用这个方法，判断XXXX.class返回的数组中对应的类是否添加了@Import
*
* import注入的selector类中返回的数组表示要注入的bean，这些bean
* 是存放到了configurationClasses这个map中
*
* 那么configurationClasses中的bean是在什么时候初始化呢？
* 是在org.springframework.context.annotation.ConfigurationClassBeanDefinitionReader#loadBeanDefinitions(java.util.Set)中
*
*
*/
processImports(configClass, sourceClass, getImports(sourceClass), true);
/**
* 这是对importResource注解进行处理
*/
// Process any @ImportResource annotations
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
/**
* 序号3：
* 处理配置类中的 @Bean注解的方法 在这里扫描出来 存放到beanMethods这个set中，在后面处理bean注解的时候，直接从这个set中遍历
*/
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;
}
方法中的代码我进行了删减之后粘贴；其中：
- 序号1这部分代码是来处理@ComponentScan注解的；
- 序号2这部分是处理配置类中@Import注解的
- 序号3：就是我们这篇文章要关注的：@Bean的处理
beanMethod的解析
如果想要将@Bean修饰的方法中要注入的bean，解析为beanDefinition；首先要解析到配置类中有哪些@Bean修饰的方法；
org.springframework.context.annotation.ConfigurationClassParser#retrieveBeanMethodMetadata
private Set<MethodMetadata> retrieveBeanMethodMetadata(SourceClass sourceClass) {
AnnotationMetadata original = sourceClass.getMetadata();
//1.获取到配置类中所有@Bean对应的方法
Set<MethodMetadata> beanMethods = original.getAnnotatedMethods(Bean.class.getName());
if (beanMethods.size() > 1 && original instanceof StandardAnnotationMetadata) {
// Try reading the class file via ASM for deterministic declaration order...
// Unfortunately, the JVM's standard reflection returns methods in arbitrary
// order, even between different runs of the same application on the same JVM.
try {
//2.根据配置类的className获取到类中所有加了注解的方法；这里不太明白为什么要用metadataReaderFactory再获取一遍注解方法
AnnotationMetadata asm =
this.metadataReaderFactory.getMetadataReader(original.getClassName()).getAnnotationMetadata();
Set<MethodMetadata> asmMethods = asm.getAnnotatedMethods(Bean.class.getName());
if (asmMethods.size() >= beanMethods.size()) {
Set<MethodMetadata> selectedMethods = new LinkedHashSet<>(asmMethods.size());
for (MethodMetadata asmMethod : asmMethods) {
for (MethodMetadata beanMethod : beanMethods) {
//根据1和2两处获取到的beanName进行对比，如果一致，就添加到待处理的set集合中
if (beanMethod.getMethodName().equals(asmMethod.getMethodName())) {
selectedMethods.add(beanMethod);
break;
}
}
}
if (selectedMethods.size() == beanMethods.size()) {
// All reflection-detected methods found in ASM method set -> proceed
beanMethods = selectedMethods;
}
}
}
catch (IOException ex) {
logger.debug("Failed to read class file via ASM for determining @Bean method order", ex);
// No worries, let's continue with the reflection metadata we started with...
}
}
return beanMethods;
}
这个方法完成的操作，总结而言：
1.获取到配置类中所有加了@Bean注解的方法
2.通过MetadataReaderFactory获取到配置类中所有的注解方法，进而获取到所有加了@Bean注解的方法
3.将1和2两步获取到的方法进行对比，如果方法名一致，就是要处理的
在序号3这里，获取到所有的beanMethod之后，就会遍历所有的beanMethod，然后依次new一个BeanMethod对象，并存入到org.springframework.context.annotation.ConfigurationClass#beanMethods的这个set集合中，以便在后面进行统一的处理
beanMethod的处理
上面是对beanMethod的解析，下面我们来说，对解析之后的beanMethod的处理
org.springframework.context.annotation.ConfigurationClassPostProcessor#processConfigBeanDefinitions
我们要回到该方法中的this.reader.loadBeanDefinitions(configClasses);这行代码的调用
这里是对ImportBeanDefinitionRegistrar/ImportSelector/@Bean/@ImportResource的统一处理
public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();
for (ConfigurationClass configClass : configurationModel) {
loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
}
}
/**
* Read a particular {@link ConfigurationClass}, registering bean definitions
* for the class itself and all of its {@link Bean} methods.
*/
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;
}
//这里是对importSelector注入的bean进行初始化
if (configClass.isImported()) {
registerBeanDefinitionForImportedConfigurationClass(configClass);
}
//@Bean 注解需要注入的bean对象
for (BeanMethod beanMethod : configClass.getBeanMethods()) {
loadBeanDefinitionsForBeanMethod(beanMethod);
}
//对importResource注解 注入的配置文件进行处理
loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());
//这里是对ImportBeanDefinitionRegistrar注入的bean进行初始化
loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}
由于我们本篇文章来解析@Bean注解，所以我们只需要关注：
loadBeanDefinitionsForBeanMethod(beanMethod);这个方法
/**
* 对配置类中的@Bean修饰的方法中要注入的bean进行转换
* 将bean转换为beanDefinition
* Read the given {@link BeanMethod}, registering bean definitions
* with the BeanDefinitionRegistry based on its contents.
*/
private void loadBeanDefinitionsForBeanMethod(BeanMethod beanMethod) {
ConfigurationClass configClass = beanMethod.getConfigurationClass();
MethodMetadata metadata = beanMethod.getMetadata();
// 获取@Bean对应方法的 方法名
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;
}
// 这里应该是判断当前方法是否有@Bean注解
AnnotationAttributes bean = AnnotationConfigUtils.attributesFor(metadata, Bean.class);
Assert.state(bean != null, "No @Bean annotation attributes");
// Consider name and any aliases
// 获取@Bean注解中配置的name属性；如果配置了多个名称，就用第一个；如果未配置name属性，就用@Bean修饰的方法名
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()));
//如果@Bean的方法是static，那么会给bean添加一个factoryMethod
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);
}
// 这里可以看到，对于@Bean注入的bean，默认的注入模型是AUTOWIRE_CONSTRUCTOR
beanDef.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
beanDef.setAttribute(RequiredAnnotationBeanPostProcessor.SKIP_REQUIRED_CHECK_ATTRIBUTE, Boolean.TRUE);
AnnotationConfigUtils.processCommonDefinitionAnnotations(beanDef, metadata);
// 如果在@Bean注解中指定了注入模型，就用指定的；如果未指定，就使用默认的AUTOWIRE_CONSTRUCTOR
Autowire autowire = bean.getEnum("autowire");
if (autowire.isAutowire()) {
beanDef.setAutowireMode(autowire.value());
}
// 设置bean的初始化方法
String initMethodName = bean.getString("initMethod");
if (StringUtils.hasText(initMethodName)) {
beanDef.setInitMethodName(initMethodName);
}
// 设置bean的销毁方法
String destroyMethodName = bean.getString("destroyMethod");
beanDef.setDestroyMethodName(destroyMethodName);
// Consider scoping
ScopedProxyMode proxyMode = ScopedProxyMode.NO;
AnnotationAttributes attributes = AnnotationConfigUtils.attributesFor(metadata, Scope.class);
if (attributes != null) {
// 设置bean的scope
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));
}
// 将@Bean对于的bean存入到beanDefinitionMap中
this.registry.registerBeanDefinition(beanName, beanDefToRegister);
}
这也是为什么我们在使用@Bean的时候，如果不指定beanName，默认使用方法名作为beanName的原因
对于@Bean注入的bean，注入模型，默认为AUTOWIRE_CONSTRUCTOR
指定bean的初始化和销毁方法，分别通过initMethod和destroyMethod
都在方法注释中进行了说明
最后，会调用org.springframework.beans.factory.support.DefaultListableBeanFactory#registerBeanDefinition方法，将当前bean存入到BeanDefinitionMap中
总结而言：
- spring在扫描到配置类(加了@Configuration注解的类)，会获取到所有的注解方法，获取到其中加了@Bean注解的方法，并将对应的方法存到集合中
- 在完成@ComponentScan注解的解析之后，遍历第一步中的集合，一次获取到beanMethod
- 对每个beanMethod，声明一个ConfigurationClassBeanDefinition类型的beanDefinition对象，然后根据@Bean的配置，设置beanDefinition的属性信息
- 最后将beanName和beanDefinition对象存入到beanDefinitionMap中
以上，就是对spring源码中，@Bean注解的解析和学习