• 极客专栏正式上线!欢迎访问 https://www.jikewenku.com/topic.html
  • 极客专栏正式上线!欢迎访问 https://www.jikewenku.com/topic.html

彻底搞懂动态代理副本

技术杂谈 勤劳的小蚂蚁 3个月前 (01-24) 166次浏览 已收录 0个评论 扫描二维码

什么是代理模式?

如果用专业术语来解:为其他对象提供一种代理以控制对这个对象的访问。如果投影在生活中,它可以理解成中介 黄牛 经纪人等…
解决的问题:
在直接访问对象时带来的问题,比如说:要访问的对象在远程的机器上。在面向对象系统中,有些对象由于某些原因(比如对象创建开销很大,或者某些操作需要安全控制,或者需要进程外的访问),直接访问会给使用者或者系统结构带来很多麻烦,我们可以在访问此对象时加上一个对此对象的访问层。说白了就是在你代码前面插一段后面插一段。
Java动态代理实现方式:

1. JDK 自带的动态代理

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

1.1 People.java

注意这必须是一个接口,原因往下看。
  1. publicinterfacePeople{
  2.    /**
  3.     * 交谈
  4.     */
  5.    void speak();
  6. }
这个接口很简单,就是一个讲话的功能,但是它为什么必须是一个接口呢。因为在HuangNiu这个类中,Proxy.newProxyInstance 这个方法的实现需要接口,这一点我在HuangNiu类下解释的很清楚,往下看。

1.2 HuangNiu.java

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

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

  12.    @Override
  13.    publicObject invoke(Object proxy,Method method,Object[] args)throwsThrowable{
  14.        System.out.println("代理中...");
  15.        method.invoke(people);
  16.        System.out.println("代理处理完毕,OK,请查收");
  17.        returnnull;
  18.    }
  19. }
在实例化HuangNiu这个对象的时候,我们调用了Proxy的newProxyInstance方法:
  1. returnProxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(),this);
其中clazz是People的class对象。再来看看newProxyInstance的源码实现:
  1. publicstaticObject newProxyInstance(ClassLoader loader,
  2.                                          Class<?>[] interfaces,
  3.                                          InvocationHandler h){

  4.        finalClass<?>[] intfs = interfaces.clone();

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

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

  7.        //获取代理类的构造函数对象
  8.        //参数constructorParames为常量值:private static final Class<?>[] constructorParams = { InvocationHandler.class };
  9.        finalConstructor<?> cons = cl.getConstructor(constructorParames);
  10.        finalInvocationHandler ih = h;
  11.        //根据代理类的构造函数对象来创建代理类对象
  12.        return newInstance(cons, ih);
  13. }
getProxyClass0方法源码:
  1.    privatestaticClass<?> getProxyClass0(ClassLoader loader,
  2.                                           Class<?>... interfaces){
  3.        if(interfaces.length >65535){
  4.            thrownewIllegalArgumentException("interface limit exceeded");
  5.        }

  6.        // If the proxy class defined by the given loader implementing
  7.        // the given interfaces exists, this will simply return the cached copy;
  8.        // otherwise, it will create the proxy class via the ProxyClassFactory
  9.        return proxyClassCache.get(loader, interfaces);
  10.    }
如果缓存中有该代理类,则取缓存,如果没有,则通过ProxyClassFactory来创建代理类。如果对如何生成代理类感兴趣则追踪下去即可。
我只取了核心代码和注释,可以看到JDK的动态代理实现是依据接口来重新生成一个新的代理类,
什么是新的代理类?
通俗点说就是综合和前后代理逻辑并重新生成一份.class文件来实现动态代理的类,下面也会具体说。

1.3 Me.java

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

  2.    privateString name;
  3.    privateString type;

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

1.4 Main.java

  1. publicclassMain{
  2.    publicstaticvoid main(String[] args){
  3.        People instance =(People)newHuangNiu().getInstance(newMe("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",newClass[]{instance.getClass()});
  6.    String path =Main.class.getResource("").toString();
  7. //            System.out.println("get the path"+path);
  8.    FileOutputStream fileOutputStream =newFileOutputStream("$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. //

  5. import com.sun.proxy..Proxy0;
  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. publicfinalclass $Proxy0 extendsProxyimplementsProxy0{
  11.    privatestaticMethod m1;
  12.    privatestaticMethod m5;
  13.    privatestaticMethod m2;
  14.    privatestaticMethod m4;
  15.    privatestaticMethod m11;
  16.    privatestaticMethod m13;
  17.    privatestaticMethod m0;
  18.    privatestaticMethod m10;
  19.    privatestaticMethod m12;
  20.    privatestaticMethod m6;
  21.    privatestaticMethod m9;
  22.    privatestaticMethod m3;
  23.    privatestaticMethod m7;
  24.    privatestaticMethod m8;

  25.    public $Proxy0(InvocationHandler var1)throws  {
  26.        super(var1);
  27.    }

  28.    publicfinalboolean equals(Object var1)throws  {
  29.        try{
  30.            return(Boolean)super.h.invoke(this, m1,newObject[]{var1});
  31.        }catch(RuntimeException|Error var3){
  32.            throw var3;
  33.        }catch(Throwable var4){
  34.            thrownewUndeclaredThrowableException(var4);
  35.        }
  36.    }

  37.    publicfinalInvocationHandler getInvocationHandler(Object var1)throwsIllegalArgumentException{
  38.        try{
  39.            return(InvocationHandler)super.h.invoke(this, m5,newObject[]{var1});
  40.        }catch(RuntimeException|Error var3){
  41.            throw var3;
  42.        }catch(Throwable var4){
  43.            thrownewUndeclaredThrowableException(var4);
  44.        }
  45.    }

  46.    publicfinalString toString()throws  {
  47.        try{
  48.            return(String)super.h.invoke(this, m2,(Object[])null);
  49.        }catch(RuntimeException|Error var2){
  50.            throw var2;
  51.        }catch(Throwable var3){
  52.            thrownewUndeclaredThrowableException(var3);
  53.        }
  54.    }

  55.    publicfinalClass getProxyClass(ClassLoader var1,Class[] var2)throwsIllegalArgumentException{
  56.        try{
  57.            return(Class)super.h.invoke(this, m4,newObject[]{var1, var2});
  58.        }catch(RuntimeException|Error var4){
  59.            throw var4;
  60.        }catch(Throwable var5){
  61.            thrownewUndeclaredThrowableException(var5);
  62.        }
  63.    }

  64.    publicfinalClass getClass()throws  {
  65.        try{
  66.            return(Class)super.h.invoke(this, m11,(Object[])null);
  67.        }catch(RuntimeException|Error var2){
  68.            throw var2;
  69.        }catch(Throwable var3){
  70.            thrownewUndeclaredThrowableException(var3);
  71.        }
  72.    }

  73.    publicfinalvoid notifyAll()throws  {
  74.        try{
  75.            super.h.invoke(this, m13,(Object[])null);
  76.        }catch(RuntimeException|Error var2){
  77.            throw var2;
  78.        }catch(Throwable var3){
  79.            thrownewUndeclaredThrowableException(var3);
  80.        }
  81.    }

  82.    publicfinalint hashCode()throws  {
  83.        try{
  84.            return(Integer)super.h.invoke(this, m0,(Object[])null);
  85.        }catch(RuntimeException|Error var2){
  86.            throw var2;
  87.        }catch(Throwable var3){
  88.            thrownewUndeclaredThrowableException(var3);
  89.        }
  90.    }

  91.    publicfinalvoid wait()throwsInterruptedException{
  92.        try{
  93.            super.h.invoke(this, m10,(Object[])null);
  94.        }catch(RuntimeException|InterruptedException|Error var2){
  95.            throw var2;
  96.        }catch(Throwable var3){
  97.            thrownewUndeclaredThrowableException(var3);
  98.        }
  99.    }

  100.    publicfinalvoid notify()throws  {
  101.        try{
  102.            super.h.invoke(this, m12,(Object[])null);
  103.        }catch(RuntimeException|Error var2){
  104.            throw var2;
  105.        }catch(Throwable var3){
  106.            thrownewUndeclaredThrowableException(var3);
  107.        }
  108.    }

  109.    publicfinalObject newProxyInstance(ClassLoader var1,Class[] var2,InvocationHandler var3)throwsIllegalArgumentException{
  110.        try{
  111.            return(Object)super.h.invoke(this, m6,newObject[]{var1, var2, var3});
  112.        }catch(RuntimeException|Error var5){
  113.            throw var5;
  114.        }catch(Throwable var6){
  115.            thrownewUndeclaredThrowableException(var6);
  116.        }
  117.    }

  118.    publicfinalvoid wait(long var1)throwsInterruptedException{
  119.        try{
  120.            super.h.invoke(this, m9,newObject[]{var1});
  121.        }catch(RuntimeException|InterruptedException|Error var4){
  122.            throw var4;
  123.        }catch(Throwable var5){
  124.            thrownewUndeclaredThrowableException(var5);
  125.        }
  126.    }

  127.    publicfinalvoid speak()throws  {
  128.        try{
  129.            super.h.invoke(this, m3,(Object[])null);
  130.        }catch(RuntimeException|Error var2){
  131.            throw var2;
  132.        }catch(Throwable var3){
  133.            thrownewUndeclaredThrowableException(var3);
  134.        }
  135.    }

  136.    publicfinalboolean isProxyClass(Class var1)throws  {
  137.        try{
  138.            return(Boolean)super.h.invoke(this, m7,newObject[]{var1});
  139.        }catch(RuntimeException|Error var3){
  140.            throw var3;
  141.        }catch(Throwable var4){
  142.            thrownewUndeclaredThrowableException(var4);
  143.        }
  144.    }

  145.    publicfinalvoid wait(long var1,int var3)throwsInterruptedException{
  146.        try{
  147.            super.h.invoke(this, m8,newObject[]{var1, var3});
  148.        }catch(RuntimeException|InterruptedException|Error var5){
  149.            throw var5;
  150.        }catch(Throwable var6){
  151.            thrownewUndeclaredThrowableException(var6);
  152.        }
  153.    }

  154.    static{
  155.        try{
  156.            m1 =Class.forName("java.lang.Object").getMethod("equals",Class.forName("java.lang.Object"));
  157.            m5 =Class.forName("com.sun.proxy.$Proxy0").getMethod("getInvocationHandler",Class.forName("java.lang.Object"));
  158.            m2 =Class.forName("java.lang.Object").getMethod("toString");
  159.            m4 =Class.forName("com.sun.proxy.$Proxy0").getMethod("getProxyClass",Class.forName("java.lang.ClassLoader"),Class.forName("[Ljava.lang.Class;"));
  160.            m11 =Class.forName("com.sun.proxy.$Proxy0").getMethod("getClass");
  161.            m13 =Class.forName("com.sun.proxy.$Proxy0").getMethod("notifyAll");
  162.            m0 =Class.forName("java.lang.Object").getMethod("hashCode");
  163.            m10 =Class.forName("com.sun.proxy.$Proxy0").getMethod("wait");
  164.            m12 =Class.forName("com.sun.proxy.$Proxy0").getMethod("notify");
  165.            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"));
  166.            m9 =Class.forName("com.sun.proxy.$Proxy0").getMethod("wait",Long.TYPE);
  167.            m3 =Class.forName("com.sun.proxy.$Proxy0").getMethod("speak");
  168.            m7 =Class.forName("com.sun.proxy.$Proxy0").getMethod("isProxyClass",Class.forName("java.lang.Class"));
  169.            m8 =Class.forName("com.sun.proxy.$Proxy0").getMethod("wait",Long.TYPE,Integer.TYPE);
  170.        }catch(NoSuchMethodException var2){
  171.            thrownewNoSuchMethodError(var2.getMessage());
  172.        }catch(ClassNotFoundException var3){
  173.            thrownewNoClassDefFoundError(var3.getMessage());
  174.        }
  175.    }
  176. }
里面大多是Object中的方法,还有我们定义的speak()方法,然后就是静态代码块(对变量进行初始化)。
当我们在Main中:
  1. People instance =(People)newHuangNiu().getInstance(newMe("Fantj","JAY演唱会门票"));
  2. instance.speak();

  3. 调用instance.speak();时,事实上就调用了$Proxy0中的speak()方法,然后在该方法中再调用父类Proxyinvoke方法:

  4. publicfinalvoid speak()throws  {
  5.    try{
  6.        super.h.invoke(this, m3,(Object[])null);
  7.    }catch(RuntimeException|Error var2){
  8.        throw var2;
  9.    }catch(Throwable var3){
  10.        thrownewUndeclaredThrowableException(var3);
  11.    }
  12. }
其中,super.h.invoke的调用的是父类Proxy中的InvocationHandler.invoke()方法.

最后

你一定也很好奇它的名字为什么是$Proxy0,也一定很好奇第二个代理类的命名。
ProxyClassFactory类中的代码中有体现:
  1. privatestaticfinalclassProxyClassFactory
  2.    implementsBiFunction<ClassLoader,Class<?>[],Class<?>>
  3. {
  4.    // prefix for all proxy class names
  5.    // 所有代理类的前缀
  6.    privatestaticfinalString proxyClassNamePrefix ="$Proxy";

  7.    // next number to use for generation of unique proxy class names
  8.    // 用java8新增的原子性AtomicLong类来做线程安全计数
  9.    privatestaticfinalAtomicLong nextUniqueNumber =newAtomicLong();

  10.        /*
  11.         * Choose a name for the proxy class to generate.
  12.         */
  13.      // 拼接代理类 类名
  14.        long num = nextUniqueNumber.getAndIncrement();
  15.        String proxyName = proxyPkg + proxyClassNamePrefix + num;
  16.        ...
  17.        ...
  18. }

2. Cglib实现动态代理

Cglib动态代理的实现原理和jdk基本一样,但是也有不同点。

不同点:

  1. jdk动态代理生成的代理类是继承自Proxy,实现你的被代理类所实现的接口,要求必须有接口。
  2. cglib动态代理生成的代理类是被代理者的子类,并且会重写父类的所有方法,要求该父类必须有空的构造方法,否则会报错:Superclass has no null constructors but no arguments were given,还有,private和final修饰的方法不会被子类重写。

相同点:

都是生成了新的代理类(字节码重组)。
Me.java
  1. publicclassMe{

  2.    privateString name ="FantJ";
  3.    privateString type ="JAY演唱会门票";

  4.    Me(){

  5.    }

  6.    Me(String name,String type){
  7.        this.name = name;
  8.        this.type = type;
  9.    }
  10.    publicvoid speak(){
  11.        System.out.println("我叫"+name+