一、动态代理浅析何为代理？就是暂时代人担任 某单位的负责职务。比如代课，火车票代售点。 代理模式：为其他对象提供一种代理以控制这个对象的访问。下面为代理模式的类图
如何实现代理通过 组合 来实现： 首先定义一个学生接口 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.1Proxypublic class Proxy extends Object implements Serializable
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、InvocationHandlerpublic interface InvocationHandler
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、代理模式的应用
二、动态代理深入理解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对象，由于代码的注释比较详细，我们只挑关键点进行阐述，其他的就不反复赘述了。
生成具体的字节码是调用了ProxyGenerator这个类的generateProxyClass方法。这个类放在sun.misc包下，后续我们会扒出这个类继续深究其底层源码。到这里我们已经分析了Proxy这个类是怎样生成代理类对象的，通过源码我们更直观的了解了整个的执行过程，包括代理类的类名是怎样生成的，代理类的访问标志是怎样确定的，生成的代理类会放到哪个包下面，以及InvocationHandler实例的引用是怎样传入的
|
|
|
