java动态代理简单使用（Java动态代理机制和实现原理详解）(1)

代理模式Java动态代理

// 该方法用于获取指定代理对象所关联的调用处理器 public static InvocationHandler getInvocationHandler(Object proxy); // 该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象 public static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces); // 该方法用于判断指定类对象是否是一个动态代理类 public static boolean isProxyClass(Class<?> cl); // 该方法用于为指定类装载器,一组接口以及调用处理器生成动态代理类实例 public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h);

/** * 该方法负责集中处理动态代理类上的所有方法调用 * * @param proxy 代理实例 * @param method 被调用的方法对象 * @param args 调用参数 * @return 返回调用处理器根据三个参数进行预处理或者分派到委托类实例上反射执行的对象 */ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;

Java动态代理机制Java动态代理创建对象的过程:

/* * InvocationHandlerImpl实现了InvocationHandler接口 * 并能实现方法调用从代理类到委托类的分派转发向委托类实例的引用,用于真正执行分派转发过来的方法调用 */ InvocationHandler handler = new InvocationHandlerImpl(...);

// 通过Proxy为包括Interface接口在内的一组接口动态创建代理类的类对象 Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... });

// 通过反射从生成的类对象获得构造函数对象 Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class });

// 通过构造函数创建动态代理类实例 Interface proxy = (Interface)constructor.newInstance(new Object[] { handler });

为了简化对象创建过程 ,Proxy 类中使用 newInstanceProxy 封装了 步骤2-步骤4, 因此只需要两个步骤即可完成代理对象的创建

// InvocationHandlerImpl实现了InvocationHandler接口,并能实现方法调用从代理类到委托类的分派转发 InvocationHandler handler = new InvocationHandlerImpl(...); // 通过 Proxy 直接创建动态代理类的实例 Interface proxy = (Interface)Proxy.newProxyInstance(classLoader, new Class[] { Interface.class }, handler);

Java动态代理注意点

/* * 记录非公共代理接口的包,以便在同一个包中定义代理类 * 验证所有非公共代理接口是否都在同一个包中 */ for (int i =0; i < interfaces.length; i ) { int flags = interfaces[i].getModifiers(); if (!Modifier.isPublic(flags)) { String name = interfaces[i].getName(); int n = name.lastIndexOf("."); String pkg = ((n == -1) ? "" : name.subString(0, n 1)); if (proxyPkg == null) { proxyPkg = pkg; } else if (!pkg.equals(proxyPkg)) { throw new IllegalArgumentException("non-public interfaces from different packaes"); } } } if (proxyPkg == null) { // 没有使用非公共代理接口代理类的包 proxyPkg = ReflectUtil.PROXY_PACKAGE "."; }

synchronized (cache) { /* * 不必担心获取到清除掉弱引用的缓存 * 因为如果一个代理类已经被垃圾回收,代理类的类加载器也会被垃圾回收 * 所以获取到的缓存都是加载到缓存中的映射 */ do { Object value = cache.get(key); if (value instanceof Reference) { proxyClass = (Class) ((Reference) value).get(); if (proxyClass != null) { /* * 代理类已经生成,返回代理类 */ return proxyClass; } else if (value == pendingGenerationmarker) { /* * 代理类正在生成,等待代理类生成 */ try { cache.wait(); } catch (InterruptedException e) { /* * 等待生成的代理类有一个极小的限定的时间,因此可以忽略线程在这里的影响 */ } continue; } else { /* * 如果没有这个接口列表已经生成或者正在生成的代理类 * 需要去生成这些接口的代理类,将这些接口标记为待生成 */ cache.put(key, pendingGenerationMarker); break; } }while (true); }

Java动态代理测试创建一个动态代理类

public class serviceProxy implements InvocationHandler { private Object target; /** * 绑定委托对象并返回一个代理对象 * @param target 真实对象 * @return 代理对象 */ public Object bind(Object target, Class[] interfaces) { this.target = target; // 取得代理对象 return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this); } /** * 通过代理对象调用方法首先进入这个方法 * @param proxy 代理对象 * @param Method 方法,被调用方法 * @param args 方法的参数 */ @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { /* * JDK动态代理 */ Object result = null; // 反射方法前调用 System.err.println("--反射方法前执行的方法--"); // 反射执行方法,相当于调用target.xXX() result = method.invoke(target, args); // 反射方法后调用 System.err.println("--反射方法后执行的方法--"); return result; } }

ProxyTest

public class ProxyTest { public static void main(String[] args) { HelloServiceProxy proxy = new HelloServiceProxy(); HelloService service = new HelloServiceImpl(); // 绑定代理对象 service = (HelloService) proxy.bind(service, new Class[] {HelloService.class}); service.sayHello("user"); } }

class文件分析在运行期生成二进制字节码ASMJavassist源码分析Proxy类

// 映射表: 用于维护类装载器对象到其对应的代理类缓存 private static Map loaderToCache = new WeakHashMap(); // 标记: 用于标记一个动态代理类正在被创建中 private static Object pendingGenerationMarker = new Object(); // 同步表: 记录已经被创建的动态代理类类型,主要通过方法isProxyClass进行相关判断 private static Map proxyClasses = Collections.synchronizedMap(new WeakHashMap()); // 关联的调用处理器引用 protected InvocationHandler h;

newProxyInstance

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException { /* * 检查关联调用处理器是否为空,如果是空则抛出异常 */ if (h == null) { throw new NullPointerException(); } /* * 获得与指定类型装载器和一组接口相关的代理类类型对象 */ Class<?> cl = getProxyClass0(loader, interfaces); /* * 通过反射获取构造函数对象并生成代理类实例 */ try { final Constructor<?> cons = cl.getConstructor(constructorParams); final InvocationHandler ih = h; SecurityManager sm = System.getSecurityManager(); if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) { /* * 使用doPrivilege创建动态代理类实例 * 因为代理类实现可能需要特殊权限的非公共接口 */ return AccessController.doPrivileged(new PrivilegedAction<Object>() { public Object run() { return newInstance(cons, ih); } }); } else { return newInstance(cons, ih); } } catch (NoSuchMethodException e) { throw new InternalError(e.toString()); } } private static Object newInstance(Constructor<?> cons, InvocationHandler h) { try { return cons.newInstance(new Object[] {h}); } catch (IllegalAccessException e) { throw new InternalError(e.toString()); } catch (InstantationException e) { throw new InternalException(e.toString()); } catch (InvocationTargetException e) { Throwable t = e.getCause(); if (t instanceof RuntimeException) { throw (RuntimeException) t; } else { throw new InternalException(e.toString()); } } }

getProxyClass0方法分析

getProxyClass0()方法分为四个步骤:

  1. 对这组接口进行一定程度的安全检查:1.1 接口类对象是否对类装载器可见1.2 接口类对象与类装载器所识别的接口类对象完全相同1.3 确保是interface类型而不是class类型.

for (int i = 0; i < interfaces.length; i ) { /* * 验证类加载器是否将此接口的名称解析为相同的类对象 */ String interfaceName = interface[i].getName(); Class interfaceClass = null; try { /* * forName(String name, boolean initialize, ClassLoader loader) * Returns the Class object associated with the class or interface with the given string name, * using the given class loader */ interfaceClass = Class.forName(interfaceName, false, loader); } catch (ClassNotFoundException e) { } if (interfaceClass != interface[i]) { throw new IllegalArgumentException(interface[i] "is not visible from class loader."); } /* * 验证类加载器得到的类对象是否是interface类型 */ if (! interfaceClass.isInterface()) { throw new IllegalArgumentException(interfaceClass.getName() "is not an interface."); } /* * 验证类加载器得到的类对象接口不是一个重复的接口 */ if (interfaceSet.contains(interfaceClass)) { throw new IllegalArgumentException("repeated interface:" interface.getName()); } interfaceSet.add(interfaceClass); interfaceName[i] = interfaceName; }

  1. 从 loaderToCache 映射表中获取以类装载器对象为关键字所对应的缓存表,如果不存在,就会创建一个新的缓存表并更新到 loaderToCahe 中:2.1 loaderToCache 存放键值对 : 接口名字列表:动态生成的代理类的类对象的引用2.2 当代理类正在被创建时,会临时进行保存 : 接口名字列表:pendingGenerationMarker2.3 标记 pendingGenerationMarker 的作用是通知后续的同类请求(接口数组相同且组内接口排列顺序也相同)代理类正在被创建,请保持等待直至创建完成

/* * 寻找类加载器的缓存表,如果没有就为类加载器创建代理类缓存 */ Map cache; synchronized (loaderToCache) { cache = (Map) loaderToCache.get(loader); if (cache == null) { cache = new HashMap(); loaderToCache = put(loader, cache); } } do { /* * 以接口名字作为关键字获得对应的cache值 */ Object value = cache.get(key); if (value instanceof Reference) { proxyClass = (Class)((Reference)value).get(); } if (proxyClass != null) { // 如果已经创建,直接返回 return proxyClass; } else if (value == pendingGenerationMarker) { // 代理类正在创建,保持等待 try { cache.wait() } catch (InterruptException e) { } // 等待被唤醒,继续循环并通过二次检查以确保创建完成,否则重新等待 continue; } else { // 标记代理类正在被创建 cache.put(key, pendingGenerationMarker); // 跳出循环已进入创建过程 break; } } while(true)

  1. 动态创建代理类的class对象

/* * 选择一个名字代理类来生成 */ long num; synchronized (nextUniqueNumberLock) { num = nextUniqueNumber ; } String proxyName = proxyPkg proxyClassNamePrefix num; /* * 验证类加载器中没有使用这个名字定义的类 */ ... // 动态生成代理类的字节码数组 byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces); try { // 动态地定义新生成的代理类 proxyClass = defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length); } catch (ClassFormatError e) { /* * 这里的类格式错误指的是生代理类代码中的错误 * 还有一些应用到代理类生成的参数的错误,比如一些虚拟机限制的超量 */ throw new IllegalArgumentException(e.toString()); } // 将生成的代理类对象记录到proxyClasses中 proxyClasses.put(proxyClass, null);

首先根据接口 public 与否的规则生成代理类的名称 - $ProxyN 格式,然后动态生成代理类. 所有的代码生成工作由 ProxyGenerator 完成,该类在 rt.jar 中,需要进行反编译

public static byte[] generateProxyClass(final String name, Class[] interfaces) { ProxyGenerator gen = new ProxyGenerator(name, interfaces); // 动态生成代理类的字节码 final byte[] classFile = gen.generateClassFile(); // 如果saveGeneratedFiles的值为true,则会把所生成的代理类的字节码保存到硬盘上 if (saveGeneratedFiles) { java.security.AccessController.doPrivileged( new java.security.PrivilegedAction<Void>() { public Void run() { try{ FileOutputStream file = new FileOutputStream(doToSlash(name) ".class"); file.write(classFile); file.close(); return null; } catch (IOException e) { throw new InternalError("I/O exception saving generated file :" e); } } } ); } // 返回代理类的字节码 return classFile; }

  1. 代码生成过程进入结尾部分,根据结果更新缓存表. 如果代理类成功生成则将代理类的类对象引用更新进缓存表,否则清除缓存表中对应的关键值,最后唤醒所有可能的正在等待的线程

finally { synchronized (cache) { if (proxyClass != null) { cache.put(key, new WeakReference(proxyClass)); } else { cache.remove(key); } cache.notifyAll(); } } return proxyClass;

InvocationHandler解析JDK动态代理机制

/** * 交通工具接口 */ public interface Vehicle { public void drive(); }

/** * 充电接口 */ public interface Rechargable { public void recharge(); }

/** * 电动车类 * 实现Rechargable, Vehicle接口 */ public class ElectricCar implements Rechargable, Vehicle { @Override public void drive() { System.out.println("ElectricCar can drive."); } @Override public void recharge() { System.out.println("ElectricCar can recharge."); } }

/** * 动态代理类的触发器 */ public class InvocationHandlerImpl implements InvocationHandler { private ElectricCar car; public InvocationHandlerImpl(Electric car) { this.car = car; } @Override public Object invoke(Object paramObject, Method paramMethod, Object[] paramArrayOfObject) throws Throwable { System.out.println("正在调用方法:" paramMethod.getName() "..."); paramMethod.invoke(car, null); System.out.println("方法" paramMethod.getName() "调用结束."); return null; } }

public class ProxyTest { public static void main(String[] args) { ElectricCar car = new ElectricCar(); // 获取对应的ClassLoader ClassLoader classLoader = car.getClass().getClassLoader(); // 获取ElectricCar所实现的所有接口 Class[] interfaces = car.getClass().getInterfaces(); // 设置一个来自代理传过来的方法调用请求处理器,处理所有的代理对象上的方法调用 InvocationHandler handler = new InvocationHandlerImpl(car); /* * 创建代理对象在这个过程中: * a. JDK根据传入的参数信息动态地在内存中创建和 .class 等同的字节码 * b. 根据相应的字节码转换成对应的class * c. 然后调用newInstance()创建实例 */ Object o = Proxy.newProxyInstance(classLoader, interfaces, handler); Vehicle vehicle = (Vehicle) o; vehicle.drive(); Rechargable rechargable = (Rechargable) o; rechargable.recharge(); } }

public class proxyUtils { /* * 根据类信息,动态生成二进制字节码保存到硬盘中 * 默认是clazz目录下 * * @params clazz 需要生成动态代理类的类 * @proxyName 动态生成代理类的名称 */ public static void generateClassFile(Class clazz, String proxyName) { // 根据提供的代理类名称和类信息,生成字节码 byte[] classFile = ProxyGenerator.generateProxyClass(ProxyName, clazz.getInterfaces()); String paths = clazz.getResource(".").getPath(); System.out.println(paths); FileOutputStream out = null; try { // 保留到硬盘中 out = new FileOutputStream(paths proxyName ".class"); out.write(classFile); out.flush(); } catch (Exception e) { e.printStackTrace(); } finally { try { out.close(); } catch (IOException e) { e.printStackTrace(); } } } }

ProxyUtils.generateClassFile(car.getClass(), "ElectricCarProxy");

这样将在 ElectricCar.class 同级目录下产生 ElectricCarProxy.class 文件

/** * 生成的动态代理类的组织模式是继承Proxy类,然后实现需要实现代理的类上的所有接口 * 在实现过程中,是通过将所有的方法都交给InvocationHandler来处理 */ public final class ElectricCarProxy extends Proxy implements Rechargable,Vehicle { private static Method m1; private static Method m3; private static Method m4; private static Method m0; private static Method m2; public ElectricCarProxy(InvocationHandler paramInvocationHandler) throws { super(paramInvocationHandler); } public final boolean equals(Object paramObject) throws { try { /* * 方法功能的实现交给InvocationHandler处理 */ return ((Boolean) this.h.invoke(this, m1, new Object[] {paramObject})).booleanValue(); } catch (Error | RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new Undeclared ThrowableException(localThrowable); } } public final void recharge() throws { try { /* * 方法功能的实现交给InvocationHandler处理 */ this.h.invoke(this, m3, null); return; } catch (Error | RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new Undeclared ThrowableException(localThrowable); } } public final drive() throws { try { /* * 方法实现交给InvocationHandler处理 */ this.h.invoke(this, m4, null); return; } catch (Error | RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new Undeclared ThrowableException(localThrowable); } } public final int hasCode() throws { try { /* * 方法功能交给InvocationHandler处理 */ return ((Integer) this.h.invoke(this, m0, null)).intValue(); } catch (Error | RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new Undeclared ThrowableException(localThrowable); } } public final String toString() throws { try { /* * 方法功能实现交给InvocationHandler处理 */ return (String)this.h.invoke(this, m2, null); } catch (Error | RuntimeException localError) { throw localError; } catch (Throwable localThrowable) { throw new Undeclared ThrowableException(localThrowable); } } static { try { /* * 为每一个需要方法对象 * 当调用相应的方法时,分别将方法对象作为参数传递给InvocationHandler处理 */ m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") }); m3 = Class.forName("com.oxford.proxy.Rechargable").getMethod("recharge", new Class[0]); m4 = Class.forName("com.oxford.proxy.Vehicle").getMethod("drive", new Class[0]); m0 = Class.forName("java.lang.Object").getMethod("hasCode", new Class[0]); m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]); return; } catch (NoSuchMethodException localNoSuchMethodException) { throw new NoSuchMethodError(localNoSuchMethodException.getMessage()); } catch (ClassNotFoundException localClassNotFoundException) { throw new NoClassDefFoundError(localClassNotFoundException.getMessge()); } } }

CGLIB动态代理机制

/** * 开发人员类 */ public class Programmer { public void code() { System.out.println("开发人员开发程序代码."); } }

/** * 黑客类 * 实现了方法拦截器接口 */ public class Hacker implements MethodInterceptor { @Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { System.out.println("Hacker what to do."); proxy.invokeSuper(obj, args); System.out.println("Hacker done this."); return null; } }

public class Test { public static void main(String[] args) { Programmer programmer = new Programmer(); Hacker hacker = new Hacker(); // CGLIB中的加强器,用来创建动态代理 Enhancer enhancer = new Enhancer(); // 设置要创建动态代理的类 enhancer.setSuperclass(programmer.getClass()); /* * 设置回调 * 这里相当于对于代理类上所有方法的调用,都会调用CallBack * 而CallBack则需要实行intercept()方法进行拦截 */ enhancer.setCallBack(hacker); Programmer proxy = (Programmer) enhancer.create(); proxy.code(); } }

public class Programmer EnhancerByCGLIB fa7aa2cd extends Programmer implements Factory { /* * .... */ // Enhancer传入的methodInterceptor private MethodInterceptor CGLIB$CALLBACK_0; /* * ... */ public final void code() { MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0; if (tmp4_1 == null) { tmp4_1; // 若callback不为空,则调用methodInterceptor的intercept()方法 CGLIB$BIND_CALLBACKS(this); } if (this.CGLIB$CALLBACK_0 != null) return; // 如果没有设置callback回调函数,则默认执行父类的方法 super.code(); } /* * ... */ }

,