Spring系列之AOP(3)——AnnotationAwareAspectJAutoProxyCreator创建代理

1、时序图

图片.png

2、源码分析

(1)、AnnotationAwareAspectJAutoProxyCreator

AnnotationAwareAspectJAutoProxyCreator实现了BeanPostProcessor接口，而实现Bean-PostProcessor后，当Spring加载这个Bean时会在实例化前调用其postProcessAfterInitialization方法

图片.png

//AbstractAutoProxyCreator
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean != null) {
                        // 根据给定的bean 的class 和name 构建出个key ，格式：beanClassName_beanName
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            if (!this.earlyProxyReferences.containsKey(cacheKey)) {
                                 // 如果它适合被代理,则需要封装指定bean。
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
} 

protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        // 如果已经 处理过
               if (beanName != null && this.targetSourcedBeans.containsKey(beanName)) {
            return bean;
        }
                //无需增强
        if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            return bean;
        }
               // 给定的bean 类是否代表一个基础设施类，基础设施类不应代理,或者配置了指定bean 不需要自动代理
        if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }
 
        // Create proxy if we have advice.
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
                 // 如果获取到了增强则需要针对增强创建代理
        if (specificInterceptors != DO_NOT_PROXY) {
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
                        //创建代理
            Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
            this.proxyTypes.put(cacheKey, proxy.getClass());
            return proxy;
        }
 
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
}

创建代理
（1）获取当前类中的属性。
（2）添加代理接口。
（3）封装Advisor并加入到ProxyFactory中。
（4）设置要代理的类。
（5）当然在Spring中还为子类提供了定制的函数customizeProxyFactory，子类可以在此函数中进行对ProxyFactory的进一步封装。
（6）进行获取代理操作。
其中，封装Advisor并加入到ProxyFactory中以及创建代理是两个相对繁琐的过程，可以通过ProxyFactory提供的addAdvisor方法直接将增强器置入代理创建工厂中，但是将拦截器封装为增强器还是需要一定的逻辑的。

//AbstractAutoProxyCreator
protected Object createProxy(
            Class beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
 
        ProxyFactory proxyFactory = new ProxyFactory();
        // Copy our properties (proxyTargetClass etc) inherited from ProxyConfig.
 //获取当前类中的属性
        proxyFactory.copyFrom(this);
  //决定对于给定的bean 是否应该使用targetClass 而不是他的接口代理, 
 //检查proxyTargeClass 设置以及preserveTargetClass 属性
        if (!shouldProxyTargetClass(beanClass, beanName)) {
            // Must allow for introductions; can't just set interfaces to
            // the target's interfaces only.
            Class[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, this.proxyClassLoader);
            for (Class targetInterface : targetInterfaces) {
                proxyFactory.addInterface(targetInterface);
            }
        }
 
        Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
        for (Advisor advisor : advisors) {
            proxyFactory.addAdvisor(advisor);
        }
 
        proxyFactory.setTargetSource(targetSource);
        customizeProxyFactory(proxyFactory);
 
        proxyFactory.setFrozen(this.freezeProxy);
        if (advisorsPreFiltered()) {
            proxyFactory.setPreFiltered(true);
        }
  //ProxyFactory的getProxy方法，默认也是由DefaultAopProxyFactory的createAopProxy方法实现，同ProxyFactoryBean中
        return proxyFactory.getProxy(this.proxyClassLoader);
    }
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
}

DefaultAopProxyFactory中createAopProxy方法，调用JdkDynamicAopProxy或者ObjenesisCglibAopProxy

@Override
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        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);
        }
        else {
            return new JdkDynamicAopProxy(config);
        }
    }

AbstractAutoProxyCreator 封装Advisor并加入到ProxyFactory中

protected Advisor[] buildAdvisors(String beanName, Object[] specificInterceptors) {
        // Handle prototypes correctly...
        Advisor[] commonInterceptors = resolveInterceptorNames();
 
        List