Spring IOC @Configuration注解分析

引入

在使用SpringBoot开发时，最常用的注解有@Component、@Service、@Controller、@Configuration等。当类使用这些注解标记时，类会被Spring IOC容器管理，包括创建，填充属性和实例化。
但是Spring容器如何发现并将这些类放到容器进行管理呢？
今天这篇博客主要分析Spring如何处理@Configuration注解。
@Configuration定义

1. @Target(ElementType.TYPE)
2. @Retention(RetentionPolicy.RUNTIME)
3. @Documented
4. @Component
5. public @interface Configuration {
6.         @AliasFor(annotation = Component.class)
7.         String value() default "";
8.        
9.         //Since: 5.2
10.         boolean proxyBeanMethods() default true;
12.         //Since: 6.0
13.         boolean enforceUniqueMethods() default true;
14. }

复制代码

看Configuration注解的定义，它本质也是一个@Component注解。
所以，标记有@Configuration注解的类在Spring注册bean的第一阶段就会被注册到容器中，但是使用@Configuration注解的类内部的其他bean并没有被注册到容器中。
想知道@Configuration注解被如何处理，需要看invokeBeanFactoryPostProcessors 方法。
ConfigurationClassPostProcessor处理@Configuration注解

先大致说一下invokeBeanFactoryPostProcessors 方法的基本流程，因为这个方法会处理所有BeanDefinitionRegistryPostProcessor和BeanFactoryPostProcessor接口的子类：

• 先处理方法入参：beanFactoryPostProcessors（如果只是分析AnnotationConfigApplicationContext，这个参数是空的。只有在分析SpringBoot的启动过程时，这个参数才会有值）
  
• 再处理BeanDefinitionRegistryPostProcessor的子类
  
  
  
  • 这里最重要的一件事情是调用ConfigurationClassPostProcessor的processConfigBeanDefinitions方法。
    
  
  
• 最后处理BeanFactoryPostProcessor的子类
  

invokeBeanFactoryPostProcessors 的部分代码：

1. public static void invokeBeanFactoryPostProcessors(
2.                 ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
3.        
4.         Set<String> processedBeans = new HashSet<>();
5.         if (beanFactory instanceof BeanDefinitionRegistry) {
6.                 //省略部分代码，处理入参：beanFactoryPostProcessors
8.         //开始处理BeanDefinitionRegistryPostProcessor接口的子类
9.         //保存所有符合的子类，即实现BeanDefinitionRegistryPostProcessor，同样实现PriorityOrdered
10.                 List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
11.                 String[] postProcessorNames =
12.                                 beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
13.                 for (String ppName : postProcessorNames) {
14.                         if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
15.                                 currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
16.                                 processedBeans.add(ppName);
17.                         }
18.                 }
19.                 sortPostProcessors(currentRegistryProcessors, beanFactory);
20.                 registryProcessors.addAll(currentRegistryProcessors);
21.         //调用currentRegistryProcessors中所有的BDRPP
22.                 invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup());
23.                 currentRegistryProcessors.clear();
25.                 //省略部分代码，同样处理BeanDefinitionRegistryPostProcessor接口的子类
26.         }
27.         else {
28.                 //省略部分代码
29.         }
30.         //省略部分代码 处理BeanFactoryPostProcessor接口的子类
31. }

复制代码

以上是invokeBeanFactoryPostProcessors的部分代码，接下来看ConfigurationClassPostProcessor的processConfigBeanDefinitions方法，在这个方法里开始正式地处理@Configruation注解：

1. public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
2.         List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
3.         String[] candidateNames = registry.getBeanDefinitionNames();
5.         //遍历所有的候选者
6.         for (String beanName : candidateNames) {
7.                 BeanDefinition beanDef = registry.getBeanDefinition(beanName);
8.                 if (beanDef.getAttribute(ConfigurationClassUtils.CONFIGURATION_CLASS_ATTRIBUTE) != null) {
9.                         if (logger.isDebugEnabled()) {
10.                                 logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
11.                         }
12.                 }
13.                 //校验候选者类上是否使用了@Configuration注解
14.                 else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
15.                         configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
16.                 }
17.         }
19.         //如果configCandidates为空，则立即返回
20.         if (configCandidates.isEmpty()) {
21.                 return;
22.         }
24.         configCandidates.sort((bd1, bd2) -> {
25.                 int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
26.                 int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
27.                 return Integer.compare(i1, i2);
28.         });
30.         SingletonBeanRegistry sbr = null;
31.         if (registry instanceof SingletonBeanRegistry) {
32.                 sbr = (SingletonBeanRegistry) registry;
33.                 if (!this.localBeanNameGeneratorSet) {
34.                         BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(
35.                                         AnnotationConfigUtils.CONFIGURATION_BEAN_NAME_GENERATOR);
36.                         if (generator != null) {
37.                                 this.componentScanBeanNameGenerator = generator;
38.                                 this.importBeanNameGenerator = generator;
39.                         }
40.                 }
41.         }
43.         if (this.environment == null) {
44.                 this.environment = new StandardEnvironment();
45.         }
47.         // 创建一个解析@Configuration的解析器
48.         ConfigurationClassParser parser = new ConfigurationClassParser(
49.                         this.metadataReaderFactory, this.problemReporter, this.environment,
50.                         this.resourceLoader, this.componentScanBeanNameGenerator, registry);
51.         Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
52.         Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
54.         do {
55.                 StartupStep processConfig = this.applicationStartup.start("spring.context.config-classes.parse");
56.                 //开始解析候选类
57.                 parser.parse(candidates);
59.                 parser.validate();
60.                 Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
61.                 configClasses.removeAll(alreadyParsed);
62.                 // Read the model and create bean definitions based on its content
63.                 if (this.reader == null) {
64.                         this.reader = new ConfigurationClassBeanDefinitionReader(
65.                                         registry, this.sourceExtractor, this.resourceLoader, this.environment,
66.                                         this.importBeanNameGenerator, parser.getImportRegistry());
67.                 }
69.                 //注册解析后的类到容器中
70.                 this.reader.loadBeanDefinitions(configClasses);
72.                 alreadyParsed.addAll(configClasses);
73.                 processConfig.tag("classCount", () -> String.valueOf(configClasses.size())).end();
74.                 candidates.clear();
75.                 if (registry.getBeanDefinitionCount() > candidateNames.length) {
76.                         String[] newCandidateNames = registry.getBeanDefinitionNames();
77.                         Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
78.                         Set<String> alreadyParsedClasses = new HashSet<>();
79.                         for (ConfigurationClass configurationClass : alreadyParsed) {
80.                                 alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
81.                         }
82.                         for (String candidateName : newCandidateNames) {
83.                                 if (!oldCandidateNames.contains(candidateName)) {
84.                                         BeanDefinition bd = registry.getBeanDefinition(candidateName);
85.                                         if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
86.                                                         !alreadyParsedClasses.contains(bd.getBeanClassName())) {
87.                                                 candidates.add(new BeanDefinitionHolder(bd, candidateName));
88.                                         }
89.                                 }
90.                         }
91.                         candidateNames = newCandidateNames;
92.                 }
93.         }
95.         while (!candidates.isEmpty());
96.         // Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
97.         if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
98.                 sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
99.         }
101.         if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
102.                 // Clear cache in externally provided MetadataReaderFactory; this is a no-op
103.                 // for a shared cache since it'll be cleared by the ApplicationContext.
104.                 ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
105.         }
107. }

复制代码

这个方法的关键点：

• 找到所有要解析的类
  
• 创建一个解析者
  
• 开始解析类
  
  
  
  • 记住，这里只是解析，也就是确认所有需要处理的类或者方法，这些类或者方法最终也会注册到容器中
    
  
  
• 注册解析后的类到容器中：this.reader.loadBeanDefinitions(configClasses);
  

解析

那么实际上如何解析呢？

1. protected final SourceClass doProcessConfigurationClass(
2.                 ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
3.                 throws IOException {
4.         //1. 判断当前类是否有内部类，如果有内部类是否使用了@Configuration注解，如果使用了该注解，那么需要先处理内部类的配置
5.         //存在这种可能，但是实际开发中很少使用
6.         if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
7.                 processMemberClasses(configClass, sourceClass, filter);
8.         }
10.         // 处理@PropertySource注解
11.         for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
12.                         sourceClass.getMetadata(), PropertySources.class,
13.                         org.springframework.context.annotation.PropertySource.class)) {
14.                 if (this.environment instanceof ConfigurableEnvironment) {
15.                         processPropertySource(propertySource);
16.                 }
17.                 else {
18.                         logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
19.                                         "]. Reason: Environment must implement ConfigurableEnvironment");
20.                 }
21.         }
23.         // 处理@ComponentScan注解
24.         Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
25.                         sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
26.         if (!componentScans.isEmpty() &&
27.                         !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
28.                 for (AnnotationAttributes componentScan : componentScans) {
29.                         Set<BeanDefinitionHolder> scannedBeanDefinitions =
30.                                         this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
31.                         for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
32.                                 BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
33.                                 if (bdCand == null) {
34.                                         bdCand = holder.getBeanDefinition();
35.                                 }
36.                                 if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
37.                                         parse(bdCand.getBeanClassName(), holder.getBeanName());
38.                                 }
39.                         }
40.                 }
41.         }
43.         // 处理@Import注解
44.         processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
46.         // 处理@ImportResource注解
47.         AnnotationAttributes importResource =
48.                         AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
49.         if (importResource != null) {
50.                 String[] resources = importResource.getStringArray("locations");
51.                 Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
52.                 for (String resource : resources) {
53.                         String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
54.                         configClass.addImportedResource(resolvedResource, readerClass);
55.                 }
56.         }
58.         // 处理使用了@Bean的方法
59.         Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
60.         for (MethodMetadata methodMetadata : beanMethods) {
61.                 configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
62.         }
63.         // Process default methods on interfaces
64.         processInterfaces(configClass, sourceClass);
65.         // Process superclass, if any
66.         if (sourceClass.getMetadata().hasSuperClass()) {
67.                 String superclass = sourceClass.getMetadata().getSuperClassName();
68.                 if (superclass != null && !superclass.startsWith("java") &&
69.                                 !this.knownSuperclasses.containsKey(superclass)) {
70.                         this.knownSuperclasses.put(superclass, configClass);
71.                         // Superclass found, return its annotation metadata and recurse
72.                         return sourceClass.getSuperClass();
73.                 }
74.         }
75.         // No superclass -> processing is complete
76.         return null;
77. }

复制代码

processImports方法主要处理两种情况：

• 实现ImportSelector接口的类
  
• 实现ImportBeanDefinitionRegistrar接口的类
  

但是需要注意，这个方法只是把这些类放到了集合中，但是还没有开始处理。
下面开始看如何处理使用@Bean的方法

1. @Configuration
2. @Import(MyBeanFactoryPostProcessor.class)
3. public class JavaConfig {
4.     @Bean
5.     public Country country() {
6.         return new Country();
7.     }
8. }

复制代码

最后返回所有需要处理的方法。
注册

1. public class MyBeanFactoryPostProcessor implements ImportBeanDefinitionRegistrar {
2.     @Override
3.     public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {
4.         ImportBeanDefinitionRegistrar.super.registerBeanDefinitions(importingClassMetadata, registry, importBeanNameGenerator);
5.         RootBeanDefinition rootBeanDefinition = new RootBeanDefinition();
6.         rootBeanDefinition.setBeanClass(Person.class);
8.         registry.registerBeanDefinition("person", rootBeanDefinition);
9.     }
11.     @Override
12.     public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
13.         ImportBeanDefinitionRegistrar.super.registerBeanDefinitions(importingClassMetadata, registry);
14.     }
15. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！