createAopProxy() 方法决定了是使用 JDK 还是 Cglib 来做动态代理：

  • 如果目标对象实现了接口，默认情况下会采用 JDK 的动态代理

  • 如果目标对象没有实现了接口，会使用 CGLIB 动态代理

    1. public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {
    3.   @Override
    4.   public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    5.       if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
    6.           Class<?> targetClass = config.getTargetClass();
    7.           if (targetClass == null) {
    8.               throw new AopConfigException("TargetSource cannot determine target class: " +
    9.                       "Either an interface or a target is required for proxy creation.");
    10.           }
    11.           if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
    12.               return new JdkDynamicAopProxy(config);
    13.           }
    14.           return new ObjenesisCglibAopProxy(config);
    15.       }
    16.       else {
    17.           return new JdkDynamicAopProxy(config);
    18.       }
    19.   }
    20. .......
    21. }

    JdkDynamicAopProxy

    JDK动态代理时候InvocationHandler的实现类为org.springframework.aop.framework.JdkDynamicAopProxy。
    那么代理方法的调用肯定会进入JdkDynamicAopProxy.invoke()方法 ```java public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object oldProxy = null; boolean setProxyContext = false;

    TargetSource targetSource = this.advised.targetSource; Object target = null;

    try {

    1.   if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
    2.       // The target does not implement the equals(Object) method itself.
    3.       return equals(args[0]);
    4.   }
    5.   else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
    6.       // The target does not implement the hashCode() method itself.
    7.       return hashCode();
    8.   }
    9.   else if (method.getDeclaringClass() == DecoratingProxy.class) {
    10.       // There is only getDecoratedClass() declared -> dispatch to proxy config.
    11.       return AopProxyUtils.ultimateTargetClass(this.advised);
    12.   }
    13.   else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
    14.           method.getDeclaringClass().isAssignableFrom(Advised.class)) {
    15.       // Service invocations on ProxyConfig with the proxy config...
    16.       return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
    17.   }
    19.   Object retVal;
    21.   if (this.advised.exposeProxy) {
    22.       // Make invocation available if necessary.
    23.       oldProxy = AopContext.setCurrentProxy(proxy);
    24.       setProxyContext = true;
    25.   }
    27.   // Get as late as possible to minimize the time we "own" the target,
    28.   // in case it comes from a pool.
    29.   target = targetSource.getTarget(); // 目标对象
    30.   Class<?> targetClass = (target != null ? target.getClass() : null); // 目标对象的类型
    32.   // Get the interception chain for this method.
    33.   // 这里会对方法进行匹配，因为不是目标对象中的所有方法都需要增强
    34.   List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
    36.   // Check whether we have any advice. If we don't, we can fallback on direct
    37.   // reflective invocation of the target, and avoid creating a MethodInvocation.
    38.   if (chain.isEmpty()) {
    39.       // We can skip creating a MethodInvocation: just invoke the target directly
    40.       // Note that the final invoker must be an InvokerInterceptor so we know it does
    41.       // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
    42.       // 没有匹配的切面，直接通过反射调用目标对象的目标方法
    43.       Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
    44.       retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
    45.   }
    46.   else {
    47.       // We need to create a method invocation...
    48.       MethodInvocation invocation =
    49.               new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
    50.       // Proceed to the joinpoint through the interceptor chain.
    51.       /**
    52.        * @see ReflectiveMethodInvocation#proceed()
    53.        */
    54.       // 这里才是增强的调用，重点，火炬的传递
    55.       retVal = invocation.proceed();
    56.   }
    58.   // Massage return value if necessary.
    59.   Class<?> returnType = method.getReturnType();
    60.   if (retVal != null && retVal == target &&
    61.           returnType != Object.class && returnType.isInstance(proxy) &&
    62.           !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
    63.       // Special case: it returned "this" and the return type of the method
    64.       // is type-compatible. Note that we can't help if the target sets
    65.       // a reference to itself in another returned object.
    66.       retVal = proxy;
    67.   }
    68.   else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
    69.       throw new AopInvocationException(
    70.               "Null return value from advice does not match primitive return type for: " + method);
    71.   }
    72.   return retVal;

    } finally {

    1.   if (target != null && !targetSource.isStatic()) {
    2.       // Must have come from TargetSource.
    3.       targetSource.releaseTarget(target);
    4.   }
    5.   if (setProxyContext) {
    6.       // Restore old proxy.
    7.       AopContext.setCurrentProxy(oldProxy);
    8.   }

    } }

  1. <a name="mh22o"></a>
  2. # ReflectiveMethodInvocation
  3. `interceptorsAndDynamicMethodMatchers`中第一个advice为org.springframework.aop.interceptor.ExposeInvocationInterceptor。
  4. ```java
  5. public Object proceed() throws Throwable {
  6.     // We start with an index of -1 and increment early.
  7.     if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
  8.         // 执行到最后一个Advice，才会到这里执行目标方法
  9.         return invokeJoinpoint();
  10.     }
  12.     Object interceptorOrInterceptionAdvice =
  13.             this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
  14.     if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
  15.         // Evaluate dynamic method matcher here: static part will already have
  16.         // been evaluated and found to match.
  17.         // dm.isRuntime()=true的走这
  18.         InterceptorAndDynamicMethodMatcher dm =
  19.                 (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
  20.         Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
  21.         if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
  22.             return dm.interceptor.invoke(this);
  23.         }
  24.         else {
  25.             // Dynamic matching failed.
  26.             // Skip this interceptor and invoke the next in the chain.
  27.             return proceed();
  28.         }
  29.     }
  30.     else {
  31.         // It's an interceptor, so we just invoke it: The pointcut will have
  32.         // been evaluated statically before this object was constructed.
  33.         // 走这
  34.         return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
  35.     }
  36. }