彻底搞懂动态代理（上）

2022-02-25 04:33:16

什么是代理模式?


如果用专业术语来解：为其他对象提供一种代理以控制对这个对象的访问。如果投影在生活中，它可以理解成中介 黄牛 经纪人等…


解决的问题:


在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。说白了就是在你代码前面插一段后面插一段。

Java动态代理实现方式:


  • JDK 自带的动态代理


  • Cglib动态代理


1. JDK 自带的动态代理


我以黄牛为例，黄牛刚开始了解该人需求，该人将信息(JAY演唱会门票)给予黄牛，黄牛给票。黄牛就是该买票人的代理。


1.1 People.java


注意这必须是一个接口，原因往下看。


  1. public interface People {
  2.    /**
  3.     * 交谈
  4.     */
  5.    void speak();
  6. }


这个接口很简单，就是一个讲话的功能，但是它为什么必须是一个接口呢。因为在HuangNiu这个类中，Proxy.newProxyInstance 这个方法的实现需要接口,这一点我在HuangNiu类下解释的很清楚，往下看。


1.2 HuangNiu.java


黄牛代理类，获取到People信息后调用Proxy来生成一个新的代理类,它必须实现InvocationHandler接口,这个接口使得它可以通过invoke方法实现对真实角色(People)的代理访问。


  1. public class HuangNiu  implements InvocationHandler {

  3.    private People people;
  4.    /**
  5.     * 获取被代理对象信息
  6.     */
  7.    public Object getInstance(People people){
  8.        this.people = people;
  9.        Class clazz = people.getClass();
  10.        System.out.println("没生成代理之前的class对象:"+clazz );
  11.        return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
  12.    }

  14.    @Override
  15.    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  16.        System.out.println("代理中...");
  17.        method.invoke(people);
  18.        System.out.println("代理处理完毕,OK,请查收");
  19.        return null;
  20.    }
  21. }


在实例化HuangNiu这个对象的时候，我们调用了Proxy的newProxyInstance方法:


  1. return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);


其中clazz是People的class对象。再来看看newProxyInstance的源码实现:


  1. public static Object newProxyInstance(ClassLoader loader,
  2.                                          Class<?>[] interfaces,
  3.                                          InvocationHandler h){

  5.        final Class<?>[] intfs = interfaces.clone();

  7.        //Look up or generate the designated proxy class.

  9.        Class<?> cl = getProxyClass0(loader, intfs);

  11.        //获取代理类的构造函数对象
  12.        //参数constructorParames为常量值：private static final Class<?>[] constructorParams = { InvocationHandler.class };
  13.        final Constructor<?> cons = cl.getConstructor(constructorParames);
  14.        final InvocationHandler ih = h;
  15.        //根据代理类的构造函数对象来创建代理类对象
  16.        return newInstance(cons, ih);
  17. }


getProxyClass0方法源码:


  1.    private static Class<?> getProxyClass0(ClassLoader loader,
  2.                                           Class<?>... interfaces) {
  3.        if (interfaces.length > 65535) {
  4.            throw new IllegalArgumentException("interface limit exceeded");
  5.        }

  7.        // If the proxy class defined by the given loader implementing
  8.        // the given interfaces exists, this will simply return the cached copy;
  9.        // otherwise, it will create the proxy class via the ProxyClassFactory
  10.        return proxyClassCache.get(loader, interfaces);
  11.    }


如果缓存中有该代理类，则取缓存，如果没有，则通过ProxyClassFactory来创建代理类。如果对如何生成代理类感兴趣则追踪下去即可。


我只取了核心代码和注释，可以看到JDK的动态代理实现是依据接口来重新生成一个新的代理类，


什么是新的代理类?

通俗点说就是综合和前后代理逻辑并重新生成一份.class文件来实现动态代理的类，下面也会具体说。


1.3 Me.java


被代理对象，实现了People接口,给代理提供需要的信息来实现被代理。


  1. public class Me implements People {

  3.    private String name;
  4.    private String type;

  6.    Me(String name, String type){
  7.        this.name = name;
  8.        this.type = type;
  9.    }
  10.    @Override
  11.    public void speak() {
  12.        System.out.println("我叫"+name+", 我要一张"+type);
  13.    }
  14. }


1.4 Main.java


  1. public class Main {
  2.    public static void main(String[] args) {
  3.        People instance = (People)new HuangNiu().getInstance(new Me("Fantj", "JAY演唱会门票"));
  4.        instance.speak();
  5.        System.out.println("生成代理对象后对象变成:"+instance.getClass());
  6.    }
  7. }

执行结果:

  1. 没生成代理之前的class对象:class com.fantj.proxy.jdk.Me
  2. 代理中...
  3. 我叫Fantj, 我要一张JAY演唱会门票
  4. 代理处理完毕,OK,请查收
  5. 生成代理对象后对象变成:class com.sun.proxy.$Proxy0


为了证明事实上真的有代理类的产生，我在代理完成前和代理完成后分别打印出它的类信息，可以看出是不同的，可以猜想到代理中是有代理类产生的，这个代理类就是$Proxy0。


那既然知道了这个类的信息，我们就可以逆向生成这个.class文件来看看(在main方法后追加):


  1. /**
  2. * 生成代码
  3. */
  4. try {
  5.    byte[] $Proxy0s = ProxyGenerator.generateProxyClass("$Proxy0", new Class[]{instance.getClass()});
  6.    String path = Main.class.getResource("").toString();
  7. //            System.out.println("get the path"+path);
  8.    FileOutputStream fileOutputStream = new FileOutputStream("$Proxy0.class");
  9.    fileOutputStream.write($Proxy0s);
  10.    fileOutputStream.close();
  11. } catch (IOException e) {
  12.    e.printStackTrace();
  13. }


它默认生成在项目根目录下: 我使用的IDEA工具会自动反编译.class文件为java代码，直接打开即刻看到源码，如果用别的工具的可以下载反编译工具来进行反编译。


$Proxy0.class


  1. //
  2. // Source code recreated from a .class file by IntelliJ IDEA
  3. // (powered by Fernflower decompiler)
  4. //

  6. import com.sun.proxy..Proxy0;
  7. import java.lang.reflect.InvocationHandler;
  8. import java.lang.reflect.Method;
  9. import java.lang.reflect.Proxy;
  10. import java.lang.reflect.UndeclaredThrowableException;

  12. public final class $Proxy0 extends Proxy implements Proxy0 {
  13.    private static Method m1;
  14.    private static Method m5;
  15.    private static Method m2;
  16.    private static Method m4;
  17.    private static Method m11;
  18.    private static Method m13;
  19.    private static Method m0;
  20.    private static Method m10;
  21.    private static Method m12;
  22.    private static Method m6;
  23.    private static Method m9;
  24.    private static Method m3;
  25.    private static Method m7;
  26.    private static Method m8;

  28.    public $Proxy0(InvocationHandler var1) throws  {
  29.        super(var1);
  30.    }

  32.    public final boolean equals(Object var1) throws  {
  33.        try {
  34.            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
  35.        } catch (RuntimeException | Error var3) {
  36.            throw var3;
  37.        } catch (Throwable var4) {
  38.            throw new UndeclaredThrowableException(var4);
  39.        }
  40.    }

  42.    public final InvocationHandler getInvocationHandler(Object var1) throws IllegalArgumentException {
  43.        try {
  44.            return (InvocationHandler)super.h.invoke(this, m5, new Object[]{var1});
  45.        } catch (RuntimeException | Error var3) {
  46.            throw var3;
  47.        } catch (Throwable var4) {
  48.            throw new UndeclaredThrowableException(var4);
  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.    public final Class getProxyClass(ClassLoader var1, Class[] var2) throws IllegalArgumentException {
  63.        try {
  64.            return (Class)super.h.invoke(this, m4, new Object[]{var1, var2});
  65.        } catch (RuntimeException | Error var4) {
  66.            throw var4;
  67.        } catch (Throwable var5) {
  68.            throw new UndeclaredThrowableException(var5);
  69.        }
  70.    }

  72.    public final Class getClass() throws  {
  73.        try {
  74.            return (Class)super.h.invoke(this, m11, (Object[])null);
  75.        } catch (RuntimeException | Error var2) {
  76.            throw var2;
  77.        } catch (Throwable var3) {
  78.            throw new UndeclaredThrowableException(var3);
  79.        }
  80.    }

  82.    public final void notifyAll() throws  {
  83.        try {
  84.            super.h.invoke(this, m13, (Object[])null);
  85.        } catch (RuntimeException | Error var2) {
  86.            throw var2;
  87.        } catch (Throwable var3) {
  88.            throw new UndeclaredThrowableException(var3);
  89.        }
  90.    }

  92.    public final int hashCode() throws  {
  93.        try {
  94.            return (Integer)super.h.invoke(this, m0, (Object[])null);
  95.        } catch (RuntimeException | Error var2) {
  96.            throw var2;
  97.        } catch (Throwable var3) {
  98.            throw new UndeclaredThrowableException(var3);
  99.        }
  100.    }

  102.    public final void wait() throws InterruptedException {
  103.        try {
  104.            super.h.invoke(this, m10, (Object[])null);
  105.        } catch (RuntimeException | InterruptedException | Error var2) {
  106.            throw var2;
  107.        } catch (Throwable var3) {
  108.            throw new UndeclaredThrowableException(var3);
  109.        }
  110.    }

  112.    public final void notify() throws  {
  113.        try {
  114.            super.h.invoke(this, m12, (Object[])null);
  115.        } catch (RuntimeException | Error var2) {
  116.            throw var2;
  117.        } catch (Throwable var3) {
  118.            throw new UndeclaredThrowableException(var3);
  119.        }
  120.    }

  122.    public final Object newProxyInstance(ClassLoader var1, Class[] var2, InvocationHandler var3) throws IllegalArgumentException {
  123.        try {
  124.            return (Object)super.h.invoke(this, m6, new Object[]{var1, var2, var3});
  125.        } catch (RuntimeException | Error var5) {
  126.            throw var5;
  127.        } catch (Throwable var6) {
  128.            throw new UndeclaredThrowableException(var6);
  129.        }
  130.    }

  132.    public final void wait(long var1) throws InterruptedException {
  133.        try {
  134.            super.h.invoke(this, m9, new Object[]{var1});
  135.        } catch (RuntimeException | InterruptedException | Error var4) {
  136.            throw var4;
  137.        } catch (Throwable var5) {
  138.            throw new UndeclaredThrowableException(var5);
  139.        }
  140.    }

  142.    public final void speak() throws  {
  143.        try {
  144.            super.h.invoke(this, m3, (Object[])null);
  145.        } catch (RuntimeException | Error var2) {
  146.            throw var2;
  147.        } catch (Throwable var3) {
  148.            throw new UndeclaredThrowableException(var3);
  149.        }
  150.    }

  152.    public final boolean isProxyClass(Class var1) throws  {
  153.        try {
  154.            return (Boolean)super.h.invoke(this, m7, new Object[]{var1});
  155.        } catch (RuntimeException | Error var3) {
  156.            throw var3;
  157.        } catch (Throwable var4) {
  158.            throw new UndeclaredThrowableException(var4);
  159.        }
  160.    }

  162.    public final void wait(long var1, int var3) throws InterruptedException {
  163.        try {
  164.            super.h.invoke(this, m8, new Object[]{var1, var3});
  165.        } catch (RuntimeException | InterruptedException | Error var5) {
  166.            throw var5;
  167.        } catch (Throwable var6) {
  168.            throw new UndeclaredThrowableException(var6);
  169.        }
  170.    }

  172.    static {
  173.        try {
  174.            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
  175.            m5 = Class.forName("com.sun.proxy.$Proxy0").getMethod("getInvocationHandler", Class.forName("java.lang.Object"));
  176.            m2 = Class.forName("java.lang.Object").getMethod("toString");
  177.            m4 = Class.forName("com.sun.proxy.$Proxy0").getMethod("getProxyClass", Class.forName("java.lang.ClassLoader"), Class.forName("[Ljava.lang.Class;"));
  178.            m11 = Class.forName("com.sun.proxy.$Proxy0").getMethod("getClass");
  179.            m13 = Class.forName("com.sun.proxy.$Proxy0").getMethod("notifyAll");
  180.            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
  181.            m10 = Class.forName("com.sun.proxy.$Proxy0").getMethod("wait");
  182.            m12 = Class.forName("com.sun.proxy.$Proxy0").getMethod("notify");
  183.            m6 = Class.forName("com.sun.proxy.$Proxy0").getMethod("newProxyInstance", Class.forName("java.lang.ClassLoader"), Class.forName("[Ljava.lang.Class;"), Class.forName("java.lang.reflect.InvocationHandler"));
  184.            m9 = Class.forName("com.sun.proxy.$Proxy0").getMethod("wait", Long.TYPE);
  185.            m3 = Class.forName("com.sun.proxy.$Proxy0").getMethod("speak");
  186.            m7 = Class.forName("com.sun.proxy.$Proxy0").getMethod("isProxyClass", Class.forName("java.lang.Class"));
  187.            m8 = Class.forName("com.sun.proxy.$Proxy0").getMethod("wait", Long.TYPE, Integer.TYPE);
  188.        } catch (NoSuchMethodException var2) {
  189.            throw new NoSuchMethodError(var2.getMessage());
  190.        } catch (ClassNotFoundException var3) {
  191.            throw new NoClassDefFoundError(var3.getMessage());
  192.        }
  193.    }
  194. }


里面大多是Object中的方法，还有我们定义的speak()方法，然后就是静态代码块(对变量进行初始化)。

上一篇：软件测试方法和技术


下一篇：mybatis-plus的使用 ------ 进阶