一、为什么需要运行时代码生成

• java是强类型语言

变量与对象必须有一个明确的类型，如果在赋值操作中出现类型不兼容的情况，就会抛出异常。

• 发射解决：通用类编译期还不知道被调用者类型的问题

在对外提供一个通用 jar 包时，我们通常不能引用用户应用中定义的任何类型，因为当这个通用 jar 包被编译时，我们还不知道这些用户的自定义类型。为了调用用户自定义的类，访问其属性或方法，Java 类库提供了一套反射 API 帮助我们查找未知类型，以及调用其方法或字段。

Java 反射 API 有两个明显的缺点：

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

反射 API 能绕过类型安全检查，反射 API 自身并不是类型安全的。

• 字节码增强技术：模拟动态编程语言特性

运行时代码生成在 Java 应用启动之后再动态生成一些类定义，不丢失 Java 的强类型检查。

• 垃圾回收

在运行时生成代码需要特别注意的是 Java 类型被 JVM 加载之后，一般不会被垃圾被回收，因此不应该过度使用代码生成。

二、常见运行时代码生成技术

在 Java 的世界中，代码生成库不止 Byte Buddy 一个，以下代码生成库在 Java 中也很流行：

• Java Proxy

只能面对一个已经存在的接口，对类进行扩展的时候Proxy办不到

Java Proxy 是 JDK 自带的一个代理工具，它允许为实现了一系列接口的类生成代理类。Java Proxy 要求目标类必须实现接口是一个非常大限制，例如，在某些场景中，目标类没有实现任何接口且无法修改目标类的代码实现，Java Proxy 就无法对其进行扩展和增强了。

• CGLIB

年代久远，无人维护

CGLIB 诞生于 Java 初期，但不幸的是没有跟上 Java 平台的发展。虽然 CGLIB 本身是一个相当强大的库，但也变得越来越复杂。鉴于此，导致许多用户放弃了 CGLIB 。

• Javassist

自带一个相比javac弱小编译器，但是动态生成字节码时容易出错

Javassist 的使用对 Java 开发者来说是非常友好的，它使用Java 源代码字符串和 Javassist 提供的一些简单 API ，共同拼凑出用户想要的 Java 类，Javassist 自带一个编译器，拼凑好的 Java 类在程序运行时会被编译成为字节码并加载到 JVM 中。Javassist 库简单易用，而且使用 Java 语法构建类与平时写 Java 代码类似，但是 Javassist 编译器在性能上比不了 Javac 编译器，而且在动态组合字符串以实现比较复杂的逻辑时容易出错。

• Byte Buddy

Byte Buddy 提供了一种非常灵活且强大的领域特定语言，通过编写简单的 Java 代码即可创建自定义的运行时类。与此同时，Byte Buddy 还具有非常开放的定制性，能够应付不同复杂度的需求。

下表是 Byte Buddy 官网给出的数据，显示了上述代码生成库的基本性能，以纳秒为单位，标准偏差在括号内附加：

Byte Buddy设计理念

代码生成库需要在“生成快速的代码”与“快速生成代码”之间进行折中。Byte Buddy 折中的考虑是：类型动态创建不是程序中的常见步骤，并不会对长期运行的应用程序产生重大性能影响，但方法调用等操作却在程序中随处可见。所以，Byte Buddy 的主要侧重点在于生成更快速的代码。

三、Byte Buddy 基础入门（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>

三种动态增强方式

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

• subclass：对应 ByteBuddy.subclass() 方法。这种方式比较好理解，就是为目标类（即被增强的类）生成一个子类，在子类方法中插入动态代码。
• rebasing：对应 ByteBuddy.rebasing() 方法。当使用 rebasing 方式增强一个类时，Byte Buddy 保存目标类中所有方法的实现，也就是说，当 Byte Buddy 遇到冲突的字段或方法时，会将原来的字段或方法实现复制到具有兼容签名的重新命名的私有方法中，而不会抛弃这些字段和方法实现。从而达到不丢失实现的目的。这些重命名的方法可以继续通过重命名后的名称进行调用。例如：

class Foo { // Foo的原始定义

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

class Foo { // 增强后的Foo定义
  String bar() { return "foo" + bar$original(); }
// 目标类原有方法
  private String bar$original() { return "bar"; }

• redefinition：对应 ByteBuddy.redefine() 方法。当重定义一个类时，Byte Buddy 可以对一个已有的类添加属性和方法，或者删除已经存在的方法实现。如果使用其他的方法实现替换已经存在的方法实现，则原来存在的方法实现就会消失。例如，这里依然是增强 Foo 类的 bar() 方法使其直接返回 "unknow" 字符串，增强结果如下：

class Foo { // 增强后的Foo定义
  String bar() { return "unknow"; }
}

常见类加载策略

通过增强之后，得到 DynamicType.Unloaded 对象，表示的是一个未加载的类型，通过在 ClassLoadingStrategy.Default中定义的加载策略，加载此类型。

Class<?> loaded = new ByteBuddy()
        .subclass(Object.class)
        .name("com.xxx.Type")
        .make()
        // 使用 WRAPPER 策略加载生成的动态类型
        .load(Main2.class.getClassLoader(), 
              ClassLoadingStrategy.Default.WRAPPER)
        .getLoaded();

• WRAPPER 策略：创建一个新的 ClassLoader 来加载动态生成的类型。
• CHILD_FIRST 策略：创建一个子类优先加载的 ClassLoader，即打破了双亲委派模型。
• INJECTION 策略：使用反射将动态生成的类型直接注入到当前 ClassLoader 中。

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

简单小栗子：toString

在实际应用中动态生成新类型的一般目的就是为了增强原始的方法，下面通过一个示例展示 Byte Buddy 如何增强 toString() 方法：

String str = new ByteBuddy() // 创建ByteBuddy对象
        .subclass(Object.class) // subclass增强方式
        .name("com.xxx.Type") // 新类型的类名
        // 拦截其中的toString()方法
        .method(ElementMatchers.named("toString")) 
        // 让toString()方法返回固定值
        .intercept(FixedValue.value("Hello World!")) 
        .make()
        // 加载新类型，默认WRAPPER策略
        .load(ByteBuddy.class.getClassLoader()) 
        .getLoaded()
        .newInstance() // 通过 Java反射创建 com.xxx.Type实例
        .toString(); // 调用 toString()方法

System.out.println(str);

• 解析： method() 方法

method() 方法可以通过传入的 ElementMatchers 参数匹配多个需要修改的方法，这里的 ElementMatchers.named("toString") 即为按照方法名匹配 toString() 方法。如果同时存在多个重载方法，则可以使用 ElementMatchers 其他 API 描述方法的签名，如下所示：

ElementMatchers.named("toString") // 指定方法名称
    .and(ElementMatchers.returns(String.class)) // 指定方法的返回值
    .and(ElementMatchers.takesArguments(0)) // 指定方法参数

• 解析：intercept() 方法

由 Intercept() 方法指定的 Implementation 对象决定如何增强。这里的 FixValue.value() 会将方法的实现修改为固定值，上例中就是固定返回 “Hello World!” 字符串。

关于method() 和 Intercept() 的拦截顺序

Byte Buddy 会按照栈的顺序来进行拦截

这里 method() 方法出现了三次，且每次出现后面都跟着的 intercept() 方法使用的 Implementation 参数都不同。Byte Buddy 会按照栈的方式将后定义 method() 方法在栈顶，先定义的方法在栈底。在匹配方法的时候，按照下图执行出栈流程逐一匹配：

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且只有一个
                                               // 参数的方法
  .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

输出结果：

One!
Two!
Three!

MethodDelegation

将拦截到的目标方法委托为另一个类去处理。

// 方法拦截
String helloWorld = new ByteBuddy()
         .subclass(DB.class)
         .method(named("hello"))
         // 拦截DB.hello()方法，并委托给 Interceptor中的静态方法处理
         .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 中有三个方法，最终会委托给哪个方法呢？答案是 intercept(String name) 方法，委托并不是根据名称来的，而是和 Java 编译器在选重载时用的参数绑定类似。如果我们将 Intercept(String) 这个重载去掉，则 Byte Buddy 会选择 Intercept(Object) 方法。你可以尝试执行一下该示例，得到的输出分别是 String 和 Object。

四、Byte Buddy 基础入门（skywalking中常见使用方式）-- 注解方式

除了通过上述 API 拦截方法并将方法实现委托给 Interceptor 增强之外，Byte Buddy 还提供了一些预定义的注解，通过这些注解我们可以告诉 Byte Buddy 将哪些需要的数据注入到 Interceptor 中

常用注解含义

• @RuntimeType 注解：告诉 Byte Buddy 不要进行严格的参数类型检测，在参数匹配失败时，尝试使用类型转换方式（runtime type casting）进行类型转换，匹配相应方法。
• @This 注解：注入被拦截的目标对象（即前面示例的 DB 对象）。
• @AllArguments 注解：注入目标方法的全部参数，是不是感觉与 Java 反射的那套 API 有点类似了？
• @Origin 注解：注入目标方法对应的 Method 对象。如果拦截的是字段的话，该注解应该标注到 Field 类型参数。
• @Super 注解：注入目标对象。通过该对象可以调用目标对象的所有方法。
• @SuperCall：这个注解比较特殊，我们要在 intercept() 方法中调用目标方法的话，需要通过这种方式注入，与 Spring AOP 中的 ProceedingJoinPoint.proceed() 方法有点类似，需要注意的是，这里不能修改调用参数，从上面的示例的调用也能看出来，参数不用单独传递，都包含在其中了。另外，@SuperCall 注解还可以修饰 Runnable 类型的参数，只不过目标方法的返回值就拿不到了。

class Interceptor {
    @RuntimeType
    public Object intercept(
      @This Object obj, // 目标对象
      @AllArguments Object[] allArguments, // 注入目标方法的全部参数
      @SuperCall Callable<?> zuper, // 调用目标方法，必不可少哦
      @Origin Method method, // 目标方法
      @Super DB db // 目标对象
    ) throws Exception {
        System.out.println(obj); 
        System.out.println(db);
        // 从上面两行输出可以看出，obj和db是一个对象
        try {
          return zuper.call(); // 调用目标方法
        } finally {
        }
}

有一个地方需要注意，这里定义的 Interceptor.intercept() 方法不是静态方法，而是一个实例方法。前面示例中要委托到 Interceptor 的静态方法，在 MethodDelegation.to() 方法中传递的参数是 Interceptor.class，这里要委托到 Interceptor 的实例方法需要在 MethodDelegation.to() 方法中传递

Interceptor 实例：

MethodDelegation.to(Interceptor.class) // 委托到 Interceptor的静态方法

MethodDelegation.to(new Interceptor()) // 委托到 Interceptor的实例方法

@Morph与@SuperCall

@SuperCall 注解注入的 Callable 参数来调用目标方法时，是无法动态修改参数的，如果想要动态修改参数，则需要用到 @Morph 注解以及一些绑定操作

String hello = new ByteBuddy()
    .subclass(DB.class)
    .method(named("hello"))
    .intercept(MethodDelegation.withDefaultConfiguration()
        .withBinders( 
            // 要用@Morph注解之前，需要通过 Morph.Binder 告诉 Byte Buddy 
            // 要注入的参数是什么类型
            Morph.Binder.install(OverrideCallable.class)
        )
        .to(new Interceptor()))
    .make()
    .load(Main.class.getClassLoader(), INJECTION)
    .getLoaded()
    .newInstance()
    .hello("World");

Interceptor 会使用 @Morph 注解注入一个 OverrideCallable 对象作为参数，然后通过该 OverrideCallable 对象调用目标方法

class Interceptor {
    @RuntimeType
    public Object intercept(@This Object obj,
          @AllArguments Object[] allArguments,// 注入目标方法的全部参数
          @Origin Method method,
          @Super DB db,
          @Morph OverrideCallable callable // 通过@Morph注解注入
    ) throws Throwable {
        try {
            System.out.println("before");
            // 通过 OverrideCallable.call()方法调用目标方法，此时需要传递参数
            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);
}

拦截构造方法

class DB { // 只有一个有参数的构造方法
    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()方法拦截所有构造方法
        // 拦截的操作：首先调用目标对象的构造方法，根据前面自动匹配，
        // 这里直接匹配到参数为String.class的构造方法
        .intercept(SuperMethodCall.INSTANCE.andThen(
            // 执行完原始构造方法，再开始执行interceptor的代码
           MethodDelegation.withDefaultConfiguration()
              .to(new Interceptor())
        )).make().load(Main.class.getClassLoader(), INJECTION)
        .getLoaded()
        .getConstructor(String.class); 
// 下面通过反射创建生成类型的对象
constructor.newInstance("MySQL")

SuperMethodCall 会在新生成的方法中先调用目标方法，如果未找到目标方法则抛出异常，如果目标方法是构造方法，则根据方法签名匹配。

综合例子

• defineMethod() 方法：新增方法。
• defineField() 方法：新增字段。
• Implement() 方法：实现一个接口。

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") // 新增方法的参数参数
  .intercept(FixedValue.value("Zero!")) // 方法的具体实现，返回固定值
  // 新增一个字段，该字段名称成为"name"，类型是 String，且public修饰
  .defineField("name", String.class, Modifier.PUBLIC)
  .implement(DemoInterface.class) // 实现DemoInterface接口
  // 实现 DemoInterface接口的方式是读写name字段
  .intercept(FieldAccessor.ofField("name")) 
  .make().load(Main.class.getClassLoader(),
   ClassLoadingStrategy.Default.INJECTION)
  .getLoaded(); // 获取加载后的Class

Foo dynamicFoo = loaded.newInstance(); // 反射
// 要调用新定义的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));
// 通过反射调用 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