SPRING 阅读--JdkDynamicAopProxy

一、简介

　　JdkDynamicAopProxy 代理类是spring 默认的JDK动态的代理类实现。它实现了Java 动态代理接口InvocationHandler接口和Spring定义的AopProxy接口。AopProxy定义了返回代理的对象。

二、阅读

public JdkDynamicAopProxy(AdvisedSupport config) throws AopConfigException {

   Assert.notNull(config, "AdvisedSupport must not be null");

   if (config.getAdvisors().length == 0 && config.getTargetSource() == AdvisedSupport.EMPTY_TARGET_SOURCE) {

      throw new AopConfigException("No advisors and no TargetSource specified");

   }

   this.advised = config;

}

　　从其构造函数来看，该类的入参是AdvisedSupport，并把入参设置到成员变量中。其中AdvisedSupport类是Aop代理的配置管理类，里面包括了代理的对象和被代理对象需要织入的通知Advice.

从该类实现了AopProxy接口，那么久可以返回代理的对象，其实现如下：

@Override

public Object getProxy(@Nullable ClassLoader classLoader) {

   if (logger.isTraceEnabled()) {

      logger.trace("Creating JDK dynamic proxy: " + this.advised.getTargetSource());

   }

   Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true);

   findDefinedEqualsAndHashCodeMethods(proxiedInterfaces);

   return Proxy.newProxyInstance(classLoader, proxiedInterfaces, this);

}

　　首先从AopProxyUtils.completeProxiedInterfaces工具方法得到需要代理的接口，接着通过findDefinedEqualsAndHashCodeMethods私有方法判断这些需要的代理接口proxiedInterfaces是否重新定义了equals和hashcode方法，并把接口记录到this.equalsDefined 和 this.hashCodeDefined成员变量中。最后核心其实是通过Java的动态代理类Proxy 产生一个代理对象。所以每调用一次getProxy都会产生新的一个代理对象。

　　接着我们需要看下的就是InvocationHandler接口的invoke方法是如何实现的。注入和原理如下：

@Override

@Nullable

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

   Object oldProxy = null;

   boolean setProxyContext = false;

    // 通过this.advised得到代理的目标类，

   TargetSource targetSource = this.advised.targetSource;

   Object target = null;

   try {

    // 如何代理接口没有定义equals方法，则调用JdkDynamicAopProxy的重写的equals方法

      if (!this.equalsDefined && AopUtils.isEqualsMethod(method)) {

         // The target does not implement the equals(Object) method itself.

         return equals(args[0]);

      }

     // 如何代理接口没有定义equals方法，则调用JdkDynamicAopProxy的重写的equals方法

      else if (!this.hashCodeDefined && AopUtils.isHashCodeMethod(method)) {

         // The target does not implement the hashCode() method itself.

         return hashCode();

      }

      //如果该方法申明类是DecoratingProxy，则直接最终的被代理类的类Class

      else if (method.getDeclaringClass() == DecoratingProxy.class) {

         // There is only getDecoratedClass() declared -> dispatch to proxy config.

         return AopProxyUtils.ultimateTargetClass(this.advised);

      }

     //如果目标对象是Advice类型，则直接使用反射进行调用

     //opaque-->标记是否需要阻止通过该配置创建的代理对象转换为Advised类型，默认值为false，表示代理对象可以被转换为Advised类型

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

     //  看是否需要暴露代理对象，如果需要放到threadLocal上

      if (this.advised.exposeProxy) {

         // Make invocation available if necessary.

         oldProxy = AopContext.setCurrentProxy(proxy);

         setProxyContext = true;

      }

      // Get as late as possible to minimize the time we "own" the target,

      // in case it comes from a pool.

      target = targetSource.getTarget();

      Class<?> targetClass = (target != null ? target.getClass() : null);

      // 得到该调用方法的拦截链

      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 {

         // 否则创建 MethodInvocation 执行拦截调用

         MethodInvocation 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 != Object.class && 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.

         // 如果返回值是this,那么返回值替换为代理对象，而不是原对象。

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

      }

   }

}

　　从上面我们知道有几个特殊的接口，当方法的代理类是DecoratingProxy，或者是Advised都做了特殊的处理。原因在于在创建JdkDynamicAopProxy 对象是，有Class<?>[] proxiedInterfaces = AopProxyUtils.completeProxiedInterfaces(this.advised, true); 这么一句语句。它返回的代理接口就可能包括DecortingProxy 和Advised。具体如下：

static Class<?>[] completeProxiedInterfaces(AdvisedSupport advised, boolean decoratingProxy) {

   Class<?>[] specifiedInterfaces = advised.getProxiedInterfaces();

   // 首先得到用户设置的代理接口，如果没有检查和设置代理类是否是一个接口

   if (specifiedInterfaces.length == 0) {

      // No user-specified interfaces: check whether target class is an interface.

      Class<?> targetClass = advised.getTargetClass();

      if (targetClass != null) {

         if (targetClass.isInterface()) {

            advised.setInterfaces(targetClass);

         }

         else if (Proxy.isProxyClass(targetClass)) {

            advised.setInterfaces(targetClass.getInterfaces());

         }

         specifiedInterfaces = advised.getProxiedInterfaces();

      }

   }

   // 如果用户代理的接口设置中没有SpringProxy接口，需要把代理类实现SpringProxy接口，该接口是个标记接口，说明是Spring代理

   boolean addSpringProxy = !advised.isInterfaceProxied(SpringProxy.class);

  // 如果代理类可以转化为Advised类型，并且用户没有指定Advised，则添加该接口，

  //所以这里可以知道一般Spring的代理类都实现了该Advised接口

   boolean addAdvised = !advised.isOpaque() && !advised.isInterfaceProxied(Advised.class);

  //如果decoratingProxy==true，并且用户未添加DecoratingProxy接口，则代理需要实现该接口DecoratingProxy

   boolean addDecoratingProxy = (decoratingProxy && !advised.isInterfaceProxied(DecoratingProxy.class));

   int nonUserIfcCount = 0;

   if (addSpringProxy) {

      nonUserIfcCount++;

   }

   if (addAdvised) {

      nonUserIfcCount++;

   }

   if (addDecoratingProxy) {

      nonUserIfcCount++;

   }

   Class<?>[] proxiedInterfaces = new Class<?>[specifiedInterfaces.length + nonUserIfcCount];

   System.arraycopy(specifiedInterfaces, 0, proxiedInterfaces, 0, specifiedInterfaces.length);

   int index = specifiedInterfaces.length;

   if (addSpringProxy) {

         proxiedInterfaces[index] = SpringProxy.class;

         index++;

      }

      if (addAdvised) {

         proxiedInterfaces[index] = Advised.class;

         index++;

   }

   if (addDecoratingProxy) {

      proxiedInterfaces[index] = DecoratingProxy.class;

   }

   // 所以从上面分析得知，proxiedInterfaces会返回用户制定的代理接口+SpringProxy、Advised、DecoratingProxy

   return proxiedInterfaces;

}

三、测试

public interface Human {

	Human getInstance();

}

public class ChineseHuman implements Human {

	private String desc;

	public ChineseHuman() {

	}

	public ChineseHuman(String desc) {

		this.desc = desc;

	}

	public String getDesc() {

		return desc;

	}

	public void setDesc(String desc) {

		this.desc = desc;

	}

	@Override

	public Human getInstance() {

		System.out.println("human desc:" + desc);

		return this;

	}

}

public class JdkDynamicAopProxyTests {

	@Test

	public void testJdkProxy() {

		AdvisedSupport advisedSupport = new AdvisedSupport();

		advisedSupport.setInterfaces(Human.class);

		advisedSupport.setTargetSource(new TargetSource() {

			@Override

			public Class<?> getTargetClass() {

				return ChineseHuman.class;

			}

			@Override

			public boolean isStatic() {

				return false;

			}

			@Override

			public Object getTarget() throws Exception {

				return new ChineseHuman("中国人");

			}

			@Override

			public void releaseTarget(Object target) throws Exception {

			}

		});

		JdkDynamicAopProxy jdkDynamicAopProxy = new JdkDynamicAopProxy(advisedSupport);

		Human human = (Human) Proxy.newProxyInstance(JdkDynamicAopProxy.class.getClassLoader(), new Class[]{Human.class}, jdkDynamicAopProxy);

		System.out.println(human.getInstance());

		// JDK原生代理，必然为true，因为本身是生成的是代理的接口的对象

		System.out.println("human instanceof Human:" + (human instanceof Human));

		//false

		System.out.println("human instanceof ChineseHuman:" + (human instanceof ChineseHuman));

		//false

		System.out.println("human instanceof Advised:" + (human instanceof Advised));

		//false

		System.out.println("human instanceof SpringProxy:" + (human instanceof SpringProxy));

		//false

		System.out.println("human instanceof DecoratingProxy:" + (human instanceof DecoratingProxy));

		//true, 有个面试题是这么问的，java动态代理为啥代理是接口，不能是类，

		// 其根原在于JDK的动态代理实现方式是代理对象继承了java.lang.reflect.Proxy，并且java单继承，所以无法代理类

		System.out.println("human instanceof Proxy:" + (human instanceof Proxy));

		System.out.println("Spring JDK代理扩展=========");

		human = (Human) jdkDynamicAopProxy.getProxy();

		System.out.println(human.getInstance());

		// 该代理对象的getInstance返回是其本身，原因也在于上面分析的红色部分原因。

		System.out.println("human== human.getInstance():" + (human == human.getInstance()));

		// true

		System.out.println("human instanceof Human:" + (human instanceof Human));

		//false

		System.out.println("human instanceof ChineseHuman:" + (human instanceof ChineseHuman));

		//true

		System.out.println("human instanceof Advised:" + (human instanceof Advised));

		// true

		System.out.println("human instanceof SpringProxy:" + (human instanceof SpringProxy));

		// true

		System.out.println("human instanceof DecoratingProxy:" + (human instanceof DecoratingProxy));

		//true

		System.out.println("human instanceof Proxy:" + (human instanceof Proxy));

	}

}

　　从上面的测试可以知道，一个对象被Spring的JDK动态代理后，其代理对象会实现其用户指定的代理接口外，还会实现Advised,SpringProxy，DecoratingProxy接口。

巴特西

SPRING 阅读--JdkDynamicAopProxy

最新文章

热门文章