CGLIB动态代理原理分析

Dear 丶 2023-07-06 13:28 11阅读 0赞

## 原理 ##

采用字节码技术，动态生成代理类，并在代理类中做回调处理完成方法增强。

假设业务类User，我们现在要对其进行处理。CGLIB动态代理会生成User的代理类UserProxy，其中UserProxy继承自User。既然是继承，那么必然User的方法他也有，除非用final修饰。

因此，我们可以在UserProxy中对User的方法做处理，实现代理的作用。

## 实例 ##

现在通过代码看下：  
业务类User

public class User {
    
        public final void getId(){
            System.out.println("这是final方法");
        }
        public void getName(String id){
            System.out.println("User方法-获取名称返回:"+id);
        }
    }

设置业务类的拦截器，用于后面的方法拦截，做个性化处理。

public class UserMethodInterceptor implements MethodInterceptor {
        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
            System.out.println("拦截器拦截前："+method.getName());
            Object object=proxy.invokeSuper(obj,args);  //invokeSuper而非invoke
            System.out.println("拦截器拦截后:"+method.getName());
            return object;
        }
    }

调用测试：

public class MainTest {
        public static void main(String[] args) {
            //输出cglib动态代理产生的代理类
            System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"/Users/**/Documents/log/cglibProxyClass");
            
           //以下用于设置动态代理类的参数
            Enhancer enhancer=new Enhancer();
            enhancer.setSuperclass(User.class);
            enhancer.setCallback(new UserMethodInterceptor());
            User user=(User)enhancer.create();
            user.getName("a");
        }
    }

打印结果：

拦截器拦截前：getName
    User方法-获取名称返回:a
    拦截器拦截后:getName

## 重点说明 ##

### 1.代理类 ###

通过下面代码，我们可以在该路径下生成代理类。

System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"/Users/**/Documents/log/cglibProxyClass");

下面截取部分代码：

public class User$$EnhancerByCGLIB$$1e96607 extends User implements Factory {
    	 final void CGLIB$getName$0(String var1) {
            super.getName(var1);
        }
    
        public final void getName(String var1) {
            MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
            if (var10000 == null) {
                CGLIB$BIND_CALLBACKS(this);
                var10000 = this.CGLIB$CALLBACK_0;
            }
    
            if (var10000 != null) {
                var10000.intercept(this, CGLIB$getName$0$Method, new Object[]{var1}, CGLIB$getName$0$Proxy);
            } else {
                super.getName(var1);
            }
        }
    }

其中：  
a.代理类与被代理类的继承关系（ extends）  
b.final修饰的方法无法继承，生成的代理类中并没有getId()。  
c.普通方法getName()有两个，一个是直接调用父类的方法，另一个先处理了拦截（intercept）。

### 2.CGLIB效率——FastClass机制 ###

在JDK1.8之前，CGLIB动态代理的效率要比JDK动态代理高很多。这是为什么呢？如何实现的呢？  
JDK动态代理使用的是反射，那么CGLIB是如何处理的呢？  
CGLIB使用FastClass机制来实现对被拦截方法的调用。对类的方法建立索引，通过索引来调用相应的方法，快速高效。

public class ClassA {
    
        public void a1(){
            System.out.println("这是ClassA的a1方法");
        }
    
        public void a2(){
            System.out.println("这是ClassA的a2方法");
        }
    }
    
    public class ClassB {
        public int getIndex(String signature){
            switch (signature.hashCode()){
                case 3014151:
                    return 1;
                case 3014521:
                    return 2;
            }
            return -1;
        }
    
        public void invoke(int index,Object object,Object[] objects){
            ClassA classA=new ClassA();
            switch (index){
                case 1:
                    classA.a1();
                    return ;
                case 2:
                    classA.a2();
                    return ;
            }
    
        }
    }

通过在一个类中建立另一个类的方法的索引，就可以快速准确的定位到调用的方法。无需使用反射。但也可以发现，这种方式弊端就是两个类过于耦合，维护代价很大。

对应到源码中的FastClassInfo类

private static class FastClassInfo
        {
            FastClass f1;
            FastClass f2;
            int i1;
            int i2;
        }

f1，f2分别对应代理类、被代理类，按照上面说的类方法索引的方式，生成新的类，方便使用。在例子中看一下，如下图所示。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAwNjY5MzQ_size_16_color_FFFFFF_t_70]  
被代理类的FastClass：

public class User$$FastClassByCGLIB$$8b45c2e9 extends FastClass {
    
    	    public int getIndex(Signature var1) {
            String var10000 = var1.toString();
            switch(var10000.hashCode()) {
            case 1826985398:
                if (var10000.equals("equals(Ljava/lang/Object;)Z")) {
                    return 2;
                }
                break;
            case 1871866270:
                if (var10000.equals("getName(Ljava/lang/String;)V")) {
                    return 0;
                }
                break;
            case 1913648695:
                if (var10000.equals("toString()Ljava/lang/String;")) {
                    return 3;
                }
                break;
            case 1955814084:
                if (var10000.equals("getId()V")) {
                    return 1;
                }
                break;
            case 1984935277:
                if (var10000.equals("hashCode()I")) {
                    return 4;
                }
            }
    
            return -1;
        }
    	
    	 public Object invoke(int var1, Object var2, Object[] var3) throws InvocationTargetException {
    	   //实例化User对象，根据int值进行调用。
            User var10000 = (User)var2;
            int var10001 = var1;
    
            try {
                switch(var10001) {
                case 0:
                    var10000.getName((String)var3[0]);
                    return null;
                case 1:
                    var10000.getId();
                    return null;
                case 2:
                    return new Boolean(var10000.equals(var3[0]));
                case 3:
                    return var10000.toString();
                case 4:
                    return new Integer(var10000.hashCode());
                }
            } catch (Throwable var4) {
                throw new InvocationTargetException(var4);
            }
    
            throw new IllegalArgumentException("Cannot find matching method/constructor");
        }
    
    }

代理类的FastClass:  
（类似部分略过）

public class User$$EnhancerByCGLIB$$1e96607$$FastClassByCGLIB$$6706c1cf extends FastClass {
    	 public int getIndex(Signature var1) {
    		//具体实现略
    	}
    
    	  public Object invoke(int var1, Object var2, Object[] var3) throws InvocationTargetException {
    	   //“1e96607”即对应上面截图中的“User$$EnhancerByCGLIB$$1e96607”
            1e96607 var10000 = (1e96607)var2;
            int var10001 = var1;
    
            try {
                switch(var10001) {
                case 0:
                    return new Boolean(var10000.equals(var3[0]));
                case 1:
                    return var10000.toString();
                case 2:
                    return new Integer(var10000.hashCode());
                case 3:
                    return var10000.clone();
                case 4:
                    var10000.getName((String)var3[0]);
                    return null;
                case 5:
                    return var10000.newInstance((Callback[])var3[0]);
                case 6:
                    return var10000.newInstance((Callback)var3[0]);
                case 7:
                    return var10000.newInstance((Class[])var3[0], (Object[])var3[1], (Callback[])var3[2]);
                case 8:
                    return 1e96607.CGLIB$findMethodProxy((Signature)var3[0]);
                case 9:
                    var10000.setCallback(((Number)var3[0]).intValue(), (Callback)var3[1]);
                    return null;
                case 10:
                    var10000.setCallbacks((Callback[])var3[0]);
                    return null;
                case 11:
                    1e96607.CGLIB$SET_STATIC_CALLBACKS((Callback[])var3[0]);
                    return null;
                case 12:
                    1e96607.CGLIB$SET_THREAD_CALLBACKS((Callback[])var3[0]);
                    return null;
                case 13:
                    return var10000.getCallback(((Number)var3[0]).intValue());
                case 14:
                    return var10000.getCallbacks();
                case 15:
                    1e96607.CGLIB$STATICHOOK1();
                    return null;
                case 16:
                    var10000.CGLIB$getName$0((String)var3[0]);
                    return null;
                case 17:
                    return new Boolean(var10000.CGLIB$equals$1(var3[0]));
                case 18:
                    return var10000.CGLIB$toString$2();
                case 19:
                    return new Integer(var10000.CGLIB$hashCode$3());
                case 20:
                    return var10000.CGLIB$clone$4();
                case 21:
                    var10000.getId();
                    return null;
                }
            } catch (Throwable var4) {
                throw new InvocationTargetException(var4);
            }
    
            throw new IllegalArgumentException("Cannot find matching method/constructor");
        }
    
    }

### 3.字节码技术 ###

字节码增强技术相当于是一把打开运行时JVM的钥匙，利用它可以动态地对运行中的程序做修改，也可以跟踪JVM运行中程序的状态。  
上面我们介绍过，代理类是动态生成的，负责拦截调用的FastClass也是动态生成的。通过这些动态生成的类，我们实现了对原始业务类中方法的增强处理。

## 小结 ##

1.反射是个好东西，但效率一般不高。在选型时，要综合考虑，平衡把握，没有恒强的技术。  
2.系统间的低耦合、可维护、可插拔都是我们所追求的。实现方式多种多样，各个方面各个层次的实现思路也是不同的。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAwNjY5MzQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200219161052348.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTAwNjY5MzQ=,size_16,color_FFFFFF,t_70