0x01 前言

首先动态代理也是一种设计模式而已
动态代理与静态代理从功能与目的来说是没有区别的,唯一有区别的就是动态与静态的差别

这个差别如下:

  1. 动态代理是指代理对象在程序运行时才进行创建的代理方式
  2. 需要通过反射实现,借助Java自带的java.lang.reflect.Proxy与invocationHandler接口
  3. 这种情况下,代理对象并不是在Java代码中直接定义死的,而是在运行时根据“指示”动态生产的

对比静态代理,动态代理最大的优势是在于可以很方便的对代理对象的各个方法进行统一的处理,而不用去修改每个代理对象的方法

0x02 环境

  1. 编辑器为: IntelliJ IDEA
  3. java版本:
  4. java version "1.7.0_80"
  5. Java(TM) SE Runtime Environment (build 1.7.0_80-b15)
  6. Java HotSpot(TM) 64-Bit Server VM (build 24.80-b11, mixed mode)
  8. 代码仓库: https://github.com/pmiaowu/JavaProxyTest

0x03 语法介绍

0x03.1 invocationHandler接口

InvocationHandler是一个接口,按照官方文档的解释说
每个代理的实例都有一个与之关联的InvocationHandler实现类,如果代理的方法被调用,那么代理便会通知与转发给内部的InvocationHandler实现类,由它进行处理

  1. // 该接口里只有一个方法invoke,这个方法非常重要,先记下来
  2. public interface InvocationHandler {
  3.     /**
  4.      * @param proxy  被代理的对象
  5.      * @param method 要调用的方法
  6.      * @param args   方法调用时所需要参数 
  7.      * @return
  8.      * @throws Throwable
  9.      */
  10.     public Object invoke(Object proxy, Method method, Object[] args)
  11.         throws Throwable;
  12. }

0x03.2 java.lang.reflect.Proxy包

  1. // Proxy动态产生的代理会调用InvocationHandler实现类,因此InvocationHandler是实际执行者
  2. public class Proxy implements java.io.Serializable {
  3.     ...
  4.     /**
  5.      * @param loader        代理对象的类加载器
  6.      * @param interfaces    代理类全部的接口
  7.      * @param h                实现InvocationHandler接口的对象 
  8.      * @return                返回代理对象生成的类实例
  9.      * @throws IllegalArgumentException
  10.      */
  11.     @CallerSensitive
  12.     public static Object newProxyInstance(ClassLoader loader,
  13.                                           Class<?>[] interfaces,
  14.                                           InvocationHandler h)
  15.         throws IllegalArgumentException
  16.     {
  17.         if (h == null) {
  18.             throw new NullPointerException();
  19.         }
  21.         final Class<?>[] intfs = interfaces.clone();
  22.         final SecurityManager sm = System.getSecurityManager();
  23.         if (sm != null) {
  24.             checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
  25.         }
  27.         /*
  28.          * Look up or generate the designated proxy class.
  29.          */
  30.         Class<?> cl = getProxyClass0(loader, intfs);
  32.         /*
  33.          * Invoke its constructor with the designated invocation handler.
  34.          */
  35.         try {
  36.             final Constructor<?> cons = cl.getConstructor(constructorParams);
  37.             final InvocationHandler ih = h;
  38.             if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {
  39.                 // create proxy instance with doPrivilege as the proxy class may
  40.                 // implement non-public interfaces that requires a special permission
  41.                 return AccessController.doPrivileged(new PrivilegedAction<Object>() {
  42.                     public Object run() {
  43.                         return newInstance(cons, ih);
  44.                     }
  45.                 });
  46.             } else {
  47.                 return newInstance(cons, ih);
  48.             }
  49.         } catch (NoSuchMethodException e) {
  50.             throw new InternalError(e.toString());
  51.         }
  52.     }
  53.     ...
  54. }

0x04 例子

0x04.1 案例介绍

例如我们去影院看电影:
我们平常去电影院看电影时,在电影开始与结束阶段是不是都会放广告呢?
电影是电影公司授权给影院进行播放与售卖的
那么电影公司就是目标对象,他只管和影院根据票房分钱,剩下的事情就不关它事了
而影院就是代理对象,负责其他的事情
在例如影院可以在播放电影的前后,产生一些除了电影票之外的额外收益
比如在影片开始与结束时播发一些广告
或是去洗手间的时候播发一些广告

现在我们使用代码来进行模拟

0x04.2 电影的播放(代码模拟)

首先开始创建接口,通用的接口是代理模式实现的基础
这个接口就命名为Movie,里面有个play方法,表示电影播放的能力

  1. package 动态代理;
  3. public interface Movie {
  4.     void play();
  5. }

电影公司比较好授权给影院两部电影
接着创建个实现这个Movie接口的两个类,这两个类表示电影公司授权给影院的电影

  1. package 动态代理;
  3. public class RealMovie1 implements Movie {
  4.     @Override
  5.     public void play() {
  6.         System.out.println("您正在观看电影《嗨客帝国》");
  7.     }
  8. }
  1. package 动态代理;
  3. public class RealMovie2 implements Movie {
  4.     @Override
  5.     public void play() {
  6.         System.out.println("您正在观看电影《花园宝宝历险记》");
  7.     }
  8. }

0x04.3 上厕所的操作(代码模拟)

这个接口就命名为Toilet,里面有个go方法,表示可以走进厕所的动作

  1. package 动态代理;
  3. public interface Toilet {
  4.     void go();
  5. }

影院比较好,建立了一个厕所
接着创建个实现这个Toilet接口的类,这个类表示影院给用户的基础设施

  1. package 动态代理;
  3. public class RealToilet implements Toilet {
  4.     @Override
  5.     public void go() {
  6.         System.out.println("您冲进了洗手间");
  7.     }
  8. }

0x04.4 影院(代码模拟)

然后创建个Cinema类,这个类表示影院要播放的电影,还有一些额外的操作
这个Cinema类就是个代理对象了

  1. package 动态代理;
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.Method;
  5. import java.lang.reflect.Proxy;
  7. public class Cinema implements InvocationHandler {
  8.     Object target;
  10.     public Object bind(Object target) {
  11.         this.target = target;
  12.         return Proxy.newProxyInstance(
  13.                 target.getClass().getClassLoader(),
  14.                 target.getClass().getInterfaces(),
  15.                 this);
  16.     }
  18.     @Override
  19.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  20.         System.out.println(" ");
  21.         System.out.println("------------------");
  22.         System.out.println("该影院叫: " + this.getClass().getSimpleName());
  23.         this.advertising1();
  24.         Object result = method.invoke(this.target, args);
  25.         this.advertising2();
  26.         System.out.println("------------------");
  27.         return result;
  28.     }
  30.     public void advertising1() {
  31.         System.out.println("开始广告: 电影准备开始了,肯德基十翅一桶,只需要39元,快来买啊!");
  32.     }
  34.     public void advertising2() {
  35.         System.out.println("结束广告: 电影结束了,肯德基十翅一桶,只需要39元,快买回家吃吧!");
  36.     }
  37. }

0x04.5 运行测试代码

运行看看结果

  1. package 动态代理;
  3. import sun.misc.ProxyGenerator;
  4. import java.io.FileOutputStream;
  6. public class Test {
  7.     public static void main(String[] args) {
  8.         Cinema cinema = new Cinema();
  10.         // 观看电影《嗨客帝国》
  11.         RealMovie1 realMovie1 = new RealMovie1();
  12.         Movie movieProxy1 = (Movie) cinema.bind(realMovie1);
  13.         movieProxy1.play();
  15.         // 观看电影《花园宝宝历险记》
  16.         RealMovie2 realMovie2 = new RealMovie2();
  17.         Movie movieProxy2 = (Movie) cinema.bind(realMovie2);
  18.         movieProxy2.play();
  20.         // 冲进洗手间
  21.         RealToilet realToilet = new RealToilet();
  22.         Toilet toiletProxy = (Toilet) cinema.bind(realToilet);
  23.         toiletProxy.go();
  25.         System.out.println(" ");
  26.         System.out.println("------------------");
  27.         System.out.println("动态代理类名为: " + movieProxy1.getClass().getName());
  28.         System.out.println("动态代理类名为: " + movieProxy2.getClass().getName());
  29.         System.out.println("动态代理类名为: " + toiletProxy.getClass().getName());
  30.         System.out.println("------------------");
  33.         // 将代理类反编译到文件中
  34.         byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", RealMovie1.class.getInterfaces());
  35.         // Path: 为反编译后保存的文件路径
  36.         String path = "./src/main/java/动态代理/$Proxy0.class";
  37.         try {
  38.             FileOutputStream fos = new FileOutputStream(path);
  39.             fos.write(classFile);
  40.             fos.flush();
  41.             System.out.println(" ");
  42.             System.out.println("------------------");
  43.             System.out.println("动态代理类写入成功");
  44.             System.out.println("路径: " + path);
  45.             System.out.println("------------------");
  46.         } catch (Exception e) {
  47.             e.printStackTrace();
  48.         }
  49.     }
  50. }
  56. // 执行结果
  57. ------------------
  58. 该影院叫: Cinema
  59. 开始广告: 电影准备开始了,肯德基十翅一桶,只需要39元,快来买啊!
  60. 您正在观看电影《嗨客帝国》
  61. 结束广告: 电影结束了,肯德基十翅一桶,只需要39元,快买回家吃吧!
  62. ------------------
  64. ------------------
  65. 该影院叫: Cinema
  66. 开始广告: 电影准备开始了,肯德基十翅一桶,只需要39元,快来买啊!
  67. 您正在观看电影《花园宝宝历险记》
  68. 结束广告: 电影结束了,肯德基十翅一桶,只需要39元,快买回家吃吧!
  69. ------------------
  71. ------------------
  72. 该影院叫: Cinema
  73. 开始广告: 电影准备开始了,肯德基十翅一桶,只需要39元,快来买啊!
  74. 您冲进了洗手间
  75. 结束广告: 电影结束了,肯德基十翅一桶,只需要39元,快买回家吃吧!
  76. ------------------
  78. ------------------
  79. 动态代理类名为: com.sun.proxy.$Proxy0
  80. 动态代理类名为: com.sun.proxy.$Proxy0
  81. 动态代理类名为: com.sun.proxy.$Proxy1
  82. ------------------
  84. ------------------
  85. 动态代理类写入成功
  86. 路径: ./src/main/java/动态代理/$Proxy0.class
  87. ------------------

0x05 自动调用invoke方法的原理

就用下面提供的示例代码作为分析的入口

  1. package 动态代理;
  3. import sun.misc.ProxyGenerator;
  4. import java.io.FileOutputStream;
  6. public class Test {
  7.     public static void main(String[] args) {
  8.         Cinema cinema = new Cinema();
  10.         // 观看电影《嗨客帝国》
  11.         RealMovie1 realMovie1 = new RealMovie1();
  12.         Movie movieProxy1 = (Movie) cinema.bind(realMovie1);
  13.         movieProxy1.play();
  15.         // 将代理类反编译到文件中
  16.         byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", RealMovie1.class.getInterfaces());
  17.         // Path: 为反编译后保存的文件路径
  18.         String path = "./src/main/java/动态代理/$Proxy0.class";
  19.         try {
  20.             FileOutputStream fos = new FileOutputStream(path);
  21.             fos.write(classFile);
  22.             fos.flush();
  23.             System.out.println(" ");
  24.             System.out.println("------------------");
  25.             System.out.println("动态代理类写入成功");
  26.             System.out.println("路径: " + path);
  27.             System.out.println("------------------");
  28.         } catch (Exception e) {
  29.             e.printStackTrace();
  30.         }
  31.     }
  32. }

让我们在自问自答中了解自动调用invoke方法的原理

第一个问题,我们通过java.lang.reflect.Proxy的newProxyInstance方法
生成的Movie movieProxy1对象,是Cinema类的实例化的吗?

第一个问题答案:
�答案很简单当然不是,可以打个debug查看
image.png
通过debug,可以很清楚的看到movieProxy1的类是$Proxy0

第二个问题,查看一下$Proxy0(生成的代理对象)干了什么
要想知道这个可以打开我们前面测试代码保存的$Proxy0.class文件
通过IDEA打开$Proxy0.class如下:

  1. //
  2. // Source code recreated from a .class file by IntelliJ IDEA
  3. // (powered by Fernflower decompiler)
  4. //
  6. import java.lang.reflect.InvocationHandler;
  7. import java.lang.reflect.Method;
  8. import java.lang.reflect.Proxy;
  9. import java.lang.reflect.UndeclaredThrowableException;
  10. import 动态代理.Movie;
  12. public final class $Proxy0 extends Proxy implements Movie {
  13.     private static Method m1;
  14.     private static Method m0;
  15.     private static Method m3;
  16.     private static Method m2;
  18.     public $Proxy0(InvocationHandler var1) throws  {
  19.         super(var1);
  20.     }
  22.     public final boolean equals(Object var1) throws  {
  23.         try {
  24.             return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
  25.         } catch (RuntimeException | Error var3) {
  26.             throw var3;
  27.         } catch (Throwable var4) {
  28.             throw new UndeclaredThrowableException(var4);
  29.         }
  30.     }
  32.     public final int hashCode() throws  {
  33.         try {
  34.             return (Integer)super.h.invoke(this, m0, (Object[])null);
  35.         } catch (RuntimeException | Error var2) {
  36.             throw var2;
  37.         } catch (Throwable var3) {
  38.             throw new UndeclaredThrowableException(var3);
  39.         }
  40.     }
  42.     public final void play() throws  {
  43.         try {
  44.             super.h.invoke(this, m3, (Object[])null);
  45.         } catch (RuntimeException | Error var2) {
  46.             throw var2;
  47.         } catch (Throwable var3) {
  48.             throw new UndeclaredThrowableException(var3);
  49.         }
  50.     }
  52.     public final String toString() throws  {
  53.         try {
  54.             return (String)super.h.invoke(this, m2, (Object[])null);
  55.         } catch (RuntimeException | Error var2) {
  56.             throw var2;
  57.         } catch (Throwable var3) {
  58.             throw new UndeclaredThrowableException(var3);
  59.         }
  60.     }
  62.     static {
  63.         try {
  64.             m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
  65.             m0 = Class.forName("java.lang.Object").getMethod("hashCode");
  66.             m3 = Class.forName("动态代理.Movie").getMethod("play");
  67.             m2 = Class.forName("java.lang.Object").getMethod("toString");
  68.         } catch (NoSuchMethodException var2) {
  69.             throw new NoSuchMethodError(var2.getMessage());
  70.         } catch (ClassNotFoundException var3) {
  71.             throw new NoClassDefFoundError(var3.getMessage());
  72.         }
  73.     }
  74. }

通过查看$Proxy0.class源码,就清楚许多了
主要查看上面$Proxy0.class源码的play()方法,里面的h = Cinema类,简单把

以上面的代码为例,整个动态代理的执行流程如下:
Proxy.newProxyInstance生成代理类$Proxy0并实例化,赋值为movieProxy1返回
在执行movieProxy1.play()时
先执行$Proxy0.play()
在执行Cinema.invoke()
最后面在执行realMovie1.play()结束整个流程

0x06 总结

通过这个简单的案例可以得出动态代理的好处

  1. Cinema类的代码量被固定下来,不会因为业务的逐渐庞大而庞大
  2. 可以实现AOP编程
  3. 解耦,例如在web业务中,可以实现数据层和业务层的分离

对于黑客们来说,一定要知道以下几点

  1. java.lang.reflect.Proxy,实现了java.io.Serializable接口,所以被代理的类会支持序列化/反序列化
  2. 当某个对象(Cinema)用java.lang.reflect.Proxy进行代理的时候会变成代理对象(cinema.bind())
  3. 代理对象(cinema.bind())执行任何方法(movieProxy1.play())都会调用该对象(Cinema)的invoke方法
  4. 代理对象(cinema.bind())会被java.lang.reflect.Proxy重写java.lang.Object类的equals()、toString()、hashCode()方法
  5. 如果动态代理生成了多个动态代理类,新生成的类名中的0会自增,com.sun.proxy.``$Proxy0/$Proxy1/$Proxy2

黑客们必须知道上面提到的几点,脑子记得就行,不用太深入原理,后面学习反序列化漏洞时,需要使用到!!!!