动态代理
一、动态代理浅析
何为代理?就是暂时代人担任 某单位的负责职务。比如代课,火车票代售点。
代理模式:为其他对象提供一种代理以控制这个对象的访问。下面为代理模式的类图
如何实现代理
通过 组合 来实现:
首先定义一个学生接口
public interface Student { /** * 上课 */ public void goToClass(); }
定义一个真实的学生实体SliuStudent
public class SliuStudent implements Student{ @Override public void goToClass() { System.out.println("sliu go to class"); } }
现在该学生想找一个代理来代替他去上课,但是代理要收取费用,所以代理要计算上课花费时间。
public class StudentProxy implements Student{ private Student student; public StudentProxy(Student student){ this.student =student; } @Override public void goToClass() { long start = System.currentTimeMillis(); student.goToClass(); long end = System.currentTimeMillis(); System.out.println("上课耗时:"+(end - start)); } }
1.1、静态代理
上述学生代课的例子是一个典型的静态代理,有如下缺点:
-
如果同时代理多个类,依然会导致类无限制扩展
-
如果类中有多个方法,同样的逻辑需要反复实现
1.2、动态代理
动态代理,就是通过一个代理类,能够执行任何一个真实实体类的任何方法,并且在不改变源码的基础上,增加一些自定义操作,比如权限管理,事务提交等。通过动态代理就可以实现AOP编程。
JDK提供了Proxy和InvocationHandler接口来 实现动态代理。
1.2.1Proxy
public class Proxy extends Object implements Serializable
Proxy 提供用于创建动态代理类和实例的静态方法,它还是由这些方法创建的所有动态代理类的超类。
Proxy.newProxyInstance方法(摘自JDK API 1.6.0中文版)
public static Object newProxyInstance( ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException 返回一个指定接口的代理类实例,该接口可以将方法调用指派到指定的调用处理程序。 - 此方法相当于: Proxy.getProxyClass(loader, interfaces). getConstructor(new Class[] { InvocationHandler.class }). newInstance(new Object[] { handler }); - Proxy.newProxyInstance 抛出 IllegalArgumentException,原因与 Proxy.getProxyClass 相同。 参数: loader - 定义代理类的类加载器 - ClassLoader对象,定义了由哪个ClassLoader对象来对生成的代理对象进行加载 interfaces - 代理类要实现的接口列表 - Interface对象的数组,表示的是我将要给我需要代理的对象提供一组什么接口 - 如果我提供了一组接口给它,那么这个代理对象就宣称实现了该接口(多态),这样我就能调用这组接口中的方法了 h - 指派方法调用的调用处理程序 - InvocationHandler对象,表示的是当我这个动态代理对象在调用方法的时候,会关联到哪一个InvocationHandler对象上 返回: 一个带有代理类的指定调用处理程序的代理实例,它由指定的类加载器定义,并实现指定的接口
1.2.2、InvocationHandler
public interface InvocationHandler
InvocationHandler 是代理实例的调用处理程序实现的接口。
每个代理实例都具有一个关联的调用处理程序。
对代理实例调用方法时,将对方法调用进行编码并将其指派到它的调用处理程序的 invoke 方法。
invoke方法描述(摘自JDK API 1.6.0中文版)
public Object invoke(Object proxy,Method method,Object[] args)throws Throwable 在代理实例上处理方法调用并返回结果。 在与方法关联的代理实例上调用方法时,将在调用处理程序上调用此方法。 参数: proxy - 在其上调用方法的代理实例,指代我们所代理的那个真实对象 - 如果你的接口中有方法需要返回自身,如果在invoke中没有传入这个参数,将导致实例无法正常返回。在这种场景 中,proxy的用途就表现出来了。简单来说,这其实就是最近非常火的链式编程的一种应用实现。 method - 对应于在代理实例上调用的接口方法的 Method 实例。 - Method 对象的声明类将是在其中声明方法的接口,该接口可以是代理类赖以继承方法的代理接口的超接口。 - 指代的是我们所要调用真实对象的某个方法的Method对象 args - 包含传入代理实例上方法调用的参数值的对象数组,如果接口方法不使用参数,则为 null。 - 基本类型的参数被包装在适当基本包装器类(如 java.lang.Integer 或 java.lang.Boolean)的实例中。 - 指代的是调用真实对象某个方法时接受的参数 返回: 从代理实例的方法调用返回的值。 如果接口方法的声明返回类型是基本类型,则此方法返回的值一定是相应基本包装对象类的实例; 否则,它一定是可分配到声明返回类型的类型。 如果此方法返回的值为 null 并且接口方法的返回类型是基本类型,则代理实例上的方法调用将抛出 NullPointerException。 否则,如果此方法返回的值与上述接口方法的声明返回类型不兼容,则代理实例上的方法调用将抛出 ClassCastException。
现在我们通过动态代理来完成学生代课逻辑,Student类,SliuStudent类还是和上面一样,现在我们重写一个代理工厂类,来负责生成任何类的任何方法的代理类。
public class ProxyFactory { public static Object getProxyInstance(final Class<?> serviceClass){ return Proxy.newProxyInstance(serviceClass.getClassLoader(),serviceClass.getInterfaces(), new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("method "+method); System.out.println("args "+args); long start = System.currentTimeMillis(); Object invoke = method.invoke(serviceClass.newInstance(),args); long end = System.currentTimeMillis(); System.out.println("上课耗时:"+(end - start)); return invoke; } }); } }
1.3、代理模式的应用
-
动态代理是十分强大的设计模式,代理类的代码量被固定下来,不会因为业务的逐渐庞大而庞大;
-
可以实现AOP编程,实际上静态代理也可以实现,总的来说,AOP可以算作是代理模式的一个典型应用;
-
事务提交或回退(Web开发中很常见)
-
权限管理
-
自定义缓存逻辑处理
-
SDK Bug修复
-
解耦,通过参数就可以判断真实类,不需要事先实例化,更加灵活多变;
二、动态代理深入理解
2.1、原理
JDK的Proxy类是代理类的超类,通过静态方法newProxyInstance来动态生成对应的代理类实例,该代理类应该是继承Proxy并实现了方法中传入的接口的所有方法。所以Proxy类只能代理有接口的类。
下面我们来看一下动态生成的代理类到底长什么样:
首先列出相关代码,Student,SliuStudent,ProxyFactory
public interface Student { /** * 上课 */ public void goToClass(String name); } public class SliuStudent implements Student { @Override public void goToClass(String name) { System.out.println("sliu go to class:" + name); } } public class ProxyFactory { public static Object getProxyInstance(final Class<?> serviceClass){ return Proxy.newProxyInstance(serviceClass.getClassLoader(),serviceClass.getInterfaces(), new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("method "+method); System.out.println("args "+args); long start = System.currentTimeMillis(); Object invoke = method.invoke(serviceClass.newInstance(),args); long end = System.currentTimeMillis(); System.out.println("上课耗时:"+(end - start)); return invoke; } }); } }
然后我们写一个Test类,将Proxy类生成的代理类的对象字节码写到磁盘然后通过反编译器来查看
public class Test { public static void main(String[] args) throws IOException { SliuStudent sliuStudent = new SliuStudent(); Student proxy = (Student) ProxyFactory.getProxyInstance(sliuStudent.getClass()); proxy.goToClass("语文"); System.out.println(proxy.getClass()); /** * 上面生成的代理对象字节码 com.sun.proxy.$Proxy0 是在内存中的 * 这里将其对象写到文件中,通过反编译查看 */ byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0",new Class[]{Student.class}); FileOutputStream fos = new FileOutputStream("E:\\$Proxy0.class"); fos.write(bytes); System.out.println("写入文件成功"); } }
$Proxy0.class类的反编译文件如下:
public final class $Proxy0 extends Proxy implements Student { private static Method m1; private static Method m2; private static Method m3; private static Method m0; public $Proxy0(InvocationHandler var1) throws { super(var1); } public final boolean equals(Object var1) throws { try { return (Boolean)super.h.invoke(this, m1, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } public final String toString() throws { try { return (String)super.h.invoke(this, m2, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } public final void goToClass(String var1) throws { try { super.h.invoke(this, m3, new Object[]{var1}); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } public final int hashCode() throws { try { return (Integer)super.h.invoke(this, m0, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } static { try { m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object")); m2 = Class.forName("java.lang.Object").getMethod("toString"); m3 = Class.forName("proxy.Student").getMethod("goToClass", Class.forName("java.lang.String")); m0 = Class.forName("java.lang.Object").getMethod("hashCode"); } catch (NoSuchMethodException var2) { throw new NoSuchMethodError(var2.getMessage()); } catch (ClassNotFoundException var3) { throw new NoClassDefFoundError(var3.getMessage()); } } }
可以看出,该类继承了Proxy超类,并实现了Student接口的方法,连equals,toString,hashCode也实现了。并且这里的方法都调用了InvocationHandler接口的invoke()方法。通过super.h.invoke调用用户自定义实现的方法,在invoke方法中,method.invoke才是真正通过反射调用了我们自身所写的方法,而我们可以在这个方法的前后嵌入我们的代码。这样就实现了不改变源码的情况下增强方法。
2.2、Proxy源码
首先看一下newProxyInstance方法实现,该方法首先对参数进行了一些权限校验,然后通过getProxyClass0方法获得代理类的类对象,然后获取行参为InvocationHandler.class的构造函数。最后传入InvocationHandler实例生成代理类实例。
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException { //验证传入的InvocationHandler不能为空 Objects.requireNonNull(h); //复制代理类实现的所有接口 final Class<?>[] intfs = interfaces.clone(); //获取安全管理器 final SecurityManager sm = System.getSecurityManager(); //进行一些权限检验 if (sm != null) { checkProxyAccess(Reflection.getCallerClass(), loader, intfs); } //该方法先从缓存获取代理类, 如果没有再去生成一个代理类 Class<?> cl = getProxyClass0(loader, intfs); try { //进行一些权限检验 if (sm != null) { checkNewProxyPermission(Reflection.getCallerClass(), cl); } //获取参数类型是InvocationHandler.class的代理类构造器 final Constructor<?> cons = cl.getConstructor(constructorParams); final InvocationHandler ih = h; //如果代理类是不可访问的, 就使用特权将它的构造器设置为可访问 if (!Modifier.isPublic(cl.getModifiers())) { AccessController.doPrivileged(new PrivilegedAction<Void>() { public Void run() { cons.setAccessible(true); return null; } }); } //传入InvocationHandler实例去构造一个代理类的实例 //所有代理类都继承自Proxy, 因此这里会调用Proxy的构造器将InvocationHandler引用传入 return cons.newInstance(new Object[]{h}); } catch (Exception e) { //为了节省篇幅, 笔者统一用Exception捕获了所有异常 throw new InternalError(e.toString(), e); } } private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) { //目标类实现的接口不能大于65535 if (interfaces.length > 65535) { throw new IllegalArgumentException("interface limit exceeded"); } //获取代理类使用了缓存机制 return proxyClassCache.get(loader, interfaces); }
可以看到getProxyClass0方法内部没有多少内容,首先是检查目标代理类实现的接口不能大于65535这个数,之后是通过类加载器和接口集合去缓存里面获取,如果能找到代理类就直接返回,否则就会调用ProxyClassFactory这个工厂去生成一个代理类。关于这里使用到的缓存机制我们留到下一篇专门介绍,首先我们先看看这个工厂类是怎样生成代理类的。
//代理类生成工厂 private static final class ProxyClassFactory implements BiFunction<ClassLoader, Class<?>[], Class<?>> { //代理类名称前缀 private static final String proxyClassNamePrefix = "$Proxy"; //用原子类来生成代理类的序号, 以此来确定唯一的代理类 private static final AtomicLong nextUniqueNumber = new AtomicLong(); @Override public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) { Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length); for (Class<?> intf : interfaces) { //这里遍历interfaces数组进行验证, 主要做三件事情 //1.intf是否可以由指定的类加载进行加载 //2.intf是否是一个接口 //3.intf在数组中是否有重复 } //生成代理类的包名 String proxyPkg = null; //生成代理类的访问标志, 默认是public final的 int accessFlags = Modifier.PUBLIC | Modifier.FINAL; for (Class<?> intf : interfaces) { //获取接口的访问标志 int flags = intf.getModifiers(); //如果接口的访问标志不是public, 那么生成代理类的包名和接口包名相同 if (!Modifier.isPublic(flags)) { //生成的代理类的访问标志设置为final accessFlags = Modifier.FINAL; //获取接口全限定名, 例如:java.util.Collection String name = intf.getName(); int n = name.lastIndexOf('.'); //剪裁后得到包名:java.util String pkg = ((n == -1) ? "" : name.substring(0, n + 1)); //生成的代理类的包名和接口包名是一样的 if (proxyPkg == null) { proxyPkg = pkg; } else if (!pkg.equals(proxyPkg)) { //代理类如果实现不同包的接口, 并且接口都不是public的, 那么就会在这里报错 throw new IllegalArgumentException( "non-public interfaces from different packages"); } } } //如果接口访问标志都是public的话, 那生成的代理类都放到默认的包下:com.sun.proxy if (proxyPkg == null) { proxyPkg = ReflectUtil.PROXY_PACKAGE + "."; } //生成代理类的序号 long num = nextUniqueNumber.getAndIncrement(); //生成代理类的全限定名, 包名+前缀+序号, 例如:com.sun.proxy.$Proxy0 String proxyName = proxyPkg + proxyClassNamePrefix + num; //这里是核心, 用ProxyGenerator来生成字节码, 该类放在sun.misc包下 byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags); try { //根据二进制文件生成相应的Class实例 return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length); } catch (ClassFormatError e) { throw new IllegalArgumentException(e.toString()); } } }
该工厂的apply方法会被调用用来生成代理类的Class对象,由于代码的注释比较详细,我们只挑关键点进行阐述,其他的就不反复赘述了。
-
在代码中可以看到JDK生成的代理类的类名是“$Proxy”+序号。
-
如果接口是public的,代理类默认是public final的,并且生成的代理类默认放到com.sun.proxy这个包下。
-
如果接口是非public的,那么代理类也是非public的,并且生成的代理类会放在对应接口所在的包下。
-
如果接口是非public的,并且这些接口不在同一个包下,那么就会报错。
生成具体的字节码是调用了ProxyGenerator这个类的generateProxyClass方法。这个类放在sun.misc包下,后续我们会扒出这个类继续深究其底层源码。到这里我们已经分析了Proxy这个类是怎样生成代理类对象的,通过源码我们更直观的了解了整个的执行过程,包括代理类的类名是怎样生成的,代理类的访问标志是怎样确定的,生成的代理类会放到哪个包下面,以及InvocationHandler实例的引用是怎样传入的