接上文介绍了Srping AOP中代理对象的生成，今天介绍下另一个重要部分：拦截器，正是通过拦截器，才能帮我们实现代理的功能。

JdkDynamicAopProxy

         在代理模式中，我们实现代理工作是通过实现InvocationHandler接口，重写其中的invoke()方法，在method.invoke()前后加入我们需要代理的逻辑，在JdkDynamicAopProxy中，spring也是采用了类似的手段：

/**
 * Implementation of {@code InvocationHandler.invoke}.
 * <p>Callers will see exactly the exception thrown by the target,
 * unless a hook method throws an exception.
 */
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   MethodInvocation invocation;
   Object oldProxy = null;
   boolean setProxyContext = false;

   TargetSource targetSource = this.advised.targetSource;
   Class<?> targetClass = null;
   Object target = null;

   try {
      if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
         // The target does not implement the equals(Object) method itself.
         return equals(args[0]);
      }
      if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
         // The target does not implement the hashCode() method itself.
         return hashCode();
      }
      if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
            method.getDeclaringClass().isAssignableFrom(Advised.class)) {
         // Service invocations on ProxyConfig with the proxy config...
         return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
      }

      Object retVal;

      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 = targetSource.getTarget();
      if (target != null) {
         targetClass = target.getClass();
      }

      // Get the interception chain for this method.
      List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

      // Check whether we have any advice. If we don't, we can fallback on direct
      // reflective invocation of the target, and avoid creating a MethodInvocation.
      if (chain.isEmpty()) {
         // 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 = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
      }
      else {
         // We need to create a method invocation...
         invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
         // Proceed to the joinpoint through the interceptor chain.
         retVal = invocation.proceed();
      }

      // Massage return value if necessary.
      Class<?> returnType = method.getReturnType();
      if (retVal != null && retVal == target && 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) {
         // Restore old proxy.
         AopContext.setCurrentProxy(oldProxy);
      }
   }
}

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

  
         retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
   
         invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
         retVal = invocation.proceed();
    

上面就是JdkDynamicAopProxy中重写的invoke()方法，主要内容有两部分，我用两种颜色标出来：

红色部分是代表设置了拦截器，里面主要有两个步骤：

第一部分：获取增强链

第二部分：创建ReflectiveMthodInvocation,处理增强

 

绿色部分则是没有设置拦截起，直接通过反射调用目标对象的方法即可。

 

获取增强链

         所有定义好的增强用一个list维护，形成一个增强链，

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

 

         可以看到我们的增强链是通过advised对象获取的，这个advised是一个AdvisedSupport对,我们看下对象的类图：

 

可以看到，它还是ProxyFactoryBean和ProxyFactory的基类，我们看下他获取增强链的具体实现：

public List<Object> getInterceptorsAndDynamicInterceptionAdvice(Method method, Class<?> targetClass) {
   MethodCacheKey cacheKey = new MethodCacheKey(method);
   List<Object> cached = this.methodCache.get(cacheKey);
   if (cached == null) {
      cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
            this, method, targetClass);
      this.methodCache.put(cacheKey, cached);
   }
   return cached;
}

为了提高的获取增强链的效率，这里还使用了缓存，我们看下第一次是怎么获取的：

cached = this.advisorChainFactory.getInterceptorsAndDynamicInterceptionAdvice(
      this, method, targetClass);

 

这里通过advisorChainFactory这个对象来获取增强链，真正的实现则是通过DefaultAdvisorChainFactory：

DefaultAdvisorChainFactory

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

 

这里首先会根据增强的数量设定好list容器的容量，如果是用ProxyFactory以编程的方式来获取的代理，那么这里面的增强就是我们通过addAdvice()方法添加的增强，如果是用ProxyFactoryBean以配置文件形式添加的增强，那么这里的增强就是我们interceptornames属性指定的那些增强。

         接着通过AdvisorAdapterRegistry对象来完成拦截器的注册，注册好的拦截器会被加入上面维护的list中，在目标方法被调用时获取。

         我们看下拦截器注册的实现过程（适配器模式）：

首先通过

AdvisorAdapterRegistry registry = GlobalAdvisorAdapterRegistry.getInstance();

获取AdvisorAdapterRegistry，然后通过AdvisorAdapterRegistry获取增强对象：

MethodInterceptor[] interceptors = registry.getInterceptors(advisor);

 

GlobalAdvisorAdapterRegistry:

public abstract class GlobalAdvisorAdapterRegistry {

   /**
    * Keep track of a single instance so we can return it to classes that request it.
    */
   private static AdvisorAdapterRegistry instance = new DefaultAdvisorAdapterRegistry();

   /**
    * Return the singleton {@link DefaultAdvisorAdapterRegistry} instance.
    */
   public static AdvisorAdapterRegistry getInstance() {
      return instance;
   }

   /**
    * Reset the singleton {@link DefaultAdvisorAdapterRegistry}, removing any
    * {@link AdvisorAdapterRegistry#registerAdvisorAdapter(AdvisorAdapter) registered}
    * adapters.
    */
   static void reset() {
      instance = new DefaultAdvisorAdapterRegistry();
   }

}

 

这里通过一个单例模式返回一个DefaultAdvisorAdapterReistry,在DefaultAdvisorAdapterReistry中，提供了一系列的适配器，通过这些适配器获取advice。

 

DefaultAdvisorAdapterReistry：

首先看下构造函数：

private final List<AdvisorAdapter> adapters = new ArrayList<AdvisorAdapter>(3);

 

public DefaultAdvisorAdapterRegistry() {
   registerAdvisorAdapter(new MethodBeforeAdviceAdapter());
   registerAdvisorAdapter(new AfterReturningAdviceAdapter());
   registerAdvisorAdapter(new ThrowsAdviceAdapter());
}

在DefaultAdvisorAdapterReistry内部通过list直接维护了三个适配器，这三个适配器对应的前置增强，后置增强和异常抛出增强。

 

 我们来看下这里的适配器提供了什么方法：

 

可以看到这些适配器只有两个方法：

boolean supportsAdvice(Advice advice);

和

MethodInterceptor getInterceptor(Advisor advisor);

 

 

我们以MethodBeforeAdviceAdapter为例进行说明：

class MethodBeforeAdviceAdapter implements AdvisorAdapter, Serializable {

   @Override
   public boolean supportsAdvice(Advice advice) {
      return (advice instanceof MethodBeforeAdvice);
   }

   @Override
   public MethodInterceptor getInterceptor(Advisor advisor) {
      MethodBeforeAdvice advice = (MethodBeforeAdvice) advisor.getAdvice();
      return new MethodBeforeAdviceInterceptor(advice);
   }

}

 

supportsAdvice方法用来判断增强的类型

getInterceptor方法用来获取具体的增强示例

 

 

了解了上面的知识以后，我们再继续看下DefaultAdvisorChainFactory的getInterceptors():方法：

@Override
public MethodInterceptor[] getInterceptors(Advisor advisor) throws UnknownAdviceTypeException {
   List<MethodInterceptor> interceptors = new ArrayList<MethodInterceptor>(3);
   Advice advice = advisor.getAdvice();
   if (advice instanceof MethodInterceptor) {
      interceptors.add((MethodInterceptor) advice);
   }
   for (AdvisorAdapter adapter : this.adapters) {
      if (adapter.supportsAdvice(advice)) {
         interceptors.add(adapter.getInterceptor(advisor));
      }
   }
   if (interceptors.isEmpty()) {
      throw new UnknownAdviceTypeException(advisor.getAdvice());
   }
   return interceptors.toArray(new MethodInterceptor[interceptors.size()]);
}

 

可以看到，这里面核心的部分就是通过适配器来返回增强实例，返回的增强被放入准备好的容器，也就是我们invoke中的获取到的增强链。

 

 

 

处理增强

         在获取到增强链以后，我们需要ReflectiveMethodInvocation来进行调用：

// We need to create a method invocation...
invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
// Proceed to the joinpoint through the interceptor chain.
retVal = invocation.proceed();

 

         我们看下ReflectiveMethodInvocation中proceed的逻辑：

ReflectiveMethodInvocation#proceed()

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中，会逐个运行拦截器中的调用方法，在调用之前，对代理方法有一个匹配的判断，这里匹配的就是对pointcut进行匹配的过程，这里可以看到红色部分，会迭代处理所有的增强，直到处理完毕。

 

 

 

CglibAopProxy

 

         在上面我们介绍了JdkDynamicAopProxy中的拦截器的实现，下面我们看下CglibAopProxy中的拦截器：

         在我们的代理模式中，我们通过实现MethodInterceptor,重写其中的intercept()方法来完成代理工作，spring中是怎么处理的呢？

         在CglibAopProxyz中，spring通过DynamicAdvisedInterceptor对象来完成拦截器的回调，这是一个内部类：

private static class DynamicAdvisedInterceptor implements MethodInterceptor, Serializable {

   private final AdvisedSupport advised;

   public DynamicAdvisedInterceptor(AdvisedSupport advised) {
      this.advised = advised;
   }

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

   @Override
   public boolean equals(Object other) {
      return (this == other ||
            (other instanceof DynamicAdvisedInterceptor &&
                  this.advised.equals(((DynamicAdvisedInterceptor) other).advised)));
   }

   /**
    * CGLIB uses this to drive proxy creation.
    */
   @Override
   public int hashCode() {
      return this.advised.hashCode();
   }

   protected Object getTarget() throws Exception {
      return this.advised.getTargetSource().getTarget();
   }

   protected void releaseTarget(Object target) throws Exception {
      this.advised.getTargetSource().releaseTarget(target);
   }
}

 

可以看到，这里面处理的逻辑和JdkdynamicAopProxy非常相似，都是先获取增强链，然后再进行处理。这里获取增强链的逻辑都是一样的，与JdkDynamicAopProxy不同的是，这里使用的对象是CglibMethodInvocation:

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

 

我们看下这个构造函数的内容：

 

private static class CglibMethodInvocation extends ReflectiveMethodInvocation {

   private final MethodProxy methodProxy;

   private final boolean publicMethod;

   public CglibMethodInvocation(Object proxy, Object target, Method method, Object[] arguments,
         Class<?> targetClass, List<Object> interceptorsAndDynamicMethodMatchers, MethodProxy methodProxy) {

      super(proxy, target, method, arguments, targetClass, interceptorsAndDynamicMethodMatchers);
      this.methodProxy = methodProxy;
      this.publicMethod = Modifier.isPublic(method.getModifiers());
   }

   /**
    * Gives a marginal performance improvement versus using reflection to
    * invoke the target when invoking public methods.
    */
   @Override
   protected Object invokeJoinpoint() throws Throwable {
      if (this.publicMethod) {
         return this.methodProxy.invoke(this.target, this.arguments);
      }
      else {
         return super.invokeJoinpoint();
      }
   }
}

 

可以看到这里继承了ReflectiveMethodInvocation,里面还是调用的父类的处理，也就是说CglibAopProxy和JdkdynamicAopProxy都是通过ReflectiveMethodInvocation来处理增强的。

 

 

总结

 

         JdkDynamicAopProxy通过实现InvocationHandler接口，通过重写的invoke()对目标方法进行拦截，内部通过ReflectiveMethodInvocation完成对增强的处理；

CglibAopProxy内部通过DynamicAdvisedInterceptor完成对目标方法的拦截，这个对象实现了MethodInterceptor接口，通过重写intercept()方法进行拦截，内部使用了CglibMethodInvocation来对增强进行处理，这个类是ReflectiveMethodInvocation的子类，所以这两种方式其实都是通过ReflectiveMethodInvocation来处理增强的／