配置类为什么要添加@Configuration注解？

@ComponentScan("com.dmz.source.code")
//@Configuration
public class Config{
 @Bean
 public A a(){
 return new A(dmzService());
 }

 @Bean
 public DmzService dmzService(){
  return new DmzService();
 }
}

public class A {
 public A(DmzService dmzService){
  System.out.println("create A by dmzService");
 }
}

@Component
public class DmzService {
 public DmzService(){
  System.out.println("create dmzService");
 }
}

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

create dmzService
create A by dmzService
create dmzService

create dmzService
create A by dmzService

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);
   // 在执行postProcessBeanDefinitionRegistry方法的时就已经将这个id添加到registriesPostProcessed集合中了
   if (!this.registriesPostProcessed.contains(factoryId)) {
       processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
   }
 // 看起来这个方法就是完成了代理
   enhanceConfigurationClasses(beanFactory);
   // 添加了一个后置处理器
   beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
}

 public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {  // map中放置的是所有需要被代理的类
  Map<String, AbstractBeanDefinition> configBeanDefs = new LinkedHashMap<>();
  for (String beanName : beanFactory.getBeanDefinitionNames()) {
   BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
   if (ConfigurationClassUtils.isFullConfigurationClass(beanDef)) {
    // 省略异常跟日志代码....
               // 这个代码的含义就是如果是一个被@Configuration注解标注的类,那么将其放入到configBeanDefs这个集合中
    configBeanDefs.put(beanName, (AbstractBeanDefinition) beanDef);
   }
  }
       
  if (configBeanDefs.isEmpty()) {
   // nothing to enhance -> return immediately
   return;
  }
  
       // 对配置类进行代理的核心类
  ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();
  for (Map.Entry<String, AbstractBeanDefinition> entry : configBeanDefs.entrySet()) {
   AbstractBeanDefinition beanDef = entry.getValue();
   // 对于配置类永远使用cglib代理
   beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
   try {
    // cglib代理是基于类实现的,所以在这之前要明确代理的类是什么
    Class<?> configClass = beanDef.resolveBeanClass(this.beanClassLoader);
    if (configClass != null) {
                   // 通过ConfigurationClassEnhancer获取到一个经过代理的class
     Class<?> enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);
                  // 省略日志....
                   
                   // 将原有的配置类的bd中的beanClass属性替换成代理后的class
      beanDef.setBeanClass(enhancedClass);
     }
    }
   }
   catch (Throwable ex) {
    throw new IllegalStateException("Cannot load configuration class: " + beanDef.getBeanClassName(), ex);
   }
  }
 }

public class Target{
   public void f(){
       System.out.println("Target f()");
   }
   public void g(){
       System.out.println("Target g()");
   }
}

public class Interceptor implements MethodInterceptor {
   @Override
   public Object intercept(Object obj, Method method, Object[] args,    MethodProxy proxy) throws Throwable {
       System.out.println("I am intercept begin");
//Note: 此处一定要使用proxy的invokeSuper方法来调用目标类的方法
       proxy.invokeSuper(obj, args);
       System.out.println("I am intercept end");
       return null;
   }
}

public class Test {
   public static void main(String[] args) {
       // 设置这个属性，将代理类的字节码文件生成到F盘的code目录下
   System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "F:\\code");
        //实例化一个增强器，也就是cglib中的一个class generator
       Enhancer eh = new Enhancer();
        //设置目标类
       eh.setSuperclass(Target.class);
       // 设置拦截对象
       eh.setCallback(new Interceptor());
       // 生成代理类并返回一个实例
       Target t = (Target) eh.create();
       t.f();
       t.g();
   }
}

I am intercept begin
Target f()
I am intercept end
I am intercept begin
Target g()
I am intercept end

// 省略多余的方法，我们就关注g方法
public class Target$$EnhancerByCGLIB$$788444a0 extends Target implements Factory
{
   
   final void CGLIB$g$0()
   {
     super.g();
   }
   
   // 经过代理过的g方法
   public final void g()
   {
   
   // 查看是否有拦截器存在
     MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
     if (tmp4_1 == null)
     {
         CGLIB$BIND_CALLBACKS(this);
         tmp4_1 = this.CGLIB$CALLBACK_0;
     }
     
     // 如果有拦截器的存在的话，直接调用拦截器的方法
     if (this.CGLIB$CALLBACK_0 != null) {
         tmp4_1.intercept(this, CGLIB$g$0$Method, CGLIB$emptyArgs, CGLIB$g$0$Proxy);
     }
     
     // 如果没有拦截器，说明不需要代理，直接调用父类方法，也就是目标类的方法
     else{
         super.g();
     }
   }
}

从上面的代码中我们可以看出
1. 代理类继承了目标类
2. 目标类中的方法在代理类中对应了两个方法,就以上面例子中的目标类中的g()方法为例，其对应的代理类中的两个方法为
- CGLIB$g$0()
- g()

public class Main {
 public static void main(String[] args) {
  System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "F:\\code");
  //实例化一个增强器，也就是cglib中的一个class generator
  Enhancer eh = new Enhancer();
  //设置目标类
  eh.setSuperclass(Target.class);
  // 设置拦截对象
  eh.setCallbacks(new Callback[]{new Interceptor(), NoOp.INSTANCE});
  eh.setCallbackFilter(new CallbackFilter() {
   @Override
   public int accept(Method method) {
    if(method.getName().equals("g"))
             // 这里返回的是上面定义的callback数组的下标，0就是我们的Interceptor对象，1是内置的NoOp对象，代表不做任何操作
    return 0;
    else return 1;
   }
  });
  // 生成代理类并返回一个实例
  Target t = (Target) eh.create();
  t.f();
  t.g();
 }
}

Target f()
I am intercept begin
Target g()
I am intercept end

public Class<?> enhance(Class<?> configClass, @Nullable ClassLoader classLoader) {
   // 如果已经实现了EnhancedConfiguration接口，说明被代理过了，直接返回
   if (EnhancedConfiguration.class.isAssignableFrom(configClass)) {
       return configClass;
   }
   // 否则调用newEnhancer方法先创建一个增强器，然后直接使用这个增强器生成代理类的字节码对象
   Class<?> enhancedClass = createClass(newEnhancer(configClass, classLoader));
   if (logger.isDebugEnabled()) {
       logger.debug(String.format("Successfully enhanced %s; enhanced class name is: %s",
                                  configClass.getName(), enhancedClass.getName()));
   }
   return enhancedClass;
}

private Enhancer newEnhancer(Class<?> configSuperClass, @Nullable ClassLoader classLoader) {
   Enhancer enhancer = new Enhancer();
   // 设置目标类
   enhancer.setSuperclass(configSuperClass);
   // 让代理类实现EnhancedConfiguration接口，这个接口继承了BeanFactoryAware接口
   // 主要两个作用：1.起到标记作用，如果实现了，代表已经被代理过了
   // 2.代理类需要访问BeanFactory，所有实现了BeanFactoryAware接口
   enhancer.setInterfaces(new Class<?>[] {EnhancedConfiguration.class});
   // 设置生成的代理类不实现factory接口
   enhancer.setUseFactory(false);
   // 设置代理类名称的生成策略
   enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
   // 代理类中引入一个BeanFactory字段
   enhancer.setStrategy(new BeanFactoryAwareGeneratorStrategy(classLoader));
   // 设置过滤器，CALLBACK_FILTER中也同时设置了拦截器
   enhancer.setCallbackFilter(CALLBACK_FILTER);
   enhancer.setCallbackTypes(CALLBACK_FILTER.getCallbackTypes());
   return enhancer;
}

// 使用增强器生成代理类的字节码对象
private Class<?> createClass(Enhancer enhancer) {
   Class<?> subclass = enhancer.createClass();
   Enhancer.registerStaticCallbacks(subclass, CALLBACKS);
   return subclass;
}

// 声明的三个拦截器
private static final Callback[] CALLBACKS = new Callback[] {
   new BeanMethodInterceptor(),
   new BeanFactoryAwareMethodInterceptor(),
   NoOp.INSTANCE
};

private static class BeanFactoryAwareMethodInterceptor implements MethodInterceptor, ConditionalCallback {

  @Override
  @Nullable
  public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
   // 在生成代理类的字节码时，使用了BeanFactoryAwareGeneratorStrategy策略
   // 这个策略会在代理类中添加一个字段，BEAN_FACTORY_FIELD = "$$beanFactory"
   Field field = ReflectionUtils.findField(obj.getClass(), BEAN_FACTORY_FIELD);
   Assert.state(field != null, "Unable to find generated BeanFactory field");
   // 此时调用的方法是setBeanFactory方法，
   // 直接通过反射将beanFactory赋值给BEAN_FACTORY_FIELD字段
   field.set(obj, args[0]);

   // Does the actual (non-CGLIB) superclass implement BeanFactoryAware?
   // If so, call its setBeanFactory() method. If not, just exit.
   // 如果目标配置类直接实现了BeanFactoryAware接口，那么直接调用目标类的setBeanFactory方法
   if (BeanFactoryAware.class.isAssignableFrom(ClassUtils.getUserClass(obj.getClass().getSuperclass()))) {
    return proxy.invokeSuper(obj, args);
   }
   return null;
  }

  @Override
  // 在调用setBeanFactory方法时才会拦截
  // 从前文我们知道，代理类是实现了实现EnhancedConfiguration接口的，
  // 这就意味着它也实现了BeanFactoryAware接口，那么在创建配置类时，
  // setBeanFactory方法就会被调用，之后会就进入到这个拦截器的intercept方法逻辑中
  public boolean isMatch(Method candidateMethod) {
   return isSetBeanFactory(candidateMethod);
  }

  public static boolean isSetBeanFactory(Method candidateMethod) {
   return (candidateMethod.getName().equals("setBeanFactory") &&
     candidateMethod.getParameterCount() == 1 &&
     BeanFactory.class == candidateMethod.getParameterTypes()[0] &&
     BeanFactoryAware.class.isAssignableFrom(candidateMethod.getDeclaringClass()));
  }
 }

public boolean isMatch(Method candidateMethod) {
   // 第一个条件，不能是Object，这个必定是满足的
   // 第二个条件，不能是setBeanFactory方法，显而易见的嘛，我们要拦截的方法实际只应该是添加了@Bean注解的方法
   // 第三个条件，添加了@Bean注解
   return (candidateMethod.getDeclaringClass() != Object.class &&
           !BeanFactoryAwareMethodInterceptor.isSetBeanFactory(candidateMethod) &&
           BeanAnnotationHelper.isBeanAnnotated(candidateMethod));
}

public Object intercept(Object enhancedConfigInstance, Method beanMethod, Object[] beanMethodArgs,
        MethodProxy cglibMethodProxy) throws Throwable {
   // 之前不是给BEAN_FACTORY_FIELD这个字段赋值了BeanFactory吗，这里就是反射获取之前赋的值
   ConfigurableBeanFactory beanFactory = getBeanFactory(enhancedConfigInstance);
   // 确定Bean的名称
   String beanName = BeanAnnotationHelper.determineBeanNameFor(beanMethod);

   // Determine whether this bean is a scoped-proxy
   // 判断这个Bean是否是一个域代理的类
   Scope scope = AnnotatedElementUtils.findMergedAnnotation(beanMethod, Scope.class);
   // 存在@Scope注解，并且开启了域代理模式
   if (scope != null && scope.proxyMode() != ScopedProxyMode.NO) {
    String scopedBeanName = ScopedProxyCreator.getTargetBeanName(beanName);
    // 域代理对象的目标对象正在被创建,什么时候会被创建？当然是使用的时候嘛
    if (beanFactory.isCurrentlyInCreation(scopedBeanName)) {
     // 使用的时候调用@Bean方法来创建这个域代理的目标对象，所以@Bean方法代理的时候针对的是域代理的目标对象，目标对象需要通过getBean的方式创建
     beanName = scopedBeanName;
    }
   }

   // 判断这个bean是否是一个factoryBean
   if (factoryContainsBean(beanFactory, BeanFactory.FACTORY_BEAN_PREFIX + beanName) &&
     factoryContainsBean(beanFactory, beanName)) {
    Object factoryBean = beanFactory.getBean(BeanFactory.FACTORY_BEAN_PREFIX + beanName);
    if (factoryBean instanceof ScopedProxyFactoryBean) {
     // ScopedProxyFactoryBean还记得吗？在进行域代理时使用的就是这个对象
     // 对于这个FactoryBean我们是不需要进行代理的，因为这个factoryBean的getObject方法
     // 只是为了得到一个类似于占位符的Bean,这个Bean只是为了让依赖它的Bean在创建的过程中不会报错
     // 所以对于这个FactoryBean我们是不需要进行代理的
     // 我们只需要保证这个FactoryBean所生成的代理对象的目标对象是通过getBean的方式创建的即可
    } else {
     // 而对于普通的FactoryBean我们需要代理其getObject方法，确保getObject方法产生的Bean是通过getBean的方式创建的
     // It is a candidate FactoryBean - go ahead with enhancement
     return enhanceFactoryBean(factoryBean, beanMethod.getReturnType(), beanFactory, beanName);
    }
   }
   // 举个例子，假设我们被@Bean标注的是A方法，当前创建的BeanName也是a，这样就符合了这个条件
   // 但是如果是这种请求，a(){b()},a方法中调用的b方法，那么此时调用b方法创建b对象时正在执行的就是a方法
   // 此时就不满足这个条件，会调用这个resolveBeanReference方法来解决方法引用
   if (isCurrentlyInvokedFactoryMethod(beanMethod)) {
    // 如果当前执行的方法就是这个被拦截的方法，（说明是在创建这个Bean的过程中）
    // 那么直接执行目标类中的方法，也就是我们在配置类中用@Bean标注的方法
    return cglibMethodProxy.invokeSuper(enhancedConfigInstance, beanMethodArgs);
   }
   // 说明不是在创建中了，而是别的地方直接调用了这个方法，这时候就需要代理了，实际调用getBean方法
   return resolveBeanReference(beanMethod, beanMethodArgs, beanFactory, beanName);

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

   // 什么时候会是alreadyInCreation？就是正在创建中，当Spring完成扫描后得到了所有的BeanDefinition
   // 那么之后就会遍历所有的BeanDefinition，根据BeanDefinition一个个的创建Bean，在创建Bean前会将这个Bean
   // 标记为正在创建的，如果是正在创建的Bean,先将其标记为非正在创建，也就是这行代码beanFactory.setCurrentlyInCreation(beanName, false)
   // 这是因为之后又会调用getBean方法，如果已经被标记为创建中了，那么在调用getBean时会报错
   boolean alreadyInCreation = beanFactory.isCurrentlyInCreation(beanName);
   try {
               // 如果是正在创建的Bean,先将其标记为非正在创建，避免后续调用getBean时报错
    if (alreadyInCreation) {
     beanFactory.setCurrentlyInCreation(beanName, false);
    }
               
               // 在调用beanMthod的时候，也就是被@Bean注解标注的方法的时候如果使用了参数，只要有一个参数为null,就直接调用getBean(beanName),否则带参数调用getBean(beanName,args)，后面通过例子解释这段代码
    boolean useArgs = !ObjectUtils.isEmpty(beanMethodArgs);
    if (useArgs && beanFactory.isSingleton(beanName)) {
     for (Object arg : beanMethodArgs) {
      if (arg == null) {
       useArgs = false;
       break;
      }
     }
    }
    Object beanInstance = (useArgs ? beanFactory.getBean(beanName, beanMethodArgs) :
      beanFactory.getBean(beanName));
               // 这里发现getBean返回的类型不是我们方法返回的类型，这意味着什么呢？
               // 在《你知道Spring是怎么解析配置类的吗？》我有提到过BeanDefinition的覆盖
               // 这个地方说明beanMethod所定义的bd被覆盖了
    if (!ClassUtils.isAssignableValue(beanMethod.getReturnType(), beanInstance)) {

     if (beanInstance.equals(null)) {
      beanInstance = null;
     } else {
      // 省略日志
      throw new IllegalStateException(msg);
     }
    }
               // 注册Bean之间的依赖关系
               // 这个method是当前执行的一个创建bean的方法
    Method currentlyInvoked = SimpleInstantiationStrategy.getCurrentlyInvokedFactoryMethod();
               // 不等于null意味着currentlyInvoked这个方法创建的bean依赖了beanName所代表的Bean
            // 在开头的例子中，currentlyInvoked就是a(),beanName就是dmzService,outBeanName就是a
    if (currentlyInvoked != null) {
     String outerBeanName = BeanAnnotationHelper.determineBeanNafanhr(currentlyInvoked);
                   // 注册的就是a跟dmzService的依赖关系，注册到容器中的dependentBeanMap中
                   // key为依赖，value为依赖所在的bean
     beanFactory.registerDependentBean(beanName, outerBeanName);
    }
    return beanInstance;
   } finally {
    if (alreadyInCreation) {
                   // 实际还在创建中，要走完整个生命周期流程
     beanFactory.setCurrentlyInCreation(beanName, true);
    }
   }
  }

@Configuration
@EnableAspectJAutoProxy
public class Config {
   @Bean
   @Scope(value = WebApplicationContext.SCOPE_REQUEST,proxyMode = ScopedProxyMode.TARGET_CLASS)
   public DmzService dmzService() {
       return new DmzService();
   }
}

@RestController
@RequestMapping("/test")
public class Controller {

   DmzService dmzService;

   @Autowired
   public void setDmzService(DmzService dmzService) {
       this.dmzService = dmzService;
   }

   @GetMapping("/get")
   public ResponseEntity<?> get() {
       System.out.println(dmzService);
       return ResponseEntity.ok().build();
   }
}

// 判断这个Bean是否是一个域代理的类
Scope scope = AnnotatedElementUtils.findMergedAnnotation(beanMethod, Scope.class);
// 存在@Scope注解，并且开启了域代理模式
if (scope != null && scope.proxyMode() != ScopedProxyMode.NO) {
   String scopedBeanName = ScopedProxyCreator.getTargetBeanName(beanName);
   // 域代理对象的目标对象正在被创建,什么时候会被创建？当然是使用的时候嘛
   if (beanFactory.isCurrentlyInCreation(scopedBeanName)) {
       // 使用的时候调用@Bean方法来创建这个域代理的目标对象，所以@Bean方法代理的时候针对的是域代理的目标对象
       beanName = scopedBeanName;
   }
}

if (alreadyInCreation) {
   beanFactory.setCurrentlyInCreation(beanName, false);
}

@ComponentScan(value = "com.dmz.spring.first")
@Configuration
public class Config {
 @Bean
 public A a(){
  return new A();
 }

 @Bean
 public B b(){
  a();
  return new B();
 }
}

class A{
 B b;

 @Autowired
 public void setB(B b) {
  this.b = b;
 }
}
class B{

}

@Configuration
public class AnotherConfig {
 @Bean
 public DmzService dmzService(IndexService indexService) {
  return new DmzService(indexService);
 }

 @Bean
 public OrderService orderService() {
  DmzService dmzService = dmzService(null);
  return dmzService.createOrder();
 }
}


@Component
public class IndexService {
}

public class DmzService {
 public DmzService(IndexService indexService) {

 }

 public OrderService createOrder() {
  return new OrderService();
 }
}

public class OrderService {
}

@Configuration
public class AnotherConfig {
 
 @Autowired
 ApplicationContext applicationContext;
 
 @Bean
 public DmzService dmzService(IndexService indexService) {
  return new DmzService(indexService);
 }

 @Bean
 public OrderService orderService() {
  DmzService dmzService = (DmzService) applicationContext.getBean("dmzService");
  return dmzService.createOrder();
 }
}

@Configuration
public class AnotherConfig {
 @Bean
 public DmzService dmzService(){
  return new DmzService();
 }

 @Bean
 public OrderService orderService(){
  return new OrderService(dmzService());
 }
}