Spring AOP解析(2)--AOP的实现原理及源码解析

前言：

上一篇对于AOP的使用做了简单的介绍，本文开始着重对于AOP的实现原理进行解析，AOP的使用主要是通过自定义标签<aop:aspectj-autoproxy>开启，所以就需要通过该标签入手开始探寻AOP的奥秘

一、<aop:aspectj-autoproxy>标签的解析

Spring的标签分为默认的标签和自定义的标签，自定义的标签都需要自定义解析器来对标签进行解析，所以可以先从该标签的解析器入手。全局搜索aspectj-autoproxy，可以发现Spring-Aop包中果然存在一个aspectj-autoproxy的解析器，在AopNamespaceHandler的初始化方法中定义，注册了一个标签解析器AspectJAutoProxyBeanDefinitionParser，源码如下：

public class AopNamespaceHandler extends NamespaceHandlerSupport {

    @Override
    public void init() {
        // In 2.0 XSD as well as in 2.1 XSD.
        registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
        registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
        registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());

        // Only in 2.0 XSD: moved to context namespace as of 2.1
        registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
    }

}

AspectJAutoProxyBeanDefinitionParser主要需要执行parser方法，源码如下：

@Override
    @Nullable
    public BeanDefinition parse(Element element, ParserContext parserContext) {
        AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
        extendBeanDefinition(element, parserContext);
        return null;
    }

其中核心逻辑在线第4行，用于注册AnnotationAwareAutoProxyCreator，首先是创建一个该类的BeanDefintion，然后是解析<aop:aspectj-autoproxy>标签的两个属性proxy-target-class和expose-proxy，最后注册该BeanDefinition，源码如下：

public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(
            ParserContext parserContext, Element sourceElement) {
        /** 获取org.springframework.aop.config.internalAutoProxyCreator类的BeanDefinition对象*/
        BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(
                parserContext.getRegistry(), parserContext.extractSource(sourceElement));
        /** 用于解析 proxy-target-class属性 和 expose-proxy属性*/
        useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
        /** 注册AnnotationAutoProxyCreator组件*/
        registerComponentIfNecessary(beanDefinition, parserContext);
    }

目前可以得出结论，AOP的实现功能或者说<aop:aspectj-autoproxy/>标签的功能实现是通过AnnotationAwareAutoProxyCreator来实现的，而上面的步骤都是在创建和注册AnnotationAwareAutoProxyCreator的bean的定义的过程。

二、AnnotationAwareAutoProxyCreator的源码解析

AnnotationAwareAutoProxyCreator类实现了很多的接口，分别实现了Orderd、BeanPostProcessor的子接口、BeanFactoryAware、BeanClassLoaderAware等接口，而既然实现了BeanPostProcessor接口，很显然在bean加载时就会执行BeanPostProcessor的postProcessorBeforeInstantiation方法和postProcessAfterInitialization方法，其中postProcessBeforeInstantiation方法是在bean实例化之前执行，而postProcessAfterInitialization是在bean执行了init方法之后执行，均是在父类AbstarctAutoProxyCreator中实现。

方法postProcessorBeforeInstantiation源码解析：

/** 目标对象源bean集合*/
    private final Set<String> targetSourcedBeans = Collections.newSetFromMap(new ConcurrentHashMap<>(16));

    /** 提前曝光的代理引用集合*/
    private final Map<Object, Object> earlyProxyReferences = new ConcurrentHashMap<>(16);

    /** 代理类型集合*/
    private final Map<Object, Class<?>> proxyTypes = new ConcurrentHashMap<>(16);

    /** 增强bean集合,Advice、PointCut、Advisor、AopInfrastructureBean等类的bean会加入该集合*/
    private final Map<Object, Boolean> advisedBeans = new ConcurrentHashMap<>(256);

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
        /**
         * 1.根据beanClass和beanName获取缓存的key
         * 如果是工厂bean则key = &beanName
         * 如果不是工厂bean则key = beanName
         * */
        Object cacheKey = getCacheKey(beanClass, beanName);

        /**
         * 2.如果targetSourcedBeans中不包含当前bean则进行判断
         * */
        if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
            if (this.advisedBeans.containsKey(cacheKey)) {
                return null;
            }
            /**
             * 3.isInfrastructureClass方法是判断当前beanClass是否是AOP增强相关的接口
             *  判断beanClass是否是Advice、PointCut、Advisor、AopInfrastructureBean等接口的实现类
             *  如果是则加入到advisedBeans集合中
             * */
            if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
                this.advisedBeans.put(cacheKey, Boolean.FALSE);
                return null;
            }
        }

        /**
         * 4.根据beanClass和beanName获取自定义的TargetSource实例,如果存在的话则创建代理,如果不存在则直接跳过
         * TargetSource实例相当于就是目标对象bean的封装实例
         * */
        TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
        if (targetSource != null) {
            if (StringUtils.hasLength(beanName)) {
                this.targetSourcedBeans.add(beanName);
            }
            /** 4.1.获取当前bean所有的增强数组  */
            Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
            /** 4.2.根据增强数组为目标对象创建代理对象 */
            Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
            this.proxyTypes.put(cacheKey, proxy.getClass());
            /** 4.3.返回代理bean*/
            return proxy;
        }
        return null;
    }

实例化前置方法逻辑不多，主要是判断有没有自定义的TargetSource对象，如果有自定义的则直接获取增强创建代理，如果不是则直接返回null

其中核心步骤之一

方法postProcessAfterInitialization源码解析

@Override
    public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
        if (bean != null) {
            Object cacheKey = getCacheKey(bean.getClass(), beanName);
            if (this.earlyProxyReferences.remove(cacheKey) != bean) {
                /** 调用wrapIfNecessary方法为当前bean创建代理*/
                return wrapIfNecessary(bean, beanName, cacheKey);
            }
        }
        return bean;
    }

    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        /**
         * 第一步:判断当前bean是否已经存在targetSourcedBeans集合和advisedBeans中,并且如果是Advise相关bean则加入到advisedBeans集合中
         * */
        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;
        }

        /**
         * 第二步:获取当前bean所有的增强数组,也就是Advisor数组
         * */
        Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
        if (specificInterceptors != DO_NOT_PROXY) {
            this.advisedBeans.put(cacheKey, Boolean.TRUE);
            /**
             *  第三步:将目标bean封装成TargetSource对象，然后根据增强数组创建目标对象的代理对象
             * */
            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;
    }

 初始化后置方法逻辑和实例化前置方法逻辑基本上差不多，同样是先获取当前bean的所有增强数组，然后将增强数组织入到bean中创建一个代理对象

 总结这两个方法可以看出创建代理的流程一共可以分成三步：

第一步：将当前的bean封装成TargetSource对象，如果自定义优先使用自定义的TargetSource；如果没有自定义则使用默认的SingletonTargetSource对象

第二步：获取当前bean需要增强的所有Advisor数组，也就是需要在这个bean上需要织入的增强对象数组

第三步：根据目标对象的封装对象TargetSource对象 和 增强数组Advisor数组 给当前的bean创建一个代理对象

第一步很好理解，实际就是创建一个TargetSource对象，TargetSource对象中持有目标bean的引用，通过TargetSource对象可以访问到目标对象bean

第二步是获取当前bean需要织入的所有增强数组，通过调用getAdvicesAndAdvisorForBean方法实现，而getAdvicesAndAdvisorForBean方法是通过子类AbstractAdvisorAutoProxyCreator类实现，源码如下：

/**
     * 获取当前bean所有的增强
     * */
    @Override
    @Nullable
    protected Object[] getAdvicesAndAdvisorsForBean(
            Class<?> beanClass, String beanName, @Nullable TargetSource targetSource) {

        /** 调用findEligibleAdvisors方法获取Advisor列表*/
        List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
        if (advisors.isEmpty()) {
            return DO_NOT_PROXY;
        }
        return advisors.toArray();
    }

直接调用了内部的findEligibleAdvisors方法，继续查看源码：

/** 查询Advisor列表*/
    protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
        /**
         * 1、查询所有定义的Advisor列表
         *   实现逻辑就是从BeanFactory根据Advisor类型查询所有的Advisor实例,一种是实现来Advisor接口的，一种是被@Aspectj注解修饰的转化成Advisor
         * */
        List<Advisor> candidateAdvisors = findCandidateAdvisors();
        /**
         * 2、根据bean来筛选出需要在当前bean上增强的Advisor列表
         *
         * */
        List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
        extendAdvisors(eligibleAdvisors);
        if (!eligibleAdvisors.isEmpty()) {
            /** 3、对所有Advisor进行排序 */
            eligibleAdvisors = sortAdvisors(eligibleAdvisors);
        }
        return eligibleAdvisors;
    }

该方法分成了三步，第一步是从BeanFactory中找到所有的Advisor集合，有的是实现了Advisor接口定义的，有的是通过@AspectJ注解定义转化来的；第二步是找出匹配当前bean的所有Advisor；最后一步是对匹配的Advisor列表进行排序

可以发现第一步逻辑应该还比较清楚，就是从容器中找到所有的Advisor，第三步排序也比较好理解，核心是第二步匹配逻辑比较复杂，所以接下来就着重查看Advisor是如何针对bean进行匹配的，方法为findAdvisorsThatCanApply，源码如下：

/**
     * 查询指定beanClass和beanName中需要增强的Advisor列表
     * */
    protected List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {

        ProxyCreationContext.setCurrentProxiedBeanName(beanName);
        try {
            /** 直接调用AopUtils的findAdvisorThatCanApply方法*/
            return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
        }
        finally {
            ProxyCreationContext.setCurrentProxiedBeanName(null);
        }
    }

直接调用了AopUtils工具类的findAdvisorsThatCanApply方法，源码如下：

public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
        if (candidateAdvisors.isEmpty()) {
            return candidateAdvisors;
        }
        List<Advisor> eligibleAdvisors = new ArrayList<>();
        /**
         * 1、遍历所有的Advisor, 调用canApply方法判断当前的bean和当前的advisor是否匹配
         * */
        for (Advisor candidate : candidateAdvisors) {
            /**
             * 2、首先判断当前增强是否是引介增强，如果是执行canApply方法判断是否匹配
             * */
            if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
                eligibleAdvisors.add(candidate);
            }
        }
        boolean hasIntroductions = !eligibleAdvisors.isEmpty();
        for (Advisor candidate : candidateAdvisors) {
            if (candidate instanceof IntroductionAdvisor) {
                // already processed
                continue;
            }
            /**
             * 3、如果不是引介增强，则执行canApply方法判断是否匹配
             * */
            if (canApply(candidate, clazz, hasIntroductions)) {
                eligibleAdvisors.add(candidate);
            }
        }
        return eligibleAdvisors;
    }

该方法的功能是从Advisor列表中筛选出所有和clazz匹配的增强列表，根据当前增强是否是引介增强（IntroductionAdvisor接口实现）分别调用重载的canApply方法进行判断当前Advisor和当前的clazz是否匹配，所以判断是否匹配的逻辑就在canApply方法中。

canApply方法源码如下：

/**
     * 判断当前增强advisor是否匹配当前的目标类targetClass
     * */
    public static boolean canApply(Advisor advisor, Class<?> targetClass) {
        //调用内部canApply方法
        return canApply(advisor, targetClass, false);
    }

    /**
     * 功能同上
     * @param advisor:增强对象
     * @param targetClass:目标类
     * @param hasIntroductions:是否有引介增强
     * */
    public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
        if (advisor instanceof IntroductionAdvisor) {
            /**
             * 如果是引介增强,则调用IntroductionAdvisor的getClassFilter.matches方法判断是否匹配
             * */
            return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
        }
        else if (advisor instanceof PointcutAdvisor) {
            /**
             * 如果是普通增强,调用canApply方法判断是否匹配
             * */
            PointcutAdvisor pca = (PointcutAdvisor) advisor;
            return canApply(pca.getPointcut(), targetClass, hasIntroductions);
        }
        else {
            // It doesn't have a pointcut so we assume it applies.
            return true;
        }
    }

public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
        Assert.notNull(pc, "Pointcut must not be null");
        if (!pc.getClassFilter().matches(targetClass)) {
            return false;
        }

        MethodMatcher methodMatcher = pc.getMethodMatcher();
        if (methodMatcher == MethodMatcher.TRUE) {
            // No need to iterate the methods if we're matching any method anyway...
            return true;
        }

        IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
        if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
            introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
        }

        Set<Class<?>> classes = new LinkedHashSet<>();
        if (!Proxy.isProxyClass(targetClass)) {
            classes.add(ClassUtils.getUserClass(targetClass));
        }
        classes.addAll(ClassUtils.getAllInterfacesForClassAsSet(targetClass));

        for (Class<?> clazz : classes) {
            Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
            for (Method method : methods) {
                if (introductionAwareMethodMatcher != null ?
                        introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) :
                        methodMatcher.matches(method, targetClass)) {
                    return true;
                }
            }
        }

        return false;
    }

通过第一步和第二步已经得到了需要织入增强的目标对象TargetSource和需要织入的所有增强Advisor数组，最后一步就是调用createProxy方法将这两者合并起来创建一个目标对象的代理过程，createProxy方法源码如下：

/**
     * 创建代理
     * */
    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);
        }

        /**
         * 1.创建代理工厂类,并复制当前类的属性
         * */
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.copyFrom(this);

        if (!proxyFactory.isProxyTargetClass()) {
            if (shouldProxyTargetClass(beanClass, beanName)) {
                proxyFactory.setProxyTargetClass(true);
            }
            else {
                evaluateProxyInterfaces(beanClass, proxyFactory);
            }
        }

        /**
         * 2.设置代理工厂属性,将增强数组advisors和目标对象targetSource加入到代理工厂中
         * */
        Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
        proxyFactory.addAdvisors(advisors);
        proxyFactory.setTargetSource(targetSource);
        customizeProxyFactory(proxyFactory);

        proxyFactory.setFrozen(this.freezeProxy);
        if (advisorsPreFiltered()) {
            proxyFactory.setPreFiltered(true);
        }
        /**
         * 3.调用代理工厂类的getProxy方法创建代理对象
         * */
        return proxyFactory.getProxy(getProxyClassLoader());
    }

从源码可以看出，主要逻辑就是构建了一个ProxyFactory对象，然后是给ProxyFactory对象的属性进行赋值，并且将增强属性和目标对象都传到代理工厂ProxyFactory中，而创建代理的过程最终是调用了ProxyFactory的getProxy方法进行创建，逻辑如下：

/** 创建代理对象*/
    public Object getProxy(@Nullable ClassLoader classLoader) {
        //创建AopProxy对象,然后调用AopProxy对象的getProxy方法
        return createAopProxy().getProxy(classLoader);
    }

    /** 创建AopProxy对象 */
    protected final synchronized AopProxy createAopProxy() {
        if (!this.active) {
            activate();
        }
        //先获取AopProxy工厂,然后创建AopProxy对象
        return getAopProxyFactory().createAopProxy(this);
    }

    @Override
    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        /**
         * 判断条件选取是采用 JDK动态代理还是CGLIB代理
         * isOptimize: 判断是否采用优化策略,只有CGLIB代理才有效
         * isProxyTargetClass: 该属性对于<aop:aspectj-autoproxy/>标签中的proxy-target-class属性的值.
         *                     表示是否代理目标类本身,而不是目标类的接口
         *                     比如当前目标类为 GoodsServiceImpl 实现类 GoodsService接口
         *                     如果该属性为false时,则创建的代理是代理的GoodsService接口,需要用JDK动态代理
         *                     如果该属性为true时,则创建的代理是代理的GoodsServiceImpl本身,所以必须采用CGLIB来创建代理
         * hasNoUserSuppliedProxyInterfaces ：判断是否存在代理接口
         * */
        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)) {
                /** 如果目标对象是一个接口,则创建JDK动态代理对象 */
                return new JdkDynamicAopProxy(config);
            }
            /**
             * 如果目标对象不是一个接口,则创建 CGLIB代理对象
             * */
            return new ObjenesisCglibAopProxy(config);
        }
        else {
            /** 创建 JDK动态代理对象 */
            return new JdkDynamicAopProxy(config);
        }
    }

该方法中对于AOP的参数进行了判断，判断当前的对象是采用JDK动态代理还是CGLIB代理，则分别创建不同的代理对象AopProxy实现类，至于如何选择JDK动态代理还是CGLIB代理，大致规则如下：

（*** 重点 ***）

1、如果目标对象实现了接口，默认情况下会采用JDK动态代理；但是可以通过配置 proxy-target-class属性的值为true强制使用CGLIB代理，则代理的是目标对象的本身

2、如果目标对象没有实现接口，那么必须采用CGLIB创建代理对象

到目前为止已经知道了如何一步一步创建的代理了，接下来就是不同类型的代理来对目标对象创建代理对象的逻辑了，主要是通过调用AopProxy对象的getProxy方法创建，不同类型的实现分别如下：

1、JDK动态代理创建代理对象

JDK动态代理创建对象是通过代理JdkDynamicAopProxy实现的，而JdkDynamicAopProxy实现了InvocationHandler接口

/**
     * JDK动态代理创建代理对象
     * */
    @Override
    public Object getProxy() {
        //调用内部重载方法getProxy
        return getProxy(ClassUtils.getDefaultClassLoader());
    }

    @Override
    public Object getProxy(@Nullable ClassLoader classLoader) {

        Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
        findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
        //创建代理实例,并且代理实现就是JdkDynamicAopProxy本身
        return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
    }

最终通过Proxy.newProxyInstance方法创建了代理对象，而代理执行者就是this,也就是JdkDynamicAopProxy本身，所以目标对象的所有方法执行都会执行到JdkDynamicAopProxy对象的invoke方法

注：此处涉及到Java的动态代理技术，不懂的同学可以参考文章：Java技术整理--反射机制及动态代理详解

既然目标对象的方法执行最终都会执行JdkDynamicAopProxy的invoke方法，所以核心就在于该方法的实现，源码如下：（以下是AOP动态代理最终的核心逻辑）

@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)) {
                return equals(args[0]);
            }
            //处理hash方法
            else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
                return hashCode();
            }
            //如果目标对象是DecoratingProxy类型,则返回目标对象的最终对象类型
            else if (method.getDeclaringClass() == DecoratingProxy.class) {
                return AopProxyUtils.ultimateTargetClass(this.advised);
            }
            /**
             * 如果目标对象是Advice接口类型,则直接使用反射进行调用
             * */
            else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
                    method.getDeclaringClass().isAssignableFrom(Advised.class)) {
                return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
            }

            Object retVal;

            /**
             * 判断是否暴露代理对象,通过<aop:aspectj-autoproxy expose-proxy="true"/>设置
             * 当exposeProxy为true时,AopContext会在ThreadLocal中就将代理对象设置进去,就可以通过AopContext.getCurrentProxy方法获取当前的代理对象
             * 主要是用来解决目标对象内部调用无法织入增强的问题
             * */
            if (this.advised.exposeProxy) {
                // Make invocation available if necessary.
                oldProxy = AopContext.setCurrentProxy(proxy);
                setProxyContext = true;
            }

            //获取目标对象
            target = targetSource.getTarget();
            //获取目标对象的Class对象
            Class<?> targetClass = (target != null ? target.getClass() : null);

            /** 获取当前方法上的拦截器链*/
            List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

            if (chain.isEmpty()) {
                //通过反射直接调用目标对象的方法
                Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
                retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
            }
            else {
                //将拦截器链封装到MethodInvocation对象中
                MethodInvocation invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                /** 然后执行拦截器链 */
                retVal = invocation.proceed();
            }

            //获取方法返回结果的类型
            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()) {
                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(target);
            }
            if (setProxyContext) {
                //
                AopContext.setCurrentProxy(oldProxy);
            }
        }
    }

    @Override
    @Nullable
    public Object proceed() throws Throwable {
        /**
         * 当前所以的增强方法执行完毕后，通过反射执行目标对象的方法
         * */
        if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
            return invokeJoinpoint();
        }

        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 {
            /**
             * 执行普通拦截器的逻辑
             * */
            return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
        }
    }

总结代理对象执行目标对象方法的逻辑：

1、 将所有增强封装成方法拦截器MethodInterceptor对象，生成拦截器链

2、按顺序依次执行拦截器链上所有的拦截器逻辑，直到所有的拦截器逻辑通过反射执行完成，最终会通过反射执行目标对象的方法

3、拦截器的执行顺序是先执行后置增强拦截器、再执行环绕增强拦截器、然后再执行前置增强拦截器、最终才是执行目标对象的方法

后置增强拦截器处理逻辑是先执行其他拦截器逻辑，在finally中执行后置拦截器的本身逻辑，代码如下：

@Override
    public Object invoke(MethodInvocation mi) throws Throwable {
        try {
            /**
             * 继续执行其他方法拦截器
             * */
            return mi.proceed();
        }
        finally {
            /**
             * 最终通过反射执行后置增强拦截器本身的逻辑
             * */
            invokeAdviceMethod(getJoinPointMatch(), null, null);
        }
    }

异常增强拦截器处理逻辑是通过try/catch捕获拦截器链的执行，一旦抛异常就通过反射执行本身的逻辑，代码如下：

@Override
    public Object invoke(MethodInvocation mi) throws Throwable {
        try {
            /**
             * 执行拦截器链方法
             * */
            return mi.proceed();
        }
        catch (Throwable ex) {
            if (shouldInvokeOnThrowing(ex)) {
                /**
                 * 如果拦截器链方法抛异常,则通过反射执行异常增强本身方法
                 * */
                invokeAdviceMethod(getJoinPointMatch(), null, ex);
            }
            throw ex;
        }
    }

环绕增强拦截器处理逻辑是执行通过反射执行环绕增强拦截器的逻辑，而在环绕增强逻辑中会执行 JoinPoint的proceed()继续执行拦截器链路的方法，代码如下：

@Override
    public Object invoke(MethodInvocation mi) throws Throwable {
        if (!(mi instanceof ProxyMethodInvocation)) {
            throw new IllegalStateException("MethodInvocation is not a Spring ProxyMethodInvocation: " + mi);
        }
        ProxyMethodInvocation pmi = (ProxyMethodInvocation) mi;
        ProceedingJoinPoint pjp = lazyGetProceedingJoinPoint(pmi);
        JoinPointMatch jpm = getJoinPointMatch(pmi);
        /** 通过反射执行环绕增强的逻辑*/
        return invokeAdviceMethod(pjp, jpm, null, null);
    }

前置增强拦截器处理逻辑是先执行前置拦截器本身的逻辑，然后再执行拦截器链的其他方法，代码如下：

@Override
    public Object invoke(MethodInvocation mi) throws Throwable {
        /** 通过反射先执行前置增强的本身逻辑*/
        this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
        /** 继续执行拦截器链路的其他逻辑 */
        return mi.proceed();
    }

所以如果有多个前置处理器，先执行invoke方法的前置处理器会先后执行横切逻辑；而如果有多个后置处理器，先执行invoke方法的后置处理器，会后执行本身的横切逻辑

2、CGLIB动态代理创建代理对象

 CGLIb代理创建代理对象是通过ObjenesisCglibAopProxy对象实现，ObjenesisCglibAopProxy继承于CglibAopProxy，获取代理的方法同样也是getProxy，实现逻辑如下：

@Override
    public Object getProxy() {
        /**  调用内部重载方法getProxy*/
        return getProxy(null);
    }

    @Override
    public Object getProxy(@Nullable ClassLoader classLoader) {

        try {
            /** 获取目标对象的Class对象*/
            Class<?> rootClass = this.advised.getTargetClass();
            Class<?> proxySuperClass = rootClass;
            if (rootClass.getName().contains(ClassUtils.CGLIB_CLASS_SEPARATOR)) {
                proxySuperClass = rootClass.getSuperclass();
                Class<?>[] additionalInterfaces = rootClass.getInterfaces();
                for (Class<?> additionalInterface : additionalInterfaces) {
                    this.advised.addInterface(additionalInterface);
                }
            }


            /**
             * 构造Enhancer对象,并设置Enhancer对象的各种属性
             * */
            Enhancer enhancer = createEnhancer();
            if (classLoader != null) {
                enhancer.setClassLoader(classLoader);
                if (classLoader instanceof SmartClassLoader &&
                        ((SmartClassLoader) classLoader).isClassReloadable(proxySuperClass)) {
                    enhancer.setUseCache(false);
                }
            }
            enhancer.setSuperclass(proxySuperClass);
            enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
            enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
            enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(classLoader));

            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
            enhancer.setCallbackFilter(new ProxyCallbackFilter(
                    this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
            enhancer.setCallbackTypes(types);

            /** 调用createProxyClassAndInstance方法创建代理对象 */
            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) {
            throw new AopConfigException("Unexpected AOP exception", ex);
        }
    }

    protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
        enhancer.setInterceptDuringConstruction(false);
        enhancer.setCallbacks(callbacks);
        /** 执行Enhancer的create方法创建代理对象*/
        return (this.constructorArgs != null && this.constructorArgTypes != null ?
                enhancer.create(this.constructorArgTypes, this.constructorArgs) :
                enhancer.create());
    }

    public Object create() {
        classOnly = false;
        argumentTypes = null;
        return createHelper();
    }

    private Object createHelper() {
        preValidate();
        Object key = KEY_FACTORY.newInstance((superclass != null) ? superclass.getName() : null,
                ReflectUtils.getNames(interfaces),
                filter == ALL_ZERO ? null : new WeakCacheKey<CallbackFilter>(filter),
                callbackTypes,
                useFactory,
                interceptDuringConstruction,
                serialVersionUID);
        this.currentKey = key;
        Object result = super.create(key);
        return result;
    }

    protected Object create(Object key) {
        try {
            ClassLoader loader = getClassLoader();
            Map<ClassLoader, ClassLoaderData> cache = CACHE;
            ClassLoaderData data = cache.get(loader);
            if (data == null) {
                synchronized (AbstractClassGenerator.class) {
                    cache = CACHE;
                    data = cache.get(loader);
                    if (data == null) {
                        Map<ClassLoader, ClassLoaderData> newCache = new WeakHashMap<ClassLoader, ClassLoaderData>(cache);
                        data = new ClassLoaderData(loader);
                        newCache.put(loader, data);
                        CACHE = newCache;
                    }
                }
            }
            this.key = key;
            Object obj = data.get(this, getUseCache());
            if (obj instanceof Class) {
                return firstInstance((Class) obj);
            }
            return nextInstance(obj);
        }
        catch (RuntimeException | Error ex) {
            throw ex;
        }
        catch (Exception ex) {
            throw new CodeGenerationException(ex);
        }
    }

CGLIB 是一套强大的高性能的代码生成工具包，底层通过字节码生成技术ASM框架来实现，由于直接实现ASM需要熟悉JVM内部结构以及Class文件格式和指令集，所以不推荐直接使用ASM，而CGLIB就是在ASM框架基础之上的封装。所以在继续分析CGLIB实现AOP逻辑原理之前可以先熟悉下CGLIB的用法。

2.1、CGLIB的使用案例

第一步：定义目标类

public class UserService {

    public void addUser(){
        System.out.println("添加新用户");
    }

    public void getUser(){
        System.out.println("查询用户信息");
    }
}

定义UserService类，注意这里是类而不是接口，因为CGLIB是原理是给目标类生成子类，而不是实现接口

第二步：定义Callback，或者说是方法拦截器，或者说就是AOP中的增强逻辑

package com.lucky.test.spring.cglib;

import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

/**
 * 自定义方法拦截器
 */
public class CglibMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        System.out.println("前置增强方法执行");

        /** 执行父类方法 */
        Object result = methodProxy.invokeSuper(o, objects);

        System.out.println("后置增强方法执行");
        return result;
    }
}

自定义方法拦截器实现了CGLIB包中的MethodInterceotor接口，该接口继承之Callback接口，在实现中插入了前置增强和后置增强逻辑，并且在实现中通过MethodProxy.invokeSuper方法执行了父类的方法

第三步：创建子类

/** 创建目标类的子类实例*/
    public static Object getInstance(Class superClass, Callback callback){
        Enhancer enhancer = new Enhancer();
        //设置父类
        enhancer.setSuperclass(superClass);
        //设置回调,MethodInterceptor就是继承的Callback接口
        enhancer.setCallback(callback);
        //通过字节码生成技术,创建目标类superClass的子类实例
        return enhancer.create();
    }

CGLIB创建目标类子类是通过Enhancer类的create方法创建的，所以在创建之前需要先构造一个Enhancer对象，然后设置父类、callback等属性，最后通过ASM框架的字节码生成技术创建目标类的子类

第四步：测试代码如下：

public static void main(String[] args){

        //新建方法拦截器对象
        MethodInterceptor callback = new CglibMethodInterceptor();
        //构造目标类的子类
        UserService userService = (UserService)getInstance(UserService.class, callback);
        //执行目标类方法,实际执行的是子类的方法
        userService.addUser();
    }

先创建Callback实现类MethodInterceptor的实例，然后调用getInstance方法传入目标类UserService.class和方法拦截器CglibMethodInterceptor对象获取目标类的子类实例，最好执行子类方法，结果如下：

前置增强方法执行
添加新用户
后置增强方法执行

通过CGLIB创建子类的方式，成功实现了AOP的增强逻辑织入。

2.2、Spring AOP 的CGLIB生成代理的实现逻辑总结

（**重点*）

1、获取到目标对象的Class对象

2、获取所有的增强Advisor列表，并全部封装成Callback实现类MethodIncetor对象

3、构造Enhancer对象，并设置属性将目标类和需要添加的Callback全部设置为Enhancer的属性

4、通过调用Enhancer对象的create方法通过底层ASM框架的字节码生成技术创建目标对象的子类

5、获取到目标对象的子类，通过子类的方法，在子类方法中相当于也是执行了Callback的链，和JDK的方法拦截器流程类似

6、每次执行子类方法，都会执行链路上的所有Callback的intercept方法，在方法内部执行增强逻辑，并执行invokeSuper方法执行父类（目标类）的方法