代理技术分为很多种，如 Java 的动态代理 Proxy，还有基于 ASM 框架的 CGLIB 代理

一个 Demo

我们先看一个 Demo，这里的 AppConfig 并没有使用 @Configuration 注解

  1. @ComponentScan("org.wesoft.spring.cglib")
  2. public class AppConfig {
  3.     @Bean
  4.     public Foo foo(){
  5.         System.out.println("foo init");
  6.         return new Foo();
  7.     }
  8.     @Bean
  9.     public Bar bar(){
  10.         System.out.println("bar init");
  11.         foo();
  12.         return new Bar();
  13.     }
  14. }
  16. public class App {
  17.     public static void main(String[] args) {
  18.         AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();
  19.         ac.register(AppConfig.class);
  20.         ac.refresh();
  22.         System.out.println(ac.getBean(AppConfig.class));
  23.     }
  24. }
  26. foo init
  27. bar init
  28. foo init
  29. org.wesoft.spring.cglib.AppConfig@71bbf57e

当我们执行 main 方法的时候，可以看到 foo init，打印了两次，的确这是我们预期的，因为我们在 bar 中又调用了 foo 方法，但是，这样好么？foo 方法不应该是单例的么？为什么还会被实例化呢？

使用 @Configuration 注解

  1. @Configuration
  2. @ComponentScan("org.wesoft.spring.cglib")
  3. public class AppConfig {
  4.     @Bean
  5.     public Foo foo(){
  6.         System.out.println("foo init");
  7.         return new Foo();
  8.     }
  9.     @Bean
  10.     public Bar bar(){
  11.         System.out.println("bar init");
  12.         foo();
  13.         return new Bar();
  14.     }
  15. }
  17. public class App {
  18.     public static void main(String[] args) {
  19.         AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();
  20.         ac.register(AppConfig.class);
  21.         ac.refresh();
  23.         // 如果加上 @Configuration 那么 这个类就被代理了
  24.         System.out.println(ac.getBean(AppConfig.class));
  25.     }
  26. }
  28. foo init
  29. bar init
  30. org.wesoft.spring.cglib.AppConfig$$EnhancerBySpringCGLIB$$623e8cd1@711f39f9

此时，我们 foo init 只打印了一次，我们在看 AppConfig，它被 CGLIB 代理了

所以我们知道了 @Configuration 注意的意义是：让 AppConfig（配置类）保证实现 Spring 的单例原则，所以进行了代理，保证 @Bean 产生的对象都是单例的

那么 @Configuration 是如何实现代理的呢？

CGLIB 代理

什么是 CGLIB 代理，它的实现是怎样的呢？和 JDK 动态代理有什么区别呢？

JDK 动态代理

JDK 动态代理是基于聚合，也就是针对实现了某一接口的类

CGLIB 代理

CGLIB 代理是基于继承，它可以实现某一个类的代理

CGLIB 案例

简单的实现一个类的 CGLIB 代理，在原方法前后各增加了一句话

  1. public class A {
  2.     public void print() {
  3.         System.out.println("hello cglib");
  4.     }
  5. }
  7. public static void main(String[] args) throws IllegalAccessException, InstantiationException {
  8.     Enhancer enhancer = new Enhancer();
  9.     enhancer.setSuperclass(A.class); // 设置父类
  10.     enhancer.setCallback(new MethodInterceptor() {
  11.         @Override
  12.         public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
  13.             System.out.println("cglib begin");
  14.             Object returnType = methodProxy.invokeSuper(o, objects);
  15.             System.out.println("cglib end");
  16.             return returnType;
  17.         }
  18.     });
  19.     A proxy = (A) enhancer.create();
  20.     proxy.print();
  21. }
  24. // 输出结果
  25. cglib begin
  26. hello cglib
  27. cglib end

Spring 的 CGLIB 实现

通过这行代码完成了 CGLIB 代理，实现类是 ConfigurationClassPostProcessor

  1. invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
  3. private static void invokeBeanFactoryPostProcessors(
  4.     Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {
  6.     for (BeanFactoryPostProcessor postProcessor : postProcessors) {
  7.         postProcessor.postProcessBeanFactory(beanFactory);
  8.     }
  9. }
  11. @Override
  12. public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) {
  13.     int factoryId = System.identityHashCode(beanFactory);
  14.     if (this.factoriesPostProcessed.contains(factoryId)) {
  15.         throw new IllegalStateException(
  16.             "postProcessBeanFactory already called on this post-processor against " + beanFactory);
  17.     }
  18.     this.factoriesPostProcessed.add(factoryId);
  19.     if (!this.registriesPostProcessed.contains(factoryId)) {
  20.         // BeanDefinitionRegistryPostProcessor hook apparently not supported...
  21.         // Simply call processConfigurationClasses lazily at this point then.
  22.         processConfigBeanDefinitions((BeanDefinitionRegistry) beanFactory);
  23.     }
  25.     // ★★★ 关键代码：进行 CGLIB 动态代理
  26.     enhanceConfigurationClasses(beanFactory);
  27.     // ★★★ 添加 BeanPostProcessor
  28.     beanFactory.addBeanPostProcessor(new ImportAwareBeanPostProcessor(beanFactory));
  29. }

我们来研究一下 enhanceConfigurationClasses(beanFactory); 这段逻辑

  1. public void enhanceConfigurationClasses(ConfigurableListableBeanFactory beanFactory) {
  2.     Map<String, AbstractBeanDefinition> configBeanDefs = new LinkedHashMap<>();
  3.     for (String beanName : beanFactory.getBeanDefinitionNames()) {
  4.         BeanDefinition beanDef = beanFactory.getBeanDefinition(beanName);
  5.         // AppConfig 上是否配置了 @Configuration
  6.         if (ConfigurationClassUtils.isFullConfigurationClass(beanDef)) {
  7.             // 不能是一个抽象类
  8.             if (!(beanDef instanceof AbstractBeanDefinition)) {
  9.                 throw new BeanDefinitionStoreException("Cannot enhance @Configuration bean definition '" +
  10.                                                        beanName + "' since it is not stored in an AbstractBeanDefinition subclass");
  11.             }
  12.             else if (logger.isInfoEnabled() && beanFactory.containsSingleton(beanName)) {
  13.                 logger.info("Cannot enhance @Configuration bean definition '" + beanName +
  14.                             "' since its singleton instance has been created too early. The typical cause " +
  15.                             "is a non-static @Bean method with a BeanDefinitionRegistryPostProcessor " +
  16.                             "return type: Consider declaring such methods as 'static'.");
  17.             }
  18.             // 将 配置类 放入 map 中
  19.             configBeanDefs.put(beanName, (AbstractBeanDefinition) beanDef);
  20.         }
  21.     }
  23.     // 如果 没有一个是 @Configuration 的 全配置类（full），就直接返回
  24.     if (configBeanDefs.isEmpty()) {
  25.         // nothing to enhance -> return immediately
  26.         return;
  27.     }
  29.     // 开始完成代理
  30.     ConfigurationClassEnhancer enhancer = new ConfigurationClassEnhancer();
  31.     for (Map.Entry<String, AbstractBeanDefinition> entry : configBeanDefs.entrySet()) {
  32.         AbstractBeanDefinition beanDef = entry.getValue();
  33.         // If a @Configuration class gets proxied, always proxy the target class
  34.         beanDef.setAttribute(AutoProxyUtils.PRESERVE_TARGET_CLASS_ATTRIBUTE, Boolean.TRUE);
  35.         try {
  36.             // Set enhanced subclass of the user-specified bean class
  37.             // 原 AppConfig 类
  38.             Class<?> configClass = beanDef.resolveBeanClass(this.beanClassLoader);
  39.             if (configClass != null) {
  40.                 // 代理的 AppConfig 类
  41.                 Class<?> enhancedClass = enhancer.enhance(configClass, this.beanClassLoader);
  42.                 if (configClass != enhancedClass) {
  43.                     if (logger.isTraceEnabled()) {
  44.                         logger.trace(String.format("Replacing bean definition '%s' existing class '%s' with " +
  45.                                                    "enhanced class '%s'", entry.getKey(), configClass.getName(), enhancedClass.getName()));
  46.                     }
  47.                     // 关键代码：修改 BD 中的 beanClass 为 代理类
  48.                     beanDef.setBeanClass(enhancedClass);
  49.                 }
  50.             }
  51.         }
  52.         catch (Throwable ex) {
  53.             throw new IllegalStateException("Cannot load configuration class: " + beanDef.getBeanClassName(), ex);
  54.         }
  55.     }
  56. }
  1. @Override
  2. @Nullable
  3. public Object intercept(Object enhancedConfigInstance, Method beanMethod, Object[] beanMethodArgs,
  4.                         MethodProxy cglibMethodProxy) throws Throwable {
  6.     ConfigurableBeanFactory beanFactory = getBeanFactory(enhancedConfigInstance);
  7.     String beanName = BeanAnnotationHelper.determineBeanNameFor(beanMethod);
  9.     // Determine whether this bean is a scoped-proxy
  10.     if (BeanAnnotationHelper.isScopedProxy(beanMethod)) {
  11.         String scopedBeanName = ScopedProxyCreator.getTargetBeanName(beanName);
  12.         if (beanFactory.isCurrentlyInCreation(scopedBeanName)) {
  13.             beanName = scopedBeanName;
  14.         }
  15.     }
  17.     // To handle the case of an inter-bean method reference, we must explicitly check the
  18.     // container for already cached instances.
  20.     // First, check to see if the requested bean is a FactoryBean. If so, create a subclass
  21.     // proxy that intercepts calls to getObject() and returns any cached bean instance.
  22.     // This ensures that the semantics of calling a FactoryBean from within @Bean methods
  23.     // is the same as that of referring to a FactoryBean within XML. See SPR-6602.
  24.     // 是不是一个 factoryBean
  25.     if (factoryContainsBean(beanFactory, BeanFactory.FACTORY_BEAN_PREFIX + beanName) &&
  26.         factoryContainsBean(beanFactory, beanName)) {
  27.         Object factoryBean = beanFactory.getBean(BeanFactory.FACTORY_BEAN_PREFIX + beanName);
  28.         if (factoryBean instanceof ScopedProxyFactoryBean) {
  29.             // Scoped proxy factory beans are a special case and should not be further proxied
  30.         }
  31.         else {
  32.             // It is a candidate FactoryBean - go ahead with enhancement
  33.             return enhanceFactoryBean(factoryBean, beanMethod.getReturnType(), beanFactory, beanName);
  34.         }
  35.     }
  37.     // 是否是当前要执行的工厂方法
  38.     if (isCurrentlyInvokedFactoryMethod(beanMethod)) {
  39.         // The factory is calling the bean method in order to instantiate and register the bean
  40.         // (i.e. via a getBean() call) -> invoke the super implementation of the method to actually
  41.         // create the bean instance.
  42.         if (logger.isInfoEnabled() &&
  43.             BeanFactoryPostProcessor.class.isAssignableFrom(beanMethod.getReturnType())) {
  44.             logger.info(String.format("@Bean method %s.%s is non-static and returns an object " +
  45.                                       "assignable to Spring's BeanFactoryPostProcessor interface. This will " +
  46.                                       "result in a failure to process annotations such as @Autowired, " +
  47.                                       "@Resource and @PostConstruct within the method's declaring " +
  48.                                       "@Configuration class. Add the 'static' modifier to this method to avoid " +
  49.                                       "these container lifecycle issues; see @Bean javadoc for complete details.",
  50.                                       beanMethod.getDeclaringClass().getSimpleName(), beanMethod.getName()));
  51.         }
  52.         // 执行父类的方法
  53.         return cglibMethodProxy.invokeSuper(enhancedConfigInstance, beanMethodArgs);
  54.     }
  55.     // 执行 bean 自己的方法，就是从 spring 中 getBean()
  56.     // 从而保证了单例
  57.     return resolveBeanReference(beanMethod, beanMethodArgs, beanFactory, beanName);
  58. }

CGLIB @Bean 方法的代理逻辑

  1. 先 getBean，如果 bean 不存在则进行创建，如果是 @Bean 方法（工厂方法）则创建时，先将其加入正在创建的 ThreadLocal 中
  2. 执行 @Bean 方法
  3. 判断当前执行 bean 方法是否是当前线程正在创建的 bean 方法
    1. 如果当前执行 bean 方法是当前线程正在创建的 bean 方法，直接调用其父类的方法，然后再从 ThreadLocal 将其剔除
    2. 如果当前执行 bean 方法不是当前线程正在创建的 bean 方法，如，方法中调用其他 bean 方法，
      1. 则会从单例池中寻找所调用的 bean 方法
      2. 给当前正在执行的 bean 方法注册一个所调用的 bean 方法的依赖关系
      3. 返回从单例池找到的 bean 方法（则不在调用父类的方法，就保证了单例）