闲来无事，撸撸源码
食用方法
直接看代码吧。。
package com.test.demo.proxy;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;/** * 每个代理对象 内部都有一个实现了InvocationHandler接口的 类的实例 * * InvocationHandler 顾名思义就是 代理对象的方法调用的处理类(调用它的invoke方法) * * @author lizhecao 2018/4/19 * @version 1.0 */public class InvocationHandlerImpl implements InvocationHandler { // 目标对象 private Object target; public InvocationHandlerImpl(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { // 代理方法简单地打下日志，这其实就是spring aop的简单实现 System.out.println("start"); // 调用目标对象的实际方法 Object result = method.invoke(target, args); System.out.println("end"); return result; } /** * 通过Proxy.newProxyInstance 生成代理对象（重要的方法） */ public Object getProxy() { return Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), target.getClass().getInterfaces(), this); } public static void main(String[] args) { // 实例化目标对象 User user = new UserImpl(); // 用目标对象实例化InvocationHandler InvocationHandlerImpl invocationHandler = new InvocationHandlerImpl(user); // 生成代理对象 User proxyUser = (User) invocationHandler.getProxy(); // 调用代理对象的方法，实际上就是调用了invocationHandler的invoke方法 proxyUser.sayHello(); }}package com.test.demo.proxy;/** * 目标类的接口，jdk动态代理的类一定要实现某一个接口 * * @author lizhecao 2018/4/19 * @version 1.0 */public interface User { void sayHello();}package com.test.demo.proxy;/** * 目标对象的具体类 * * @author lizhecao 2018/4/19 * @version 1.0 */public class UserImpl implements User { @Override public void sayHello() { System.out.println("hello"); }}运行了InvocationHandlerImpl中的main方法我们会得到结果：
starthelloend理解原理
通过上面的例子可以看到，生成代理对象的重点是
Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), target.getClass().getInterfaces(), this);这个方法，我们进入这个方法看看jdk动态代理的具体实现。
去繁就简，删掉一些不关注的东西，有兴趣的自己一一过下
/** * 返回指定接口的代理类实例，并分配方法的调用给指定的invocationHandler * * @param loader 用来define代理类的 类加载器 * @param interfaces 代理类要实现的接口（这里也说明了jdk动态代理对象必须实现接口） * @param h 用来分配方法调用的 invocation handler * @return 一个实现了特定接口，用特定的class loader define的包含特定的invocation hanlder的代理类的实例 */ @CallerSensitive public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException { // 不允许hanlder 为空（不然搞啥） Objects.requireNonNull(h); // 防止接口被改 final Class<?>[] intfs = interfaces.clone(); /* * 查找或生产指定代理类（也就是说有缓存机制）（这里是重点，生产了代理类的Class！！） */ Class<?> cl = getProxyClass0(loader, intfs); /* * 用我们的handler 作为proxy class的构造方法的参数，创建proxy 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; } }); } return cons.newInstance(new Object[]{h}); }继续看这个getProxyClass0(loader, intfs) 是怎么生产代理类的
private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) { // 接口的数量不能超过65535个（呵呵） if (interfaces.length > 65535) { throw new IllegalArgumentException("interface limit exceeded"); } // 从WeakCache的缓存中获取，如果没有就创建 return proxyClassCache.get(loader, interfaces); }这里是通过WeakCache缓存了代理类的实例，就是这货
/** * a cache of proxy classes */ private static final WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());这里简单讲下WeakCache，不然没玩过的朋友可能看不下去了。
WeakCache<K, P, V> 缓存的是<key, sub-key> -> value这样的键值对，key和value是弱引用的，sub-key是强引用的（当然，这不重要）K， P， V分别表示key，参数，value的类型。有人会好奇，那sub-key呢？参数用来干嘛？我们重点看它的构造方法
/** * @param subKeyFactory 一个这样 (key, parameter) -> sub-key 的函数 * @param valueFactory 一个那样 (key, parameter) -> value的函数 */ public WeakCache(BiFunction<K, P, ?> subKeyFactory, BiFunction<K, P, V> valueFactory) { this.subKeyFactory = Objects.requireNonNull(subKeyFactory); this.valueFactory = Objects.requireNonNull(valueFactory); }可以看到，只要传入两个函数类，就可以通过key 和 parameter 分别生成 sub-key和value了，这样我们就可以理解生成代理对象的这一句
// 第一次获取proxy class就会通过loader 和 interfaces 分别生成缓存的subkey 和 value， 并且返回valuereturn proxyClassCache.get(loader, interfaces);那么我们也知道了这个value是通过valueFactory生成的，参数是loader 和 interface，那么看下proxyClassCache的实例化方法： new WeakCache<>(new KeyFactory(), new ProxyClassFactory()) 就知道了这个ProxyClassFactory类就是真正实现了(loader, interface) -> proxyClass 的函数式类了，赶紧看下
/** * 使用给定的ClassLoader 和 接口数组来 生成，define，返回代理类的函数工厂 */ private static final class ProxyClassFactory implements BiFunction<ClassLoader, Class<?>[], Class<?>> { // 所有代理类名称的前缀（有时候debug不是会经常看到这个名称吗哈哈） 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) { /* * 验证下Class loader根据类的名称 解析出来的 class跟我们传进来的是否一样（相当于看下是不是同一个loader加载的吧） */ Class<?> interfaceClass = null; try { interfaceClass = Class.forName(intf.getName(), false, loader); } catch (ClassNotFoundException e) { } // 如果不一样，抛异常（loader说我不认识这个接口class） if (interfaceClass != intf) { throw new IllegalArgumentException( intf + " is not visible from class loader"); } /* * 验证是否接口（又强调了一定要是接口吧） */ if (!interfaceClass.isInterface()) { throw new IllegalArgumentException( interfaceClass.getName() + " is not an interface"); } /* * 验证是否重复 */ if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) { throw new IllegalArgumentException( "repeated interface: " + interfaceClass.getName()); } } String proxyPkg = null; // package to define proxy class in int accessFlags = Modifier.PUBLIC | Modifier.FINAL; /* * 这下面一大段就是确定下代理类要放在哪个包下 * 如果存在非public的接口，那么proxy class就要放在跟她同一个目录下 * 而且非public的接口一定要在同一个目录下（不然放哪里都有问题） */ for (Class<?> intf : interfaces) { int flags = intf.getModifiers(); if (!Modifier.isPublic(flags)) { accessFlags = Modifier.FINAL; String name = intf.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 packages"); } } } // 如果接口都public，那么就是放到com.sun.proxy 包下 if (proxyPkg == null) { proxyPkg = ReflectUtil.PROXY_PACKAGE + "."; } /* * 用原子数字自增产生的一个代理类的唯一的代号 */ long num = nextUniqueNumber.getAndIncrement(); String proxyName = proxyPkg + proxyClassNamePrefix + num; /* * 上面啪啦啪啦一大堆，其实都是一些验证啊，确定包的位置啊，名称啊的细碎的东西 * 下面这一句才是重点，通过ProxyGenerator产生了代理类的 class 文件的字节数组 */ byte[] proxyClassFile = ProxyGenerator.generateProxyClass( proxyName, interfaces, accessFlags); try { // 最后通过native方法 来生成Class 对象 return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length); } catch (ClassFormatError e) { throw new IllegalArgumentException(e.toString()); } } }ProxyGenerator 是sun.misc包里面的方法，没有开源，所以我们简单撸一下即可
public static byte[] generateProxyClass(final String var0, Class<?>[] var1, int var2) { ProxyGenerator var3 = new ProxyGenerator(var0, var1, var2); // 生成class文件的字节数组 final byte[] var4 = var3.generateClassFile(); // 如果saveGeneratedFiles为true，那么将.class文件写到硬盘中 if (saveGeneratedFiles) { // 省略具体保存文件方法 } return var4; }看下这个保存文件的条件
private static final boolean saveGeneratedFiles = ((Boolean)AccessController.doPrivileged(new GetBooleanAction("sun.misc.ProxyGenerator.saveGeneratedFiles"))).booleanValue();也就是说只要我们设置了这个"sun.misc.ProxyGenerator.saveGeneratedFiles" 系统值为true就可以保存文件了
话不多说来看看jdk动态代理给我们自动生成的这个class文件长什么样吧，用以下代码来测试
package com.test.demo.proxy;import sun.misc.ProxyGenerator;import java.io.FileOutputStream;import java.io.IOException;/** * 写代理类文件到磁盘中 * * @author lizhecao 2018/4/20 * @version 1.0 */public class ProxyClassGen { public static void main(String[] args) throws IOException {// // 第一种方法，直接将生成的字节数组写到文件中// byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy33", UserImpl.class.getInterfaces());//// try(FileOutputStream outputStream = new FileOutputStream(// "/Users/lizhecao/java/demo/src/main/java/com/test/demo/proxy/$Proxy33.class")) {// outputStream.write(bytes);// } // 第二种方法，设置系统属性值，有jdk自动写 System.setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true"); ProxyGenerator.generateProxyClass("$Proxy34", UserImpl.class.getInterfaces()); }}运行之后可以看到在项目的根目录下产生了$Proxy34.class 这么一个文件，用ide直接打开可以看到如下内容
//// Source code recreated from a .class file by IntelliJ IDEA// (powered by Fernflower decompiler)//import com.test.demo.proxy.User;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.lang.reflect.UndeclaredThrowableException;public final class $Proxy34 extends Proxy implements User { private static Method m1; private static Method m3; private static Method m2; private static Method m0; public $Proxy34(InvocationHandler var1) throws { super(var1); } // 除了接口方法之外，还实现了Object的equals, hashCode和toString方法 public final boolean equals(Object var1) throws { try { return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue(); } catch (RuntimeException | Error var3) { throw var3; } catch (Throwable var4) { throw new UndeclaredThrowableException(var4); } } // 实现了我们的User接口的sayHello方法 public final void sayHello() throws { try { // 内部其实就是调用了invokeHandler实例的invoke方法 // 在最下面可以看到m3 就是通过反射获取的User接口的sayHello Method // Class.forName("com.test.demo.proxy.User").getMethod("sayHello"); super.h.invoke(this, m3, (Object[])null); } catch (RuntimeException | Error var2) { throw var2; } catch (Throwable var3) { throw new UndeclaredThrowableException(var3); } } 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 int hashCode() throws { try { return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue(); } 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")); m3 = Class.forName("com.test.demo.proxy.User").getMethod("sayHello"); m2 = Class.forName("java.lang.Object").getMethod("toString"); m0 = Class.forName("java.lang.Object").getMethod("hashCode"); } catch (NoSuchMethodException var2) { throw new NoSuchMethodError(var2.getMessage()); } catch (ClassNotFoundException var3) { throw new NoClassDefFoundError(var3.getMessage()); } }}到了这里，jdk动态代理就已经是拨开云雾见青天，一清二楚了
感谢以下的博主分享：
JDK动态代理实现原理
本文由博客群发一文多发等运营工具平台 OpenWrite 发布
原文转载：http://www.shaoqun.com/a/561577.html
黄劲：https://www.ikjzd.com/w/2426
手机trademanager：https://www.ikjzd.com/w/730
闲来无事，撸撸源码食用方法直接看代码吧。。packagecom.test.demo.proxy;importjava.lang.reflect.InvocationHandler;importjava.lang.reflect.Method;importjava.lang.reflect.Proxy;/***每个代理对象内部都有一个实现了InvocationHandler接口的类的实例**Invo
picitup：picitup
feedly：feedly
46.6亿！阿里巴巴入股申通，打造物流网！：46.6亿！阿里巴巴入股申通，打造物流网！
2019年亚马逊最新政策解读：2019年亚马逊最新政策解读
FBA实操：亚马逊FBA混装发货模式怎样操作？：FBA实操：亚马逊FBA混装发货模式怎样操作？
No comments:
Post a Comment