Spring源码学习笔记（7）

Spring源码学习笔记（七）

　　前言--

　　　　最近花了些时间看了《Spring源码深度解析》这本书，算是入门了Spring的源码吧。打算写下系列文章，回忆一下书的内容，总结代码的运行流程。推荐那些和我一样没接触过SSH框架源码又想学习的，阅读郝佳编著的《Spring源码深度解析》这本书，会是个很好的入门

 

---

 

　　　　　　写前说句话， 开篇不尴尬 ---- 接下的这一篇当中， 我们将来回顾 Spring 中 AOP 功能的实现流程。  早上精力充沛， 开始新一天的学习 \(^o^)/~

 

---

 

　　　　　　接触过 Spring 框架的同学都知道， Spring 中使用的两个功能无非就是依赖注入的 DI 以及面向切面编程的 AOP， 其中 AOP 又包括了动态 AOP 和静态 AOP 两个方向。 首先，我们来看看 Spring 是如何实现我们最常接触到的动态 AOP 的。

 

动态AOP

　　　 启用 Spring 的 AOP 功能， 需要我们在 Spring 的配置文件中添加 <aop:aspectj-autoproxy/> 。我们将从这个配置为入口看看 AOP 的实现过程。

　　　　　在 AopNamespaceHandler 中， 有一下初始化代码：

public class AopNamespaceHandler extends NamespaceHandlerSupport {
    public AopNamespaceHandler() {
    }

    public void init() {
        this.registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
        //第一步：  在此注册 AOP 功能
        this.registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
        this.registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());
        this.registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
    }
}

 

　　　　进入 AspectJAutoProxyBeanDefinitionParser 类中， 发现该类实现了 BeanDefinitionParser 接口， 所以查看该类的 parse() 方法， 其实现逻辑：

    public BeanDefinition parse(Element element, ParserContext parserContext) {
          //第一步：  注册 AnnotationAwareAspectJAutoProxyCreator
        
　　　　 AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
        this.extendBeanDefinition(element, parserContext);
        return null;
    }

 

　　　　进入 registerAspectJAnnotationAutoProxyCreatorIfNecessary() 方法中查看实现逻辑：

    public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(ParserContext parserContext, Element sourceElement) {
        //第一步：  注册 AutoProxyCreator 的 BeanDefinition
        BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext.getRegistry(), parserContext.extractSource(sourceElement));
        //第二步：   处理 proxy-target-class 和 expose-proxy 属性
    useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
        //第三步：  通知监听器, beanDefinition 的 className 为 AnnotationAwareAspectJAutoProxyCreator
    registerComponentIfNecessary(beanDefinition, parserContext);
    }

 

　　　　进入 registerAspectJAnnotationAutoProxyCreatorIfNecessary() 方法， 一步步查看三个方法中的每个方法.

　　　 首先 registerAspectJAnnotationAutoProxyCreatorIfNecessary()， 注册实现 AOP 功能的 AnnotationAwareAspectJAutoProxyCreator 类：

    public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, Object source) {
        // 第一步：  继续方法的调用
        return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
    }

 

    private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, Object source) {
        Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
        //第一步： 判断是否已经存在 AutoProxyCreator 且存在的 Creator 和当前的不一致, 需要决定使用哪个
        if(registry.containsBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator")) {
            BeanDefinition apcDefinition = registry.getBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator");
            if(!cls.getName().equals(apcDefinition.getBeanClassName())) {
                int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
                int requiredPriority = findPriorityForClass(cls);
                if(currentPriority < requiredPriority) {
                    apcDefinition.setBeanClassName(cls.getName());
                }
            }
            //第二步：  存在 AutoProxyCreator 且与当前的一致, 则直接返回
            return null;
        } else {
            //第三步：  重新创建 AutoProxyCreator
            RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
            beanDefinition.setSource(source);
            beanDefinition.getPropertyValues().add("order", Integer.valueOf(-2147483648));
            beanDefinition.setRole(2);
            registry.registerBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator", beanDefinition);
            return beanDefinition;
        }
    }

　　　　简单易懂， 条理清晰， 我喜欢 ~(￣▽￣)~*

　　　　接下来在 registerAspectJAnnotationAutoProxyCreatorIfNecessary() 方法中, 第二步对 proxy-target-class 和 expose-proxy 属性的处理的 useClassProxyingIfNecessary() 逻辑：

    private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, Element sourceElement) {
        if(sourceElement != null) {
            //第一步： 处理 proxy-target-class
            boolean proxyTargetClass = Boolean.valueOf(sourceElement.getAttribute("proxy-target-class")).booleanValue();
            if(proxyTargetClass) {
                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
            }
            //第二步：  处理 expose-proxy 
            boolean exposeProxy = Boolean.valueOf(sourceElement.getAttribute("expose-proxy")).booleanValue();
            if(exposeProxy) {
                AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
            }
        }

    }

 

　　　　进入处理 proxy-target-class 属性的逻辑：

    public static void forceAutoProxyCreatorToUseClassProxying(BeanDefinitionRegistry registry) {
         if(registry.containsBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator")) {
            BeanDefinition definition = registry.getBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator");
            //第一步：  为 BeanDefinition 添加 proxyTargetClass 属性
            definition.getPropertyValues().add("proxyTargetClass", Boolean.TRUE);
        }

    }

 

　　　　进入处理 expose-proxy 属性的逻辑：

    static void forceAutoProxyCreatorToExposeProxy(BeanDefinitionRegistry registry) {
        if(registry.containsBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator")) {
            BeanDefinition definition = registry.getBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator");
            //第一步：  为 BeanDefinition 添加 exposeProxy 属性
            definition.getPropertyValues().add("exposeProxy", Boolean.TRUE);
        }

    }

 

　　　　实现的逻辑很简单， 为 BeanDefinition 添加了不同的属性。 Spring 使用 JDK 的动态代理 或者使用 CGLIB 创建代理类， 使用 proxy-target-class 配置来决定使用哪种方式，需要注意其中使用的区别：

　　　　1, 强制使用 CGLIB 生成代理类， 配置  <aop:config proxy-target-class="true"/>;

　　　2, 使用 CGLIB 和 @AspectJ 自动代理时， 配置  <aop:aspectj-autoproxy proxy-target-class="true"/>;

　　　3, 只有在类有实现接口的情况下， 才能使用 JDK 的动态代理生成代理类， 使用 CGLIB 的时候需要注意不能通知 final 方法;

　　　　而对于 expose-proxy 的是情况是， 在代理的目标类里， 类方法调用自身的方法时， 被调用方法不会再调用方法的增强逻辑， 若需要调用， 则需要配置：

　　　　　　<aop:aspectj-autoproxy expose-proxy="true"/>

　　　　讲了这么多， 发现我们只是看到了 Spring AOP 的入口方法以及基础的实现类， 而真正的创建 代理类 的逻辑我们并没有看到，因此，这就是我们接下来要做的事情。

　　　　

　　　　上面讲到 Spring AOP 的基本的实现类是 AnnotationAwareAspectJAutoProxyCreator , 使用 IntelliJ 的功能， 我们瞄一下该类的层次结构：

　　　　

　　　　可以看到 AnnotationAwareAspectJAutoProxyCreator  实现了 BeanPostProcessor 类，查看其实现的方法， 在父类 AbstractAutoProxyCreator 中：

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if(bean != null) {
            //第一步： 构建对应 bean 的 className_beanName 的 key
            Object cacheKey = this.getCacheKey(bean.getClass(), beanName);
            if(!this.earlyProxyReferences.contains(cacheKey)) {
                //第二步： 需要代理， 封装 bean
                return this.wrapIfNecessary(bean, beanName, cacheKey);
            }
        }

        return bean;
    }

 

    protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
        //第一步： 已经处理过直接返回
        if(beanName != null && this.targetSourcedBeans.contains(beanName)) {
            return bean;
        } else 
         //第二步：  无需增强直接返回
 if(Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
            return bean;
        } //第三步： 略过 基础类 或者 配置了 不用代理 
            else if(!this.isInfrastructureClass(bean.getClass()) && !this.shouldSkip(bean.getClass(), beanName)) {
            //第四步： 获取 增强器
            Object[] specificInterceptors = this.getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, (TargetSource)null);
            //第五步： 存在增强则增强
            if(specificInterceptors != DO_NOT_PROXY) {
                this.advisedBeans.put(cacheKey, Boolean.TRUE);
                 //第六步：  用增强器创建代理类
                Object proxy = this.createProxy(bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
                this.proxyTypes.put(cacheKey, proxy.getClass());
                return proxy;
            } else {
                this.advisedBeans.put(cacheKey, Boolean.FALSE);
                return bean;
            }
        } else {
            this.advisedBeans.put(cacheKey, Boolean.FALSE);
            return bean;
        }
    }

 

 　　　　看起来很简单， 是否爽了一把， 接下来分分点分析其中的逻辑。

一, 获取增强器

    protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource targetSource) {
        List<Advisor> advisors = this.findEligibleAdvisors(beanClass, beanName);
        return advisors.isEmpty()?DO_NOT_PROXY:advisors.toArray();
    }

    protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
        //第一步： 查询所有的增强
        List<Advisor> candidateAdvisors = this.findCandidateAdvisors();
        //第二步： 查询适合的增强
        List<Advisor> eligibleAdvisors = this.findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
        this.extendAdvisors(eligibleAdvisors);
        if(!eligibleAdvisors.isEmpty()) {
            eligibleAdvisors = this.sortAdvisors(eligibleAdvisors);
        }

        return eligibleAdvisors;
    }

 

 　　　　我不想解释， 你也不想听！！！( *^-^)ρ(*╯^╰)

 　　　　查询所有的增强的方法 findCandidateAdvisors() 的实现逻辑， 在 AnnotationAwareAspectJAutoProxyCreator 类中：

    protected List<Advisor> findCandidateAdvisors() {
        //第一步： 调用父类加载 XML 文件的方法
        List<Advisor> advisors = super.findCandidateAdvisors();
        //第二步:   类扩展父类实现的通过注解获取增强的方法
         advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
        return advisors;
    }

 

 

 

 　　　　由前面的 Diagram 图可以看出， AnnotationAwareAspectJAutoProxyCreator 类继承 AbstractAdvisorAutoProxyCreator 类， 子类在父类获取 XML 文件的增强之外， 还实现了从 @AspectJ 获取增强的方法。

　　　　在 findCandidateAdvisors() 方法中， 第二步通过注解获取增强的方法 buildAspectJAvisors() 的实现逻辑：

    public List<Advisor> buildAspectJAdvisors() {
        List<String> aspectNames = null;
        synchronized(this) {
            aspectNames = this.aspectBeanNames;
            if(aspectNames == null) {
                List<Advisor> advisors = new LinkedList();
                List<String> aspectNames = new LinkedList();
                //第一步： 获取所有的 beanName
                String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this.beanFactory, Object.class, true, false);
                String[] var18 = beanNames;
                int var19 = beanNames.length;
                //第二步： 遍历所有的 beanName 找出增强方法
                for(int var7 = 0; var7 < var19; ++var7) {
                    String beanName = var18[var7];
                    if(this.isEligibleBean(beanName)) {
                        //第三步： 获取 bean 的类型
                        Class<?> beanType = this.beanFactory.getType(beanName);
                        //第四步：  存在 AspectJ 注解 （此处的 advisorFactory 是 AbstractAspectJAdvisorFactory）
                        if(beanType != null && this.advisorFactory.isAspect(beanType)) {
                            aspectNames.add(beanName);
                            AspectMetadata amd = new AspectMetadata(beanType, beanName);
                            if(amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
                                MetadataAwareAspectInstanceFactory factory = new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
                                //第五步：解析 AspectJ 注解的增强方法 
                                List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
                                //第六步:  加入缓存的操作
                                if(this.beanFactory.isSingleton(beanName)) {
                                    this.advisorsCache.put(beanName, classAdvisors);
                                } else {
                                    this.aspectFactoryCache.put(beanName, factory);
                                }

                                advisors.addAll(classAdvisors);
                            } else {
                                if(this.beanFactory.isSingleton(beanName)) {
                                    throw new IllegalArgumentException("Bean with name '" + beanName + "' is a singleton, but aspect instantiation model is not singleton");
                                }

                                MetadataAwareAspectInstanceFactory factory = new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
                                this.aspectFactoryCache.put(beanName, factory);
                                advisors.addAll(this.advisorFactory.getAdvisors(factory));
                            }
                        }
                    }
                }

                this.aspectBeanNames = aspectNames;
                return advisors;
            }
        }

        if(aspectNames.isEmpty()) {
            return Collections.emptyList();
        } else {
            List<Advisor> advisors = new LinkedList();
            Iterator var3 = aspectNames.iterator();
            //第七步：  加入缓存的操作
            while(var3.hasNext()) {
                String aspectName = (String)var3.next();
                List<Advisor> cachedAdvisors = (List)this.advisorsCache.get(aspectName);
                if(cachedAdvisors != null) {
                    advisors.addAll(cachedAdvisors);
                } else {
                    MetadataAwareAspectInstanceFactory factory = (MetadataAwareAspectInstanceFactory)this.aspectFactoryCache.get(aspectName);
                    advisors.addAll(this.advisorFactory.getAdvisors(factory));
                }
            }

            return advisors;
        }
    }

 

 　　　　在  buildAspectJAdvisors() 方法中， 第五步获取增强器的 getAdvisors() 的实现， 实现在 ReflectiveAspectJAdvisorFactory 类中：

   public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory maaif) {
        //第一步： 获取标记为 AspectJ 的类
        Class<?> aspectClass = maaif.getAspectMetadata().getAspectClass();
        //第二步： 获取标记为 AspectJ 的名字
        String aspectName = maaif.getAspectMetadata().getAspectName();
        this.validate(aspectClass);
        MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory = new LazySingletonAspectInstanceFactoryDecorator(maaif);
        List<Advisor> advisors = new LinkedList();
        //第三步： 获取所有的方法
        Iterator var6 = this.getAdvisorMethods(aspectClass).iterator();
        //第四步:  遍历所有的方法
        while(var6.hasNext()) {
            Method method = (Method)var6.next();
            Advisor advisor = this.getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
            if(advisor != null) {
                advisors.add(advisor);
            }
        }
        //第五步： 增强器不为空且配置增强延迟初始化则封装同步化实例增强器
        if(!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
            Advisor instantiationAdvisor = new ReflectiveAspectJAdvisorFactory.SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
            advisors.add(0, instantiationAdvisor);
        }
        //第六步：  获取 DeclareParents 注解
        Field[] var12 = aspectClass.getDeclaredFields();
        int var13 = var12.length;

        for(int var14 = 0; var14 < var13; ++var14) {
            Field field = var12[var14];
            Advisor advisor = this.getDeclareParentsAdvisor(field);
            if(advisor != null) {
                advisors.add(advisor);
            }
        }

        return advisors;
    }

 

　　　　在 getAdvisors() 方法中， 第四步普通增强器的获取方法 getAdvisor()  方法的实现逻辑：

    public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aif, int declarationOrderInAspect, String aspectName) {
        this.validate(aif.getAspectMetadata().getAspectClass());
        //第一步：  切点信息的获取 封装类
        AspectJExpressionPointcut ajexp = this.getPointcut(candidateAdviceMethod, aif.getAspectMetadata().getAspectClass());
        //第二步： 根据切点信息生成增强器  也是封装类
        return ajexp == null?null:new InstantiationModelAwarePointcutAdvisorImpl(this, ajexp, aif, candidateAdviceMethod, declarationOrderInAspect, aspectName);
    }

 

 　　　　在 getAdvisor() 方法中， 第一步切点信息的获取方法 getPointcut() 方法的实现逻辑， 封装成 AspectJExpressionPointcut 类：

    private AspectJExpressionPointcut getPointcut(Method candidateAdviceMethod, Class<?> candidateAspectClass) {
        //第一步： 获取方法上的注解
        AspectJAnnotation<?> aspectJAnnotation = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
        if(aspectJAnnotation == null) {
            return null;
        } else {
            //第二步：  封装获取的信息 
            AspectJExpressionPointcut ajexp = new AspectJExpressionPointcut(candidateAspectClass, new String[0], new Class[0]);
            ajexp.setExpression(aspectJAnnotation.getPointcutExpression());
            return ajexp;
        }
    }

 

　　　　第一步中获取方法上的注解 findAspectJAnnotationOnMethod() 方法的实现逻辑：   （这个方法值得注意一下~~~~~~~~~~~~~）

    protected static AbstractAspectJAdvisorFactory.AspectJAnnotation<?> findAspectJAnnotationOnMethod(Method method) {
        //第一步： 列举所有的 注解的类
        Class<?>[] classesToLookFor = new Class[]{Before.class, Around.class, After.class, AfterReturning.class, AfterThrowing.class, Pointcut.class};
        Class[] var2 = classesToLookFor;
        int var3 = classesToLookFor.length;
        //第二步：遍历所有的注解类 匹配注解信息
        for(int var4 = 0; var4 < var3; ++var4) {
            Class<?> c = var2[var4];
            AbstractAspectJAdvisorFactory.AspectJAnnotation<?> foundAnnotation = findAnnotation(method, c);
            if(foundAnnotation != null) {
                return foundAnnotation;
            }
        }

        return null;
    }

 

 　　　　在  findAspectJAnnotationOnMethod() 方法中， 第二步获取指定方法上的注解并使用 AspectJAnnotation 封装信息的 findAnnotation() 实现逻辑：

    private static <A extends Annotation> AbstractAspectJAdvisorFactory.AspectJAnnotation<A> findAnnotation(Method method, Class<A> toLookFor) {
        //第一步： 匹配注解类
        A result = AnnotationUtils.findAnnotation(method, toLookFor);
        //第二步： 封装到类中
        return result != null?new AbstractAspectJAdvisorFactory.AspectJAnnotation(result):null;
    }

 

 　　　　瞄一下匹配注解类的方法 AnnotationUtils.findAnnotation()  的实现逻辑：

    public static <A extends Annotation> A findAnnotation(Method method, Class<A> annotationType) {
        //第一步：  获取注解
        A annotation = getAnnotation(method, annotationType);
        //第二步：  获取 class 
        Class<?> clazz = method.getDeclaringClass();
        if(annotation == null) {
            annotation = searchOnInterfaces(method, annotationType, clazz.getInterfaces());
        }
        //第三步：  递归到父类去查找
        while(annotation == null) {
            clazz = clazz.getSuperclass();
            if(clazz == null || clazz.equals(Object.class)) {
                break;
            }

            try {
                //第四步： 获取类中指定的方法 及 方法上的注解
                Method equivalentMethod = clazz.getDeclaredMethod(method.getName(), method.getParameterTypes());
                annotation = getAnnotation(equivalentMethod, annotationType);
            } catch (NoSuchMethodException var5) {
                ;
            }

            if(annotation == null) {
                annotation = searchOnInterfaces(method, annotationType, clazz.getInterfaces());
            }
        }

        return annotation;
    }

 

　　　　在 findAnnotation() 方法中， 深入的实现逻辑并看不懂， 应该是从 getAnnotation() 和 searchOnInterfaces() 方法入口， 方法的重载也很多， 容易晕！！！

　　　　避实就虚， 抱大腿， 回到 getAdvisor() 方法中， 封装增强器的 InstantiationModelAwarePointcutAdvisorImpl 类是 Advisor 的实现类， 瞄一下该类的构造器：

  public InstantiationModelAwarePointcutAdvisorImpl(AspectJAdvisorFactory af, AspectJExpressionPointcut ajexp, MetadataAwareAspectInstanceFactory aif, Method method, int declarationOrderInAspect, String aspectName) {
        // 例子 ：@Before("test()") 
        //第一步： 被切入方法 test()
        this.declaredPointcut = ajexp;
        //第二步： 切入的方法
        this.method = method;
        this.atAspectJAdvisorFactory = af;
        this.aspectInstanceFactory = aif;
        this.declarationOrder = declarationOrderInAspect;
        //第三步： 切面的名称
        this.aspectName = aspectName;
        //第四步：pointcut 是懒加载类型
        if(aif.getAspectMetadata().isLazilyInstantiated()) {
            Pointcut preInstantiationPointcut = Pointcuts.union(aif.getAspectMetadata().getPerClausePointcut(), this.declaredPointcut);
            this.pointcut = new InstantiationModelAwarePointcutAdvisorImpl.PerTargetInstantiationModelPointcut(this.declaredPointcut, preInstantiationPointcut, aif, (InstantiationModelAwarePointcutAdvisorImpl.SyntheticClass_1)null);
            this.lazy = true;
        } else {
            //第五步：  单例 aspect
            this.instantiatedAdvice = this.instantiateAdvice(this.declaredPointcut);
            this.pointcut = this.declaredPointcut;
            this.lazy = false;
        }

    }

 

 　　　　在该构造方法中， 根据注解信息初始化对应的增强器 instantiateAdvice() 方法的实现逻辑：

    private Advice instantiateAdvice(AspectJExpressionPointcut pcut) {
        //第一步： 继续调用方法
        return this.atAspectJAdvisorFactory.getAdvice(this.method, pcut, this.aspectInstanceFactory, this.declarationOrder, this.aspectName);
    }

 

 　　　　这里的  AspectJAdvisorFactory 类型的 atAspectJAdvisorFactory 对象是 ReflectiveAspectJAdvisorFactory 的实例，该类中的 getAdvice() 方法的实现逻辑：

    public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut ajexp, MetadataAwareAspectInstanceFactory aif, int declarationOrderInAspect, String aspectName) {
        Class<?> candidateAspectClass = aif.getAspectMetadata().getAspectClass();
        this.validate(candidateAspectClass);
        AspectJAnnotation<?> aspectJAnnotation = AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
        if(aspectJAnnotation == null) {
            return null;
        } else if(!this.isAspect(candidateAspectClass)) {
            throw new AopConfigException("Advice must be declared inside an aspect type: Offending method '" + candidateAdviceMethod + "' in class [" + candidateAspectClass.getName() + "]");
        } else {
            if(this.logger.isDebugEnabled()) {
                this.logger.debug("Found AspectJ method: " + candidateAdviceMethod);
            }

            Object springAdvice;
            //第一步：  对不同增强器的方法封装不同的类
            switch(ReflectiveAspectJAdvisorFactory.SyntheticClass_1.$SwitchMap$org$springframework$aop$aspectj$annotation$AbstractAspectJAdvisorFactory$AspectJAnnotationType[aspectJAnnotation.getAnnotationType().ordinal()]) {
            case 1:
                springAdvice = new AspectJMethodBeforeAdvice(candidateAdviceMethod, ajexp, aif);
                break;
            case 2:
                springAdvice = new AspectJAfterAdvice(candidateAdviceMethod, ajexp, aif);
                break;
            case 3:
                springAdvice = new AspectJAfterReturningAdvice(candidateAdviceMethod, ajexp, aif);
                AfterReturning afterReturningAnnotation = (AfterReturning)aspectJAnnotation.getAnnotation();
                if(StringUtils.hasText(afterReturningAnnotation.returning())) {
                    ((AbstractAspectJAdvice)springAdvice).setReturningName(afterReturningAnnotation.returning());
                }
                break;
            case 4:
                springAdvice = new AspectJAfterThrowingAdvice(candidateAdviceMethod, ajexp, aif);
                AfterThrowing afterThrowingAnnotation = (AfterThrowing)aspectJAnnotation.getAnnotation();
                if(StringUtils.hasText(afterThrowingAnnotation.throwing())) {
                    ((AbstractAspectJAdvice)springAdvice).setThrowingName(afterThrowingAnnotation.throwing());
                }
                break;
            case 5:
                springAdvice = new AspectJAroundAdvice(candidateAdviceMethod, ajexp, aif);
                break;
            case 6:
                if(this.logger.isDebugEnabled()) {
                    this.logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
                }

                return null;
            default:
                throw new UnsupportedOperationException("Unsupported advice type on method " + candidateAdviceMethod);
            }
             //第二步：  配置增强器
             ((AbstractAspectJAdvice)springAdvice).setAspectName(aspectName);
            ((AbstractAspectJAdvice)springAdvice).setDeclarationOrder(declarationOrderInAspect);
            String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
            if(argNames != null) {
                ((AbstractAspectJAdvice)springAdvice).setArgumentNamesFromStringArray(argNames);
            }

            ((AbstractAspectJAdvice)springAdvice).calculateArgumentBindings();
            return (Advice)springAdvice;
        }
    }

 

 　　　　从上面的 getAdvice() 方法中，我们可以看出， 对不同的注解 Spring 会生成不同的 Advice 进行处理。

　　　　 对 @AtBefore 注解， 对应的是 AspectJMethodBeforeAdvice :　　（逻辑是对的， 但是找不到 AspectJMethodBeforeAdvice 和 MethodBeforeAdviceInterceptor 的关系  (￣～￣) ！）

public class MethodBeforeAdviceInterceptor implements MethodInterceptor, Serializable {
    private MethodBeforeAdvice advice;

    public MethodBeforeAdviceInterceptor(MethodBeforeAdvice advice) {
        //第一步： 构造函数中传入一个 MethodBeforeAdvice 
        Assert.notNull(advice, "Advice must not be null");
        this.advice = advice;
    }
    //第二步： 调用 before() 方法
    public Object invoke(MethodInvocation mi) throws Throwable {
        this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
        return mi.proceed();
    }
}

 

 　　　　其中的 advice 属性是 AspectJMethodBeforeAdvice 类的， 查看 before() 方法：

    public void before(Method method, Object[] args, Object target) throws Throwable {
        this.invokeAdviceMethod(this.getJoinPointMatch(), (Object)null, (Throwable)null);
    }

 

    protected Object invokeAdviceMethod(JoinPointMatch jpMatch, Object returnValue, Throwable ex) throws Throwable {
        return this.invokeAdviceMethodWithGivenArgs(this.argBinding(this.getJoinPoint(), jpMatch, returnValue, ex));
    }

    protected Object invokeAdviceMethodWithGivenArgs(Object[] args) throws Throwable {
        //第一步： 获取参数
        Object[] actualArgs = args;
        if(this.aspectJAdviceMethod.getParameterTypes().length == 0) {
            actualArgs = null;
        }

        try {
            ReflectionUtils.makeAccessible(this.aspectJAdviceMethod);
            //第二步： 调用方法
            return this.aspectJAdviceMethod.invoke(this.aspectInstanceFactory.getAspectInstance(), actualArgs);
        } catch (IllegalArgumentException var4) {
            throw new AopInvocationException("Mismatch on arguments to advice method [" + this.aspectJAdviceMethod + "]; pointcut expression [" + this.pointcut.getPointcutExpression() + "]", var4);
        } catch (InvocationTargetException var5) {
            throw var5.getTargetException();
        }
    }

 

 　　　　而对于 @After 注解， 对应的是 AspectJAfterAdvice 类 ：

public class AspectJAfterAdvice extends AbstractAspectJAdvice implements MethodInterceptor, AfterAdvice {
    public AspectJAfterAdvice(Method aspectJBeforeAdviceMethod, AspectJExpressionPointcut pointcut, AspectInstanceFactory aif) {
        super(aspectJBeforeAdviceMethod, pointcut, aif);
    }

    public Object invoke(MethodInvocation mi) throws Throwable {
        Object var2;
        try {
            //第一步： 调用 被切入方法
            var2 = mi.proceed();
        } finally {
            //第二步：  调用 切入方法
            this.invokeAdviceMethod(this.getJoinPointMatch(), (Object)null, (Throwable)null);
        }

        return var2;
    }

    public boolean isBeforeAdvice() {
        return false;
    }

    public boolean isAfterAdvice() {
        return true;
    }
}

 

 　　　　way so far, way so hard!  可能已经忘了， 回到 getAdvisors() 方法的第五步中， 同步实例化增强器  SyntheticInstantiationAdvisor 的作用， 该类是 ReflectiveAspectJAdvisorFactory 的一个内部类：

    protected static class SyntheticInstantiationAdvisor extends DefaultPointcutAdvisor {
        public SyntheticInstantiationAdvisor(final MetadataAwareAspectInstanceFactory aif) {
            super(aif.getAspectMetadata().getPerClausePointcut(), new MethodBeforeAdvice() {
                //第一步： 目标方法前调用 before 方法
                public void before(Method method, Object[] args, Object target) {
                    //第二步： 初始化 aspect
                    aif.getAspectInstance();
                }
            });
        }
    }

 

　　　　在 getAdvisors() 方法中， 第六步获取 DeclareParents 注解的作用主要是处理 IntroductionAdvisor ，具体干什么的其实我也没见过 (ಥ _ ಥ)

    private Advisor getDeclareParentsAdvisor(Field introductionField) {
        DeclareParents declareParents = (DeclareParents)introductionField.getAnnotation(DeclareParents.class);
        if(declareParents == null) {
            return null;
        } else if(DeclareParents.class.equals(declareParents.defaultImpl())) {
            throw new IllegalStateException("defaultImpl must be set on DeclareParents");
        } else {
            //  封装信息
            return new DeclareParentsAdvisor(introductionField.getType(), declareParents.value(), declareParents.defaultImpl());
        }
    }

 

　　　　不骗你， 这么多的代码，其实只是 findEligibleAdvisors() 方法中的 findCandidateAdvisors() 方法的深入， 找到所有的增强器之后还需要找合适的增强器 findAdvisorsThatCanApply()：

    protected List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {
        ProxyCreationContext.setCurrentProxiedBeanName(beanName);

        List var4;
        try {
            //第一步：  过滤已经得到的 advisors
            var4 = AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
        } finally {
            ProxyCreationContext.setCurrentProxiedBeanName((String)null);
        }

        return var4;
    }

 

 

    public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
        if(candidateAdvisors.isEmpty()) {
            return candidateAdvisors;
        } else {
            List<Advisor> eligibleAdvisors = new LinkedList();
            Iterator var3 = candidateAdvisors.iterator();
            
            while(var3.hasNext()) {
                Advisor candidate = (Advisor)var3.next();
                //第一步： 首先处理  IntroductionAdvisor 
                if(candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
                    eligibleAdvisors.add(candidate);
                }
            }

            boolean hasIntroductions = !eligibleAdvisors.isEmpty();
            Iterator var7 = candidateAdvisors.iterator();

            while(var7.hasNext()) {
                Advisor candidate = (Advisor)var7.next();
                //第二步： 略过已经处理的 IntroductionAdvisor  并处理普通的 bean 
                if(!(candidate instanceof IntroductionAdvisor) && canApply(candidate, clazz, hasIntroductions)) {
                    eligibleAdvisors.add(candidate);
                }
            }

            return eligibleAdvisors;
        }
    }

    public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
        //第一步： 处理 IntroductionAdvisor
        if(advisor instanceof IntroductionAdvisor) {
            return ((IntroductionAdvisor)advisor).getClassFilter().matches(targetClass);
        } else if(advisor instanceof PointcutAdvisor) {
            //第二步： 处理 普通 bean
            PointcutAdvisor pca = (PointcutAdvisor)advisor;
            return canApply(pca.getPointcut(), targetClass, hasIntroductions);
        } else {
            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;
        } else {
            MethodMatcher methodMatcher = pc.getMethodMatcher();
            IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
            if(methodMatcher instanceof IntroductionAwareMethodMatcher) {
                introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher)methodMatcher;
            }

            Set<Class<?>> classes = new HashSet(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
            classes.add(targetClass);
            Iterator var6 = classes.iterator();

            while(var6.hasNext()) {
                Class<?> clazz = (Class)var6.next();
                Method[] methods = clazz.getMethods();
                Method[] var9 = methods;
                int var10 = methods.length;
                //第一步： 遍历所有的方法并进行方法匹配
                for(int var11 = 0; var11 < var10; ++var11) {
                    Method method = var9[var11];
                    if(introductionAwareMethodMatcher != null && introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions) || methodMatcher.matches(method, targetClass)) {
                        return true;
                    }
                }
            }

            return false;
        }
    }

 

 二, 创建代理

　　　　网上拉，知道看到 wrapIfNecessary() 方法中的第二步， 通过获取的增强器创建代理的 createProxy() 方法， 知道人生这么一天其实也就一个方法而已。。。。　  

    protected Object createProxy(Class<?> beanClass, String beanName, Object[] specificInterceptors, TargetSource targetSource) {
        ProxyFactory proxyFactory = new ProxyFactory();
        //第一步： 获取当前类的相关属性
        proxyFactory.copyFrom(this);
        int var8;
        int var9;
        if(!this.shouldProxyTargetClass(beanClass, beanName)) {
            //第二步：  添加接口
            Class<?>[] targetInterfaces = ClassUtils.getAllInterfacesForClass(beanClass, this.proxyClassLoader);
            Class[] var7 = targetInterfaces;
            var8 = targetInterfaces.length;

            for(var9 = 0; var9 < var8; ++var9) {
                Class<?> targetInterface = var7[var9];
                proxyFactory.addInterface(targetInterface);
            }
        }
        //第三步： 加入增强器
        Advisor[] advisors = this.buildAdvisors(beanName, specificInterceptors);
        Advisor[] var13 = advisors;
        var8 = advisors.length;

        for(var9 = 0; var9 < var8; ++var9) {
            Advisor advisor = var13[var9];
            proxyFactory.addAdvisor(advisor);
        }
        //第四步： 设置要代理的类
        proxyFactory.setTargetSource(targetSource);
        //第五步： 使用自己的代理方法
        this.customizeProxyFactory(proxyFactory);
        //第六步： 设置代理之后是否允许修改
        proxyFactory.setFrozen(this.freezeProxy);
        if(this.advisorsPreFiltered()) {
            proxyFactory.setPreFiltered(true);
        }
        //第七步： 创建代理对象
        return proxyFactory.getProxy(this.proxyClassLoader);
    }

 

 　　　　在 createProxy() 方法的第三步中， 在加入增强器之前，需要把 拦截器封装成增强器的实现逻辑：

    protected Advisor[] buildAdvisors(String beanName, Object[] specificInterceptors) {
        //第一步： 解析所有注册的 interceptors
        Advisor[] commonInterceptors = this.resolveInterceptorNames();
        List<Object> allInterceptors = new ArrayList();
        if(specificInterceptors != null) {
            //第二步： 加入拦截器
            allInterceptors.addAll(Arrays.asList(specificInterceptors));
            if(commonInterceptors != null) {
                if(this.applyCommonInterceptorsFirst) {
                    allInterceptors.addAll(0, Arrays.asList(commonInterceptors));
                } else {
                    allInterceptors.addAll(Arrays.asList(commonInterceptors));
                }
            }
        }
        int i;

        Advisor[] advisors = new Advisor[allInterceptors.size()];

        for(i = 0; i < allInterceptors.size(); ++i) {
            //第三步： 拦截器封装为 Advisor
            advisors[i] = this.advisorAdapterRegistry.wrap(allInterceptors.get(i));
        }

        return advisors;
    }

    public Advisor wrap(Object adviceObject) throws UnknownAdviceTypeException {
        //第一步： 若本身已是 Advisor 则直接返回
        if(adviceObject instanceof Advisor) {
            return (Advisor)adviceObject;
        } else if(!(adviceObject instanceof Advice)) {
            //第二步： 不是 Advice 或 Advisor 则抛异常
            throw new UnknownAdviceTypeException(adviceObject);
        } else {
            Advice advice = (Advice)adviceObject;
            if(advice instanceof MethodInterceptor) {
                //第三步： 处理 MethodInterceptor 的情况
                return new DefaultPointcutAdvisor(advice);
            } else {
                Iterator var3 = this.adapters.iterator();
                //第四步： 存在 Advisor 的 adapter 同样封装
                AdvisorAdapter adapter;
                do {
                    if(!var3.hasNext()) {
                        throw new UnknownAdviceTypeException(advice);
                    }

                    adapter = (AdvisorAdapter)var3.next();
                } while(!adapter.supportsAdvice(advice));

                return new DefaultPointcutAdvisor(advice);
            }
        }
    }

 

 　　　　在 createProxy() 方法中， 根据获取的 Advisor 获取创建代理的 getProxy() 方法的实现逻辑：

    public Object getProxy(ClassLoader classLoader) {
        return this.createAopProxy().getProxy(classLoader);
    }

 

　　　　首先看看 createAopProxy() 方法的实现：

    protected final synchronized AopProxy createAopProxy() {
        if(!this.active) {
            this.activate();
        }
        //第一步：  创建代理
        return this.getAopProxyFactory().createAopProxy(this);
    }

    public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
        //第一步：  1， CGLIB 的优化策略  2， 代理目标类还是目标类的接口    3，是否存在代理接口 
        if(!config.isOptimize() && !config.isProxyTargetClass() && !this.hasNoUserSuppliedProxyInterfaces(config)) {
            //第二步： 使用 JDK 动态代理创建
            return new JdkDynamicAopProxy(config);
        } else {
            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.");
            } else {
                //第三步：  接口吗 ? JDK 动态代理 ： CGLIB 创建
                return (AopProxy)(targetClass.isInterface()?new JdkDynamicAopProxy(config):new ObjenesisCglibAopProxy(config));
            }
        }
    }

 

　　　　嘿嘿嘿， 先看看 JDK 动态代理的创建方法， 在 JdkDynamicAopProxy 类中：

    public Object getProxy(ClassLoader classLoader) {
        //第一步： 获取接口
        Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised);
        this.findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);
        //第二步：  创建代理
        return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);
    }

 

　　　　查看实现了 InvocationHandler 接口重写的 invoke() 方法：

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object oldProxy = null;
        boolean setProxyContext = false;
        TargetSource targetSource = this.advised.targetSource;
        Class<?> targetClass = null;
        Object target = null;

        Object var13;
        try {
            //第一步： 处理 equals 方法
            if(!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
                Boolean var18 = Boolean.valueOf(this.equals(args[0]));
                return var18;
            } 
            //第二步：  处理 hash 方法
            if(!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
                Integer var17 = Integer.valueOf(this.hashCode());
                return var17;
            }

            Object retVal;
            if(!this.advised.opaque && method.getDeclaringClass().isInterface() && method.getDeclaringClass().isAssignableFrom(Advised.class)) {
                // 第三步： 调用切点方法
                retVal = AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
                return retVal;
            }
             //第四步： 之前讲述过的 expose-proxy 属性的情况的处理
            if(this.advised.exposeProxy) {
                oldProxy = AopContext.setCurrentProxy(proxy);
                setProxyContext = true;
            }

            target = targetSource.getTarget();
            if(target != null) {
                targetClass = target.getClass();
            }
            //第五歩： 获取方法的拦截器链
            List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
            if(chain.isEmpty()) {
                //第六步： 拦截器为空 调用切点方法
                retVal = AopUtils.invokeJoinpointUsingReflection(target, method, args);
            } else {
                //第七步：  拦截器不为空 封装拦截器并调用方法
                MethodInvocation invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
                retVal = invocation.proceed();
            }
            //第八步： 返回结果
            Class<?> returnType = method.getReturnType();
            if(retVal != null && retVal == target && returnType.isInstance(proxy) && !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
                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);
            }

            var13 = retVal;
        } finally {
            if(target != null && !targetSource.isStatic()) {
                targetSource.releaseTarget(target);
            }

            if(setProxyContext) {
                AopContext.setCurrentProxy(oldProxy);
            }

        }

        return var13;
    }

 

　　　　在  JdkDynamicAopProxy 的 invoke()  方法中， 第七步调用拦截器链的 proceed() 实现逻辑， 方法在 ReflectiveMethodInvocation 类中， 从 jdk 又跑回 Spring 中了：

    public Object proceed() throws Throwable {
        if(this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
            return this.invokeJoinpoint();
        } else {
            //第一步： 获取要执行的下一个拦截器
            Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
            //第二步：  判断类型
            if(interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
                InterceptorAndDynamicMethodMatcher dm = (InterceptorAndDynamicMethodMatcher)interceptorOrInterceptionAdvice;
                //第三步：  调用拦截器的方法
                return dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)?dm.interceptor.invoke(this):this.proceed();
            } else {
                //第四步： 若是普通的拦截器  直接调用方法
                return ((MethodInterceptor)interceptorOrInterceptionAdvice).invoke(this);
            }
        }
    }

 

　　　　大致了解了 Jdk 创建代理的方法， 下面瞄一下 CGLIB 创建代理的实现方法：

    public Object getProxy(ClassLoader classLoader) {
        if(logger.isDebugEnabled()) {
            logger.debug("Creating CGLIB proxy: target source is " + this.advised.getTargetSource());
        }

        try {
            Class<?> rootClass = this.advised.getTargetClass();
            Assert.state(rootClass != null, "Target class must be available for creating a CGLIB proxy");
            Class<?> proxySuperClass = rootClass;
            int x;
            if(ClassUtils.isCglibProxyClass(rootClass)) {
                proxySuperClass = rootClass.getSuperclass();
                Class<?>[] additionalInterfaces = rootClass.getInterfaces();
                Class[] var5 = additionalInterfaces;
                int var6 = additionalInterfaces.length;

                for(x = 0; x < var6; ++x) {
                    Class<?> additionalInterface = var5[x];
                    this.advised.addInterface(additionalInterface);
                }
            }

            this.validateClassIfNecessary(proxySuperClass);
            //第一步：创建 CGLIB 必须的 Enchancer 并为其设置属性
            Enhancer enhancer = this.createEnhancer();
            if(classLoader != null) {
                enhancer.setClassLoader(classLoader);
                if(classLoader instanceof SmartClassLoader && ((SmartClassLoader)classLoader).isClassReloadable(proxySuperClass)) {
                    enhancer.setUseCache(false);
                }
            }

            enhancer.setSuperclass(proxySuperClass);
            enhancer.setStrategy(new MemorySafeUndeclaredThrowableStrategy(UndeclaredThrowableException.class));
            enhancer.setInterfaces(AopProxyUtils.completeProxiedInterfaces(this.advised));
            //第二步： 为 enchancer 设置 拦截器
            Callback[] callbacks = this.getCallbacks(rootClass);
            Class<?>[] types = new Class[callbacks.length];

            for(x = 0; x < types.length; ++x) {
                types[x] = callbacks[x].getClass();
            }

            enhancer.setCallbackTypes(types);
            enhancer.setCallbackFilter(new CglibAopProxy.ProxyCallbackFilter(this.advised.getConfigurationOnlyCopy(), this.fixedInterceptorMap, this.fixedInterceptorOffset));
            //第三步： 生成代理及创建代理类
            return this.createProxyClassAndInstance(enhancer, callbacks);
        } 
    }

 

　　　　为 enchancer 设置拦截器的 getCallbacks() 方法的实现逻辑：

    private Callback[] getCallbacks(Class<?> rootClass) throws Exception {
        //第一步：  对于 expose-proxy 属性的处理
        boolean exposeProxy = this.advised.isExposeProxy();
        boolean isFrozen = this.advised.isFrozen();
        boolean isStatic = this.advised.getTargetSource().isStatic();
        //第二步：  封装 DynamicAdvisedInterceptor 
        Callback aopInterceptor = new CglibAopProxy.DynamicAdvisedInterceptor(this.advised);
        Object targetInterceptor;
        if(exposeProxy) {
            targetInterceptor = isStatic?new CglibAopProxy.StaticUnadvisedExposedInterceptor(this.advised.getTargetSource().getTarget()):new CglibAopProxy.DynamicUnadvisedExposedInterceptor(this.advised.getTargetSource());
        } else {
            targetInterceptor = isStatic?new CglibAopProxy.StaticUnadvisedInterceptor(this.advised.getTargetSource().getTarget()):new CglibAopProxy.DynamicUnadvisedInterceptor(this.advised.getTargetSource());
        }

        Callback targetDispatcher = (Callback)(isStatic?new CglibAopProxy.StaticDispatcher(this.advised.getTargetSource().getTarget()):new CglibAopProxy.SerializableNoOp());
        //第三步： 加入拦截器
        Callback[] mainCallbacks = new Callback[]{aopInterceptor, (Callback)targetInterceptor, new CglibAopProxy.SerializableNoOp(), targetDispatcher, this.advisedDispatcher, new CglibAopProxy.EqualsInterceptor(this.advised), new CglibAopProxy.HashCodeInterceptor(this.advised)};
        Callback[] callbacks;
        if(isStatic && isFrozen) {
            Method[] methods = rootClass.getMethods();
            Callback[] fixedCallbacks = new Callback[methods.length];
            this.fixedInterceptorMap = new HashMap(methods.length);

            for(int x = 0; x < methods.length; ++x) {
                List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(methods[x], rootClass);
                fixedCallbacks[x] = new CglibAopProxy.FixedChainStaticTargetInterceptor(chain, this.advised.getTargetSource().getTarget(), this.advised.getTargetClass());
                this.fixedInterceptorMap.put(methods[x].toString(), Integer.valueOf(x));
            }

            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;
    }

 

　　　　(ಥ _ ಥ) 神 TMD 的什么鬼， 看不懂啊 。。。。

　　　　在 CGLIB 中， 用  DynamicAdvisedInterceptor  封装了 增强器，查看该类中的 intercept() 方法：

        public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
            Object oldProxy = null;
            boolean setProxyContext = false;
            Class<?> targetClass = null;
            Object target = null;

            Object var11;
            try {
                if(this.advised.exposeProxy) {
                    oldProxy = AopContext.setCurrentProxy(proxy);
                    setProxyContext = true;
                }

                target = this.getTarget();
                if(target != null) {
                    targetClass = target.getClass();
                }

                //第一步： 获取拦截器你链
                List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
                Object retVal;
                if(chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
                    //第二步： 拦截器为空则直接调用原方法
                    retVal = methodProxy.invoke(target, args);
                } else {
                    //第三步：  拦截器不为空则调用链
                    retVal = (new CglibAopProxy.CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy)).proceed();
                }
                //第四步： 改变返回值的类型并 返回结果
                retVal = CglibAopProxy.processReturnType(proxy, target, method, retVal);
                var11 = retVal;
            } finally {
                if(target != null) {
                    this.releaseTarget(target);
                }

                if(setProxyContext) {
                    AopContext.setCurrentProxy(oldProxy);
                }

            }

            return var11;
        }

 

　　　　看到返回结果之后，我们就大致了（bu）解（dong）了 CGLIB 的运行流程了。 (ಥ _ ಥ)

 

---

 　　　 本来想把 Spring AOP 中动态 AOP 和静态 AOP 的运行流程都大致回顾一遍的， 但是回顾了动态 AOP 的内容之后， 感觉还是有很多不懂的地方， 接下去不常用的静态 AOP 的内容会是瞎蒙吧， 以后深入了解后再把没做的部分完成吧。 Spring 的源码很多， 想学深不简单， 加油！！[]~(￣▽￣)~*