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

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

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

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

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

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

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

反射 API 能繞過類型安全檢查，反射 API 自身并不是類型安全的。

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

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

• 垃圾回收

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

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

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

• Java Proxy

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

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

• CGLIB

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

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

• Javassist

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

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

• Byte Buddy

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

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

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

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

三、Byte Buddy 基礎(chǔ)入門（skywalking中常見使用方式）-- 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：對應(yīng) ByteBuddy.subclass() 方法。這種方式比較好理解，就是為目標(biāo)類（即被增強(qiáng)的類）生成一個(gè)子類，在子類方法中插入動(dòng)態(tài)代碼。
• rebasing：對應(yīng) ByteBuddy.rebasing() 方法。當(dāng)使用 rebasing 方式增強(qiáng)一個(gè)類時(shí)，Byte Buddy 保存目標(biāo)類中所有方法的實(shí)現(xiàn)，也就是說，當(dāng) Byte Buddy 遇到?jīng)_突的字段或方法時(shí)，會將原來的字段或方法實(shí)現(xiàn)復(fù)制到具有兼容簽名的重新命名的私有方法中，而不會拋棄這些字段和方法實(shí)現(xiàn)。從而達(dá)到不丟失實(shí)現(xiàn)的目的。這些重命名的方法可以繼續(xù)通過重命名后的名稱進(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：對應(yīng) ByteBuddy.redefine() 方法。當(dāng)重定義一個(gè)類時(shí)，Byte Buddy 可以對一個(gè)已有的類添加屬性和方法，或者刪除已經(jīng)存在的方法實(shí)現(xiàn)。如果使用其他的方法實(shí)現(xiàn)替換已經(jīng)存在的方法實(shí)現(xiàn)，則原來存在的方法實(shí)現(xiàn)就會消失。例如，這里依然是增強(qiáng) Foo 類的 bar() 方法使其直接返回 "unknow" 字符串，增強(qiáng)結(jié)果如下：

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

常見類加載策略

通過增強(qiáng)之后，得到 DynamicType.Unloaded 對象，表示的是一個(gè)未加載的類型，通過在 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 來加載動(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

簡單小栗子：toString

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

String str = new ByteBuddy() // 創(chuàng)建ByteBuddy對象
        .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() // 通過 Java反射創(chuàng)建 com.xxx.Type實(shí)例
        .toString(); // 調(diào)用 toString()方法

System.out.println(str);

• 解析： method() 方法

method() 方法可以通過傳入的 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 對象決定如何增強(qiáng)。這里的 FixValue.value() 會將方法的實(shí)現(xiàn)修改為固定值，上例中就是固定返回 “Hello World!” 字符串。

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

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

這里 method() 方法出現(xiàn)了三次，且每次出現(xiàn)后面都跟著的 intercept() 方法使用的 Implementation 參數(shù)都不同。Byte Buddy 會按照棧的方式將后定義 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è)方法，最終會委托給哪個(gè)方法呢？答案是 intercept(String name) 方法，委托并不是根據(jù)名稱來的，而是和 Java 編譯器在選重載時(shí)用的參數(shù)綁定類似。如果我們將 Intercept(String) 這個(gè)重載去掉，則 Byte Buddy 會選擇 Intercept(Object) 方法。你可以嘗試執(zhí)行一下該示例，得到的輸出分別是 String 和 Object。

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

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

常用注解含義

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

class Interceptor {
    @RuntimeType
    public Object intercept(
      @This Object obj, // 目標(biāo)對象
      @AllArguments Object[] allArguments, // 注入目標(biāo)方法的全部參數(shù)
      @SuperCall Callable<?> zuper, // 調(diào)用目標(biāo)方法，必不可少哦
      @Origin Method method, // 目標(biāo)方法
      @Super DB db // 目標(biāo)對象
    ) throws Exception {
        System.out.println(obj); 
        System.out.println(db);
        // 從上面兩行輸出可以看出，obj和db是一個(gè)對象
        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ù)來調(diào)用目標(biāo)方法時(shí)，是無法動(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注解之前，需要通過 Morph.Binder 告訴 Byte Buddy 
            // 要注入的參數(shù)是什么類型
            Morph.Binder.install(OverrideCallable.class)
        )
        .to(new Interceptor()))
    .make()
    .load(Main.class.getClassLoader(), INJECTION)
    .getLoaded()
    .newInstance()
    .hello("World");

Interceptor 會使用 @Morph 注解注入一個(gè) OverrideCallable 對象作為參數(shù)，然后通過該 OverrideCallable 對象調(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 // 通過@Morph注解注入
    ) throws Throwable {
        try {
            System.out.println("before");
            // 通過 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()) // 通過constructor()方法攔截所有構(gòu)造方法
        // 攔截的操作：首先調(diào)用目標(biāo)對象的構(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); 
// 下面通過反射創(chuàng)建生成類型的對象
constructor.newInstance("MySQL")

SuperMethodCall 會在新生成的方法中先調(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()方法，只能通過反射方式
Method m = loaded.getDeclaredMethod("moon", String.class);
System.out.println(m.invoke(dynamicFoo, new Object[]{""}));
Field field = loaded.getField("name"); // 通過反射方式讀寫新增的name字段
field.set(dynamicFoo, "Zero-Name"); 
System.out.println(field.get(dynamicFoo));
// 通過反射調(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