Java之动态代理实践

功能概述

Java的动态代理，是代理模式的具体实现，即为其他对象提供一个代理以控制对某个对象的访问。Java的动态代理主要涉及两个类：java.lang.reflect.Proxy 和 java.lang.reflect.InvocationHandler，内部使用了缓存机制和反射机制实现。

功能实践

场景1：为Map接口生成代理

用例代码

@Test
public void test_jdk_dynamic_proxy_v1() {Map mapProxyInstance = (Map) Proxy.newProxyInstance(ProxyTest.class.getClassLoader(), new Class[] { Map.class },new MyInvocationHandler(new HashMap<>()));mapProxyInstance.put("hello", "world"); //为接口创建代理对象后，就可以直接操作接口中的方法了（使用向上转型）mapProxyInstance.get("hello");CharSequence csProxyInstance = (CharSequence) Proxy.newProxyInstance(ProxyTest.class.getClassLoader(),new Class[] { CharSequence.class },new MyInvocationHandler("Hello World"));csProxyInstance.charAt(0);csProxyInstance.length();
}// 自定义的调用处理器
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MyInvocationHandler implements InvocationHandler {private Object target;public MyInvocationHandler(Object target) {this.target = target;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args)throws Throwable {Object result = method.invoke(target, args);System.out.println("执行方法：" + method.getName() + "，结果值：" + result);return result;}
}

运行结果

执行方法：put，结果值：null
执行方法：get，结果值：world
执行方法：charAt，结果值：H
执行方法：length，结果值：11

结果分析

为Map接口创建代理对象。并自定义调用处理器MyInvocationHandler，在使用代理接口调用方法时，就会回调MyInvocationHandler的invoke方法，传入代理对象、调用的方法、参数列表等

场景2：为自定义接口生成代理

用例代码

public void test_jdk_dynamic_proxy_v2() throws IOException {IHelloProxy helloProxy = (IHelloProxy) Proxy.newProxyInstance(ProxyTest.class.getClassLoader(),new Class[]{IHelloProxy.class}, new MyInvocationHandler(new HelloProxyImpl())); //要指定接口的实现类，在回调处理器的invoke方式时，调用目标类对应方法helloProxy.setProxyName("hello");String proxyName = helloProxy.getProxyName("hello");System.out.println("结果值：" + proxyName);
}public interface IHelloProxy {String getProxyName(String name);void setProxyName(String name);
}public class HelloProxyImpl implements IHelloProxy {private String proxyName;private static final String PREFIX = "proxy_";@Overridepublic String getProxyName(String name) {return proxyName;}@Overridepublic void setProxyName(String name) {proxyName = PREFIX + name;}
}

注明：该场景用到的MyInvocationHandler，在场景1中有声明。

运行结果

执行方法：setProxyName，结果值：null
执行方法：getProxyName，结果值：proxy_hello
结果值：proxy_hello

结果分析

在创建代理对象时，指定代理的接口IHelloProxy，以及调用处理器MyInvocationHandler，调用处理器指定了接口实现类，即目标对象
在调用接口方法时，即调用调用代理对象的方法，会回调InvocationHandler中的invoke方法，可在该方法中做增强处理

原理分析

Proxy#newProxyInstance创建代理对象分析】

public class Proxy implements java.io.Serializable {private static final WeakCache<ClassLoader, Class<?>[], Class<?>>proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory()); //代码1）public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)throws IllegalArgumentException{Objects.requireNonNull(h);final Class<?>[] intfs = interfaces.clone();final SecurityManager sm = System.getSecurityManager();if (sm != null) {checkProxyAccess(Reflection.getCallerClass(), loader, intfs);}/** Look up or generate the designated proxy class.*/Class<?> cl = getProxyClass0(loader, intfs); // 代码2）/** Invoke its constructor with the designated invocation handler.*/try {if (sm != null) {checkNewProxyPermission(Reflection.getCallerClass(), cl);}final Constructor<?> cons = cl.getConstructor(constructorParams);//...代码省略...return cons.newInstance(new Object[]{h}); // 代码3）} catch (IllegalAccessException|InstantiationException e) // ...代码省略...}}private static Class<?> getProxyClass0(ClassLoader loader,Class<?>... interfaces) {if (interfaces.length > 65535) {throw new IllegalArgumentException("interface limit exceeded");}return proxyClassCache.get(loader, interfaces); //代码4）}
}

代码解析：
- 代码1）处：WeakCache用来存储代理类的缓存，若无缓存，会通过ProxyClassFactory创建
- 代码2）处：从缓存中查找代理类，若没有创建代理类
- 代码3）处：找到代理类包含InvocationHandler为参数的构造器Constructor，通过反射机制创建代理对象
- 代码4）处：从缓存中去查代理类

ProxyClassFactory#apply创建代理类分析

private static final class ProxyClassFactoryimplements BiFunction<ClassLoader, Class<?>[], Class<?>>
{//...代码省略...@Overridepublic Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);for (Class<?> intf : interfaces) {Class<?> interfaceClass = null;try {interfaceClass = Class.forName(intf.getName(), false, loader); // 代码1）} catch (ClassNotFoundException e) {}if (interfaceClass != intf) {throw new IllegalArgumentException(intf + " is not visible from class loader");}if (!interfaceClass.isInterface()) { // 代码2）throw new IllegalArgumentException(interfaceClass.getName() + " is not an interface");}/** Verify that this interface is not a duplicate.*/if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {throw new IllegalArgumentException("repeated interface: " + interfaceClass.getName());}}// ...代码省略.../** Generate the specified proxy class.*/byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags); // 代码3）try {return defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length); //代码4）} catch (ClassFormatError e) {/** A ClassFormatError here means that (barring bugs in the* proxy class generation code) there was some other* invalid aspect of the arguments supplied to the proxy* class creation (such as virtual machine limitations* exceeded).*/throw new IllegalArgumentException(e.toString());}}
}