代理模式

Proxy Pattern，代理模式，一个类可以代表另一个类的功能。

在生活中代理模式也是比比皆是，房产中介、委托律师、海外代购、同城闪送，他们都是代理了实际用户的一些行为，并且极大地提供了专业性、方便性和扩展性。

代理模式的类图如下。

静态代理

根据代理模式的思想，可以用以下这个例子来说明。

在古代皇帝下圣旨、口谕，给王公大臣升职加薪、给后宫嫔妃册封，都是大总管去送信儿，王公大臣也得老老实实磕头谢恩，大总管就是皇帝的代理。

/*** @author lyqiang*/
interface Sayer {void saySomeThing();
}class Emperor implements Sayer {@Overridepublic void saySomeThing() {System.out.println("民有所安，万邦咸服。朕心甚喜，赏你官升P8,月薪10W。");}
}class LiGongGong implements Sayer {Emperor emperor;public LiGongGong(Emperor emperor) {this.emperor = emperor;}@Overridepublic void saySomeThing() {System.out.println("奉天承运，皇帝诏曰。");emperor.saySomeThing();System.out.println("钦此。");}
}public class ProxyTest {public static void main(String[] args) {//大总管代理了皇帝Sayer sayer = new LiGongGong(new Emperor());sayer.saySomeThing();}
}

执行结果如下。

奉天承运，皇帝诏曰。
民有所安，万邦咸服。朕心甚喜，赏你官升P8,月薪10W。
钦此。

可以看到，大总管对皇帝原话增加了开头和结尾，即代理类可以对被代理类进行功能的扩展。

从静态代理的实现方式可以看出，代理类也需要实现被代理类的接口，造成一定的代码冗余，并且代理类只能对某个固定接口的实现类进行代理，其灵活性也不强。

JDK 动态代理

JDK 提供了一套基于接口的动态代理方式。

具体实现案例如下代码。

/*** @author lyqiang*/interface Sayer {void saySomeThing();
}class Emperor implements Sayer {@Overridepublic void saySomeThing() {System.out.println("民有所安，万邦咸服。朕心甚喜，今天翻爱妃的牌。");}
}interface Killer {void kill();
}class MotherOfEmperor implements Killer {@Overridepublic void kill() {System.out.println("今日珍妃气我之甚，赐死。");}
}class GongGongHandler implements InvocationHandler {private final Object obj;public GongGongHandler(Object obj) {this.obj = obj;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {String title = "kill".equals(method.getName()) ?"太后懿旨。" : "奉天承运，皇帝诏曰。";System.out.println(title);Object result = method.invoke(obj, args);System.out.println("钦此。");return result;}
}public class DynamicProxyTest {public static void main(String[] args) {// ClassLoader loader， 被代理对象的类加载器// Class<?>[] interfaces，被代理类实现的接口列表// InvocationHandler h，动态处理器// 代理皇帝报信翻牌Sayer sayer = new Emperor();Sayer proxy = (Sayer) Proxy.newProxyInstance(Sayer.class.getClassLoader(),new Class[]{Sayer.class}, new GongGongHandler(sayer));proxy.saySomeThing();System.out.println("——————————————————");// 代理太后报信赐死Killer killer = new MotherOfEmperor();Killer killProxy = (Killer) Proxy.newProxyInstance(Killer.class.getClassLoader(),new Class[]{Killer.class}, new GongGongHandler(killer));killProxy.kill();}
}

执行结果如下。

奉天承运，皇帝诏曰。
民有所安，万邦咸服。朕心甚喜，今天翻爱妃的牌。
钦此。
——————————————————
太后懿旨。
今日珍妃气我之甚，赐死。
钦此。

上述代码可以再改动优化一下，将创建代理类放到 GongGongHandler 类中。

class GongGongHandler<T> implements InvocationHandler {private final T obj;public GongGongHandler(T obj) {this.obj = obj;}public T getProxy() {return (T) Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {String title = "kill".equals(method.getName()) ?"太后懿旨。" : "奉天承运，皇帝诏曰。";System.out.println(title);Object result = method.invoke(obj, args);System.out.println("钦此。");return result;}
}public class DynamicProxyTest {public static void main(String[] args) {// 代理皇帝报信翻牌Sayer sayerProxy = new GongGongHandler<Sayer>(new Emperor()).getProxy();sayerProxy.saySomeThing();System.out.println("——————————————————");// 代理太后赐死Killer killProxy = new GongGongHandler<Killer>(new MotherOfEmperor()).getProxy();killProxy.kill();}
}

可以看到，大总管文能代理皇帝颁布圣旨，武能代理皇太后弄死皇妃。

相比静态代理来说，JDK 动态代理做到了代理类不必实现被代理类的接口，并且可以代理多种类型的接口。

JDK 的动态代理关键点如下。

1、核心执行逻辑处理器实现 InvocationHandler 接口，并实现 invoke() 方法。
2、使用 Proxy.newProxyInstance() 来创建代理类。
- ClassLoader loader, 标识被代理类的类加载器
- Class<?>[] interfaces，标识被代理类实现的接口
- InvocationHandler h，代理的处理器
3、将代理类转为被代理类的类型，并调用方法。

JDK 动态代理的原理

静态代理是在编译时已经确定了代理关系，而动态代理是在程序运行时通过反射机制进行创建代理。 Proxy.newProxyInstance() 源码如下。

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.*/// 生成代理类 classClass<?> cl = getProxyClass0(loader, intfs);/** Invoke its constructor with the designated invocation handler.*/// 实例化代理类对象try {if (sm != null) {checkNewProxyPermission(Reflection.getCallerClass(), cl);}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});} catch ......}

重点关注 getProxyClass0 。

private static Class<?> getProxyClass0(ClassLoader loader,Class<?>... interfaces) {// 变态狂也不会这么干吧 65535个接口if (interfaces.length > 65535) {throw new IllegalArgumentException("interface limit exceeded");}// If the proxy class defined by the given loader implementing// the given interfaces exists, this will simply return the cached copy;// otherwise, it will create the proxy class via the ProxyClassFactory// 从缓存中获取return proxyClassCache.get(loader, interfaces);}

proxyClassCache 结构如下。

private static final WeakCache<ClassLoader, Class<?>[], Class<?>>proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

缓存是通过 ProxyClassFactory 的 apply() 方法放入的。

private static final class ProxyClassFactoryimplements BiFunction<ClassLoader, Class<?>[], Class<?>>{// prefix for all proxy class names// 代理类的前缀private static final String proxyClassNamePrefix = "$Proxy";// next number to use for generation of unique proxy class names// 代理类的顺序号private static final AtomicLong nextUniqueNumber = new AtomicLong();@Overridepublic Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);for (Class<?> intf : interfaces) {// ...... 省略一些不重要的代码String proxyPkg = null;     // package to define proxy class inint accessFlags = Modifier.PUBLIC | Modifier.FINAL;/** Record the package of a non-public proxy interface so that the* proxy class will be defined in the same package.  Verify that* all non-public proxy interfaces are in the same package.*/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");}}}if (proxyPkg == null) {// if no non-public proxy interfaces, use com.sun.proxy package// 默认 com.sun.proxy.proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";}/** Choose a name for the proxy class to generate.*/long num = nextUniqueNumber.getAndIncrement();// 代理类的完整名称String proxyName = proxyPkg + proxyClassNamePrefix + num;/** Generate the specified proxy class.*/// 生成 class 字节码文件的字节数组byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);try {// 根据字节码返回 classreturn defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);} 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());}}}

通过代码可以看出，根据代理类指定的信息生成了 class 字节码文件，再通过 class 文件动态创建实例，来生成代理对象。

我们把字节码文件写到一个 MyProxy.class 文件中，来看下它的结构。

public class DynamicProxyTest {public static void main(String[] args) throws IOException {// 代理皇帝报信翻牌Sayer sayerProxy = new GongGongHandler<Sayer>(new Emperor()).getProxy();sayerProxy.saySomeThing();// 生成 class 字节码文件的字节数组int accessFlags = Modifier.PUBLIC | Modifier.FINAL;byte[] proxyClassFile = ProxyGenerator.generateProxyClass(sayerProxy.getClass().getName(), new Class[]{Sayer.class}, accessFlags);// 写入文件OutputStream outputStream = new FileOutputStream("./MyProxy.class");outputStream.write(proxyClassFile);outputStream.close();}
}

将 MyProxy.class 反编译查看代码。

public final class $Proxy0 extends Proxy implements Sayer {private static Method m1;private static Method m3;private static Method m2;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 void saySomeThing() throws  {try {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);} 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.lyqiang.proxy.jdkproxy.dynamic.Sayer").getMethod("saySomeThing");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());}}
}

可见动态代理创建了一个继承 Proxy 、实现 Sayer 接口的类，其中 saySomeThing() 方法直接调用了 InvocationHandler 的 invoke() 方法。

总结

静态代理遵循代理模式，在一定程度上降低了系统耦合度，并实现了功能的扩展增强，但是不够灵活。

基于上述示例和源码分析，我们了解到动态代理的执行原理，总结如下。

1、实现 InvocationHandler 接口，在 invoke 方法中增强扩展被代理类的行为。
2、使用 Proxy.newProxyInstance 获得代理类的实例。
- a. 根据传入参数，动态生成一个类
- b. 该类继承 Proxy，实现被代理类的接口
- c. 该类中实现的被代理类接口方法，实际是调用 InvocationHandler 的 invoke 方法
3、调用代理类的方法。

动态代理虽然相对灵活，但有个缺点是被代理类必须实现某个接口。它是基于接口的代理，因为生成的代理类已经继承了 Proxy 类，而 Java 是单继承，所以只能采用实现接口的方式来实现动态扩展。

我佛了，居然有人用古代皇帝与臣子的关系讲清了JDK动态代理相关推荐

终于有人把房价和汇率的关系讲清了！
http://cj.sina.com.cn/article/detail/2652907442/93864?cre=sinapc&mod=g&loc=39&r=0&do ...
假如古代皇帝也懂负载均衡算法
大家都知道古代皇帝各个都是后宫佳丽三千,而皇帝身上都天然的带着雨露均沾的精神,不想单独的宠爱一人! 溺水三千,又怎舍得只取一瓢饮?据传皇帝们晚上睡觉个个都怕冷,因此每晚都需要有人侍寝,那么这么多 ...
后宫佳丽三千，假如古代皇帝也懂负载均衡算法...
古代皇帝,后宫佳丽三千,没法做到雨露均沾,但为了繁衍后代,子嗣繁盛,弱水三千,只取一瓢饮显然是不行的.不同的朝代有不同的宠幸妃子的方法,著名的有羊车望幸.掷筛侍寝.翻牌悬灯等等.如果皇帝懂得负载均衡算 ...
CV之IA：利用人工智能算法实现图像动画(以让古代皇帝画像以及古代四大美女画像动起来-来模仿偶像胡歌剧中角色表情动作为例-照片嗨起来)案例应用
CV之IA:利用人工智能算法实现图像动画(以让古代皇帝画像以及古代四大美女画像动起来-来模仿偶像胡歌剧中角色表情动作为例-照片嗨起来)案例应用导读:本论文来自NeurIPS2019,该算法中主要采用 ...
居然有人用腾讯QQ的申诉，来找回被盗的奇瑞QQ汽车[有图有真相]
居然有人用腾讯QQ的申诉,来找回被盗的奇瑞QQ汽车[图] http://anforen.5d6d.com/ http://four-corner.appspot.com/
为什么古代皇帝自称朕和寡人？
中国古代的君主分为皇帝和国王,皇帝从秦始皇开始,把原来每个人都能自称的"朕"用于皇帝的专称,除了皇帝之外其他人不能用. 国王则不一样,古代中国的国王(主要是秦朝以前的国王和后来分封 ...
居然有人问，软件测试算是程序员吗？
之前小编写过一篇文章<转行IT≠敲代码!这些IT岗位照样拿高薪!>被各路平台纷纷转发. 想必还是很多人想知道,有怎么样的办法可以既不用敲很多代码,又可以从事IT这个多金的行业~ 文章中,最 ...
放假回家了差点没困死一宿火车居然有人在我座位底下睡觉真吓人
回家了坐了一宿火车困死了一低头发现座位底下有人睡觉对坐的哥们很能侃时间稍微好过一点下次一定买卧铺的票!
居然有人撸了一个网易云音乐云村，高手在民间！
点击上方蓝色"程序猿DD",选择"设为星标" 回复"资源"获取独家整理的学习资料! 来自:Github精选今天推荐的这个项目是「netea ...

我佛了，居然有人用古代皇帝与臣子的关系讲清了JDK动态代理

代理模式

静态代理

JDK 动态代理

JDK 动态代理的原理

总结

我佛了，居然有人用古代皇帝与臣子的关系讲清了JDK动态代理相关推荐

最新文章

热门文章