spring——AOP原理及源码（五）

前情回顾：

　　在上一篇中，通过 wrapIfNecessary 方法，我们获取到了合适的增强器（日志方法）与业务

类进行包装，最终返回了我们业务类的代理对象。

　　

　　本篇我们将从业务方法的执行开始，看看增强器（日志方法）是怎么在方法执行的前后和发

生异常时被调用的。以及在文章的最后总结整个AOP的执行流程。

1、调试的起点：

给测试方法打上断点，然后一直跳到下一个断点直到执行方法，如下　　

接着进入方法，会被intercept方法拦截

进入断点：

 @Override
         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;
             try {
                 if (this.advised.exposeProxy) {
                     // Make invocation available if necessary.
                     oldProxy = AopContext.setCurrentProxy(proxy);
                     setProxyContext = true;
                 }
                 // May be null. Get as late as possible to minimize the time we
                 // "own" the target, in case it comes from a pool...
                 target = getTarget();
                 if (target != null) {
                     targetClass = target.getClass();
                 }
                 List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
                 Object retVal;
                 // Check whether we only have one InvokerInterceptor: that is,
                 // no real advice, but just reflective invocation of the target.
                 if (chain.isEmpty() && Modifier.isPublic(method.getModifiers())) {
                     // We can skip creating a MethodInvocation: just invoke the target directly.
                     // Note that the final invoker must be an InvokerInterceptor, so we know
                     // it does nothing but a reflective operation on the target, and no hot
                     // swapping or fancy proxying.
                     Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
                     retVal = methodProxy.invoke(target, argsToUse);
                 }
                 else {
                     // We need to create a method invocation...
                     retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
                 }
                 retVal = processReturnType(proxy, target, method, retVal);
                 return retVal;
             }
             finally {
                 if (target != null) {
                     releaseTarget(target);
                 }
                 if (setProxyContext) {
                     // Restore old proxy.
                     AopContext.setCurrentProxy(oldProxy);
                 }
             }
         }

intercept

intercept 方法从上往下看：

16~18：获取目标类（注意不是代理对象）

　　

19：通过目标类和目标方法获取拦截器链

List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

---

2、重点探究获取拦截器链的过程

进入 getInterceptorsAndDynamicInterceptionAdvice

继续进入 this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(this, method, targetClass)

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

         // This is somewhat tricky... We have to process introductions first,
         // but we need to preserve order in the ultimate list.
         List<Object> interceptorList = new ArrayList<Object>(config.getAdvisors().length);
         Class<?> actualClass = (targetClass != null ? targetClass : method.getDeclaringClass());
         boolean hasIntroductions = hasMatchingIntroductions(config, actualClass);
         AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();

         for (Advisor advisor : config.getAdvisors()) {
             if (advisor instanceof PointcutAdvisor) {
                 // Add it conditionally.
                 PointcutAdvisor pointcutAdvisor = (PointcutAdvisor) advisor;
                 if (config.isPreFiltered() || pointcutAdvisor.getPointcut().getClassFilter().matches(actualClass)) {
                     MethodInterceptor[] interceptors = registry.getInterceptors(advisor);
                     MethodMatcher mm = pointcutAdvisor.getPointcut().getMethodMatcher();
                     if (MethodMatchers.matches(mm, method, actualClass, hasIntroductions)) {
                         if (mm.isRuntime()) {
                             // Creating a new object instance in the getInterceptors() method
                             // isn't a problem as we normally cache created chains.
                             for (MethodInterceptor interceptor : interceptors) {
                                 interceptorList.add(new InterceptorAndDynamicMethodMatcher(interceptor, mm));
                             }
                         }
                         else {
                             interceptorList.addAll(Arrays.asList(interceptors));
                         }
                     }
                 }
             }
             else if (advisor instanceof IntroductionAdvisor) {
                 IntroductionAdvisor ia = (IntroductionAdvisor) advisor;
                 if (config.isPreFiltered() || ia.getClassFilter().matches(actualClass)) {
                     Interceptor[] interceptors = registry.getInterceptors(advisor);
                     interceptorList.addAll(Arrays.asList(interceptors));
                 }
             }
             else {
                 Interceptor[] interceptors = registry.getInterceptors(advisor);
                 interceptorList.addAll(Arrays.asList(interceptors));
             }
         }

         return interceptorList;
     }

getInterceptorsAndDynamicInterceptionAdvice

以上代码从上往下看：

5：创建拦截器链

List<Object> interceptorList = new ArrayList<Object>(config.getAdvisors().length)

12~32：

• 遍历所有增强器
• 经过一系列判断，将增强器放入interceptorList中 ：
• interceptorList.addAll(Arrays.asList(interceptors))

46：将拦截器链返回

接下来将拦截器链返回，并存入缓存中

最后将拦截器链返回

这就是拦截器链获取的过程

---

接下来来到 intercept 方法的真正执行部分：

retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();

通过new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy) 获取到方法拦截器链

一进来先调用父类方法：

设置好代理对象、目标类、目标方法、拦截器链等一系列属性：

接着一路返回后调用 proceed 方法进行执行：

 @Override
     public Object proceed() throws Throwable {
         //    We start with an index of -1 and increment early.
         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;
             if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {
                 return dm.interceptor.invoke(this);
             }
             else {
                 // Dynamic matching failed.
                 // Skip this interceptor and invoke the next in the chain.
                 return proceed();
             }
         }
         else {
             // It's an interceptor, so we just invoke it: The pointcut will have
             // been evaluated statically before this object was constructed.
             return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
         }
     }

proceed

3~6：可以看到有一个从-1开始的索引，这是用来记录当前执行次数的（这里的size为5对应我们的五个增强器）

8~9：每次从拦截器链中获取一个增强器，索引加一

10：判断这个增强器是不是 InterceptorAndDynamicMethodMatcher 类型，我们这里判断不满足，来到了else，返回调用 invoke 方法的结果

---

接下来我们进入这个执行过程

invoke方法调用proceed方法

来到proceed方法继续判断索引大小

往下走又来到 invoke 方法，从下图可以看到当前是异常增强器的invoke（）

进入invoke

先 return 调用 proceed 方法

可以看到下图中 catch 部分，说明如果有出现异常，会在catch部分调用增强器方法，并抛出异常

接下来又是调用AfterReturning的invoke过程

下图可以看到又调用了proceed

中间的过程也一样，这里就不演示了

最终我们的索引来到末尾

整个过程开始从内到外执行日志方法

开始调用日志方法打印：

抛出异常

最终拦截器链调用完毕，得到结果：

以上可以看到，整个执行流程是一个递归调用的过程，对之前排好序的拦截器链，通过索引判断界限，一层一层往里调用，最终递归回来一层层执行增强器（日志方法）

---

3、AOP总结：

通过@EnableAspectJAutoProxy 注解，给容器中注册 AnnotationAwareAspectJAutoProxyCreator，这个组件是一个后置处理器

会在每一个bean创建之前执行它的后置处理器方法来获取对应增强器，并获取到目标代理对象

在执行切面方法时，通过代理对象和增强器等信息，获取到拦截器链

拦截器链在包装处理后进入执行流程，嵌套调用后执行增强器方法

aop uml图

以下UML图是我对AOP的理解，如果有不对之处，欢迎大家指出