cglib

cglib【Code Generation Library:代碼生成庫】是強大高性能的代碼生成包类早、廣泛應用于許多aop框架媚媒，為其提供方法的攔截，比如說spring,可以在運行期間通過cglib繼承要被動態(tài)代理的類涩僻，重寫父類的方法缭召，在子類中采用方法攔截技術攔截父類方法栈顷，并加入相應的業(yè)務邏輯代碼，實現aop切面編程嵌巷。

在jvm中執(zhí)行程序不一定非要寫java代碼萄凤，只要能生成字節(jié)碼，jvm并不關心字節(jié)碼來源搪哪，平時寫java代碼是編譯器生成的jvm字節(jié)碼,而cglib底層是通過asm字節(jié)碼技術實現動態(tài)代理

ASM

位于字節(jié)碼之上靡努、直接操作字節(jié)碼的框架，

ASM是一個java字節(jié)碼操控框架晓折，可以以二進制的形式修改已有類惑朦，ASM可以直接生成二進制class文件，也可以在類被加載如java虛擬機之前改變類的行為漓概，asm從類文件中讀入信息漾月，甚至可以根據用戶要求生成新類

ASM在創(chuàng)建class字節(jié)碼的過程中，操縱的是底層jvm匯編指令級別胃珍，需要對class組織了解梁肿。

字節(jié)碼技術

字節(jié)碼（bytecode）是一種包含執(zhí)行程序、由一序列 op 代碼/數據對 組成的二進制文件觅彰。字節(jié)碼是一種中間碼吩蔑，它比機器碼更抽象，需要直譯器轉譯后才能成為機器碼的中間代碼

借助字節(jié)碼能做什么

字節(jié)碼作用于運行期填抬，一般用來運行期改變類的行為烛芬，可以結合代理模式

使用ASM框架提供了ClassWriter 接口，通過訪問者模式進行動態(tài)創(chuàng)建class字節(jié)碼飒责，看下面的例子：

public class Test {
    public static void main(String[] args) throws IOException {
        //ClassReader用于讀取原有字節(jié)碼蛀骇，ClassWriter用于寫入字節(jié)碼，
        ClassWriter cs = new ClassWriter(0);
        //通過vist確定類的同步信息 java版本號 類修飾符 類的權限定名
        cs.visit(Opcodes.V1_8,Opcodes.ACC_PUBLIC,"Duck",null, "java/lang/Object",null);
        //構造函數
        MethodVisitor mv = cs.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
        mv.visitCode();
        mv.visitVarInsn(Opcodes.ALOAD, 0);
        mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V");
        mv.visitInsn(Opcodes.RETURN);
        mv.visitMaxs(1, 1);
        mv.visitEnd();
        // 定義code方法
        MethodVisitor methodVisitor = cs.visitMethod(Opcodes.ACC_PUBLIC, "code", "()V", null, null);
        methodVisitor.visitCode();
        methodVisitor.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
        methodVisitor.visitLdcInsn("I'm a Duck,Just Coding.....");
        methodVisitor.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V");
        methodVisitor.visitInsn(Opcodes.RETURN);
        methodVisitor.visitMaxs(2, 2);
        methodVisitor.visitEnd();
        cs.visitEnd();
        // 使classWriter類已經完成
        // 將classWriter轉換成字節(jié)數組寫到文件里面去
        byte[] data = cs.toByteArray();
        File file = new File("D://Duck.class");
        FileOutputStream fout = new FileOutputStream(file);
        fout.write(data);
        fout.close();
    }
}

生成Duck.class

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

public class Duck {
    public Duck() {
    }

    public void code() {
        System.out.println("I'm a Duck,Just Coding.....");
    }
}

cglib測試代碼

1.代理的目標類Dao

public class Dao {
    public void select() {
        System.out.println("select 1 from dual");
    }

    public void insert() {
        System.out.println("insert into ...");
    }

    public final void delete() {
        System.out.println("delete from ...");
    }
}

2.代理類DaoProxy读拆、DaoAnotherProxy

public class DaoProxy implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("begin intercept");
        //invokeSuper方法調用目標類的方法
        proxy.invokeSuper(obj, args);
        System.out.println("end intercept");
        return obj;
    }
}

public class DaoAnotherProxy implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("開始intercept");
        proxy.invokeSuper(obj, args);
        System.out.println("結束intercept");
        return obj;
    }
}

3.過濾器DaoFilter

/**
 * 返回數值表示順序
 */
public class DaoFilter implements CallbackFilter {
    @Override
    public int accept(Method method) {
        if("select".equalsIgnoreCase(method.getName())) {
            return 0;
        } else if ("delete".equalsIgnoreCase(method.getName())) {
            return 1;
        }
        return 2;
    }
}

測試類Client

public class Client {
    public static void main(String[] args) {
        //將代理類存到本地磁盤
        System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "C:\\Users\\LJW\\IdeaProjects\\design\\structure\\src\\main\\java\\cglib\\classes");
        //實例化增強器
        Enhancer enhancer = new Enhancer();
        //設置需要代理的目標類
        enhancer.setSuperclass(Dao.class);
        //設置攔截對象 回調的實現類
       // enhancer.setCallback(new DaoProxy());
        enhancer.setCallbacks(new Callback[]{new DaoProxy(), new DaoAnotherProxy(),NoOp.INSTANCE});
        enhancer.setCallbackFilter(new DaoFilter());
        //使用create 返回Object 生成代理類并返回實例
        Dao dao = (Dao) enhancer.create();
        //select優(yōu)先級高 使用DaoProxy
        dao.select();
        //無法代理被final修飾的方法
        dao.delete();
        dao.insert();
    }
}

輸出

begin intercept
select 1 from dual
end intercept
delete from ...
insert into ...

代理類

以上僅有select方法得到加強【原因看后面分析】擅憔，并將一系列代理類通過System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY存放在磁盤中，觀察生成的類

這里用idea反編譯后得到的,生成三個類檐晕，都是以Dao開頭命名一個EnhancerBy還有一個FastClass相關

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
// 可以看到代理類繼承代理類重寫了select方法暑诸，可以當做為入口方法，這里沒有delete()的原因是final修飾辟灰，無法重寫个榕，也沒有insert() 【過濾器返回索引為2,而索引為2的代理類為空，用NoOp.INSTANCE表示】
//

package cglib.mapper;

import java.lang.reflect.Method;
import net.sf.cglib.core.ReflectUtils;
import net.sf.cglib.core.Signature;
import net.sf.cglib.proxy.Callback;
import net.sf.cglib.proxy.Factory;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import net.sf.cglib.proxy.NoOp;

public class Dao$$EnhancerByCGLIB$$7ddef0e2 extends Dao implements Factory {
    private boolean CGLIB$BOUND;
    public static Object CGLIB$FACTORY_DATA;
    private static final ThreadLocal CGLIB$THREAD_CALLBACKS;
    private static final Callback[] CGLIB$STATIC_CALLBACKS;
    private MethodInterceptor CGLIB$CALLBACK_0;
    private MethodInterceptor CGLIB$CALLBACK_1;
    private NoOp CGLIB$CALLBACK_2;
    private static Object CGLIB$CALLBACK_FILTER;
    private static final Method CGLIB$select$1$Method;
    private static final MethodProxy CGLIB$select$1$Proxy;
    private static final Object[] CGLIB$emptyArgs;

    static void CGLIB$STATICHOOK1() {
        CGLIB$THREAD_CALLBACKS = new ThreadLocal();
        CGLIB$emptyArgs = new Object[0];
        Class var0 = Class.forName("cglib.mapper.Dao$$EnhancerByCGLIB$$7ddef0e2");
        Class var1;
        CGLIB$select$1$Method = ReflectUtils.findMethods(new String[]{"select", "()V"}, (var1 = Class.forName("cglib.mapper.Dao")).getDeclaredMethods())[0];
        CGLIB$select$1$Proxy = MethodProxy.create(var1, var0, "()V", "select", "CGLIB$select$1");
    }

    final void CGLIB$select$1() {
        super.select();
    }

    public final void select() {
        MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
        if (this.CGLIB$CALLBACK_0 == null) {
            CGLIB$BIND_CALLBACKS(this);
            var10000 = this.CGLIB$CALLBACK_0;
        }
        //如果不為null 說明有相應代理類實現MethodInterceptor 會調用該對象的intercept加強方法
        if (var10000 != null) {
            var10000.intercept(this, CGLIB$select$1$Method, CGLIB$emptyArgs, CGLIB$select$1$Proxy);
        } else {
            super.select();
        }
    }

    public static MethodProxy CGLIB$findMethodProxy(Signature var0) {
        String var10000 = var0.toString();
        switch(var10000.hashCode()) {
        case -1716030215:
            if (var10000.equals("select()V")) {
                return CGLIB$select$1$Proxy;
            }
        }

        return null;
    }

    public Dao$$EnhancerByCGLIB$$7ddef0e2() {
        CGLIB$BIND_CALLBACKS(this);
    }

    public static void CGLIB$SET_THREAD_CALLBACKS(Callback[] var0) {
        CGLIB$THREAD_CALLBACKS.set(var0);
    }

    public static void CGLIB$SET_STATIC_CALLBACKS(Callback[] var0) {
        CGLIB$STATIC_CALLBACKS = var0;
    }

    private static final void CGLIB$BIND_CALLBACKS(Object var0) {
        Dao$$EnhancerByCGLIB$$7ddef0e2 var1 = (Dao$$EnhancerByCGLIB$$7ddef0e2)var0;
        if (!var1.CGLIB$BOUND) {
            var1.CGLIB$BOUND = true;
            Object var10000 = CGLIB$THREAD_CALLBACKS.get();
            if (var10000 == null) {
                var10000 = CGLIB$STATIC_CALLBACKS;
                if (CGLIB$STATIC_CALLBACKS == null) {
                    return;
                }
            }

            Callback[] var10001 = (Callback[])var10000;
            var1.CGLIB$CALLBACK_2 = (NoOp)((Callback[])var10000)[2];
            var1.CGLIB$CALLBACK_1 = (MethodInterceptor)var10001[1];
            var1.CGLIB$CALLBACK_0 = (MethodInterceptor)var10001[0];
        }

    }

    public Object newInstance(Callback[] var1) {
        CGLIB$SET_THREAD_CALLBACKS(var1);
        Dao$$EnhancerByCGLIB$$7ddef0e2 var10000 = new Dao$$EnhancerByCGLIB$$7ddef0e2();
        CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
        return var10000;
    }

    public Object newInstance(Callback var1) {
        throw new IllegalStateException("More than one callback object required");
    }

    public Object newInstance(Class[] var1, Object[] var2, Callback[] var3) {
        CGLIB$SET_THREAD_CALLBACKS(var3);
        Dao$$EnhancerByCGLIB$$7ddef0e2 var10000 = new Dao$$EnhancerByCGLIB$$7ddef0e2;
        switch(var1.length) {
        case 0:
            var10000.<init>();
            CGLIB$SET_THREAD_CALLBACKS((Callback[])null);
            return var10000;
        default:
            throw new IllegalArgumentException("Constructor not found");
        }
    }

    public Callback getCallback(int var1) {
        CGLIB$BIND_CALLBACKS(this);
        Object var10000;
        switch(var1) {
        case 0:
            var10000 = this.CGLIB$CALLBACK_0;
            break;
        case 1:
            var10000 = this.CGLIB$CALLBACK_1;
            break;
        case 2:
            var10000 = this.CGLIB$CALLBACK_2;
            break;
        default:
            var10000 = null;
        }

        return (Callback)var10000;
    }

    public void setCallback(int var1, Callback var2) {
        switch(var1) {
        case 0:
            this.CGLIB$CALLBACK_0 = (MethodInterceptor)var2;
            break;
        case 1:
            this.CGLIB$CALLBACK_1 = (MethodInterceptor)var2;
            break;
        case 2:
            this.CGLIB$CALLBACK_2 = (NoOp)var2;
        }

    }

    public Callback[] getCallbacks() {
        CGLIB$BIND_CALLBACKS(this);
        return new Callback[]{this.CGLIB$CALLBACK_0, this.CGLIB$CALLBACK_1, this.CGLIB$CALLBACK_2};
    }

    public void setCallbacks(Callback[] var1) {
        this.CGLIB$CALLBACK_0 = (MethodInterceptor)var1[0];
        this.CGLIB$CALLBACK_1 = (MethodInterceptor)var1[1];
        this.CGLIB$CALLBACK_2 = (NoOp)var1[2];
    }

    static {
        CGLIB$STATICHOOK1();
    }
}

代理大致過程

1.生成的代理類Dao$$EnhancerByCGLIB$$7ddef0e2繼承了要代理的Dao類并實現Factory【這里的Factory應該是cglib的工廠接口，不做關心】
2.代理類會為委托方法【以Dao類的select為例】生成兩個方法，以final修飾捣染，一個重寫select
  public final void select()
  {
    MethodInterceptor tmp4_1 = this.CGLIB$CALLBACK_0;
    if (tmp4_1 == null)
    {
      tmp4_1;
      CGLIB$BIND_CALLBACKS(this);
    }
    if (this.CGLIB$CALLBACK_0 != null)
      return;
    super.select();
  }
  
  另外一個CGLIB$select$1 默認調用父類的select()方法
    final void CGLIB$select$1()
  {
    super.select();
  }
  當執(zhí)行代理對象的select時，會先判斷是否存在實現MethodInterceptor接口的CGLIB$CALLBACK_0械馆，如果存在則調用intercept方法

fastclass機制

cglib執(zhí)行代理方法效率快的原因:采用fastclass機制
簡單來說就是:為代理類和被代理類各生產一個class胖眷，該class會為代理類或被代理類分配一個index(int)，該index當做為一個入參霹崎，fastclass可以直接定位到要調用的方法直接進行調用珊搀，省去反射調用【反射效率較低】，即對一個類的方法建立索引尾菇，通過索引直接調用相應方法境析。

cglib和jdk動態(tài)代理的區(qū)別

1.jdk動態(tài)代理實現了被代理對象的接口，cglib是繼承了被代理的對象【通過字節(jié)碼技術創(chuàng)建這個類的子類派诬，實現動態(tài)代理】

2.都是在運行期間劳淆，jdk是直接寫class字節(jié)碼，cglib使用asm框架寫字節(jié)碼默赂，實現更復雜

3.java動態(tài)代理是利用反射機制生成一個實現代理接口的匿名類憔儿，在調用具體方法時用InvokeHandler，cglib是通過繼承要被代理類的機制

jdk動態(tài)代理要求
1.動態(tài)代理類實現InvocationHandler接口【必須】
2.被代理的類必須要實現一個接口
3.使用Proxy.newProxyInstance產生代理對象

cglib要求
1.jdk動態(tài)代理類庫中已有放可，而cglib必須加入第三方依賴(cglib、asm)

5.jdk調用代理方法朝刊，通過反射機制耀里，cglib通過fastclass機制直接調用方法，這方面cglib執(zhí)行效率更高拾氓。

速率上的區(qū)別

對于創(chuàng)建實例:jdk更快冯挎，相比之下cglib創(chuàng)建實例的過程比較繁瑣

對于方法執(zhí)行效率:cglib更快，基于asm操作字節(jié)碼技術和fastclass機制(通過索引調用方法),比基于反射的jdk動態(tài)代理來的快咙鞍。

據說高版本的jdk有了很大的提升房官，還沒實踐過，具體參考

https://blog.csdn.net/xlgen157387/article/details/82497594

cglib的局限性(缺點)

1.cglib無法代理final修飾的類和final修飾的方法

原因:

final類不能被繼承续滋、沒有子類翰守、final類中修飾的方法默認是final

final方法不能被子類的方法覆蓋

而cglib的底層的代理類恰好就是通過繼承要代理的目標類來實現種種操作。

cglib代理內部類

內部類Target

public class Target {
    class Student { 
        public String name = "garwer";
    }
}

測試類Client

//測試代碼
public class Client {
    public static void main(String[] args) throws ClassNotFoundException {
        Class inner = Class.forName("cglib.constructionTest.Target$Student");
        //獲取內部類構造函數
        Constructor[] constructors = inner.getDeclaredConstructors();
        for(Constructor c : constructors) {
            System.out.println(Arrays.toString(c.getParameterTypes()));////輸出[class cglib.constructionTest.Target] 證明形參是外部類
        }
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Target.Student.class);
        enhancer.setCallback(NoOp.INSTANCE);
        Target.Student student = (Target.Student) enhancer.create();
        System.out.println(student.name);
    }
}

輸出結果:

[class cglib.constructionTest.Target]
Exception in thread "main" java.lang.IllegalArgumentException: Superclass has no null constructors but no arguments were given...

原因:

代理目標對象不能是內部類【內部類的創(chuàng)建依賴外部類】疲酌，如果是內部類蜡峰，cglib代理內部會獲取到一個有參構造函數【參數是外部類對象】

如果非要代理內部類，有兩種方式

1.內部類加static【即static class Student,因為被static修飾的內部類可以直接作為一個普通類來使用朗恳，而不需實例一個外部類】

2.改為Target.Student student = (Target.Student) enhancer.create(new Class[]{Target.class}, new Object[]{new Target()}); 在cglib創(chuàng)建類對象時傳入外部類對象

Spring代理選擇

當bean實現接口時湿颅，spring使用jdk動態(tài)代理

當bean沒實現接口，spring使用cglib

可以通過配置強制走cglib粥诫，<aop:aspectj-autoproxy proxy-target-class="true"/>油航，如果是基于注解的方式，比如說springboot項目的啟動類怀浆，可以使用@EnableAspectJAutoProxy(proxyTargetClass=true)注解來強制使用cglib

public class DefaultAopProxyFactory implements AopProxyFactory, Serializable {

   @Override
   public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
      if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
         Class<?> targetClass = config.getTargetClass();
         if (targetClass == null) {
            throw new AopConfigException("TargetSource cannot determine target class: " +
                  "Either an interface or a target is required for proxy creation.");
         }
         if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
            return new JdkDynamicAopProxy(config);
         }
         return new ObjenesisCglibAopProxy(config);
      }
      else {
         return new JdkDynamicAopProxy(config);
      }
   }

   /**
    * Determine whether the supplied {@link AdvisedSupport} has only the
    * {@link org.springframework.aop.SpringProxy} interface specified
    * (or no proxy interfaces specified at all).
    */
   private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
      Class<?>[] ifcs = config.getProxiedInterfaces();
      return (ifcs.length == 0 || (ifcs.length == 1 && SpringProxy.class.isAssignableFrom(ifcs[0])));
   }

}

上述測試源碼

github源碼地址

參考鏈接

深入理解CGLIB動態(tài)代理機制

Cglib動態(tài)代理實現原理

字節(jié)碼和asm的使用

Java動態(tài)代理機制詳解（JDK 和CGLIB谊囚，Javassist怕享，ASM）