Spring-AOP【五】bean实例化的增强核心逻辑

引言

通过上一篇文章的分析，我们知道AOP的具体实现在AnnotationAwareAspectJAutoProxyCreator类中。
贴上它的类继承关系图：

源码分析入口在其父类AbstractAutoProxyCreator的postProcessAfterInitialization(@Nullable Object bean, String beanName)方法中：

//如果bean被子类标识为一个代理，则使用已配置的拦截器创建一个代理。
    @Override
    public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
        if (bean != null) {
            //根据给定的bean的class和name 获取key,有三种可能：beanName；bean.getClass()；"&"+beanName
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            // 如果没有代理过cacheKey
            if (this.earlyProxyReferences.remove(cacheKey) != bean) {
                //如果需要，就为bean生成代理对象
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }

进入wrapIfNecessary方法：

//如果需要，包装给定的bean，例如，如果它符合代理的条件。
    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        // 已经处理过的bean
        if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
            return bean;
        }
        // 不需要增强的bean
        if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            return bean;
        }
        //基础bean不需要增强：Advice；Pointcut；Advisor；AopInfrastructureBean
        // beanName以beanClassName开头且以“.ORIGINAL”结尾的原始类不需要代理
        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);

        // DO_NOT_PROXY = 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;
        }

        // 如果没有增强的方法，则返回原始bean实例
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }

注释已经写的比较清楚了，主要有两大步骤：

获取指定bean的增强方法
创建代理对象

1、getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null)

获取指定bean的增强方法：

/**
    * 返回是否要代理给定的bean，应用哪些额外的advices(例如AOP联盟拦截器)和advisors。
    *
    * @param beanClass          被通知的beanClass
    * @param beanName           bean名称
    * @param customTargetSource getCustomTargetSource方法返回的TargetSource:可能会被忽略。如果没有使用自定义目标源，则为null。
    * @return 特定bean的附加拦截器数组;
    * 一个空数组，如果没有额外的拦截器，但只有常见的;
    * 如果根本没有代理，即使使用公共拦截器也不行则为null。
    * See constants DO_NOT_PROXY and PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS.
    * @throws BeansException in case of errors
    * @see #DO_NOT_PROXY = null
    * @see #PROXY_WITHOUT_ADDITIONAL_INTERCEPTORS = new Object[0]
    */
   @Nullable
   protected abstract Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName,
                                                            @Nullable TargetSource customTargetSource) throws BeansException;

最终由子类实现，这里为AbstractAdvisorAutoProxyCreator,这里的细节后期分析，本篇先把主要流程走完。
下面看创建代理对象。

2、createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean))

创建代理对象：

//为给定bean创建AOP代理。
    protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
                                 @Nullable Object[] specificInterceptors, TargetSource targetSource) {

        // 如果bean工厂为ConfigurableListableBeanFactory
        if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
            //设置BeanDefinition中的originalTargetClass属性
            AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
        }

        //获取代理工厂
        ProxyFactory proxyFactory = new ProxyFactory();
        //复制配置。
        proxyFactory.copyFrom(this);

        // 决定对给定的 bean 是否应该使用 targetClass 而不是他的接口代理，
        // 检查 proxyTargetClass 设置以及 preserveTargetClass 属性
        if (!proxyFactory.isProxyTargetClass()) {
            if (shouldProxyTargetClass(beanClass, beanName)) {
                proxyFactory.setProxyTargetClass(true);
            } else {
                // 检测 beanClass 是否实现了接口，若未实现，
                // 则将proxyFactory 的成员变量 proxyTargetClass 设为 true
                evaluateProxyInterfaces(beanClass, proxyFactory);
            }
        }

        //确定给定bean的Advisor，包括特定的拦截器和公共拦截器，所有这些都适应于Advisor接口。
        //specificInterceptors 中若包含有 Advice，此处将 Advice 转为 Advisor
        Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
        //加入增强器
        proxyFactory.addAdvisors(advisors);
        //设置要代理的类
        proxyFactory.setTargetSource(targetSource);
        //定制代理
        customizeProxyFactory(proxyFactory);
        // 用来控制代理过程被配置之后，是否还允许修改通知。
        // 默认值为 false （即在代理被配置之后，不允许修改代理的配置）
        proxyFactory.setFrozen(this.freezeProxy);

        // 是否跳过ClassFilter检查
        if (advisorsPreFiltered()) {
            proxyFactory.setPreFiltered(true);
        }
        //创建代理
        return proxyFactory.getProxy(getProxyClassLoader());
    }