Spring AOP的总体流程

• 1、注册解析AOP的服务
• 2、解析和加载横切逻辑
• 3、将横切逻辑织入目标Bean中

AnnotationAwareAspectJAutoProxyCreator继承体系图

AnnotationAwareAspectJAutoProxyCreator既实现了SmartInstantiationAwareBeanPostProcessor 又实现了BeanFactoryAware。就可以对容器做一些事情。

AnnotationAwareAspectJAutoProxyCreator 实现了Order接口，所以先于普通的BeanPostProcessor注册，并对普通BeanPostProcessor也能起作用。

AnnotationAwareAspectJAutoProxyCreator 是InstantiationAwareBeanPostProcessor，会在Bean被创建之前，在resolveBeforeInstantiation中被调用。

Spring Aop主要是通过AbstractAutoProxyCreator实现的BeanPostProcessor、InstantiationAwareBeanPostProcessor以及SmartInstantiationAwareBeanPostProcessor接口里面的后置处理器方法，来介入到Spring IOC容器的Bean的实例化以及初始化的过程中对Bean进行AOP的处理的。

所以AbstractAutoProxyCreator类里面的实现的容器级别的后置处理器方法便是介入分析的点：

• 横切逻辑的加载主要是在AbstractAutoProxyCreator类中的postProcessBeforeInstantiation方法中，该方法是在Bean的实例化之前被调用的。

• 横切逻辑织入目标Bean中主要是在AbstractAutoProxyCreator类中的postProcessAfterInitialization方法中，该方法是在Bean的实例化之后被调用的。

Spring AOP横切逻辑的织入过程：

在Spring5AOP——AbstractAutoProxyCreator横切逻辑织入目标Bean中文章中，分析了横切逻辑织入目标Bean中，本文就分析AbstractAutoProxyCreator类中wrapIfNecessary方法中的createProxy方法，创建AOP动态代理。

wrapIfNecessary

• 判断当前bean是否需要被代理，如果需要则创建动态代理类。

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
        implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {

    /**
     * Spring实现Bean代理的核心方法。wrapIfNecessary在两处会被调用，一处是getEarlyBeanReference，
     * 另一处是postProcessAfterInitialization
     */
    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        //已经被处理过
        // 1.判断当前bean是否在targetSourcedBeans缓存中存在（已经处理过），如果存在，则直接返回当前bean
        if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
            return bean;
        }
        //不需要被织入逻辑的
        // 2.在advisedBeans缓存中存在，并且value为false，则代表无需处理
        if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            return bean;
        }
        //是不是基础的bean 是不是需要跳过的
        // 3.bean的类是aop基础设施类 || bean应该跳过，则标记为无需处理，并返回
        if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }

        // Create proxy if we have advice.
        // 返回匹配当前Bean的所有Advice\Advisor\Interceptor
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        // 5.如果存在增强器则创建代理
        if (specificInterceptors != DO_NOT_PROXY) {
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
            //创建Bean对应的代理，SingletonTargetSource用于封装实现类的信息
            // 5.1 创建代理对象：这边SingletonTargetSource的target属性存放的就是我们原来的bean实例（也就是被代理对象），
            // 用于最后增加逻辑执行完毕后，通过反射执行我们真正的方法时使用（method.invoke(bean, args)）
            Object proxy = createProxy(
                    bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
            // 5.2 创建完代理后，将cacheKey -> 代理类的class放到缓存
            this.proxyTypes.put(cacheKey, proxy.getClass());
            // 返回代理对象
            return proxy;
        }
        //该Bean是不需要进行代理的，下次就不需要重复生成了
        this.advisedBeans.put(cacheKey, Boolean.FALSE);
        return bean;
    }
}

• 当执行完getAdvicesAndAdvisorsForBean方法之后，就可以从候选的Advisor列表里筛选出匹配于当前Bean的Advisor列表，获取到Advisor列表之后就会接着执行后续的创建动态代理的步骤了。

• 由于getAdvicesAndAdvisorsForBean筛选出匹配的Advisor了，将该Bean对应的cacheKey写入到advisedBeans中，并将对应的值设置为true，表示对该Bean进行过Spring AOP的处理了。

• 之后就会调用createProxy方法去创建目标代理对象实例，创建好动态代理实例之后，就会动态代理实例类型给保存到proxyTypes的缓存里面，并将动态代理实例返回，这样就完成了wrapIfNecessary方法的执行。

• 如果没有getAdvicesAndAdvisorsForBean没有筛选出匹配的Advisor的话，就证明该Bean不需要织入横切逻辑，此时就会在advisedBeans里给该Bean设置对应的cacheKey和false，以表明该bean是不需要被织入的。

本文重点分析createProxy方法——创建AOP动态代理

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
        implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {

    protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
            @Nullable Object[] specificInterceptors, TargetSource targetSource) {
        //如果beanFactory是ConfigurableListableBeanFactory的类型，暴露目标类
        if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
            AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
        }
        //创建一个ProxyFactory，当前ProxyCreator在创建代理时将需要用到的字段赋值到ProxyFactory中去
        ProxyFactory proxyFactory = new ProxyFactory();
        //将 当前的AnnotationAwareAspectJAutoProxyCreator 对象的属性赋值给ProxyFactory对象
        proxyFactory.copyFrom(this);
        // 处理 proxyTargetClass 属性
        // 如果希望使用 CGLIB 来代理接口，可以配置
        // proxy-target-class="true",这样不管有没有接口，都使用 CGLIB 来生成代理：
        // <aop:config proxy-target-class="true"></aop:config>
        if (!proxyFactory.isProxyTargetClass()) {
            // 检查preserveTargetClass属性，判断beanClass是应该基于类代理还是基于接口代理
            if (shouldProxyTargetClass(beanClass, beanName)) {
                // 如果是基于类代理，则将proxyTargetClass赋值为true
                proxyFactory.setProxyTargetClass(true);
            }
            else {
                // 评估bean的代理接口
                // 1. 有接口的，调用一次或多次：proxyFactory.addInterface(ifc);
                // 2. 没有接口的，调用：proxyFactory.setProxyTargetClass(true);
                evaluateProxyInterfaces(beanClass, proxyFactory);
            }
        }

        // 这个方法主要来对前面传递进来的横切逻辑实例进行包装
        // 注意：如果 specificInterceptors 中有 Advice 和 Interceptor，它们也会被包装成 Advisor
        // 方法会整理合并得到最终的advisors （毕竟interceptorNames还指定了一些拦截器的）
        // 至于调用的先后顺序，通过方法里的applyCommonInterceptorsFirst参数可以进行设置，
        // 若applyCommonInterceptorsFirst为true，interceptorNames属性指定的Advisor优先调用。默认为true
        Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
        // 将advisors添加到proxyFactory
        proxyFactory.addAdvisors(advisors);
        // 设置要代理的类，将targetSource赋值给proxyFactory的targetSource属性，之后可以通过该属性拿到被代理的bean的实例
        proxyFactory.setTargetSource(targetSource);
        // 这个方法是交给子类的，子类可以继续去定制此proxyFactory
        customizeProxyFactory(proxyFactory);

        // 用来控制proxyFactory被配置之后，是否还允许修改通知。默认值为false（即在代理被配置之后，不允许修改代理类的配置）
        proxyFactory.setFrozen(this.freezeProxy);
        // 设置preFiltered的属性值，默认是false。子类：AbstractAdvisorAutoProxyCreator修改为true
        // preFiltered字段意思为：是否已为特定目标类筛选Advisor
        // 这个字段和DefaultAdvisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice获取所有的Advisor有关
        //CglibAopProxy和JdkDynamicAopProxy都会调用此方法，然后递归执行所有的Advisor
        if (advisorsPreFiltered()) {
            proxyFactory.setPreFiltered(true);
        }

        // 使用proxyFactory获取代理
        return proxyFactory.getProxy(getProxyClassLoader());
    }
}

evaluateProxyInterfaces(beanClass, proxyFactory)

• 根据被代理beanClass是否实现了接口，来评估是调用CGLIB还是JDK动态代理。

public class ProxyProcessorSupport extends ProxyConfig implements Ordered, BeanClassLoaderAware, AopInfrastructureBean {

    /**
     * 这里决定了如果目标类没有实现接口直接就是Cglib代理
     * 检查给定beanClass上的接口们，并交给proxyFactory处理
     */
    protected void evaluateProxyInterfaces(Class<?> beanClass, ProxyFactory proxyFactory) {
        // 找到该类实现的所有接口们
        Class<?>[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, getProxyClassLoader());
        // 标记：是否有存在合理的接口
        boolean hasReasonableProxyInterface = false;
        for (Class<?> ifc : targetInterfaces) {
            if (!isConfigurationCallbackInterface(ifc) && !isInternalLanguageInterface(ifc) &&
                    ifc.getMethods().length > 0) {
                hasReasonableProxyInterface = true;
                break;
            }
        }
        if (hasReasonableProxyInterface) {
            // Must allow for introductions; can't just set interfaces to the target's interfaces only.
            //不管接口是否合理，都将其添加进去
            for (Class<?> ifc : targetInterfaces) {
                proxyFactory.addInterface(ifc);
            }
        }
        else {
            proxyFactory.setProxyTargetClass(true);
        }
    }
}

buildAdvisors(beanName, specificInterceptors)

• 对横切逻辑实例进行包装

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
        implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {

    protected Advisor[] buildAdvisors(@Nullable String beanName, @Nullable Object[] specificInterceptors) {
        // Handle prototypes correctly...
        // 解析interceptorNames而来得Advisor数组
        Advisor[] commonInterceptors = resolveInterceptorNames();

        List<Object> allInterceptors = new ArrayList<>();
        if (specificInterceptors != null) {
            // 添加参数传进来的，即前面解析出来的advisors
            allInterceptors.addAll(Arrays.asList(specificInterceptors));
            if (commonInterceptors.length > 0) {
                // 添加拦截器
                //调用的先后顺序，通过applyCommonInterceptorsFirst参数可以进行设置，
                // 若applyCommonInterceptorsFirst为true，interceptorNames属性指定的Advisor优先调用。
                // 默认为true
                if (this.applyCommonInterceptorsFirst) {
                    allInterceptors.addAll(0, Arrays.asList(commonInterceptors));
                }
                else {
                    allInterceptors.addAll(Arrays.asList(commonInterceptors));
                }
            }
        }
        if (logger.isTraceEnabled()) {
            int nrOfCommonInterceptors = commonInterceptors.length;
            int nrOfSpecificInterceptors = (specificInterceptors != null ? specificInterceptors.length : 0);
            logger.trace("Creating implicit proxy for bean '" + beanName + "' with " + nrOfCommonInterceptors +
                    " common interceptors and " + nrOfSpecificInterceptors + " specific interceptors");
        }
        //把拦截器包装为Advisor
        Advisor[] advisors = new Advisor[allInterceptors.size()];
        for (int i = 0; i < allInterceptors.size(); i++) {
            // wrap包装
            advisors[i] = this.advisorAdapterRegistry.wrap(allInterceptors.get(i));
        }
        return advisors;
    }
}

resolveInterceptorNames

• 解析interceptorNames而来得Advisor数组

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
        implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {

    private Advisor[] resolveInterceptorNames() {
        BeanFactory bf = this.beanFactory;
        ConfigurableBeanFactory cbf = (bf instanceof ConfigurableBeanFactory ? (ConfigurableBeanFactory) bf : null);
        List<Advisor> advisors = new ArrayList<>();
        for (String beanName : this.interceptorNames) {
            if (cbf == null || !cbf.isCurrentlyInCreation(beanName)) {
                Assert.state(bf != null, "BeanFactory required for resolving interceptor names");
                Object next = bf.getBean(beanName);
                advisors.add(this.advisorAdapterRegistry.wrap(next));
            }
        }
        return advisors.toArray(new Advisor[0]);
    }
}

wrap

• this.advisorAdapterRegistry.wrap(next)
• 将满足不是正在创建中的横切逻辑实例，给统一转换成Advisor

public class DefaultAdvisorAdapterRegistry implements AdvisorAdapterRegistry, Serializable {

    @Override
    public Advisor wrap(Object adviceObject) throws UnknownAdviceTypeException {
        //如果已经是Advisor，则无需多做处理
        if (adviceObject instanceof Advisor) {
            return (Advisor) adviceObject;
        }
        if (!(adviceObject instanceof Advice)) {
            //必须是Advice类型
            throw new UnknownAdviceTypeException(adviceObject);
        }
        Advice advice = (Advice) adviceObject;
        if (advice instanceof MethodInterceptor) {
            // So well-known it doesn't even need an adapter.
            //如果是MethodInterceptor，则直接使用DefaultPointcutAdvisor进行包装
            return new DefaultPointcutAdvisor(advice);
        }
        // 否则遍历注册的适配器，如果存在支持的适配器则使用 DefaultPointcutAdvisor 进行包装
        //BeforeAdvice、AfterAdvice、ThrowsAdvice三种通知类型的支持是借助适配器模式来实现的
        //AdvisorAdapterRegistry，DefaultAdvisorAdapterRegistry和GlobalAdvisorAdapterRegistry
        //主要负责对AdvisorAdapter进行注册
        for (AdvisorAdapter adapter : this.adapters) {
            // Check that it is supported.
            if (adapter.supportsAdvice(advice)) {
                return new DefaultPointcutAdvisor(advice);
            }
        }
        throw new UnknownAdviceTypeException(advice);
    }
}

• 接着回到createProxy方法中，在执行完buildAdvisors方法之后，就能获取到所有的适配于被代理Bean的Advisor列表，

proxyFactory.getProxy

• 使用proxyFactory获取代理

public class ProxyFactory extends ProxyCreatorSupport {

    public Object getProxy(@Nullable ClassLoader classLoader) {
        // 首先获取AopProxy对象，其主要有两个实现：JdkDynamicAopProxy和ObjenesisCglibAopProxy，
        // 分别用于Jdk和Cglib代理类的生成，其getProxy()方法则用于获取具体的代理对象
        // 1.createAopProxy：创建AopProxy
        // 2.getProxy(classLoader)：获取代理对象实例
        return createAopProxy().getProxy(classLoader);
    }
}

createAopProxy()

• 首先获取AopProxy对象，其主要有两个实现：JdkDynamicAopProxy和ObjenesisCglibAopProxy

public class ProxyCreatorSupport extends AdvisedSupport {
    protected final synchronized AopProxy createAopProxy() {
        //主要是为了激活AdvisedSupportListener监听器
        if (!this.active) {
            activate();
        }
        // 2.创建AopProxy
        return getAopProxyFactory().createAopProxy(this);
    }
}

getAopProxyFactory()

• 获取AopProxyFactory

public class ProxyCreatorSupport extends AdvisedSupport {
        
    private AopProxyFactory aopProxyFactory;

    public ProxyCreatorSupport() {
        this.aopProxyFactory = new DefaultAopProxyFactory();
    }

    protected final synchronized AopProxy createAopProxy() {
        //主要是为了激活AdvisedSupportListener监听器
        if (!this.active) {
            activate();
        }
        // 2.创建AopProxy
        return getAopProxyFactory().createAopProxy(this);
    }

    public AopProxyFactory getAopProxyFactory() {
        return this.aopProxyFactory;
    }
}

createAopProxy

• createAopProxy(this)
• 创建AopProxy

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {

    @Override
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        // 1.判断使用JDK动态代理还是Cglib代理
        // optimize：用于控制通过cglib创建的代理是否使用激进的优化策略。除非完全了解AOP如何处理代理优化，
        // 否则不推荐使用这个配置，目前这个属性仅用于cglib代理，对jdk动态代理无效
        // proxyTargetClass：默认为false，设置为true时，强制使用cglib代理，设置方式：<aop:aspectj-autoproxy proxy-target-class="true" />
        // hasNoUserSuppliedProxyInterfaces：config是否存在代理接口或者只有SpringProxy一个接口
        if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
            // 拿到要被代理的对象的类型
            Class<?> targetClass = config.getTargetClass();
            if (targetClass == null) {
                // TargetSource无法确定目标类：代理创建需要接口或目标。
                throw new AopConfigException("TargetSource cannot determine target class: " +
                        "Either an interface or a target is required for proxy creation.");
            }
            // 要被代理的对象是接口 || targetClass是Proxy class 已经是个JDK的代理类（Proxy的子类，所有的JDK代理类都是此类的子类）
            // 当且仅当使用getProxyClass方法或newProxyInstance方法动态生成指定的类作为代理类时，才返回true。
            if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
                // JDK动态代理，这边的入参config(AdvisedSupport)实际上是ProxyFactory对象
                // 具体为：AbstractAutoProxyCreator中的proxyFactory.getProxy发起的调用，在ProxyCreatorSupport使用了this作为参数，
                // 调用了的本方法，这边的this就是发起调用的proxyFactory对象，而proxyFactory对象中包含了要执行的的拦截器
                return new JdkDynamicAopProxy(config);
            }
            // Cglib代理
            return new ObjenesisCglibAopProxy(config);
        }
        else {
            // JDK动态代理
            return new JdkDynamicAopProxy(config);
        }
    }

    /**
     * 判断是否有实现自定义的接口
     */
    private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
        Class<?>[] ifcs = config.getProxiedInterfaces();
        return (ifcs.length == 0 || (ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0])));
    }

}

• 这边创建 AopProxy 的参数 config（AdvisedSupport）实际上是proxyFactory 对象。

• 具体为：AbstractAutoProxyCreator 中的 proxyFactory.getProxy 发起的调用，在 ProxyCreatorSupport 使用了 this 作为参数调用了本方法，这边的 this 就是发起调用的 proxyFactory对象，而 proxyFactory 对象中包含了要执行的的拦截器（Advisor）。

• 无论是创建 JDK 动态代理还是 CGLIB 代理，都会传入 config 参数，该参数会被保存在 advised（AdvisedSupport）变量中。

JDK 动态代理、CBLIB 代理构造函数

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {

    public JdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException {
        Assert.notNull(config, "AdvisedSupport must not be null");
        if (config.getAdvisors().length == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {
            throw new AopConfigException("No advisors and no TargetSource specified");
        }
        this.advised = config;
    }
}


class ObjenesisCglibAopProxy extends CglibAopProxy {

    public ObjenesisCglibAopProxy(AdvisedSupport config) {
        super(config);
    }
}


class CglibAopProxy implements AopProxy, Serializable {
    public CglibAopProxy(AdvisedSupport config) throws AopConfigException {
        Assert.notNull(config, "AdvisedSupport must not be null");
        if (config.getAdvisors().length == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {
            throw new AopConfigException("No advisors and no TargetSource specified");
        }
        this.advised = config;
        this.advisedDispatcher = new AdvisedDispatcher(this.advised);
    }
}

getProxy(classLoader)

• 获取代理对象实例

JdkDynamicAopProxy#getProxy

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {

    @Override
    public Object getProxy(@Nullable ClassLoader classLoader) {
        if (logger.isTraceEnabled()) {
            logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
        }
        // 1.拿到要被代理对象的所有接口
        Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
        findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
        // 2.通过classLoader、接口、InvocationHandler实现类，来获取到代理对象
        return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
    }
}

最终，通过 JDK 动态代理的类被调用时，会走到 JdkDynamicAopProxy#invoke 方法。

JdkDynamicAopProxy#invoke

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {

    @Override
    @Nullable
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object oldProxy = null;
        boolean setProxyContext = false;

        TargetSource targetSource = this.advised.targetSource;
        Object target = null;

        try {
            //若是equals方法不需要代理
            if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
                // The target does not implement the equals(Object) method itself.
                return equals(args[0]);
            }
            //若是hashCode方法不需要代理
            else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
                // The target does not implement the hashCode() method itself.
                return hashCode();
            }
            // 如果当前方法是Spring织入的DecoratingProxy接口中的方法，则返回目标对象的Class类型
            else if (method.getDeclaringClass() == DecoratingProxy.class) {
                // There is only getDecoratedClass() declared -> dispatch to proxy config.
                return AopProxyUtils.ultimateTargetClass(this.advised);
            }
            //如果被代理的对象本身就实现了Advised接口，则证明该类里面的方法已经被代理了，直接执行即可
            else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
                    method.getDeclaringClass().isAssignableFrom(Advised.class)) {
                // Service invocations on ProxyConfig with the proxy config...
                return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
            }

            Object retVal;
            //是否将动态代理暴露给AopContext
            if (this.advised.exposeProxy) {
                // Make invocation available if necessary.
                oldProxy = AopContext.setCurrentProxy(proxy);
                setProxyContext = true;
            }

            // Get as late as possible to minimize the time we "own" the target,
            // in case it comes from a pool.
            //获取我们的目标对象
            target = targetSource.getTarget();
            Class<?> targetClass = (target != null ? target.getClass() : null);

            // Get the interception chain for this method.
            //把aop的advisor转化为拦截器链
            List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

            // Check whether we have any advice. If we don't, we can fallback on direct
            // reflective invocation of the target, and avoid creating a MethodInvocation.
            if (chain.isEmpty()) {
                // We can skip creating a MethodInvocation: just invoke the target directly
                // Note that the final invoker must be an InvokerInterceptor so we know it does
                // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
                // chain 是空的，说明不需要被织入横切逻辑，直接执行被代理的方法实例本身
                Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
                retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
            }
            else {
                // We need to create a method invocation...
                // 获取目标对象的调用链逻辑，并且对该链进行调用
                MethodInvocation invocation =
                        new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                // Proceed to the joinpoint through the interceptor chain.
                retVal = invocation.proceed();
            }

            // Massage return value if necessary.
            Class<?> returnType = method.getReturnType();
            if (retVal != null && retVal == target &&
                    returnType != Object.class && returnType.isInstance(proxy) &&
                    !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
                // Special case: it returned "this" and the return type of the method
                // is type-compatible. Note that we can't help if the target sets
                // a reference to itself in another returned object.
                // 判断返回值如果为目标对象，并且当前方法的返回值类型是当前代理对象的类型，那么就将
                // 当前代理对象返回。这里的逻辑的实际意思简单的说就是，如果返回值是目标对象，那么
                // 就将当前代理对象返回
                retVal = proxy;
            }
            else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
                // 如果返回值满足其为空，不是Void类型，并且是基本数据类型，那么就抛出异常，
                // 因为基本数据类型的返回值必然不为空
                throw new AopInvocationException(
                        "Null return value from advice does not match primitive return type for: " + method);
            }
            return retVal;
        }
        finally {
            if (target != null && !targetSource.isStatic()) {
                // Must have come from TargetSource.
                // 如果TargetSource不是静态的，
                // 则调用其releaseTarget()方法将生成的目标对象释放
                targetSource.releaseTarget(target);
            }
            if (setProxyContext) {
                // Restore old proxy.
                // 处理AopContext中保存的当前代理对象
                AopContext.setCurrentProxy(oldProxy);
            }
        }
    }
}

getInterceptorsAndDynamicInterceptionAdvice

• List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass)
• 把aop的advisor转化为拦截器链

public class AdvisedSupport extends ProxyConfig implements Advised {

    /**
     * 将之前注入到advisorChain中的advisors转换为MethodInterceptor
     * 和InterceptorAndDynamicMethodMatcher集合
     */
    public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, @Nullable Class<?> targetClass) {
        MethodCacheKey cacheKey = new MethodCacheKey(method);
        //尝试从缓存获取
        List<Object> cached = this.methodCache.get(cacheKey);
        if (cached == null) {
            //缓存没有，则尝试通过advisorChainFactory去创建调用链
            cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
                    this, method, targetClass);
            //将获取到的结果加入到缓存中
            this.methodCache.put(cacheKey, cached);
        }
        return cached;
    }
}

可以看出上面方法用到缓存的，假设现在缓存没有相应的拦截器, 则到 AdvisorChainFactory 的相应方法中获取，继续跟踪AdvisorChainFactory，进入DefaultAdvisorChainFactory中的相应方法，比较长。

getInterceptorsAndDynamicInterceptionAdvice

• cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(this, method, targetClass)
• 缓存没有，则尝试通过advisorChainFactory去创建调用链。

public class DefaultAdvisorChainFactory implements AdvisorChainFactory, Serializable {

    @Override
    public List<Object> getInterceptorsAndDynamicInterceptionAdvice(
            Advised config, Method method, @Nullable Class<?> targetClass) {

        // This is somewhat tricky... We have to process introductions first,
        // but we need to preserve order in the ultimate list.
        //通过单例方式实例一个DefaultAdvisorAdapterRegistry
        // 拿到代理里面所有的通知们：getAdvisors
        AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();
        Advisor[] advisors = config.getAdvisors();
        List<Object> interceptorList = new ArrayList<>(advisors.length);
        Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
        Boolean hasIntroductions = null;

        for (Advisor advisor : advisors) {
            if (advisor instanceof PointcutAdvisor) {
                // Add it conditionally.
                PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
                if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
                    //已预过滤过的或者这个切点适用于给定的接口或目标类
                    //从registry获取MethodInterceptor拦截器
                    MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
                    boolean match;
                    if (mm instanceof IntroductionAwareMethodMatcher) {
                        if (hasIntroductions == null) {
                            hasIntroductions = hasMatchingIntroductions(advisors, actualClass);
                        }
                        match = ((IntroductionAwareMethodMatcher) mm).matches(method, actualClass, hasIntroductions);
                    }
                    else {
                        match = mm.matches(method, actualClass);
                    }
                    if (match) {
                        // 将advisor转为MethodInterceptor
                        MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
                        // 动态匹配
                        if (mm.isRuntime()) {
                            // Creating a new object instance in the getInterceptors() method
                            // isn't a problem as we normally cache created chains.
                            for (MethodInterceptor interceptor : interceptors) {
                                interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
                            }
                        }
                        else {
                            interceptorList.addAll(Arrays.asList(interceptors));
                        }
                    }
                }
            }
            else if (advisor instanceof IntroductionAdvisor) {
                IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
                if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
                    Interceptor[] interceptors = registry.getInterceptors(advisor);
                    interceptorList.addAll(Arrays.asList(interceptors));
                }
            }
            else {
                Interceptor[] interceptors = registry.getInterceptors(advisor);
                interceptorList.addAll(Arrays.asList(interceptors));
            }
        }

        return interceptorList;
    }

    private static boolean hasMatchingIntroductions(Advisor[] advisors, Class<?> actualClass) {
        for (Advisor advisor : advisors) {
            if (advisor instanceof IntroductionAdvisor) {
                IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
                if (ia.getClassFilter().matches(actualClass)) {
                    return true;
                }
            }
        }
        return false;
    }
}

如果aop的advisor转化为拦截器链为空，说明不需要被织入横切逻辑，直接执行被代理的方法实例本身。

invokeJoinpointUsingReflection

• 目标对象方法的调用
• AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse)
• 其实是通过AopUtils的方法调用，使用反射机制来对目标对象的方法进行的。

public abstract class AopUtils {

    @Nullable
    public static Object invokeJoinpointUsingReflection(@Nullable Object target, Method method, Object[] args)
            throws Throwable {

        // Use reflection to invoke the method.
        // 通过反射机制来获得相应的方法，并调用invoke
        try {
            ReflectionUtils.makeAccessible(method);
            return method.invoke(target, args);
        }
        catch (InvocationTargetException ex) {
            // Invoked method threw a checked exception.
            // We must rethrow it. The client won't see the interceptor.
            throw ex.getTargetException();
        }
        catch (IllegalArgumentException ex) {
            throw new AopInvocationException("AOP configuration seems to be invalid: tried calling method [" +
                    method + "] on target [" + target + "]", ex);
        }
        catch (IllegalAccessException ex) {
            throw new AopInvocationException("Could not access method [" + method + "]", ex);
        }
    }
}

如果aop的advisor转化为拦截器链不为空，获取目标对象的调用链逻辑，并且对该链进行调用。

• 如果存在拦截器，则创建一个 ReflectiveMethodInvocation，代理对象、被代理对象、方法、参数、被代理对象的 Class、拦截器链作为参数。这边 ReflectiveMethodInvocation 已经持有了被代理对象、方法、参数，后续就可以直接使用反射来调用被代理的方法了。

ReflectiveMethodInvocation 构造函数

public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Cloneable {

    protected ReflectiveMethodInvocation(
            Object proxy, @Nullable Object target, Method method, @Nullable Object[] arguments,
            @Nullable Class<?> targetClass, List<Object> interceptorsAndDynamicMethodMatchers) {

        this.proxy = proxy;
        this.target = target;
        this.targetClass = targetClass;
        this.method = BridgeMethodResolver.findBridgedMethod(method);
        this.arguments = AopProxyUtils.adaptArgumentsIfNecessary(method, arguments);
        this.interceptorsAndDynamicMethodMatchers = interceptorsAndDynamicMethodMatchers;
    }
}

// 获取目标对象的调用链逻辑，并且对该链进行调用
MethodInvocation invocation =
        new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);

retVal = invocation.proceed();

ReflectiveMethodInvocation#proceed() 拦截器方法执行

• 看看拦截器对象，即ReflectiveMethodInvocation中proceed()方法的调用，

public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Cloneable {

    @Override
    @Nullable
    public Object proceed() throws Throwable {
        // We start with an index of -1 and increment early.
        // 注意这里是递归调用，所以是从索引为-1的拦截器开始调用，并按序递增
        //如果拦截器链中的拦截器调用完毕，就执行被代理的方法本身
        if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
            //执行目标方法
            return invokeJoinpoint();
        }
        //获取第一个方法拦截器使用的是前++，获取下一个要执行的拦截器
        //每递归调用一次，currentInterceptorIndex加一。
        Object interceptorOrInterceptionAdvice =
                this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
        if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
            // Evaluate dynamic method matcher here: static part will already have
            // been evaluated and found to match.
            InterceptorAndDynamicMethodMatcher dm =
                    (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
            Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
            //精确匹配
            if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
                //递归调用
                return dm.interceptor.invoke(this);
            }
            else {
                // Dynamic matching failed.
                // Skip this interceptor and invoke the next in the chain.
                // 匹配错误，跳过，调用下一个
                return proceed();
            }
        }
        else {
            // It's an interceptor, so we just invoke it: The pointcut will have
            // been evaluated statically before this object was constructed.
            // 如果拦截的不是精确到方法级别的，比如是拦截一整个类，就直接调用，不用再匹配方法了
            return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
        }
    }
}

该方法是一个责任链的方法，会按索引执行所有的拦截器。

• 如果所有拦截器都执行完毕（index是从-1开始，所以跟size - 1比较），则直接使用反射调用连接点（也就是我们原本的方法）。

• MethodBeforeAdviceInterceptor 前置通知

• AspectJAfterAdvice 后置通知

• AfterReturningAdviceInterceptor 返回通知

• AspectJAfterThrowingAdvice 异常通知

以上拦截器方法都在invoke()方法中执行

递归调用拦截器

invokeJoinpoint 执行目标方法

public class ReflectiveMethodInvocation implements ProxyMethodInvocation, Cloneable {

    @Nullable
    protected Object invokeJoinpoint() throws Throwable {
        // 反射执行连接点，也就是原方法，target为被代理的对象实例、method为执行的方法、arguments为方法参数
        return AopUtils.invokeJoinpointUsingReflection(this.target, this.method, this.arguments);
    }
}


public abstract class AopUtils {

    @Nullable
    public static Object invokeJoinpointUsingReflection(@Nullable Object target, Method method, Object[] args)
            throws Throwable {

        // Use reflection to invoke the method.
        // 通过反射机制来获得相应的方法，并调用invoke
        try {
            ReflectionUtils.makeAccessible(method);
            return method.invoke(target, args);
        }
        catch (InvocationTargetException ex) {
            // Invoked method threw a checked exception.
            // We must rethrow it. The client won't see the interceptor.
            throw ex.getTargetException();
        }
        catch (IllegalArgumentException ex) {
            throw new AopInvocationException("AOP configuration seems to be invalid: tried calling method [" +
                    method + "] on target [" + target + "]", ex);
        }
        catch (IllegalAccessException ex) {
            throw new AopInvocationException("Could not access method [" + method + "]", ex);
        }
    }
}

CglibAopProxy#getProxy

class CglibAopProxy implements AopProxy, Serializable {

    @Override
    public Object getProxy(@Nullable ClassLoader classLoader) {
        if (logger.isTraceEnabled()) {
            logger.trace("Creating CGLIB proxy: " + this.advised.getTargetSource());
        }

        try {
            // 1.拿到要代理目标类
            Class<?> rootClass = this.advised.getTargetClass();
            Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");
            // proxySuperClass默认为rootClass
            Class<?> proxySuperClass = rootClass;
            // 这里判断rootClass是否是Cglib代理所产生的类（内部判断rootClass的className是否包含$$）
            // 如果rootClass是被Cglib代理过的，获取rootClass的父类作为proxySuperClass
            if (rootClass.getName().contains(ClassUtils.CGLIB_CLASS_SEPARATOR)) {
                proxySuperClass = rootClass.getSuperclass();
                Class<?>[] additionalInterfaces = rootClass.getInterfaces();
                for (Class<?> additionalInterface : additionalInterfaces) {
                    // 将父类的接口也添加到advised的interfaces属性
                    this.advised.addInterface(additionalInterface);
                }
            }

            // Validate the class, writing log messages as necessary.
            // 方法校验，final方法不能被代理，记录日志
            // 2.校验proxySuperClass，主要是校验方法是否用final修饰、跨ClassLoader的包可见方法，如果有将警告写入日志
            validateClassIfNecessary(proxySuperClass, classLoader);

            // Configure CGLIB Enhancer...
            // 3.创建和配置Cglib Enhancer
            Enhancer enhancer = createEnhancer();
            if (classLoader != null) {
                enhancer.setClassLoader(classLoader);
                if (classLoader instanceof SmartClassLoader &&
                        ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
                    enhancer.setUseCache(false);
                }
            }
            // superclass为被代理的目标类proxySuperClass，通过名字可以看出，生成的代理类实际上是继承了被代理类
            enhancer.setSuperclass(proxySuperClass);
            enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
            enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
            enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));

            // 4.获取所有要回调的拦截器
            // 通过callbacks设置拦截器链
            // spring在这里考虑了很多种情况，将所有callback放到一个数组中。
            // 而在某些特定场景下，spring还对回调进行了优化，生成新的回调函数，追加到callbacks数组中。
            Callback[] callbacks = getCallbacks(rootClass);
            Class<?>[] types = new Class<?>[callbacks.length];
            for (int x = 0; x < types.length; x++) {
                types[x] = callbacks[x].getClass();
            }
            // fixedInterceptorMap only populated at this point, after getCallbacks call above
            // 设置回调过滤器，修正后的拦截器map和偏移量在这里传进去
            // 在上面调用getCallbacks之后，此时仅填充fixedInterceptorMap
            enhancer.setCallbackFilter(new ProxyCallbackFilter(
                    this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
            enhancer.setCallbackTypes(types);

            // Generate the proxy class and create a proxy instance.
            // 生成代理类实例
            // 5.生成代理类并创建代理实例，返回代理实例
            return createProxyClassAndInstance(enhancer, callbacks);
        }
        catch (CodeGenerationException | IllegalArgumentException ex) {
            throw new AopConfigException("Could not generate CGLIB subclass of " + this.advised.getTargetClass() +
                    ": Common causes of this problem include using a final class or a non-visible class",
                    ex);
        }
        catch (Throwable ex) {
            // TargetSource.getTarget() failed
            throw new AopConfigException("Unexpected AOP exception", ex);
        }
    }
}

getCallbacks

• 获取所有要回调的拦截器

class CglibAopProxy implements AopProxy, Serializable {

    private Callback[] getCallbacks(Class<?> rootClass) throws Exception {
        // Parameters used for optimization choices...
        // 1.用于优化选择的参数
        boolean exposeProxy = this.advised.isExposeProxy();
        boolean isFrozen = this.advised.isFrozen();
        boolean isStatic = this.advised.getTargetSource().isStatic();

        // Choose an "aop" interceptor (used for AOP calls).
        // 最常用的就是这个拦截器DynamicAdvisedInterceptor
        // 2.使用AdvisedSupport作为参数，创建一个DynamicAdvisedInterceptor（“aop”拦截器，用于AOP调用）
        // this.advised就是之前创建CglibAopProxy时传进来的ProxyFactory(ProxyCreatorSupport子类)
        Callback aopInterceptor = new DynamicAdvisedInterceptor(this.advised);

        // Choose a "straight to target" interceptor. (used for calls that are
        // unadvised but can return this). May be required to expose the proxy.
        Callback targetInterceptor;
        if (exposeProxy) {
            targetInterceptor = (isStatic ?
                    new StaticUnadvisedExposedInterceptor(this.advised.getTargetSource().getTarget()) :
                    new DynamicUnadvisedExposedInterceptor(this.advised.getTargetSource()));
        }
        else {
            targetInterceptor = (isStatic ?
                    new StaticUnadvisedInterceptor(this.advised.getTargetSource().getTarget()) :
                    new DynamicUnadvisedInterceptor(this.advised.getTargetSource()));
        }

        // Choose a "direct to target" dispatcher (used for
        // unadvised calls to static targets that cannot return this).
        Callback targetDispatcher = (isStatic ?
                new StaticDispatcher(this.advised.getTargetSource().getTarget()) : new SerializableNoOp());

        // 原始的7种callback
        // 3.将aop拦截器添加到mainCallbacks中
        Callback[] mainCallbacks = new Callback[] {
                aopInterceptor,  // for normal advice
                targetInterceptor,  // invoke target without considering advice, if optimized
                new SerializableNoOp(),  // no override for methods mapped to this
                targetDispatcher, this.advisedDispatcher,
                new EqualsInterceptor(this.advised),
                new HashCodeInterceptor(this.advised)
        };

        Callback[] callbacks;

        // If the target is a static one and the advice chain is frozen,
        // then we can make some optimizations by sending the AOP calls
        // direct to the target using the fixed chain for that method.
        // 如果目标类是不可变的(getTarget()方法返回的对象是否一直是同一个，也就是说对单例对象而言，isStatic都返回true)，
        // 且代理对象被冻结(isFrozen属性设置为true)，那么spring将会采取优化，在callbacks数组中增加了新的回调，
        // 使用修正后的增强链把aop调用直接转发到目标方法来进行一些优化，也就是说此时代理将不生效
        if (isStatic && isFrozen) {
            Method[] methods = rootClass.getMethods();
            Callback[] fixedCallbacks = new Callback[methods.length];
            this.fixedInterceptorMap = new HashMap<>(methods.length);

            // TODO: small memory optimization here (can skip creation for methods with no advice)
            for (int x = 0; x < methods.length; x++) {
                Method method = methods[x];
                List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, rootClass);
                fixedCallbacks[x] = new FixedChainStaticTargetInterceptor(
                        chain, this.advised.getTargetSource().getTarget(), this.advised.getTargetClass());
                this.fixedInterceptorMap.put(method, x);
            }

            // Now copy both the callbacks from mainCallbacks
            // and fixedCallbacks into the callbacks array.
            // 把默认的7种callback和修正后的callback合并到一个数组中返回
            callbacks = new Callback[mainCallbacks.length + fixedCallbacks.length];
            System.arraycopy(mainCallbacks, 0, callbacks, 0, mainCallbacks.length);
            System.arraycopy(fixedCallbacks, 0, callbacks, mainCallbacks.length, fixedCallbacks.length);
            this.fixedInterceptorOffset = mainCallbacks.length;
        }
        else {
            callbacks = mainCallbacks;
        }
        return callbacks;
    }
}

最终，通过 CGLIB 代理的类被调用时，会走到 DynamicAdvisedInterceptor#intercept 方法。

DynamicAdvisedInterceptor#intercept

class CglibAopProxy implements AopProxy, Serializable {
    private static class DynamicAdvisedInterceptor implements MethodInterceptor, Serializable {

        private final AdvisedSupport advised;

        public DynamicAdvisedInterceptor(AdvisedSupport advised) {
            this.advised = advised;
        }

        @Override
        @Nullable
        public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
            Object oldProxy = null;
            boolean setProxyContext = false;
            Object target = null;
            TargetSource targetSource = this.advised.getTargetSource();
            try {
                if (this.advised.exposeProxy) {
                    // Make invocation available if necessary.
                    oldProxy = AopContext.setCurrentProxy(proxy);
                    setProxyContext = true;
                }
                // Get as late as possible to minimize the time we "own" the target, in case it comes from a pool...
                target = targetSource.getTarget();
                Class<?> targetClass = (target != null ? target.getClass() : null);
                // 这里获取拦截器链的方式与jdk动态代理方式调用了同一个方法
                List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
                Object retVal;
                // Check whether we only have one InvokerInterceptor: that is,
                // no real advice, but just reflective invocation of the target.
                if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
                    // We can skip creating a MethodInvocation: just invoke the target directly.
                    // Note that the final invoker must be an InvokerInterceptor, so we know
                    // it does nothing but a reflective operation on the target, and no hot
                    // swapping or fancy proxying.
                    // chain 是空的，说明不需要被织入横切逻辑，直接执行被代理的方法实例本身
                    Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
                    retVal = methodProxy.invoke(target, argsToUse);
                }
                else {
                    // We need to create a method invocation...
                    // 获取目标对象的调用链逻辑，并且对该链进行调用
                    retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
                }
                //处理返回值，并返回。
                retVal = processReturnType(proxy, target, method, retVal);
                return retVal;
            }
            finally {
                if (target != null && !targetSource.isStatic()) {
                    // 如果TargetSource不是静态的，
                    // 则调用其releaseTarget()方法将生成的目标对象释放
                    targetSource.releaseTarget(target);
                }
                if (setProxyContext) {
                    // Restore old proxy.
                    // 处理AopContext中保存的当前代理对象
                    AopContext.setCurrentProxy(oldProxy);
                }
            }
        }
    }
}

• DynamicAdvisedInterceptor#intercept()，该方法中通过List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass)获取一个List拦截链，这里获取拦截器链的方式与上面分析jdk动态代理方式调用了同一个方法。

• 然后通过retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed()方法执行对应的拦截链进行执行处理。

• 最后通过processReturnType(proxy, target, method, retVal)处理返回值，并返回。

• 整体过程完全采用动态代理模式来实现。

CglibMethodInvocation构造函数

class CglibAopProxy implements AopProxy, Serializable {

    private static class CglibMethodInvocation extends ReflectiveMethodInvocation {

        @Nullable
        private final MethodProxy methodProxy;

        public CglibMethodInvocation(Object proxy, @Nullable Object target, Method method,
                Object[] arguments, @Nullable Class<?> targetClass,
                List<Object> interceptorsAndDynamicMethodMatchers, MethodProxy methodProxy) {

            super(proxy, target, method, arguments, targetClass, interceptorsAndDynamicMethodMatchers);

            // Only use method proxy for public methods not derived from java.lang.Object
            this.methodProxy = (Modifier.isPublic(method.getModifiers()) &&
                    method.getDeclaringClass() != Object.class && !AopUtils.isEqualsMethod(method) &&
                    !AopUtils.isHashCodeMethod(method) && !AopUtils.isToStringMethod(method) ?
                    methodProxy : null);
        }
    }
}

CglibMethodInvocation#proceed()

class CglibAopProxy implements AopProxy, Serializable {

    private static class CglibMethodInvocation extends ReflectiveMethodInvocation {

        @Override
        @Nullable
        public Object proceed() throws Throwable {
            try {
                return super.proceed();
            }
            catch (RuntimeException ex) {
                throw ex;
            }
            catch (Exception ex) {
                if (ReflectionUtils.declaresException(getMethod(), ex.getClass())) {
                    throw ex;
                }
                else {
                    throw new UndeclaredThrowableException(ex);
                }
            }
        }
    }
}

CglibMethodInvocation中的proceed方法最终调用到了ReflectiveMethodInvocation类中的proceed方法，该方法在前面JDK动态代理中解析过。

至此，创建 AOP 代理，以及AOP的调用，已经介绍完毕。

总结：

• 1、@EnableAspectJAutoProxy 会注册一个AnnotationAwareAspectJAutoProxyCreator

• 2、AnnotationAwareAspectJAutoProxyCreator是一个InstantiationAwareBeanPostProcessor

• 3、创建流程：

  • A、registerBeanPostProcessors() 注册后置处理器，创建AnnotationAwareAspectJAutoProxyCreator
  • B、finishBeanFactoryInitialization 初始化剩下的单实例Bean
    • a、创建Bean和切面
    • b、AnnotationAwareAspectJAutoProxyCreator拦截创建过程
    • c、创建完Bean判断是否需要增强。通过BeanPostProcessorsAfterInitialization，wrapIfNecessary() 包装代理对象

• 4、执行目标方法

  • A、获取拦截器链（advisor包装为Interceptor）
  • B、递归调用拦截器链
    • 前置通知、目标方法、后置通知、返回通知、异常通知

参考：
https://zhuanlan.zhihu.com/p/104521455

https://segmentfault.com/a/1190000015830477

https://blog.csdn.net/fuli_mouren/article/details/45244453

http://www.mamicode.com/info-detail-890966.html