AbstractAutoProxyCreator创建AOP代理

发表于 分类于 Waline： 阅读次数：

Spring 通过 AbstractAutoProxyCreator 来创建 AOP 代理，AbstractAutoProxyCreator 是一个抽象类，它实现了 BeanPostProcessor 接口，用于在 bean 初始化完成之后创建它的代理

AbstractAutoProxyCreator 的类继承结构如下图所示（这里忽略了 Aware 相关的接口，不影响后续理解）：

image-20200416012520203

考虑普通的创建代理的流程，我们只需要关注 BeanPostProcessor 接口。回顾下 BeanPostProcessor 接口，它可以用于在 bean 的初始化前后对 bean 进行处理，可参考下图理解

image-20200402015737100

若要创建 bean 的代理，可通过 BeanPostProcessor 的 postProcessAfterInitialization 回调方法来实现。在调用 postProcessAfterInitialization 方法时，bean 已经完成了实例化、属性填充、初始化等操作，是一个可直接使用的实例。

1
2
3
4
5
6
7
8
9
10
11
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
   if (bean != null) {
      // 获取唯一的key
      Object cacheKey = getCacheKey(bean.getClass(), beanName);
      // 如果没有提前创建代理，则在此创建
      if (!this.earlyProxyReferences.contains(cacheKey)) {
         return wrapIfNecessary(bean, beanName, cacheKey);
      }
   }
   return bean;
}

在解决循环依赖时，还会触发提前创建代理。下面先看下提前创建代理的情况

提前创建代理

所谓提前创建代理，是指的下面这种情况：

为了解决循环依赖问题，在 populateBean 之前，如果允许提前暴露，spring 会将实例化好的 bean 放入 singletonFactory 中。

1
2
3
4
5
6
7
8
9
10
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
      isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
   if (logger.isTraceEnabled()) {
      logger.trace("Eagerly caching bean '" + beanName +
            "' to allow for resolving potential circular references");
   }
   // 添加bean对应的ObjectFactory，用于创建singleton bean，以及解决循环依赖
   addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

循环依赖最终解决时会通过 singletonFactory 获取依赖的 bean，进而触发到 getEarlyBeanReference 方法的调用。

1
2
// 通过工厂创建实例
singletonObject = singletonFactory.getObject();

此时也应该返回代理后的实例，这也就需要提前创建代理。要在此创建代理，AbstractAutoProxyCreator 需要实现 SmartInstantiationAwareBeanPostProcessor 的 getEarlyBeanReference 方法。

1
2
3
4
5
6
7
8
9
10
11
12
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
   Object exposedObject = bean;
   if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
      for (BeanPostProcessor bp : getBeanPostProcessors()) {
         if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
            SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
            exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
         }
      }
   }
   return exposedObject;
}

getEarlyBeanReference 方法的实现如下

1
2
3
4
5
6
7
public Object getEarlyBeanReference(Object bean, String beanName) {
   Object cacheKey = getCacheKey(bean.getClass(), beanName);
   if (!this.earlyProxyReferences.contains(cacheKey)) {
      this.earlyProxyReferences.add(cacheKey);
   }
   return wrapIfNecessary(bean, beanName, cacheKey);
}

wrapIfNecessary 方法是一个公用的创建代理方法，这个在后面再具体看

正常流程创建代理

如果没有提前创建代理，则走正常的流程，在 postProcessAfterInitialization 方法中处理。此时 if (!this.earlyProxyReferences.contains(cacheKey)) 判断通过，会走 wrapIfNecessary(bean, beanName, cacheKey) 创建代理。

1
2
3
4
5
6
7
8
9
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
   if (bean != null) {
      Object cacheKey = getCacheKey(bean.getClass(), beanName);
      if (!this.earlyProxyReferences.contains(cacheKey)) {
         return wrapIfNecessary(bean, beanName, cacheKey);
      }
   }
   return bean;
}

下面主要看下 wrapIfNecessary 方法的实现。首先是一些不需要创建代理的情况判断

1
2
3
4
5
6
7
8
9
10
if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
   return bean;
}
if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
   return bean;
}
if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
   this.advisedBeans.put(cacheKey, Boolean.FALSE);
   return bean;
}

然后会走到创建代理流程。先获取 Advice 和 Advisor

1
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);

具体的实现交给了子类，比如 BeanNameAutoProxyCreator 是根据 beanName 去匹配决定是否进行代理，它的实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
protected Object[] getAdvicesAndAdvisorsForBean(
      Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {

   if (this.beanNames != null) {
      for (String mappedName : this.beanNames) {
         if (FactoryBean.class.isAssignableFrom(beanClass)) {
            if (!mappedName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
               continue;
            }
            mappedName = mappedName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
         }
         // 判断beanName是否与配置的值匹配
         if (isMatch(beanName, mappedName)) {
            return PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS;
         }
         BeanFactory beanFactory = getBeanFactory();
         if (beanFactory != null) {
            String[] aliases = beanFactory.getAliases(beanName);
            for (String alias : aliases) {
               // 用别名去判断
               if (isMatch(alias, mappedName)) {
                  return PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS;
               }
            }
         }
      }
   }
   // 都不匹配，那不需要生成代理了
   return DO_NOT_PROXY;
}

接下来是创建 AOP 代理

1
2
Object proxy = createProxy(
      bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));

它的实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
      @Nullable Object[] specificInterceptors, TargetSource targetSource) {

   // 这个先不管
   if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
      AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
   }

   // 创建ProxyFactory
   ProxyFactory proxyFactory = new ProxyFactory();
   // 复制属性值
   proxyFactory.copyFrom(this);

   // 是代理目标类还是目标接口，用于后面区分使用哪种代理实现，jdk的或者cglib的
   if (!proxyFactory.isProxyTargetClass()) {
      if (shouldProxyTargetClass(beanClass, beanName)) {
         proxyFactory.setProxyTargetClass(true);
      }
      else {
         evaluateProxyInterfaces(beanClass, proxyFactory);
      }
   }

   // 构建Advisor
   Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
  
   // 配置proxyFactory
   proxyFactory.addAdvisors(advisors);
   proxyFactory.setTargetSource(targetSource);
   
   // 自定义proxyFactory，子类可以去扩展
   customizeProxyFactory(proxyFactory);

   // 是否冻结配置，如果冻结了advice就不能再修改了
   proxyFactory.setFrozen(this.freezeProxy);
  
   // Advisors是否已经针对目标类过滤过了
   if (advisorsPreFiltered()) {
      proxyFactory.setPreFiltered(true);
   }

   // 生成代理
   return proxyFactory.getProxy(getProxyClassLoader());
}

getProxy 有两种实现：jdk 代理和 cglib 代理。它是通过 AopProxyFactory 来判断使用何种方式的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
   // 使用 cglib 代理的前提
   if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
      Class<?> targetClass = config.getTargetClass();
      if (targetClass == null) {
         throw new AopConfigException("TargetSource cannot determine target class: " +
               "Either an interface or a target is required for proxy creation.");
      }
      if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
         return new JdkDynamicAopProxy(config);
      }
      return new ObjenesisCglibAopProxy(config);
   }
   // 否则使用 jdk 代理
   else {
      return new JdkDynamicAopProxy(config);
   }
}

若要使用 cglib 代理，目标类不能是接口，并且不能是 jdk 产生的的代理类，另外还需满足以下条件之一

  1. optimize 设置为 true

    1
    2
    3
    4
    5
    6
    /**
     * 代理是否应进行优化.
     */
    public boolean isOptimize() {
       return this.optimize;
    }

  2. proxyTargetClass 设置为 true

    1
    2
    3
    4
    5
    6
    /**
     * 是否直接代理目标类以及任何接口.
     */
    public boolean isProxyTargetClass() {
       return this.proxyTargetClass;
    }

  3. 代理的接口为空，或者仅包含 SpringProxy 接口

    1
    2
    3
    4
    private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
       Class<?>[] ifcs = config.getProxiedInterfaces();
       return (ifcs.length == 0 || (ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0])));
    }
相关文章
  • 2020-04-06
    Spring的InstantiationAware后处理器

    InstantiationAwareBeanPostProcessor 是 BeanPostProcessor 的子接口，新增了一个实例化之前（BeforeInstantiation）的回调、一个实例化之后（AfterInstantiation）填充 property 之前的回调

  • 2020-03-31
    Spring Bean的创建过程

    当调用 BeanFactory.getBean 方法获取 Bean 时，如果 Bean 还未创建，则会触发 Bean 的创建，本文主要关注 Bean 的创建过程。

  • 2020-04-03
    Spring对Aware接口的处理

    Spring 中定义了一个 Aware 接口，用于表示一个 bean 可以通过回调的方式接收 Spring 容器的通知。该接口并未定义具体的方法，而是交给子类决定，通常只包含一个只接收单个入参并且返回结果为 void 的方法。

  • 2020-04-18
    dubbo的Reference注解是如何生效的

    在 dubbo的Reference注解实现原理 中提到，@Reference 注解用于实现 RPC client 代理的自动注入，这是通过 ReferenceAnnotationBeanPostProcessor 来实现的。若要让其生效，还需要在这之前将其注册到 BeanFactory 中。

  • 2020-03-27
    Spring Bean的获取过程

    Bean 的创建与获取是一个比较复杂的过程，本文主要关注 bean 获取的过程。