文章结构

  1. 以postProcessAfterInstantiation开篇
  2. 所有的bean在初始化之后都会调用这个方法
  3. 在这里获取到之前加载到的所有的Advisor，和类的所有方法一一匹配
  4. 当类具有匹配Advisor的时候就可以为这个类生成具体的代理了

在之前的2篇文章：AOP源码分析（一）AOP源码分析（二）
中，我们搭建了SpringAOP源码分析的环境，介绍了@EnableAspectJAutoProxy注解和postProcessBeforeInstantiation方法是如何加载所有Advisor的。本篇文章则将描述一下AOP中剩余的实现逻辑

postProcessAfterInitialization

这个方法是在bean实例化之后调用的，它是适用于所有需要被代理的类的

  1. public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
  2.     if (bean != null) {
  3.         Object cacheKey = getCacheKey(bean.getClass(), beanName);
  4.         if (!this.earlyProxyReferences.contains(cacheKey)) {
  5.         //往下看
  6.             return wrapIfNecessary(bean, beanName, cacheKey);
  7.         }
  8.     }
  9.     return bean;
  10. }
  12. protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
  13. //如果已经处理过
  14.     if (beanName != null && this.targetSourcedBeans.contains(beanName)) {
  15.         return bean;
  16.     }
  17.     //如果当前类是增强类
  18.     if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
  19.         return bean;
  20.     }
  21.     //查看类是否是基础设施类，或者是否被排除
  22.     if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
  23.         this.advisedBeans.put(cacheKey, Boolean.FALSE);
  24.         return bean;
  25.     }
  27.     //校验此类是否应该被代理，获取这个类的Advisor
  28.     Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
  29.     //如果获取到了Advisor则需要针对Advisor创建代理
  30.     if (specificInterceptors != DO_NOT_PROXY) {
  31.         this.advisedBeans.put(cacheKey, Boolean.TRUE);
  32.         //创建代理
  33.         Object proxy = createProxy(
  34.                 bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
  35.         this.proxyTypes.put(cacheKey, proxy.getClass());
  36.         return proxy;
  37.     }
  39.     this.advisedBeans.put(cacheKey, Boolean.FALSE);
  40.     return bean;
  41. }

上方这段代理一共有两个重点，getAdvicesAndAdvisorsForBean和createProxy这两个方法

获取Advisors

  1. protected Object[] getAdvicesAndAdvisorsForBean(Class<?> beanClass, String beanName, TargetSource targetSource) {
  2. //往下看
  3.     List<Advisor> advisors = findEligibleAdvisors(beanClass, beanName);
  4.     if (advisors.isEmpty()) {
  5.         return DO_NOT_PROXY;
  6.     }
  7.     return advisors.toArray();
  8. }
  10. protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
  11.     //获取容器中的所有Advisor
  12.     List<Advisor> candidateAdvisors = findCandidateAdvisors();
  13.     //验证beanClass是否该被代理，如果应该，则返回适用于这个bean的Advisor
  14.     List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
  15.     extendAdvisors(eligibleAdvisors);
  16.     if (!eligibleAdvisors.isEmpty()) {
  17.         eligibleAdvisors = sortAdvisors(eligibleAdvisors);
  18.     }
  19.     return eligibleAdvisors;
  20. }

上方这个获取Advisor又分成了2部分，获取全部和根据全部处理bean相关的

获取全部Advisor

上一篇postProcessBeforeInstantiation的也有这个过程

  1. protected List<Advisor> findCandidateAdvisors() {
  2.     // 调用父类的方法加载配置文件中的AOP声明（注解与XML都存在的时候）
  3.     List<Advisor> advisors = super.findCandidateAdvisors();
  4.         //往下看
  5.         if (this.aspectJAdvisorsBuilder != null) {
  6.       advisors.addAll(this.aspectJAdvisorsBuilder.buildAspectJAdvisors());
  7.     }
  8.     return advisors;
  9.   }

下面的方法就是获取所有的Advisor的代码实现了，方法比较长，不过主要逻辑很少。
1.获取所有beanName
2.找出所有标记Aspect注解的类
3.对标记Aspect的类提取Advisor

  1. public List<Advisor> buildAspectJAdvisors() {
  2.     List<String> aspectNames = this.aspectBeanNames;
  4.     if (aspectNames == null) {
  5.       synchronized (this) {
  6.         aspectNames = this.aspectBeanNames;
  7.         if (aspectNames == null) {
  8.           List<Advisor> advisors = new LinkedList<>();
  9.           aspectNames = new LinkedList<>();
  10.                     //获取所有的bean
  11.           String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
  12.               this.beanFactory, Object.class, true, false);
  13.           for (String beanName : beanNames) {
  14.                       //校验不合法的类，Spring的一个扩展点，可以从子类中做排除切面的操作
  15.             if (!isEligibleBean(beanName)) {
  16.               continue;
  17.             }
  18.             //获取bean的类型
  19.             Class<?> beanType = this.beanFactory.getType(beanName);
  20.             if (beanType == null) {
  21.               continue;
  22.             }
  23.                         //是否带有Aspect注解
  24.             if (this.advisorFactory.isAspect(beanType)) {
  25.               aspectNames.add(beanName);
  26.               AspectMetadata amd = new AspectMetadata(beanType, beanName);
  27.               if (amd.getAjType().getPerClause().getKind() == PerClauseKind.SINGLETON) {
  28.                 MetadataAwareAspectInstanceFactory factory =
  29.                     new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
  30.                                         //解析所有的Advisor方法，下面说
  31.                 List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);
  32.                 if (this.beanFactory.isSingleton(beanName)) {
  33.                   this.advisorsCache.put(beanName, classAdvisors);
  34.                 }
  35.                 else {
  36.                   this.aspectFactoryCache.put(beanName, factory);
  37.                 }
  38.                 advisors.addAll(classAdvisors);
  39.               }
  40.               else {
  41.                 if (this.beanFactory.isSingleton(beanName)) {
  42.                   throw new IllegalArgumentException("Bean with name '" + beanName +
  43.                       "' is a singleton, but aspect instantiation model is not singleton");
  44.                 }
  45.                 MetadataAwareAspectInstanceFactory factory =
  46.                     new PrototypeAspectInstanceFactory(this.beanFactory, beanName);
  47.                 this.aspectFactoryCache.put(beanName, factory);
  48.                 advisors.addAll(this.advisorFactory.getAdvisors(factory));
  49.               }
  50.             }
  51.           }
  52.           this.aspectBeanNames = aspectNames;
  53.           return advisors;
  54.         }
  55.       }
  56.     }
  58.     if (aspectNames.isEmpty()) {
  59.       return Collections.emptyList();
  60.     }
  61.     List<Advisor> advisors = new LinkedList<>();
  62.     for (String aspectName : aspectNames) {
  63.       List<Advisor> cachedAdvisors = this.advisorsCache.get(aspectName);
  64.       if (cachedAdvisors != null) {
  65.         advisors.addAll(cachedAdvisors);
  66.       }
  67.       else {
  68.         MetadataAwareAspectInstanceFactory factory = this.aspectFactoryCache.get(aspectName);
  69.         advisors.addAll(this.advisorFactory.getAdvisors(factory));
  70.       }
  71.     }
  72.     return advisors;
  73.   }

接下来就是各个Advisor的获取方法的实现

  1. public List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory) {
  2.         //获取所有Aspect类、类名称、并校验
  3.     Class<?> aspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
  4.     String aspectName = aspectInstanceFactory.getAspectMetadata().getAspectName();
  5.     validate(aspectClass);
  8.     MetadataAwareAspectInstanceFactory lazySingletonAspectInstanceFactory =
  9.         new LazySingletonAspectInstanceFactoryDecorator(aspectInstanceFactory);
  11.     List<Advisor> advisors = new LinkedList<>();
  12.         //取出类的所有方法
  13.     for (Method method : getAdvisorMethods(aspectClass)) {
  14.             //获取Advisor方法，往下看
  15.       Advisor advisor = getAdvisor(method, lazySingletonAspectInstanceFactory, advisors.size(), aspectName);
  16.       if (advisor != null) {
  17.         advisors.add(advisor);
  18.       }
  19.     }
  21.     // 如果需要增强且配置了延迟增强则在第一个位置添加同步实例化Advisor方法
  22.     if (!advisors.isEmpty() && lazySingletonAspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
  23.       Advisor instantiationAdvisor = new SyntheticInstantiationAdvisor(lazySingletonAspectInstanceFactory);
  24.       advisors.add(0, instantiationAdvisor);
  25.     }
  27.     // 获取属性中配置DeclareParents注解的Advisor
  28.     for (Field field : aspectClass.getDeclaredFields()) {
  29.       Advisor advisor = getDeclareParentsAdvisor(field);
  30.       if (advisor != null) {
  31.         advisors.add(advisor);
  32.       }
  33.     }
  35.     return advisors;
  36.   }

普通Advisor的获取

  1. public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory,
  2.       int declarationOrderInAspect, String aspectName) {
  4.     validate(aspectInstanceFactory.getAspectMetadata().getAspectClass());
  5.         //获取切点
  6.     AspectJExpressionPointcut expressionPointcut = getPointcut(
  7.         candidateAdviceMethod, aspectInstanceFactory.getAspectMetadata().getAspectClass());
  8.     if (expressionPointcut == null) {
  9.       return null;
  10.     }
  11.         //根据切点生成Advisor
  12.     return new InstantiationModelAwarePointcutAdvisorImpl(expressionPointcut, candidateAdviceMethod,
  13.         this, aspectInstanceFactory, declarationOrderInAspect, aspectName);
  14.   }

上方代码又分为了两部分，先看一下切点信息的获取

  1. public InstantiationModelAwarePointcutAdvisorImpl(AspectJExpressionPointcut declaredPointcut,
  2.     Method aspectJAdviceMethod, AspectJAdvisorFactory aspectJAdvisorFactory,
  3.     MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
  5.   this.declaredPointcut = declaredPointcut;
  6.   this.declaringClass = aspectJAdviceMethod.getDeclaringClass();
  7.   this.methodName = aspectJAdviceMethod.getName();
  8.   this.parameterTypes = aspectJAdviceMethod.getParameterTypes();
  9.   this.aspectJAdviceMethod = aspectJAdviceMethod;
  10.   this.aspectJAdvisorFactory = aspectJAdvisorFactory;
  11.   this.aspectInstanceFactory = aspectInstanceFactory;
  12.   this.declarationOrder = declarationOrder;
  13.   this.aspectName = aspectName;
  15.   if (aspectInstanceFactory.getAspectMetadata().isLazilyInstantiated()) {
  16.     Pointcut preInstantiationPointcut = Pointcuts.union(
  17.         aspectInstanceFactory.getAspectMetadata().getPerClausePointcut(), this.declaredPointcut);
  18.     this.pointcut = new PerTargetInstantiationModelPointcut(
  19.         this.declaredPointcut, preInstantiationPointcut, aspectInstanceFactory);
  20.     this.lazy = true;
  21.   }
  22.   else {
  23.     this.pointcut = this.declaredPointcut;
  24.     this.lazy = false;
  25.            //初始化对应的Advisor器，重点
  26.     this.instantiatedAdvice = instantiateAdvice(this.declaredPointcut);
  27.   }
  28. }

到这里之后获取所有的Advisor这个流程就快要完毕了

  1. private Advice instantiateAdvice(AspectJExpressionPointcut pointcut) {
  2.         //往下看
  3.     Advice advice = this.aspectJAdvisorFactory.getAdvice(this.aspectJAdviceMethod, pointcut,
  4.         this.aspectInstanceFactory, this.declarationOrder, this.aspectName);
  5.     return (advice != null ? advice : EMPTY_ADVICE);
  6.   }
  8. public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
  9.       MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {
  11.     Class<?> candidateAspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
  12.     validate(candidateAspectClass);
  14.     AspectJAnnotation<?> aspectJAnnotation =
  15.         AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
  16.     if (aspectJAnnotation == null) {
  17.       return null;
  18.     }
  20.     if (!isAspect(candidateAspectClass)) {
  21.       throw new AopConfigException("Advice must be declared inside an aspect type: " +
  22.           "Offending method '" + candidateAdviceMethod + "' in class [" +
  23.           candidateAspectClass.getName() + "]");
  24.     }
  26.     if (logger.isDebugEnabled()) {
  27.       logger.debug("Found AspectJ method: " + candidateAdviceMethod);
  28.     }
  30.     AbstractAspectJAdvice springAdvice;
  31.         //根据不同的注解类型封装不同的Advisor器
  32.     switch (aspectJAnnotation.getAnnotationType()) {
  33.       case AtBefore:
  34.         springAdvice = new AspectJMethodBeforeAdvice(
  35.             candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
  36.         break;
  37.       case AtAfter:
  38.         springAdvice = new AspectJAfterAdvice(
  39.             candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
  40.         break;
  41.       case AtAfterReturning:
  42.         springAdvice = new AspectJAfterReturningAdvice(
  43.             candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
  44.         AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();
  45.         if (StringUtils.hasText(afterReturningAnnotation.returning())) {
  46.           springAdvice.setReturningName(afterReturningAnnotation.returning());
  47.         }
  48.         break;
  49.       case AtAfterThrowing:
  50.         springAdvice = new AspectJAfterThrowingAdvice(
  51.             candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
  52.         AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation();
  53.         if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
  54.           springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
  55.         }
  56.         break;
  57.       case AtAround:
  58.         springAdvice = new AspectJAroundAdvice(
  59.             candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
  60.         break;
  61.       case AtPointcut:
  62.         if (logger.isDebugEnabled()) {
  63.           logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
  64.         }
  65.         return null;
  66.       default:
  67.         throw new UnsupportedOperationException(
  68.             "Unsupported advice type on method: " + candidateAdviceMethod);
  69.     }
  71.     springAdvice.setAspectName(aspectName);
  72.     springAdvice.setDeclarationOrder(declarationOrder);
  73.     String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
  74.     if (argNames != null) {
  75.       springAdvice.setArgumentNamesFromStringArray(argNames);
  76.     }
  77.     springAdvice.calculateArgumentBindings();
  78.     return springAdvice;
  79.   }

获取匹配Advisor

经过上方的长篇大论，我们终于完成了所有的Advisor器的解析，还记得刚才的方法走到哪了么

  1. protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
  2.    //获取全部Advisor
  3.   List<Advisor> candidateAdvisors = findCandidateAdvisors();
  4.   List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
  5.   extendAdvisors(eligibleAdvisors);
  6.   if (!eligibleAdvisors.isEmpty()) {
  7.     eligibleAdvisors = sortAdvisors(eligibleAdvisors);
  8.   }
  9.   return eligibleAdvisors;
  10. }

接下来看看怎么为当前的Bean匹配自己的增强吧

  1. protected List<Advisor> findAdvisorsThatCanApply(
  2.       List<Advisor> candidateAdvisors, Class<?> beanClass, String beanName) {
  4.     ProxyCreationContext.setCurrentProxiedBeanName(beanName);
  5.     try {
  6.         //往下看
  7.       return AopUtils.findAdvisorsThatCanApply(candidateAdvisors, beanClass);
  8.     }
  9.     finally {
  10.       ProxyCreationContext.setCurrentProxiedBeanName(null);
  11.     }
  12.   }
  14.     public static List<Advisor> findAdvisorsThatCanApply(List<Advisor> candidateAdvisors, Class<?> clazz) {
  15.         if (candidateAdvisors.isEmpty()) {
  16.             return candidateAdvisors;
  17.         }
  18.         List<Advisor> eligibleAdvisors = new LinkedList<Advisor>();
  19.         for (Advisor candidate : candidateAdvisors) {
  20.             //处理引介Advisor，重点，再往下看
  21.             if (candidate instanceof IntroductionAdvisor && canApply(candidate, clazz)) {
  22.                 eligibleAdvisors.add(candidate);
  23.             }
  24.         }
  25.         boolean hasIntroductions = !eligibleAdvisors.isEmpty();
  26.         for (Advisor candidate : candidateAdvisors) {
  27.             if (candidate instanceof IntroductionAdvisor) {
  28.                 continue;
  29.             }
  30.             //对普通bean的处理
  31.             if (canApply(candidate, clazz, hasIntroductions)) {
  32.                 eligibleAdvisors.add(candidate);
  33.             }
  34.         }
  35.         return eligibleAdvisors;
  36.     }

引介Advisor与普通bean的处理最后都是进的同一个方法，只不过是引介Advisor的第三个参数默认使用的false

  1. public static boolean canApply(Advisor advisor, Class<?> targetClass, boolean hasIntroductions) {
  2.     //如果存在排除的配置
  3.     if (advisor instanceof IntroductionAdvisor) {
  4.         return ((IntroductionAdvisor) advisor).getClassFilter().matches(targetClass);
  5.     }
  6.     else if (advisor instanceof PointcutAdvisor) {
  7.         PointcutAdvisor pca = (PointcutAdvisor) advisor;
  8.         //往下看
  9.         return canApply(pca.getPointcut(), targetClass, hasIntroductions);
  10.     }
  11.     else {
  12.         return true;
  13.     }
  14. }
  16. public static boolean canApply(Pointcut pc, Class<?> targetClass, boolean hasIntroductions) {
  17.     Assert.notNull(pc, "Pointcut must not be null");
  18.     //切点上是否存在排除类的配置
  19.     if (!pc.getClassFilter().matches(targetClass)) {
  20.         return false;
  21.     }
  22.     //验证注解的作用域是否可以作用于方法上
  23.     MethodMatcher methodMatcher = pc.getMethodMatcher();
  24.     if (methodMatcher == MethodMatcher.TRUE) {  
  25.         return true;
  26.     }
  28.     IntroductionAwareMethodMatcher introductionAwareMethodMatcher = null;
  29.     if (methodMatcher instanceof IntroductionAwareMethodMatcher) {
  30.         introductionAwareMethodMatcher = (IntroductionAwareMethodMatcher) methodMatcher;
  31.     }
  33.     Set<Class<?>> classes = new LinkedHashSet<Class<?>>(ClassUtils.getAllInterfacesForClassAsSet(targetClass));
  34.     classes.add(targetClass);
  35.     for (Class<?> clazz : classes) {
  36.         Method[] methods = ReflectionUtils.getAllDeclaredMethods(clazz);
  37.         for (Method method : methods) {
  38.             //获取类所实现的所有接口和所有类层级的方法，循环验证
  39.             if ((introductionAwareMethodMatcher != null &&
  40.                     introductionAwareMethodMatcher.matches(method, targetClass, hasIntroductions)) ||
  41.                     methodMatcher.matches(method, targetClass)) {
  42.                 return true;
  43.             }
  44.         }
  45.     }
  47.     return false;
  48. }

现在所有的bean对应的Advisor都已经获取到了，那么就可以根据类的所有Advisor数组创建代理

创建代理

回到最上方开始获取Advisor的地方，当Advisor获取到之后就可以执行下面这个操作了

  1. protected Object createProxy(Class<?> beanClass, @Nullable String beanName,
  2.       @Nullable Object[] specificInterceptors, TargetSource targetSource) {
  4.     if (this.beanFactory instanceof ConfigurableListableBeanFactory) {
  5.       AutoProxyUtils.exposeTargetClass((ConfigurableListableBeanFactory) this.beanFactory, beanName, beanClass);
  6.     }
  8.     ProxyFactory proxyFactory = new ProxyFactory();
  9.         使用proxyFactory对象copy当前类中的相关属性
  10.     proxyFactory.copyFrom(this);
  11.         //判断是否使用Cglib动态代理
  12.     if (!proxyFactory.isProxyTargetClass()) {
  13.           //如果配置开启使用则直接设置开启
  14.       if (shouldProxyTargetClass(beanClass, beanName)) {
  15.         proxyFactory.setProxyTargetClass(true);
  16.       }
  17.       else {
  18.             //如果没有配置开启则判断bean是否有合适的接口使用JDK的动态代理（JDK动态代理必须是带有接口的类，如果类没有实现任何接口则只能使用Cglib动态代理）
  19.             //关于代理的基础知识可以参考我的另一篇文章：https://mp.weixin.qq.com/s/1DRmvuky5_NMRcH-toTLqQ
  20.         evaluateProxyInterfaces(beanClass, proxyFactory);
  21.       }
  22.     }
  23.         //添加所有Advisor
  24.     Advisor[] advisors = buildAdvisors(beanName, specificInterceptors);
  25.     proxyFactory.addAdvisors(advisors);
  26.         //设置要代理的类
  27.     proxyFactory.setTargetSource(targetSource);
  28.         //Spring的一个扩展点，默认实现为空。留给我们在需要对代理进行特殊操作的时候实现
  29.     customizeProxyFactory(proxyFactory);
  30.     proxyFactory.setFrozen(this.freezeProxy);
  31.     if (advisorsPreFiltered()) {
  32.       proxyFactory.setPreFiltered(true);
  33.     }
  34.         //使用代理工厂获取代理对象
  35.     return proxyFactory.getProxy(getProxyClassLoader());
  36.   }

获取代理对象

  1. public Object getProxy(@Nullable ClassLoader classLoader) {
  2.     return createAopProxy().getProxy(classLoader);
  3.   }
  4. protected final synchronized AopProxy createAopProxy() {
  5.     if (!this.active) {
  6.       activate();
  7.     }
  8.     return getAopProxyFactory().createAopProxy(this);
  9.   }
  10. public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
  11.     if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
  12.       Class<?> targetClass = config.getTargetClass();
  13.       if (targetClass == null) {
  14.         throw new AopConfigException("TargetSource cannot determine target class: " +
  15.             "Either an interface or a target is required for proxy creation.");
  16.       }
  17.       if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
  18.         return new JdkDynamicAopProxy(config);
  19.       }
  20.       return new ObjenesisCglibAopProxy(config);
  21.     }
  22.     else {
  23.       return new JdkDynamicAopProxy(config);
  24.     }
  25.   }

Advisor何时调用

代理创建出来了，那么我们的前置增强、后置增强、环绕增强等是如何在代理中体现的呢，对代理模式还不熟悉的同学一定要先看一下这篇文章呦：https://mp.weixin.qq.com/s/1DRmvuky5_NMRcH-toTLqQ
这里就简单看一下JDK动态代理的实现吧

  1. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  2.     MethodInvocation invocation;
  3.     Object oldProxy = null;
  4.     boolean setProxyContext = false;
  6.     TargetSource targetSource = this.advised.targetSource;
  7.     Object target = null;
  9.     try {
  10.             //equals方法处理
  11.       if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
  12.         return equals(args[0]);
  13.       }
  14.             //hash代码处理
  15.       else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
  16.         return hashCode();
  17.       }
  18.       else if (method.getDeclaringClass() == DecoratingProxy.class) {
  19.         return AopProxyUtils.ultimateTargetClass(this.advised);
  20.       }
  21.       else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
  22.           method.getDeclaringClass().isAssignableFrom(Advised.class)) {
  23.         // Service invocations on ProxyConfig with the proxy config...
  24.         return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
  25.       }
  27.       Object retVal;
  28.             //如果配置内部方法调用的Advisor
  29.       if (this.advised.exposeProxy) {
  30.         oldProxy = AopContext.setCurrentProxy(proxy);
  31.         setProxyContext = true;
  32.       }
  34.       target = targetSource.getTarget();
  35.       Class<?> targetClass = (target != null ? target.getClass() : null);
  37.       // 获取当前方法的拦截器链
  38.       List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
  40.       if (chain.isEmpty()) {
  41.                 //如果没有拦截器直接调用切点方法
  42.         Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
  43.         retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
  44.       }
  45.       else {
  46.         invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
  47.                 //执行拦截器链，重点，往下看
  48.         retVal = invocation.proceed();
  49.       }
  51.       Class<?> returnType = method.getReturnType();
  52.             //返回结果
  53.       if (retVal != null && retVal == target &&
  54.           returnType != Object.class && returnType.isInstance(proxy) &&
  55.           !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
  56.         retVal = proxy;
  57.       }
  58.       else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
  59.         throw new AopInvocationException(
  60.             "Null return value from advice does not match primitive return type for: " + method);
  61.       }
  62.       return retVal;
  63.     }
  64.     finally {
  65.       if (target != null && !targetSource.isStatic()) {
  66.         targetSource.releaseTarget(target);
  67.       }
  68.       if (setProxyContext) {
  69.         AopContext.setCurrentProxy(oldProxy);
  70.       }
  71.     }
  72.   }

看完上方的代码，可以猜到，所有的Advisor都在这个拦截器里面了，那么这个拦截器又是如何实现的呢

  1. public Object proceed() throws Throwable {
  2.     // 执行完所有的Advisor后执行切点方法
  3.     if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
  4.       return invokeJoinpoint();
  5.     }
  6.         //获取下一个要执行的拦截器
  7.     Object interceptorOrInterceptionAdvice =
  8.         this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
  9.     if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
  10.       InterceptorAndDynamicMethodMatcher dm =
  11.           (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
  12.       if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
  13.         return dm.interceptor.invoke(this);
  14.       }
  15.       else {
  16.         // 递归调用
  17.         // Dynamic matching failed.
  18.         // Skip this interceptor and invoke the next in the chain.
  19.         return proceed();
  20.       }
  21.     }
  22.     else {
  23.       // It's an interceptor, so we just invoke it: The pointcut will have
  24.       // been evaluated statically before this object was constructed.
  25.       return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
  26.     }
  27.   }

至此SpringAOP的源码解析已经完成