public Object proceed() throws Throwable {

    // 首先，判断是不是所有的interceptor（也可以想像成advisor）都被执行完了。

    // 判断的方法是看currentInterceptorIndex这个变量的值，增加到Interceptor总个数这个数值没有，

    // 如果到了，就执行被代理方法(invokeJoinpoint())；如果没到，就继续执行Interceptor。

    if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {

        return invokeJoinpoint();

    }

    // 如果Interceptor没有被全部执行完，就取出要执行的Interceptor，并执行。

    // currentInterceptorIndex先自增

     Object interceptorOrInterceptionAdvice = this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);

    // 如果Interceptor是PointCut类型

    if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {

        InterceptorAndDynamicMethodMatcher dm = (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;

        // 如果当前方法符合Interceptor的PointCut限制，就执行Interceptor

        if (dm.methodMatcher.matches(this.method, this.targetClass, this.arguments)) {

        　　 // 这里将this当变量传进去，这是非常重要的一点

            return dm.interceptor.invoke(this);

        }

        // 如果不符合，就跳过当前Interceptor，执行下一个Interceptor

        else {

            return proceed();

        }

    }

    // 如果Interceptor不是PointCut类型，就直接执行Interceptor里面的增强。

    else {

        return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);

    }

}

 @Override

 public Object invoke(MethodInvocation mi) throws Throwable {

     try {

         //直接调用MethodInvocation的proceed方法

         //从proceed()方法中我们知道dm.interceptor.invoke(this)传过来的参数就是ReflectiveMethodInvocation执行器本身

         //这里又直接调用了ReflectiveMethodInvocation的proceed()方法

         return mi.proceed();

     }

     catch (Throwable ex) {

         if (shouldInvokeOnThrowing(ex)) {

             invokeAdviceMethod(getJoinPointMatch(), null, ex);

         }

         throw ex;

     }

 }

 @Override

 public Object invoke(MethodInvocation mi) throws Throwable {

     //直接调用MethodInvocation的proceed方法

     Object retVal = mi.proceed();

     this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());

     return retVal;

 }

 @Override

 public Object invoke(MethodInvocation mi) throws Throwable {

     try {

         //直接调用MethodInvocation的proceed方法

         return mi.proceed();

     }

     finally {

         invokeAdviceMethod(getJoinPointMatch(), null, null);

     }

 }

 @Override

 public Object invoke(MethodInvocation mi) throws Throwable {

     //终于开始做事了，调用增强器的before方法，明显是通过反射的方式调用

     //到这里增强方法before的业务逻辑执行

     this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());

     //又调用了调用MethodInvocation的proceed方法

     return mi.proceed();

 }

@Nullable

protected Object invokeJoinpoint() throws Throwable {

    return AopUtils.invokeJoinpointUsingReflection(this.target, this.method, this.arguments);

}

    @Nullable

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

        throws Throwable {

    // Use reflection to invoke the method.

    try {

        ReflectionUtils.makeAccessible(method);

        //直接通过反射调用目标bean中的method

        return method.invoke(target, args);

    }

    catch (InvocationTargetException ex) {

        // Invoked method threw a checked exception.

        // We must rethrow it. The client won't see the interceptor.

        throw ex.getTargetException();

    }

    catch (IllegalArgumentException ex) {

        throw new AopInvocationException("AOP configuration seems to be invalid: tried calling method [" +

                method + "] on target [" + target + "]", ex);

    }

    catch (IllegalAccessException ex) {

        throw new AopInvocationException("Could not access method [" + method + "]", ex);

    }

}