ConfigurationClassPostProcessor bean工厂后置处理器源码总结

1、ConfigurationClassPostProcessor 概述：

ConfigurationClassPostProcessor 是spring 唯一内置的bean工厂后置处理器，对有 @Configuration、@Import 、 @Component、@ComponentScan 以及 @ImportResource 这几个注解的类都是配置类，都会对其进扫描解析。

2、ConfigurationClassPostProcessor 的继承流程图

Spring有一个内部的BeanFactoryPostProcessor：

　　org.springframework.context.annotation.internalConfigurationAnnotationProcessor (id)

　　　　---------> ConfigurationClassPostProcessor(实现类)

　　　　　　--------->BeanDefinitionRegistryPostProcessor（接口）

　　　　　　　　　--------->BeanFactoryPostProcessor（接口）

这里我们只关心：BeanDefinitionRegistryPostProcessor 和 BeanFactoryPostProcessor

ConfigurationClassPostProcessor 继承了BeanDefinitionRegistryPostProcessor 重写了BeanDefinitionRegistryPostProcessor 的postProcessorBeanDefinitionRegistry();

间接继承了BeanFactoryPostProcessor 重写了 postProcessBeanFactory

postProcessorBeanDefinitionRegistry

3、ConfigurationClassPostProcessor 实例化流程

spring在实例化容器时候调用AnnotationConfigApplicationContext（）默认构造方法的

通过AnnotatedBeanDefinitionReader 手动注册的。源码如下：

public AnnotationConfigApplicationContext() {

    /**

     * spring内部：AnnotatedBeanDefinitionReader主要读取spring的内部的bd

     * 这里主要是注册内部的bd，比如唯一的beanFactoryPostProcess 的实现类 ConfigurationClassPostProcessor 和 其他的几种

     * beanPostProcess。

     * 程序员调用：他也提供了一个可以让程序员自己注册bd到容器的接口，register（）；

     */

    this.reader = new AnnotatedBeanDefinitionReader(this);

    /**

     * 作用：这个是一个扫描器，根据包扫描所有加了注解的bean，注册 bd。

      *  按照扫描规则，找到合适的类转成bd，注册到容器。

      * 1. 程序员能够在外部调用AnnotationConfigApplicationContext对象的scan()， 或者继承该类可以重写scan规则用来动态扫描注解，

      * 需要注册到容器。

      * 2. spring内部也默认使用该scanner来扫描，不过他是自己又重新new的。

       */

    this.scanner = new ClassPathBeanDefinitionScanner(this);

}

public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {

    this.registry = registry;
    
    this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
    
    // 主要把spring内置的bean工厂后置处理器和bean后置处理器变成beanDefinition 然后注册到BeanDefinitionMap 中
    
    AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);

}

public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(

    BeanDefinitionRegistry registry, Object source) {
    
    ......
    
    Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<BeanDefinitionHolder>(4);
    
    //此处就是 吧ConfigurationClassPostProcessor 变成RootBeanDefinition 然后注册到beanDefinitionMap
    
    if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
    
    RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
    
    def.setSource(source);
    
    beanDefs.add(registerPostProcessor(registry, def,CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
    
    }
    
    .....
    
    return beanDefs;

}

private static BeanDefinitionHolder registerPostProcessor(

    BeanDefinitionRegistry registry, RootBeanDefinition definition, String beanName) {
    
    definition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    
    // 开始注册beanDefinition 即把beanDefinition 放到beanDefinitionMap
    
    registry.registerBeanDefinition(beanName, definition);
    
    return new BeanDefinitionHolder(definition, beanName);

}

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException {

    this.beanDefinitionMap.put(beanName, beanDefinition);

}

4、ConfigurationClassPostProcessor 执行时机

当容器初始化过程中，方法执行到refresh方法里面的invokeBeanFactoryPostProcessors 时候开始执行bean工厂的后置处理器具体看源码：

//IOC容器带参数构造方法（AnnotationConfigApplicationContext）

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {

    this();

    register(annotatedClasses);

    refresh();

}

public void refresh() throws BeansException, IllegalStateException {

    synchronized (this.startupShutdownMonitor) {
        .....

        try {

            // 执行工厂后置处理器的过程

            invokeBeanFactoryPostProcessors(beanFactory);

        ....

        }catch (Exception e){
            .....
        }

        .........

    }
}

    public static void invokeBeanFactoryPostProcessors(

        ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
        
        // 需要执行的 BeanDefinitionRegistryPostProcessor bean 的名字
        
        Set<String> processedBeans = new HashSet<String>();
        
        /**
         * 判断是不是BeanDefinitionRegistry的类型的类
        
          */
        
        if (beanFactory instanceof BeanDefinitionRegistry) {
        
            BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
            
            List<BeanFactoryPostProcessor> regularPostProcessors = new LinkedList<BeanFactoryPostProcessor>();
            
            //这个集合保存所有的BeanDefinitionRegistryPostProcessor 为了下面执行所有BeanDefinitionRegistryPostProcessor
            
            //的PostProcessorBeanFactory 做准备
            
            List<BeanDefinitionRegistryPostProcessor> registryPostProcessors = new LinkedList<BeanDefinitionRegistryPostProcessor>();
        
            /**
            
             * beanFactoryPostProcessors 执行程序员提供的 BeanFactoryPostProcessor，

             * 一般情况下这里面使我们通过api 手动regist上去的

             * 本处我们探讨的是ConfigurationClassPostProcessor 所以不进去

             */
        
            for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
            
                if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
                
                    BeanDefinitionRegistryPostProcessor registryPostProcessor =
                    
                    (BeanDefinitionRegistryPostProcessor) postProcessor;
                    
                    registryPostProcessor.postProcessBeanDefinitionRegistry(registry);
                    
                    registryPostProcessors.add(registryPostProcessor);
                    
                }
                
                else {
                
                    //筛选出属于BeanFactoryPostProcessor的后置处理器
                    
                    regularPostProcessors.add(postProcessor);
                
                }
            
            }
        
         /**
        
         * 助理开始执行spring内置的BeanDefinitionRegistryPostProcessor

         * getBeanNamesForType 返回值为： org.springframework.context.annotation.internalConfigurationAnnotationProcessor

         * 就是我们想找的ConfigurationClassPostProcessor

         * 通过上面继承关系图可知ConfigurationClassPostProcessor继承了PriorityOrdered 所以执priorityOrderedPostProcessors

         */
        
        String[] postProcessorNames =
        
        beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
        
        // 获取PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessor
        
        List<BeanDefinitionRegistryPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanDefinitionRegistryPostProcessor>();
        
        for (String ppName : postProcessorNames) {
            
            if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
            
                priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
                
                processedBeans.add(ppName);
            
            }
        
        }
        
        sortPostProcessors(beanFactory, priorityOrderedPostProcessors);
        
        registryPostProcessors.addAll(priorityOrderedPostProcessors);
        
        // 开始执行实现了PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessor---postProcessBeanDefinitionRegistry方法
        
        invokeBeanDefinitionRegistryPostProcessors(priorityOrderedPostProcessors, registry);
        
        
        
        invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
        
        }
        
        ......

    }

总结：ConfigurationClassPostProcessor 被执行是在AnnotationConfigApplicationContext 容器初始化的时候，调用refresh() 方法里面的invokeBeanFactoryPostProcessors 开始执行的。

invokeBeanFactoryPostProcessors 里面执行流程：

1、限制性程序员提供的BeanDefinitionRegistryPostProcessor的

PostProcessorBeanDefinitionRegistry 方法

2、再执行spring内置实现了PriorityOrdered 接口的 BeanDefinitionRegistryPostProcessor的

PostProcessorBeanDefinitionRegistry 方法

3、然后开始执行spring内置实现了Ordered 接口的 BeanDefinitionRegistryPostProcessor的

PostProcessorBeanDefinitionRegistry 方法

4、接着执行不满足上述条件的BeanDefinitionRegistryPostProcessor的

PostProcessorBeanDefinitionRegistry 方法（这里面一般情况是程序员通过注解提供的无特点的）

5、接着再执行所有的BeanDefinitionRegistryPostProcessor的PostProcessorBeanFactory方法

6、最后执行所有的BeanFactoryPostProcessor的PostProcessorBeanFactory方法

3、ConfigurationClassPostProcessor的 postProcessBeanDefinitionRegistry方法作用

该方法主要用来扫描@Configuration、@Import 、 @Component、@ComponentScan 以及 @ImportResource 这几个注解的类都是配置类，都会对其进扫描解析。把bean解析成beanDefinitionde.

postProcessBeanDefinitionRegistry---processConfigBeanDefinitions方法详解：

public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
    List<BeanDefinitionHolder> configCandidates = new ArrayList<BeanDefinitionHolder>();
    /**
     * 获取所有注册到bd里面的bean的名字 此处我们找到7个
     * 0 = "org.springframework.context.annotation.internalConfigurationAnnotationProcessor"
     * 1 = "org.springframework.context.annotation.internalAutowiredAnnotationProcessor"
     * 2 = "org.springframework.context.annotation.internalRequiredAnnotationProcessor"
     * 3 = "org.springframework.context.annotation.internalCommonAnnotationProcessor"
     * 4 = "org.springframework.context.event.internalEventListenerProcessor"
     * 5 = "org.springframework.context.event.internalEventListenerFactory"
     * 6 = "appConfig"
     * 都是通过AnnotatedBeanDefinitionReader 注册进来的
     * appConfig 是我们的配置类
     */
    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);
            }
        }
        /**
  * checkConfigurationClassCandidate()会判断一个是否是一个配置类,并为BeanDefinition设置属性为lite或者full。
         * 在这儿为BeanDefinition设置lite和full属性值是为了后面在使用
  * 如果加了@Configuration，那么对应的BeanDefinition为full;
  * 如果加了@Bean,@Component,@ComponentScan,@Import,@ImportResource这些注解，则为lite。
         * lite和full均表示这个BeanDefinition对应的类是一个配置类
  */
        else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {
            configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
        }
    }

    // Return immediately if no @Configuration classes were found
    if (configCandidates.isEmpty()) {
        return;
    }

    // 对configCandidates 进行 排序,按照@Order 配置的值进行排序
    Collections.sort(configCandidates, new Comparator<BeanDefinitionHolder>() {
        @Override
        public int compare(BeanDefinitionHolder bd1, BeanDefinitionHolder bd2) {
            int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
            int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
            return (i1 < i2) ? -1 : (i1 > i2) ? 1 : 0;
        }
    });

    // 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 && sbr.containsSingleton(CONFIGURATION_BEAN_NAME_GENERATOR)) {
            BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
            this.componentScanBeanNameGenerator = generator;
            this.importBeanNameGenerator = generator;
        }
    }

    // 创建配置类解析器 主要解析的是加了@Configuration的注解类
    ConfigurationClassParser parser = new ConfigurationClassParser(
            this.metadataReaderFactory, this.problemReporter, this.environment,
            this.resourceLoader, this.componentScanBeanNameGenerator, registry);

    Set<BeanDefinitionHolder> candidates = new LinkedHashSet<BeanDefinitionHolder>(configCandidates);
    Set<ConfigurationClass> alreadyParsed = new HashSet<ConfigurationClass>(configCandidates.size());
    do {
        parser.parse(candidates);
        parser.validate();

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

        // 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());
        }
        // 这个方法主要是把前面解析出来的配置类的beanDefinition都注册到容器中
        this.reader.loadBeanDefinitions(configClasses);
        alreadyParsed.addAll(configClasses);

        candidates.clear();
        if (registry.getBeanDefinitionCount() > candidateNames.length) {
            String[] newCandidateNames = registry.getBeanDefinitionNames();
            Set<String> oldCandidateNames = new HashSet<String>(Arrays.asList(candidateNames));
            Set<String> alreadyParsedClasses = new HashSet<String>();
            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) {
        if (!sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
            sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
        }
    }

    if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
        ((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
    }
}

总结：

1.获取BeanFactory中的已注册的beanDefinitionNames，从中找出@Configuration注解修饰的类，我debug的时候只有自己写的启动类进入了候选配置类。如果找不到@Configuration修饰的配置类，则返回。对找到的@Configuration修饰的配置类们进行排序。

2.检测是否有自定义bean名称生成器

3. 解析每一个@Configuration注解修饰的配置类

4.删除缓存

parser.parse(candidates); 方法解析

主要是遍历配置类，得到BeanDefinition，根据bd类型不同，调用不用的parse方法解析

public void parse(Set<BeanDefinitionHolder> configCandidates) {
   for (BeanDefinitionHolder holder : configCandidates) {
      BeanDefinition bd = holder.getBeanDefinition();
      try {
         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();
}

doProcessConfigurationClass方法解析

流程解析：

1.处理内部类

2.处理@PropertySource注解

3.处理@ComponentScan注解

4.处理@Import注解

5.处理@ImportResource注解

6.处理@Bean修饰的方法

7.处理接口定义的方法

8.处理父类

protected final ConfigurationClassParser.SourceClass doProcessConfigurationClass(ConfigurationClass configClass, ConfigurationClassParser.SourceClass sourceClass)
        throws IOException {

    // Recursively process any member (nested) classes first
    processMemberClasses(configClass, sourceClass);

    // 处理加了 @PropertySource 注解的bean
    for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
            sourceClass.getMetadata(), PropertySources.class,
            org.springframework.context.annotation.PropertySource.class)) {
        if (this.environment instanceof ConfigurableEnvironment) {
            processPropertySource(propertySource);
        }
        else {
            logger.warn("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
                    "]. Reason: Environment must implement ConfigurableEnvironment");
        }
    }

    // 处理加了 @ComponentScan 注解的
    Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
            sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
    if (!componentScans.isEmpty() &&
            !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationCondition.ConfigurationPhase.REGISTER_BEAN)) {
        for (AnnotationAttributes componentScan : componentScans) {
            // The config class is annotated with @ComponentScan -> perform the scan immediately
            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
            for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
                if (ConfigurationClassUtils.checkConfigurationClassCandidate(
                        holder.getBeanDefinition(), this.metadataReaderFactory)) {
                    parse(holder.getBeanDefinition().getBeanClassName(), holder.getBeanName());
                }
            }
        }
    }

    // 处理加了@Import 注解的bean
    processImports(configClass, sourceClass, getImports(sourceClass), true);

    // 处理加了@ImportResource 注解的bean
    if (sourceClass.getMetadata().isAnnotated(ImportResource.class.getName())) {
        AnnotationAttributes importResource =
                AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
        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);
        }
    }

    // 处理加了@Bean  注解的bean
    Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
    for (MethodMetadata methodMetadata : beanMethods) {
        configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
    }

    // 处理接口定义的方法
    processInterfaces(configClass, sourceClass);

    // 处理父类
    if (sourceClass.getMetadata().hasSuperClass()) {
        String superclass = sourceClass.getMetadata().getSuperClassName();
        if (!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;
}

processConfigurationClass ：

主要是把doProcessConfigurationClass方法解析出来的资源放到configurationClasses 提供给processConfigBeanDefinitions 方法使用，从而把扫描出来的对象变成BeanDefinte

this.reader.loadBeanDefinitions()

这个方法主要是把前面解析出来的配置类的beanDefinition都注册到容器中

private void loadBeanDefinitionsForConfigurationClass(ConfigurationClass configClass,
                                                      TrackedConditionEvaluator trackedConditionEvaluator) {

    // 使用条件注解判断是否需要跳过这个配置类
    if (trackedConditionEvaluator.shouldSkip(configClass)) {
        String beanName = configClass.getBeanName();

        if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
            // 跳过配置类的话在Spring容器中移除bean的注册
            this.registry.removeBeanDefinition(beanName);
        }

        // 从importRegistry 中移除
        this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
        return;
    }

    if (configClass.isImported()) {
        // 如果自身是被@Import注释修饰，注册自己
        registerBeanDefinitionForImportedConfigurationClass(configClass);
    }

    // 将@Bean方法注册为bean
    for (BeanMethod beanMethod : configClass.getBeanMethods()) {
        loadBeanDefinitionsForBeanMethod(beanMethod);
    }

    // 将configClass中ImportResource指定的资源注册为bean
    loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());

    // 如果该类有@Import，且Import进来的类实现了ImportBeanDefinitionRegistrar接口，则调用Import进来的类的registerBeanDefinitions方法。
    loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
}

1.使用条件注解判断是否要跳过配置类，如果要跳过配置类的话，在spring中移除该bean的注册，从importRegistry 中移除，返回。

2.如果该bean自身被@Import注释修饰，注册自己。

3.将@Bean方法注册为bean

4.将configClass中中ImportResource指定的资源注册为bean

5.loadBeanDefinitionsFromRegistrars方法，如果该类有@Import，且Import进来的类实现了ImportBeanDefinitionRegistrar接口，则调用Import进来的类的registerBeanDefinitions方法。

5、ConfigurationClassPostProcessor的 postProcessBeanFactory方法作用

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
   .....
   // 对加了@Configuration注解的配置类进行Cglib代理
   enhanceConfigurationClasses(beanFactory);
   // 添加一个BeanPostProcessor后置处理器
   beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
}

我们主要来分析看看enhanceConfigurationClasses方法，主要作用：

1 动态代理Configuration类

2 并将map中的bd替换成代理的类。

3 他的目的是代理类，下面的@Bean方法被spring管理，只会实例化一次。

例子如下：

@Configuration
public class C {
   @Bean
   public A getBeanA(){
      System.out.println("A"+A.class);
      return new A();
   }

   @Bean
   public B getBeanb(){
      System.out.println("B"+A.class);
      getBeanA();
      return new B();
   }
}

@Component
public class A {
}

@Component
public class B {

}

public class Test {
   public static void main(String[] args) {
      AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(Appconfig.class);
   }
}

输出结果为：

> Task :test:Test.main()
Aclass com.pwd.A
Bclass com.pwd.A

为不是：

Aclass com.pwd.A
Aclass com.pwd.A
Bclass com.pwd.A

源码：

public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {
   .....
   .....
   ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();
   for (Map.Entry<String, AbstractBeanDefinition> entry : configBeanDefs.entrySet()) {
      AbstractBeanDefinition beanDef = entry.getValue();
      // If a @Configuration class gets proxied, always proxy the target class
      beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
      // Set enhanced subclass of the user-specified bean class
      Class<?> configClass = beanDef.getBeanClass();
      Class<?> enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);
      if (configClass != enhancedClass) {
         if (logger.isTraceEnabled()) {
            logger.trace(String.format("Replacing bean definition '%s' existing class '%s' with " +
                  "enhanced class '%s'", entry.getKey(), configClass.getName(), enhancedClass.getName()));
         }
         beanDef.setBeanClass(enhancedClass);
      }
   }
}

public Class<?> enhance(Class<?> configClass, @Nullable ClassLoader classLoader) {
  //判断该类有没有被代理过，被代理过则返回
  //应为CGLIB 被代理后，代理对象会实现EnhancedConfiguration，
  // 所以能判断是否被代理过
  if (EnhancedConfiguration.class.isAssignableFrom(configClass)) {
   return configClass;
  }
                //开始实现动态代理
  Class<?> enhancedClass = createClass(newEnhancer(configClass, classLoader));
  return enhancedClass;
 }

private Class<?> createClass(Enhancer enhancer) {
   Class<?> subclass = enhancer.createClass();
   Enhancer.registerStaticCallbacks(subclass, CALLBACKS);
   return subclass;
}

private Enhancer newEnhancer(Class<?> configSuperClass, @Nullable ClassLoader classLoader) {
      Enhancer enhancer = new Enhancer();
  //父类增强，基于继承来的
  enhancer.setSuperclass(configSuperClass);
  //设置其是EnhancedConfiguration类型的，而该接口是BeanFactoryAware
  //设置好标识 检测这个class是否已经增强 同时我们在bean初始化的时候
  //会通过invokeAwareMethods回调setBeanFactory方法
  //注意 其最终会检测原始的类（superclass）是否继承了BeanFactoryAware，如果没有 反射的时候不会调用
  enhancer.setInterfaces(new Class<?>[] {EnhancedConfiguration.class});
  enhancer.setUseFactory(false);
  enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
  /**
   * BeanFactoryAwareGeneratorStrategy 是一个生产策略
   * 主要为了生产CGLIB类中添加成员变量$$beanFactory
   * 同时基于接口EnhanchedConfiguration的父类接口BeanFactoryAware中的setBeanFactory方法
   * 设置变量的值为当前context中的beanFactory,这样依赖我们这个CGLIB代理的对象就有了beanFactory
   * 有了factory就能获取对象，而不是去通过方法获得对象了，因此通过方法获得对象不能控制过程
   * 该BeanFactory的作用是在this调用时拦截该调用，并直接在beanFactory中获得bean
   */
  enhancer.setStrategy(new BeanFactoryAwareGeneratorStrategy(classLoader));
  enhancer.setCallbackFilter(CALLBACK_FILTER);
  enhancer.setCallbackTypes(CALLBACK_FILTER.getCallbackTypes());
  return enhancer;
 }

enhancer.setCallbackFilter(CALLBACK_FILTER)的CALLBACK_FILTER 里面的 BeanMethodInterceptor类
BeanMethodInterceptor 实现 MethodInterceptor 接口重写了 intercept，此方法是cglib 代理实现外部业务逻辑的入口。源码如下：

public Object intercept(Object enhancedConfigInstance, Method beanMethod, Object[] beanMethodArgs,
         MethodProxy cglibMethodProxy) throws Throwable {
   //获取beanFactroy
   ConfigurableBeanFactory beanFactory = getBeanFactory(enhancedConfigInstance);
   //通过Method 获取加了@Bean注解的方法名字
   //本初有 getBeanA 和 getBeanB
   String beanName = BeanAnnotationHelper.determineBeanNameFor(beanMethod);

   // Determine whether this bean is a scoped-proxy
   //处理加了@Scop注解的bean
   if (BeanAnnotationHelper.isScopedProxy(beanMethod)) {
      String scopedBeanName = ScopedProxyCreator.getTargetBeanName(beanName);
      if (beanFactory.isCurrentlyInCreation(scopedBeanName)) {
         beanName = scopedBeanName;
      }
   }

   ...
   //检查该bean是否真正创建，本处就是检查getBeanA 或者getBeanB是否真正创建
   if (isCurrentlyInvokedFactoryMethod(beanMethod)) {
      //调用父类方法，被cglib 代理的类会继承类的本身，
      // 在这里假设$$CGLIB$SrpingA， $$CGLIB$SrpingB 代表被cglib 代理的A 和 B 
      // 代理形成后 会变成 $$CGLIB$SrpingA extents A impl EnhancedConfiguration
      // 所以他调用的即是 A 的 getBeanA 方法
      return cglibMethodProxy.invokeSuper(enhancedConfigInstance, beanMethodArgs);
   }
   // 当getBeanB 中调用getBeanA 时候进来
   return resolveBeanReference(beanMethod, beanMethodArgs, beanFactory, beanName);
}

private boolean isCurrentlyInvokedFactoryMethod(Method method) {
   //获取正在调用的方法
   Method currentlyInvoked = SimpleInstantiationStrategy.getCurrentlyInvokedFactoryMethod();
   //比较正在调用的方法的beanName和传进来的是否一致,再比较类型是否一致
   //一致则返回true
   return (currentlyInvoked != null && method.getName().equals(currentlyInvoked.getName()) &&
         Arrays.equals(method.getParameterTypes(), currentlyInvoked.getParameterTypes()));
}

总结：本处地方就是spring 采用cglib 动态代理实现自己的而业务逻辑：

1 获取beanFactory 和beanMethodName

2 处理加了@Scop 注解的bean

3 检查bean 是否真正创建，创建则调用父类方法

4 调用自己的逻辑创建bean(resolveBeanReference)

private Object resolveBeanReference(Method beanMethod, Object[] beanMethodArgs,
      ConfigurableBeanFactory beanFactory, String beanName) {

   //判断Bean 是否正在创建  这里面进来的是getbeanA,getbeanA 此时已经被实例化，
   //我们可以看单例池即可知道，它此时已经在，但是此时正在创建的是B
   boolean alreadyInCreation = beanFactory.isCurrentlyInCreation(beanName);
   try {
      if (alreadyInCreation) {
         //如果正在创建，则移除
         beanFactory.setCurrentlyInCreation(beanName, false);
      }
      //处理方法里面的参数
      boolean useArgs = !ObjectUtils.isEmpty(beanMethodArgs);
      if (useArgs && beanFactory.isSingleton(beanName)) {       
         for (Object arg : beanMethodArgs) {
            if (arg == null) {
               useArgs = false;
               break;
            }
         }
      }
      //调用getBean 创建 getBeanA,此时回去单例池拿，所以实例化getBeanA不会打印两次Aclass com.pwd.A
      Object beanInstance = (useArgs ? beanFactory.getBean(beanName, beanMethodArgs) :
            beanFactory.getBean(beanName));
      if (!ClassUtils.isAssignableValue(beanMethod.getReturnType(), beanInstance)) {
         if (beanInstance.equals(null)) {
            beanInstance = null;
         }
      Method currentlyInvoked = SimpleInstantiationStrategy.getCurrentlyInvokedFactoryMethod();
      if (currentlyInvoked != null) {
         String outerBeanName = BeanAnnotationHelper.determineBeanNameFor(currentlyInvoked);
         beanFactory.registerDependentBean(beanName, outerBeanName);
      }
      return beanInstance;
   }
   finally {
      if (alreadyInCreation) {
         beanFactory.setCurrentlyInCreation(beanName, true);
      }
   }
}

问题：

//判断Bean 是否正在创建这里面进来的是getbeanA,getbeanA 此时已经被实例化，

//我们可以看单例池即可知道，它此时已经在，但是此时正在创建的是B

但断点到达

boolean alreadyInCreation = beanFactory.isCurrentlyInCreation(beanName); 结果如下：

总结：resolveBeanReference 主要逻辑

1 判断bean是否真正创建，是的或移除正在创建集合

2 判断是否是单例，还有是否有参数，处理方法参数

3 调用getBean 创建 getBeanA（）（getBean方法属于bean生命周期，此时不详细展开）

4 返回bean