默认情况下，当一个 bean 继承了一个或多个接口的时候，Spring 就会使用 JDK 动态代理

  1. final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
  3.     public JdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException {
  4.         Assert.notNull(config, "AdvisedSupport must not be null");
  5.         if (config.getAdvisorCount() == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {
  6.             throw new AopConfigException("No advisors and no TargetSource specified");
  7.         }
  8.         // advised 就是 ProxyFactory 对象
  9.         this.advised = config;
  10.         // 获取生成代理对象所需要实现的接口，同时还包括 Spring 自己添加的三个接口：SpringProxy，Advised，DecoratingProxy
  11.         this.proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
  12.         // 判断这些方法中有没有定义 equals 和 hashCode 方法
  13.         findDefinedEqualsAndHashCodeMethods(this.proxiedInterfaces);
  14.     }
  16.     @Override
  17.     public Object getProxy(@Nullable ClassLoader classLoader) {
  18.         if (logger.isTraceEnabled()) {
  19.             logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
  20.         }
  21.         // this.proxiedInterfaces: 获取生成代理对象所需要实现的接口
  22.         // this: 就是 JdkDynamicAopProxy，因为 JdkDynamicAopProxy 实现了 InvocationHandler
  23.         // 针对所指定的接口生成代理对象，包括用户所添加的接口以及 SpringProxy，Advised，DecoratingProxy
  24.         // 所以生成的代理对象可以强制转换为任一个接口类型
  25.         return Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this);
  26.     }
  28.     @Override
  29.     @Nullable
  30.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  31.         // ...
  32.     }
  33. }

1、准备代理

JDK 动态代理除了会添加我们自己的接口外，还会添加三个 Spring 自己的接口：SpringProxy，Advised，DecoratingProxy

  1. public JdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException {
  2.     Assert.notNull(config, "AdvisedSupport must not be null");
  3.     if (config.getAdvisorCount() == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {
  4.         throw new AopConfigException("No advisors and no TargetSource specified");
  5.     }
  6.     // advised 就是 ProxyFactory 对象
  7.     this.advised = config;
  8.     // 获取生成代理对象所需要实现的接口，同时还包括 Spring 自己添加的三个接口：SpringProxy，Advised，DecoratingProxy
  9.     this.proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);
  10.     // 判断这些方法中有没有定义 equals 和 hashCode 方法
  11.     findDefinedEqualsAndHashCodeMethods(this.proxiedInterfaces);
  12. }

2、代理类

调用代理逻辑 Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this); 这里的 this 就是 JdkDynamicAopProxy ，因为 JdkDynamicAopProxy 实现了 InvocationHandler 接口

  1. @Override
  2.     public Object getProxy(@Nullable ClassLoader classLoader) {
  3.         if (logger.isTraceEnabled()) {
  4.             logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());
  5.         }
  6.         // this.proxiedInterfaces: 获取生成代理对象所需要实现的接口
  7.         // this: 就是 JdkDynamicAopProxy，因为 JdkDynamicAopProxy 实现了 InvocationHandler
  8.         // 针对所指定的接口生成代理对象，包括用户所添加的接口以及 SpringProxy，Advised，DecoratingProxy
  9.         // 所以生成的代理对象可以强制转换为任一个接口类型
  10.         return Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this);
  11.     }

3、执行代理逻辑

当代理调用调用某个方法的时候，就会进入 invoke 方法中

  1. @Override
  2. @Nullable
  3. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  4.     Object oldProxy = null;
  5.     boolean setProxyContext = false;
  7.     TargetSource targetSource = this.advised.targetSource;
  8.     Object target = null;
  10.     try {
  11.         if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {
  12.             // The target does not implement the equals(Object) method itself.
  13.             return equals(args[0]);
  14.         }
  15.         else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {
  16.             // The target does not implement the hashCode() method itself.
  17.             return hashCode();
  18.         }
  19.         else if (method.getDeclaringClass() == DecoratingProxy.class) {
  20.             // There is only getDecoratedClass() declared -> dispatch to proxy config.
  21.             return AopProxyUtils.ultimateTargetClass(this.advised);
  22.         }
  23.         else if (!this.advised.opaque && method.getDeclaringClass().isInterface() &&
  24.                  method.getDeclaringClass().isAssignableFrom(Advised.class)) {
  25.             // Service invocations on ProxyConfig with the proxy config...
  26.             return AopUtils.invokeJoinpointUsingReflection(this.advised, method, args);
  27.         }
  29.         Object retVal;
  31.         if (this.advised.exposeProxy) {
  32.             // Make invocation available if necessary.
  33.             oldProxy = AopContext.setCurrentProxy(proxy);
  34.             setProxyContext = true;
  35.         }
  37.         // Get as late as possible to minimize the time we "own" the target,
  38.         // in case it comes from a pool.
  39.         target = targetSource.getTarget();
  40.         Class<?> targetClass = (target != null ? target.getClass() : null);
  42.         // Get the interception chain for this method.
  43.         List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
  45.         // Check whether we have any advice. If we don't, we can fallback on direct
  46.         // reflective invocation of the target, and avoid creating a MethodInvocation.
  47.         if (chain.isEmpty()) {
  48.             // We can skip creating a MethodInvocation: just invoke the target directly
  49.             // Note that the final invoker must be an InvokerInterceptor so we know it does
  50.             // nothing but a reflective operation on the target, and no hot swapping or fancy proxying.
  51.             Object[] argsToUse = AopProxyUtils.adaptArgumentsIfNecessary(method, args);
  52.             retVal = AopUtils.invokeJoinpointUsingReflection(target, method, argsToUse);
  53.         }
  54.         else {
  55.             // We need to create a method invocation...
  56.             MethodInvocation invocation =
  57.                 new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
  58.             // Proceed to the joinpoint through the interceptor chain.
  59.             retVal = invocation.proceed();
  60.         }
  62.         // Massage return value if necessary.
  63.         Class<?> returnType = method.getReturnType();
  64.         if (retVal != null && retVal == target &&
  65.             returnType != Object.class && returnType.isInstance(proxy) &&
  66.             !RawTargetAccess.class.isAssignableFrom(method.getDeclaringClass())) {
  67.             // Special case: it returned "this" and the return type of the method
  68.             // is type-compatible. Note that we can't help if the target sets
  69.             // a reference to itself in another returned object.
  70.             retVal = proxy;
  71.         }
  72.         else if (retVal == null && returnType != Void.TYPE && returnType.isPrimitive()) {
  73.             throw new AopInvocationException(
  74.                 "Null return value from advice does not match primitive return type for: " + method);
  75.         }
  76.         return retVal;
  77.     }
  78.     finally {
  79.         if (target != null && !targetSource.isStatic()) {
  80.             // Must have come from TargetSource.
  81.             targetSource.releaseTarget(target);
  82.         }
  83.         if (setProxyContext) {
  84.             // Restore old proxy.
  85.             AopContext.setCurrentProxy(oldProxy);
  86.         }
  87.     }
  88. }