一、為什么需要運(yùn)行時(shí)代碼生成

• java是強(qiáng)類型語(yǔ)言

變量與對(duì)象必須有一個(gè)明確的類型隧出，如果在賦值操作中出現(xiàn)類型不兼容的情況，就會(huì)拋出異常。

• 發(fā)射解決：通用類編譯期還不知道被調(diào)用者類型的問(wèn)題

在對(duì)外提供一個(gè)通用 jar 包時(shí)糟港，我們通常不能引用用戶應(yīng)用中定義的任何類型，因?yàn)楫?dāng)這個(gè)通用 jar 包被編譯時(shí)院仿，我們還不知道這些用戶的自定義類型秸抚。為了調(diào)用用戶自定義的類，訪問(wèn)其屬性或方法歹垫，Java 類庫(kù)提供了一套反射 API 幫助我們查找未知類型剥汤，以及調(diào)用其方法或字段。

Java 反射 API 有兩個(gè)明顯的缺點(diǎn)：

在早期 JDK 版本中排惨，反射 API 性能很差吭敢。

反射 API 能繞過(guò)類型安全檢查，反射 API 自身并不是類型安全的暮芭。

• 字節(jié)碼增強(qiáng)技術(shù)：模擬動(dòng)態(tài)編程語(yǔ)言特性

運(yùn)行時(shí)代碼生成在 Java 應(yīng)用啟動(dòng)之后再動(dòng)態(tài)生成一些類定義鹿驼，不丟失 Java 的強(qiáng)類型檢查。

• 垃圾回收

在運(yùn)行時(shí)生成代碼需要特別注意的是 Java 類型被 JVM 加載之后谴麦，一般不會(huì)被垃圾被回收蠢沿，因此不應(yīng)該過(guò)度使用代碼生成。

二匾效、常見(jiàn)運(yùn)行時(shí)代碼生成技術(shù)

在 Java 的世界中舷蟀，代碼生成庫(kù)不止 Byte Buddy 一個(gè)，以下代碼生成庫(kù)在 Java 中也很流行：

• Java Proxy

只能面對(duì)一個(gè)已經(jīng)存在的接口，對(duì)類進(jìn)行擴(kuò)展的時(shí)候Proxy辦不到

Java Proxy 是 JDK 自帶的一個(gè)代理工具野宜，它允許為實(shí)現(xiàn)了一系列接口的類生成代理類扫步。Java Proxy 要求目標(biāo)類必須實(shí)現(xiàn)接口是一個(gè)非常大限制，例如匈子，在某些場(chǎng)景中河胎，目標(biāo)類沒(méi)有實(shí)現(xiàn)任何接口且無(wú)法修改目標(biāo)類的代碼實(shí)現(xiàn)，Java Proxy 就無(wú)法對(duì)其進(jìn)行擴(kuò)展和增強(qiáng)了虎敦。

• CGLIB

年代久遠(yuǎn)游岳，無(wú)人維護(hù)

CGLIB 誕生于 Java 初期，但不幸的是沒(méi)有跟上 Java 平臺(tái)的發(fā)展其徙。雖然 CGLIB 本身是一個(gè)相當(dāng)強(qiáng)大的庫(kù)胚迫，但也變得越來(lái)越復(fù)雜。鑒于此唾那，導(dǎo)致許多用戶放棄了 CGLIB 访锻。

• Javassist

自帶一個(gè)相比javac弱小編譯器，但是動(dòng)態(tài)生成字節(jié)碼時(shí)容易出錯(cuò)

Javassist 的使用對(duì) Java 開發(fā)者來(lái)說(shuō)是非常友好的闹获，它使用Java 源代碼字符串和 Javassist 提供的一些簡(jiǎn)單 API 期犬，共同拼湊出用戶想要的 Java 類，Javassist 自帶一個(gè)編譯器避诽，拼湊好的 Java 類在程序運(yùn)行時(shí)會(huì)被編譯成為字節(jié)碼并加載到 JVM 中龟虎。Javassist 庫(kù)簡(jiǎn)單易用，而且使用 Java 語(yǔ)法構(gòu)建類與平時(shí)寫 Java 代碼類似茎用，但是 Javassist 編譯器在性能上比不了 Javac 編譯器遣总，而且在動(dòng)態(tài)組合字符串以實(shí)現(xiàn)比較復(fù)雜的邏輯時(shí)容易出錯(cuò)。

• Byte Buddy

Byte Buddy 提供了一種非常靈活且強(qiáng)大的領(lǐng)域特定語(yǔ)言轨功，通過(guò)編寫簡(jiǎn)單的 Java 代碼即可創(chuàng)建自定義的運(yùn)行時(shí)類。與此同時(shí)容达，Byte Buddy 還具有非常開放的定制性古涧，能夠應(yīng)付不同復(fù)雜度的需求。

下表是 Byte Buddy 官網(wǎng)給出的數(shù)據(jù)花盐，顯示了上述代碼生成庫(kù)的基本性能羡滑，以納秒為單位，標(biāo)準(zhǔn)偏差在括號(hào)內(nèi)附加：

Byte Buddy設(shè)計(jì)理念

代碼生成庫(kù)需要在“生成快速的代碼”與“快速生成代碼”之間進(jìn)行折中算芯。Byte Buddy 折中的考慮是：類型動(dòng)態(tài)創(chuàng)建不是程序中的常見(jiàn)步驟柒昏，并不會(huì)對(duì)長(zhǎng)期運(yùn)行的應(yīng)用程序產(chǎn)生重大性能影響，但方法調(diào)用等操作卻在程序中隨處可見(jiàn)熙揍。所以职祷，Byte Buddy 的主要側(cè)重點(diǎn)在于生成更快速的代碼。

三、Byte Buddy 基礎(chǔ)入門（skywalking中常見(jiàn)使用方式）-- API 方式

引入依賴

<dependency>
    <groupId>net.bytebuddy</groupId>
    <artifactId>byte-buddy</artifactId>
    <version>1.9.2</version>
</dependency>
<dependency>
    <groupId>net.bytebuddy</groupId>
    <artifactId>byte-buddy-agent</artifactId>
    <version>1.9.2</version>
</dependency>

三種動(dòng)態(tài)增強(qiáng)方式

DynamicType.Unloaded<?> dynamicType = new ByteBuddy()
        .subclass(Object.class) // 生成 Object的子類
        .name("com.fatsnake.Type")   // 生成類的名稱為"com.xxx.Type"
        .make();

• subclass：對(duì)應(yīng) ByteBuddy.subclass() 方法有梆。這種方式比較好理解是尖，就是為目標(biāo)類（即被增強(qiáng)的類）生成一個(gè)子類，在子類方法中插入動(dòng)態(tài)代碼泥耀。
• rebasing：對(duì)應(yīng) ByteBuddy.rebasing() 方法饺汹。當(dāng)使用 rebasing 方式增強(qiáng)一個(gè)類時(shí)，Byte Buddy 保存目標(biāo)類中所有方法的實(shí)現(xiàn)痰催，也就是說(shuō)兜辞，當(dāng) Byte Buddy 遇到?jīng)_突的字段或方法時(shí)，會(huì)將原來(lái)的字段或方法實(shí)現(xiàn)復(fù)制到具有兼容簽名的重新命名的私有方法中夸溶，而不會(huì)拋棄這些字段和方法實(shí)現(xiàn)逸吵。從而達(dá)到不丟失實(shí)現(xiàn)的目的。這些重命名的方法可以繼續(xù)通過(guò)重命名后的名稱進(jìn)行調(diào)用蜘醋。例如：

class Foo { // Foo的原始定義

  String bar() { return "bar"; }
}

class Foo { // 增強(qiáng)后的Foo定義
  String bar() { return "foo" + bar$original(); }
// 目標(biāo)類原有方法
  private String bar$original() { return "bar"; }

• redefinition：對(duì)應(yīng) ByteBuddy.redefine() 方法胁塞。當(dāng)重定義一個(gè)類時(shí)，Byte Buddy 可以對(duì)一個(gè)已有的類添加屬性和方法压语，或者刪除已經(jīng)存在的方法實(shí)現(xiàn)啸罢。如果使用其他的方法實(shí)現(xiàn)替換已經(jīng)存在的方法實(shí)現(xiàn)，則原來(lái)存在的方法實(shí)現(xiàn)就會(huì)消失胎食。例如扰才，這里依然是增強(qiáng) Foo 類的 bar() 方法使其直接返回 "unknow" 字符串苏遥，增強(qiáng)結(jié)果如下：

class Foo { // 增強(qiáng)后的Foo定義
  String bar() { return "unknow"; }
}

常見(jiàn)類加載策略

通過(guò)增強(qiáng)之后朝墩，得到 DynamicType.Unloaded 對(duì)象，表示的是一個(gè)未加載的類型戴尸，通過(guò)在 ClassLoadingStrategy.Default中定義的加載策略粥航，加載此類型琅捏。

Class<?> loaded = new ByteBuddy()
        .subclass(Object.class)
        .name("com.xxx.Type")
        .make()
        // 使用 WRAPPER 策略加載生成的動(dòng)態(tài)類型
        .load(Main2.class.getClassLoader(), 
              ClassLoadingStrategy.Default.WRAPPER)
        .getLoaded();

• WRAPPER 策略：創(chuàng)建一個(gè)新的 ClassLoader 來(lái)加載動(dòng)態(tài)生成的類型。
• CHILD_FIRST 策略：創(chuàng)建一個(gè)子類優(yōu)先加載的 ClassLoader递雀，即打破了雙親委派模型柄延。
• INJECTION 策略：使用反射將動(dòng)態(tài)生成的類型直接注入到當(dāng)前 ClassLoader 中。

雙親委派模型：https://www.cnblogs.com/wxd0108/p/6681618.html

簡(jiǎn)單小栗子：toString

在實(shí)際應(yīng)用中動(dòng)態(tài)生成新類型的一般目的就是為了增強(qiáng)原始的方法缀程，下面通過(guò)一個(gè)示例展示 Byte Buddy 如何增強(qiáng) toString() 方法：

String str = new ByteBuddy() // 創(chuàng)建ByteBuddy對(duì)象
        .subclass(Object.class) // subclass增強(qiáng)方式
        .name("com.xxx.Type") // 新類型的類名
        // 攔截其中的toString()方法
        .method(ElementMatchers.named("toString")) 
        // 讓toString()方法返回固定值
        .intercept(FixedValue.value("Hello World!")) 
        .make()
        // 加載新類型搜吧，默認(rèn)WRAPPER策略
        .load(ByteBuddy.class.getClassLoader()) 
        .getLoaded()
        .newInstance() // 通過(guò) Java反射創(chuàng)建 com.xxx.Type實(shí)例
        .toString(); // 調(diào)用 toString()方法

System.out.println(str);

• 解析： method() 方法

method() 方法可以通過(guò)傳入的 ElementMatchers 參數(shù)匹配多個(gè)需要修改的方法，這里的 ElementMatchers.named("toString") 即為按照方法名匹配 toString() 方法杨凑。如果同時(shí)存在多個(gè)重載方法滤奈，則可以使用 ElementMatchers 其他 API 描述方法的簽名，如下所示：

ElementMatchers.named("toString") // 指定方法名稱
    .and(ElementMatchers.returns(String.class)) // 指定方法的返回值
    .and(ElementMatchers.takesArguments(0)) // 指定方法參數(shù)

• 解析：intercept() 方法

由 Intercept() 方法指定的 Implementation 對(duì)象決定如何增強(qiáng)撩满。這里的 FixValue.value() 會(huì)將方法的實(shí)現(xiàn)修改為固定值蜒程，上例中就是固定返回 “Hello World!” 字符串绅你。

關(guān)于method() 和 Intercept() 的攔截順序

Byte Buddy 會(huì)按照棧的順序來(lái)進(jìn)行攔截

這里 method() 方法出現(xiàn)了三次，且每次出現(xiàn)后面都跟著的 intercept() 方法使用的 Implementation 參數(shù)都不同搞糕。Byte Buddy 會(huì)按照棧的方式將后定義 method() 方法在棧頂勇吊，先定義的方法在棧底。在匹配方法的時(shí)候窍仰，按照下圖執(zhí)行出棧流程逐一匹配：

Foo dynamicFoo = new ByteBuddy()
  .subclass(Foo.class) 
  .method(isDeclaredBy(Foo.class)) // 匹配 Foo中所有的方法
  .intercept(FixedValue.value("One!")) 
  .method(named("foo")) // 匹配名為 foo的方法
  .intercept(FixedValue.value("Two!"))
  .method(named("foo").and(takesArguments(1))) // 匹配名為foo且只有一個(gè)
                                               // 參數(shù)的方法
  .intercept(FixedValue.value("Three!"))
  .make()
  .load(getClass().getClassLoader(), INJECTION)
  .getLoaded()
  .newInstance();

System.out.println(dynamicFoo.bar());
System.out.println(dynamicFoo.foo());
System.out.println(dynamicFoo.foo(null));

倒序匹配

image

輸出結(jié)果：

One!
Two!
Three!

MethodDelegation

將攔截到的目標(biāo)方法委托為另一個(gè)類去處理汉规。

// 方法攔截
String helloWorld = new ByteBuddy()
         .subclass(DB.class)
         .method(named("hello"))
         // 攔截DB.hello()方法，并委托給 Interceptor中的靜態(tài)方法處理
         .intercept(MethodDelegation.to(Interceptor.class))
         .make()
         .load(ClassLoader.getSystemClassLoader(), INJECTION)
         .getLoaded()
         .newInstance()
         .hello("World");
System.out.println(helloWorld);
// 委托類
class Interceptor {
    public static String intercept(String name) { return "String"; }
    public static String intercept(int i) { return "int"; }
    public static String intercept(Object o) { return "Object";}
}

Interceptor 中有三個(gè)方法驹吮，最終會(huì)委托給哪個(gè)方法呢针史？答案是 intercept(String name) 方法，委托并不是根據(jù)名稱來(lái)的碟狞，而是和 Java 編譯器在選重載時(shí)用的參數(shù)綁定類似啄枕。如果我們將 Intercept(String) 這個(gè)重載去掉，則 Byte Buddy 會(huì)選擇 Intercept(Object) 方法族沃。你可以嘗試執(zhí)行一下該示例频祝，得到的輸出分別是 String 和 Object。

四脆淹、Byte Buddy 基礎(chǔ)入門（skywalking中常見(jiàn)使用方式）-- 注解方式

除了通過(guò)上述 API 攔截方法并將方法實(shí)現(xiàn)委托給 Interceptor 增強(qiáng)之外常空，Byte Buddy 還提供了一些預(yù)定義的注解，通過(guò)這些注解我們可以告訴 Byte Buddy 將哪些需要的數(shù)據(jù)注入到 Interceptor 中

常用注解含義

• @RuntimeType 注解：告訴 Byte Buddy 不要進(jìn)行嚴(yán)格的參數(shù)類型檢測(cè)盖溺，在參數(shù)匹配失敗時(shí)漓糙，嘗試使用類型轉(zhuǎn)換方式（runtime type casting）進(jìn)行類型轉(zhuǎn)換，匹配相應(yīng)方法烘嘱。
• @This 注解：注入被攔截的目標(biāo)對(duì)象（即前面示例的 DB 對(duì)象）昆禽。
• @AllArguments 注解：注入目標(biāo)方法的全部參數(shù)，是不是感覺(jué)與 Java 反射的那套 API 有點(diǎn)類似了蝇庭？
• @Origin 注解：注入目標(biāo)方法對(duì)應(yīng)的 Method 對(duì)象醉鳖。如果攔截的是字段的話，該注解應(yīng)該標(biāo)注到 Field 類型參數(shù)哮内。
• @Super 注解：注入目標(biāo)對(duì)象辐棒。通過(guò)該對(duì)象可以調(diào)用目標(biāo)對(duì)象的所有方法。
• @SuperCall：這個(gè)注解比較特殊牍蜂，我們要在 intercept() 方法中調(diào)用目標(biāo)方法的話，需要通過(guò)這種方式注入泰涂，與 Spring AOP 中的 ProceedingJoinPoint.proceed() 方法有點(diǎn)類似鲫竞，需要注意的是，這里不能修改調(diào)用參數(shù)逼蒙，從上面的示例的調(diào)用也能看出來(lái)从绘，參數(shù)不用單獨(dú)傳遞，都包含在其中了。另外僵井，@SuperCall 注解還可以修飾 Runnable 類型的參數(shù)陕截，只不過(guò)目標(biāo)方法的返回值就拿不到了。

class Interceptor {
    @RuntimeType
    public Object intercept(
      @This Object obj, // 目標(biāo)對(duì)象
      @AllArguments Object[] allArguments, // 注入目標(biāo)方法的全部參數(shù)
      @SuperCall Callable<?> zuper, // 調(diào)用目標(biāo)方法批什，必不可少哦
      @Origin Method method, // 目標(biāo)方法
      @Super DB db // 目標(biāo)對(duì)象
    ) throws Exception {
        System.out.println(obj); 
        System.out.println(db);
        // 從上面兩行輸出可以看出，obj和db是一個(gè)對(duì)象
        try {
          return zuper.call(); // 調(diào)用目標(biāo)方法
        } finally {
        }
}

有一個(gè)地方需要注意驻债，這里定義的 Interceptor.intercept() 方法不是靜態(tài)方法乳规，而是一個(gè)實(shí)例方法暮的。前面示例中要委托到 Interceptor 的靜態(tài)方法冻辩，在 MethodDelegation.to() 方法中傳遞的參數(shù)是 Interceptor.class拆祈，這里要委托到 Interceptor 的實(shí)例方法需要在 MethodDelegation.to() 方法中傳遞

Interceptor 實(shí)例：

MethodDelegation.to(Interceptor.class) // 委托到 Interceptor的靜態(tài)方法

MethodDelegation.to(new Interceptor()) // 委托到 Interceptor的實(shí)例方法

@Morph與@SuperCall

@SuperCall 注解注入的 Callable 參數(shù)來(lái)調(diào)用目標(biāo)方法時(shí)缘屹，是無(wú)法動(dòng)態(tài)修改參數(shù)的轻姿，如果想要?jiǎng)討B(tài)修改參數(shù)，則需要用到 @Morph 注解以及一些綁定操作

String hello = new ByteBuddy()
    .subclass(DB.class)
    .method(named("hello"))
    .intercept(MethodDelegation.withDefaultConfiguration()
        .withBinders( 
            // 要用@Morph注解之前犁享，需要通過(guò) Morph.Binder 告訴 Byte Buddy 
            // 要注入的參數(shù)是什么類型
            Morph.Binder.install(OverrideCallable.class)
        )
        .to(new Interceptor()))
    .make()
    .load(Main.class.getClassLoader(), INJECTION)
    .getLoaded()
    .newInstance()
    .hello("World");

Interceptor 會(huì)使用 @Morph 注解注入一個(gè) OverrideCallable 對(duì)象作為參數(shù)炊昆，然后通過(guò)該 OverrideCallable 對(duì)象調(diào)用目標(biāo)方法

class Interceptor {
    @RuntimeType
    public Object intercept(@This Object obj,
          @AllArguments Object[] allArguments,// 注入目標(biāo)方法的全部參數(shù)
          @Origin Method method,
          @Super DB db,
          @Morph OverrideCallable callable // 通過(guò)@Morph注解注入
    ) throws Throwable {
        try {
            System.out.println("before");
            // 通過(guò) OverrideCallable.call()方法調(diào)用目標(biāo)方法凤巨，此時(shí)需要傳遞參數(shù)
            Object result = callable.call(allArguments);
            System.out.println("after");
            return result;
        } catch (Throwable t) {
            throw t;
        } finally {
            System.out.println("finally");
        }
    }
}
public interface OverrideCallable {
    Object call(Object[] args);
}

攔截構(gòu)造方法

class DB { // 只有一個(gè)有參數(shù)的構(gòu)造方法
    public DB(String name) { System.out.println("DB:" + name); }
}

class Interceptor { 
    @RuntimeType
    public void intercept(@This Object obj, 
                          @AllArguments Object[] allArguments) {
        System.out.println("after constructor!");
    }
}

Constructor<? extends DB> constructor = new ByteBuddy()
        .subclass(DB.class)
        .constructor(any()) // 通過(guò)constructor()方法攔截所有構(gòu)造方法
        // 攔截的操作：首先調(diào)用目標(biāo)對(duì)象的構(gòu)造方法，根據(jù)前面自動(dòng)匹配留美，
        // 這里直接匹配到參數(shù)為String.class的構(gòu)造方法
        .intercept(SuperMethodCall.INSTANCE.andThen(
            // 執(zhí)行完原始構(gòu)造方法，再開始執(zhí)行interceptor的代碼
           MethodDelegation.withDefaultConfiguration()
              .to(new Interceptor())
        )).make().load(Main.class.getClassLoader(), INJECTION)
        .getLoaded()
        .getConstructor(String.class); 
// 下面通過(guò)反射創(chuàng)建生成類型的對(duì)象
constructor.newInstance("MySQL")

SuperMethodCall 會(huì)在新生成的方法中先調(diào)用目標(biāo)方法逢倍，如果未找到目標(biāo)方法則拋出異常较雕，如果目標(biāo)方法是構(gòu)造方法郎笆，則根據(jù)方法簽名匹配宛蚓。

綜合例子

• defineMethod() 方法：新增方法。
• defineField() 方法：新增字段远舅。
• Implement() 方法：實(shí)現(xiàn)一個(gè)接口图柏。

interface DemoInterface{

    String get();

    void set(String name);

}

Class<? extends Foo> loaded = new ByteBuddy()
  .subclass(Foo.class)
  .defineMethod("moon", // 定義方法的名稱
          String.class,  // 方法的返回值
          Modifier.PUBLIC) // public修飾
  .withParameter(String.class, "s") // 新增方法的參數(shù)參數(shù)
  .intercept(FixedValue.value("Zero!")) // 方法的具體實(shí)現(xiàn)蚤吹，返回固定值
  // 新增一個(gè)字段裁着，該字段名稱成為"name"拱她，類型是 String秉沼，且public修飾
  .defineField("name", String.class, Modifier.PUBLIC)
  .implement(DemoInterface.class) // 實(shí)現(xiàn)DemoInterface接口
  // 實(shí)現(xiàn) DemoInterface接口的方式是讀寫name字段
  .intercept(FieldAccessor.ofField("name")) 
  .make().load(Main.class.getClassLoader(),
   ClassLoadingStrategy.Default.INJECTION)
  .getLoaded(); // 獲取加載后的Class

Foo dynamicFoo = loaded.newInstance(); // 反射
// 要調(diào)用新定義的doo()方法唬复，只能通過(guò)反射方式
Method m = loaded.getDeclaredMethod("moon", String.class);
System.out.println(m.invoke(dynamicFoo, new Object[]{""}));
Field field = loaded.getField("name"); // 通過(guò)反射方式讀寫新增的name字段
field.set(dynamicFoo, "Zero-Name"); 
System.out.println(field.get(dynamicFoo));
// 通過(guò)反射調(diào)用 DemoInterface接口中定義的get()和set()方法敞咧，讀取name字段的值
Method setNameMethod = loaded.getDeclaredMethod("set", String.class);
setNameMethod.invoke(dynamicFoo, new Object[]{"Zero-Name2"});
Method getNameMethod = loaded.getDeclaredMethod("get");
System.out.println(getNameMethod.invoke(dynamicFoo, new Object[]{}))
----------

輸出如下：
Zero!
Zero-Name
Zero

參考：

https://bytebuddy.net/#/tutorial