一提起配置类，大家第一个想到的一定是

    1. @Configuration
    2. @ComponentScan("org.wesoft.spring.scan")
    3. public class AppConfig {
    4. }

    没错，这的确是一个配置类，这是类全类名为 AnnotatedGenericBeanDefinition，那么 Spring 是如何进行解析的呢？

    代码跟踪链如下：

    1. public void refresh() throws BeansException, IllegalStateException {
    2.     // 省略代码无数...
    4.     invokeBeanFactoryPostProcessors(beanFactory);
    6.     // 省略代码无数...
    7. }
    9. protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {
    10.     // 关键代码：getBeanFactoryPostProcessors() 正常情况下是空
    11.     // 除非手工通过 ac.addBeanFactoryPostProcessor() 添加
    12.     PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());
    14.     // 省略代码无数...
    15. }
    1. public static void invokeBeanFactoryPostProcessors(
    2.             ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
    3.     // 省略代码无数...
    5.     String[] postProcessorNames =
    6.                     beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
    7.     for (String ppName : postProcessorNames) {
    8.         // 是否实现了 PriorityOrdered 接口（PriorityOrdered 接口，同时又继承了 PriorityOrdered 接口）
    9.         if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
    10.             // 加入当前需要执行的集合中，执行完会清空该集合
    11.             // 为什么要放到集合中？是防止程序员也会提供一个实现
    12.             // beanFactory.getBean()，1、从容器中直接拿 bean，2、如果拿不到会实例化该 bean
    13.             // 关键代码：beanFactory.getBean() 会返回一个 ConfigurationClassPostProcessor 类
    14.             currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
    15.             // 找到的 bean 将名字放入 processedBeans 集合中，后面会用这个集合进行判断，是否执行过，就不再进行执行
    16.             processedBeans.add(ppName);
    17.         }
    18.     }
    19.     // 排序
    20.     sortPostProcessors(currentRegistryProcessors, beanFactory);
    21.     // 将所有的 bean 放入 registryProcessors 集合
    22.     registryProcessors.addAll(currentRegistryProcessors);
    23.     // ★★★ 执行 ConfigurationClassPostProcessor 的 postProcessBeanDefinitionRegistry 方法
    24.     // 因为只有 ConfigurationClassPostProcessor 继承了 BeanDefinitionRegistryPostProcessor
    25.     // 该方法完成以后，所有的 bean 都会被扫描出来放入 beanDefinitionMap 中
    26.     // 老版的 mybatis 就是通过这里入手，完成的扫描
    27.     invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
    28.     // 清空当前需要执行的集合清空
    29.     currentRegistryProcessors.clear();
    31.     // 省略代码无数...
    32. }

    首先拿到所有的 BD，此时的 BD，只有开天辟地的 5 个内置 BD 和一个手工注册的 AppConfig，然后进行循环判断，先看这个类是否被解析过，如果没有被解析过，检查并解析这个类，也就是 ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory) 这个方法，当解析完成后，就开始 parser.parse(candidates) 解析了

    1. public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    2.     List<BeanDefinitionHolder> configCandidates = new ArrayList<>();
    4.     // 获取所有 内置的 5 个 BD 和 手动 register 进去的（AppConfig.class）
    5.     String[] candidateNames = registry.getBeanDefinitionNames();
    7.     // 寻找 @Configuration 的类
    8.     for (String beanName : candidateNames) {
    9.         // 获取 BD
    10.         BeanDefinition beanDef = registry.getBeanDefinition(beanName);
    11.         // 判断有没有被解析
    12.         // ★ 如果这个类已经被解析了，且配置类上加了 @Configuration，就是 full
    13.         // ★ 如果这个类已经被解析了，且配置类上没加 @Configuration，就是 lite
    14.         // 第一次进来的时候，这个类并没有被解析，所以不会进来
    15.         if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
    16.             ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
    17.             if (logger.isDebugEnabled()) {
    18.                 logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
    19.             }
    20.         }
    21.         // ★★★ 检查 这个类是不是 AnnotatedGenericBeanDefinition
    22.         // ★★★ 同时会给这个类的 attribute 添加一个属性 key = configurationClass，value = full 或者 lite，即标记这个类已经解析过了
    23.         else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
    24.             // ★ 解析成功，加入到已经解析的配置类集合中
    25.             configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
    26.         }
    27.     }
    29.     // Return immediately if no @Configuration classes were found
    30.     if (configCandidates.isEmpty()) {
    31.         return;
    32.     }
    34.     // Sort by previously determined @Order value, if applicable
    35.     configCandidates.sort((bd1, bd2) -> {
    36.         int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
    37.         int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
    38.         return Integer.compare(i1, i2);
    39.     });
    41.     // Detect any custom bean name generation strategy supplied through the enclosing application context
    42.     SingletonBeanRegistry sbr = null;
    43.     if (registry instanceof SingletonBeanRegistry) {
    44.         sbr = (SingletonBeanRegistry) registry;
    45.         if (!this.localBeanNameGeneratorSet) {
    46.             BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
    47.             if (generator != null) {
    48.                 this.componentScanBeanNameGenerator = generator;
    49.                 this.importBeanNameGenerator = generator;
    50.             }
    51.         }
    52.     }
    54.     if (this.environment == null) {
    55.         this.environment = new StandardEnvironment();
    56.     }
    58.     // Parse each @Configuration class
    59.     ConfigurationClassParser parser = new ConfigurationClassParser(
    60.         this.metadataReaderFactory, this.problemReporter, this.environment,
    61.         this.resourceLoader, this.componentScanBeanNameGenerator, registry);
    63.     Set<BeanDefinitionHolder> candidates = new LinkedHashSet<>(configCandidates);
    64.     Set<ConfigurationClass> alreadyParsed = new HashSet<>(configCandidates.size());
    65.     do {
    66.         // ★★★ 关键代码：解析这个类中所有的注解
    67.         parser.parse(candidates);
    68.         parser.validate();
    70.         Set<ConfigurationClass> configClasses = new LinkedHashSet<>(parser.getConfigurationClasses());
    71.         configClasses.removeAll(alreadyParsed);
    73.         // Read the model and create bean definitions based on its content
    74.         if (this.reader == null) {
    75.             this.reader = new ConfigurationClassBeanDefinitionReader(
    76.                 registry, this.sourceExtractor, this.resourceLoader, this.environment,
    77.                 this.importBeanNameGenerator, parser.getImportRegistry());
    78.         }
    79.         this.reader.loadBeanDefinitions(configClasses);
    80.         alreadyParsed.addAll(configClasses);
    82.         candidates.clear();
    83.         if (registry.getBeanDefinitionCount() > candidateNames.length) {
    84.             String[] newCandidateNames = registry.getBeanDefinitionNames();
    85.             Set<String> oldCandidateNames = new HashSet<>(Arrays.asList(candidateNames));
    86.             Set<String> alreadyParsedClasses = new HashSet<>();
    87.             for (ConfigurationClass configurationClass : alreadyParsed) {
    88.                 alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
    89.             }
    90.             for (String candidateName : newCandidateNames) {
    91.                 if (!oldCandidateNames.contains(candidateName)) {
    92.                     BeanDefinition bd = registry.getBeanDefinition(candidateName);
    93.                     if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
    94.                         !alreadyParsedClasses.contains(bd.getBeanClassName())) {
    95.                         candidates.add(new BeanDefinitionHolder(bd, candidateName));
    96.                     }
    97.                 }
    98.             }
    99.             candidateNames = newCandidateNames;
    100.         }
    101.     }
    102.     while (!candidates.isEmpty());
    104.     // Register the ImportRegistry as a bean in order to support ImportAware @Configuration classes
    105.     if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
    106.         sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
    107.     }
    109.     if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
    110.         // Clear cache in externally provided MetadataReaderFactory; this is a no-op
    111.         // for a shared cache since it'll be cleared by the ApplicationContext.
    112.         ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
    113.     }
    114. }

    这里的判断首先看这个 BD 是不是 AnnotatedBeanDefinition 类型，这里就解释了很多问题，前面我们说过，AppConfig 是 AnnotatedGenericBeanDefinition，@Component 标记的 bean 是 ScannedGenericBeanDefinition 类型，@Bean 标记的是 ConfigurationClassBeanDefinition 类型，而这些都是 AnnotatedBeanDefinition 的子类

    1. public static boolean checkConfigurationClassCandidate(
    2.             BeanDefinition beanDef, MetadataReaderFactory metadataReaderFactory) {
    4.     String className = beanDef.getBeanClassName();
    5.     if (className == null || beanDef.getFactoryMethodName() != null) {
    6.         return false;
    7.     }
    9.     AnnotationMetadata metadata;
    10.     /*
    11.     一个配置类的 db 类型，就是 AnnotatedGenericBeanDefinition extends GenericBeanDefinition implement AnnotatedBeanDefinition
    12.     通常 AnnotatedBeanDefinition 类型的类，就是一个配置类，因为 Spring 会将配置类写死为 AnnotatedGenericBeanDefinition
    14.     ★★★ AnnotatedBeanDefinition 的实现类有三个，AnnotatedGenericBeanDefinition，ConfigurationClassBeanDefinition，ScannedGenericBeanDefinition
    16.     就是判断 beanDef 是不是一个配置类，所以也解释了 @Component 里为什么也可以写 @Bean
    17.     因为 @Component 是一个 ScannedGenericBeanDefinition，他是 AnnotatedBeanDefinition 的子类
    19.     而开天辟地的 5 BD 都是 RootBeanDefinition，所以是不会进行解析的
    20.     */
    21.     if (beanDef instanceof AnnotatedBeanDefinition &&
    22.         className.equals(((AnnotatedBeanDefinition) beanDef).getMetadata().getClassName())) {
    23.         // Can reuse the pre-parsed metadata from the given BeanDefinition...
    24.         // 获取这个类上所有的 注解信息
    25.         metadata = ((AnnotatedBeanDefinition) beanDef).getMetadata();
    26.     }
    27.     else if (beanDef instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) beanDef).hasBeanClass()) {
    28.         // Check already loaded Class if present...
    29.         // since we possibly can't even load the class file for this Class.
    30.         Class<?> beanClass = ((AbstractBeanDefinition) beanDef).getBeanClass();
    31.         metadata = new StandardAnnotationMetadata(beanClass, true);
    32.     }
    33.     else {
    34.         try {
    35.             MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(className);
    36.             metadata = metadataReader.getAnnotationMetadata();
    37.         }
    38.         catch (IOException ex) {
    39.             if (logger.isDebugEnabled()) {
    40.                 logger.debug("Could not find class file for introspecting configuration annotations: " +
    41.                              className, ex);
    42.             }
    43.             return false;
    44.         }
    45.     }
    47.     // 判断是不是一个 加了 @Configuration 的注解类，此时就是一个 full 配置类
    48.     if (isFullConfigurationCandidate(metadata)) {
    49.         beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_FULL);
    50.     }
    51.     // 判断是不是一个 没加 @Configuration 的注解类，此时就是一个 lite 配置类
    52.     else if (isLiteConfigurationCandidate(metadata)) {
    53.         beanDef.setAttribute(CONFIGURATION_CLASS_ATTRIBUTE, CONFIGURATION_CLASS_LITE);
    54.     }
    55.     else {
    56.         return false;
    57.     }
    59.     // It's a full or lite configuration candidate... Let's determine the order value, if any.
    60.     Integer order = getOrder(metadata);
    61.     if (order != null) {
    62.         beanDef.setAttribute(ORDER_ATTRIBUTE, order);
    63.     }
    65.     return true;
    66. }