ByteBuddy使用手册

Byte Buddy是一个字节码生成和操作库，用于在Java应用程序运行时创建和修改Java类，而无需编译器的帮助。除了Java类库附带的代码生成实用程序外，Byte Buddy还允许创建任意类，并且不限于实现用于创建运行时代理的接口。此外，Byte Buddy提供了一种方便的API，可以使用Java代理或在构建过程中手动更改类。

无需理解字节码指令，即可使用简单的 API 就能很容易操作字节码，控制类和方法。
比起JDK动态代理、cglib、Javassist，Byte Buddy在使用上更简单，更便捷。

1. 引入jar包

在maven的pom.xml中引入bytebuddy的依赖。

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

2. 动态创建类

DynamicType.Unloaded<Object> unloaded = new ByteBuddy()
        .subclass(Object.class)
        .name("com.bytbuddy.DynmicClass")
        .method(ElementMatchers.isToString())
        .intercept(FixedValue.value("Hello world"))
        .make();
Class<?> dynmicClass = unloaded.load(CustomClass.class.getClassLoader()).getLoaded();
Object instance = dynmicClass.newInstance();
Method toStr = dynmicClass.getMethod("toString");
System.out.println(toStr.invoke(instance));

通过ByteBuddy动态创建DynmicClass类，并拦截toString方法，修改返回值。

subClass: 指定继承的父类

name: 指定生成的类名

method: 方法筛选器，选择toString方法

intercept: 拦截器，拦截toString方法，并返回固定值

unloaded：未加载的类的处理。

3. 创建方法和字段

public class Test3 {
    public static void main(String[] args) {
        try{
            Class<?> type = new ByteBuddy()
                    .subclass(Object.class)
                    .name("com.bytbuddy.MyClassName")
                    .defineMethod("custom", String.class, Modifier.PUBLIC)
                    .intercept(MethodDelegation.to(Bar.class))
                    .defineField("name", String.class, Modifier.PUBLIC)
                    .defineMethod("getName",String.class,Modifier.PUBLIC)
                    .intercept(FixedValue.value("zhang san"))
                    .make()
                    .load(Test3.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
                    .getLoaded();

            Method m = type.getDeclaredMethod("custom", null);
            Method getName = type.getDeclaredMethod("getName", null);
            System.out.println(m.invoke(type.newInstance()));
            System.out.println(type.getDeclaredField("name"));
            System.out.println(getName.invoke(type.newInstance()));
        }catch (Exception e){
            e.printStackTrace();
        }

    }


    public static class Bar {
        public static String sayHelloBar() {
            return "Holla in Bar!";
        }
    }

defineMethod： 重新定义一个方法，设置返回类型和访问权限

.intercept(MethodDelegation.to(Bar.class))： 方法代理，方法的实现委托给Bar.class实现

defineField： 定义一个名为name的字段

4. Redefine

重写顾明思议就是可以对一个现有类的属性、方法进行增、删、改

public class Foo {
    String bar() {
        return "foo";
    }
}

public class Bar {
    String bar() {
        return "bar";
    }

}

ByteBuddyAgent.install();
new ByteBuddy()
        .redefine(Foo.class)
        .method(ElementMatchers.named("bar"))
        .intercept(FixedValue.value("Hello Foo Redefined"))
        .make()
        .load(
                Foo.class.getClassLoader(),
                ClassReloadingStrategy.fromInstalledAgent());

Foo f = new Foo();
System.out.println(f.bar());

5. Java Agent

public class Agent {
    public static void premain(String arguments,
                               Instrumentation instrumentation) {
        new AgentBuilder.Default()
                .type(ElementMatchers.nameEndsWith("invoke"))
                .transform((builder, type, classLoader, module) ->
                        builder.method(ElementMatchers.any())
                                .intercept(MethodDelegation.to(TimingInterceptor.class))
                ).installOn(instrumentation);
    }
}

public class TimingInterceptor {
    @RuntimeType
    public static Object intercept(Method method, Callable<?> callable) {
        long start = System.currentTimeMillis();
        try {
            return callable.call();
        }catch (Exception e){
            e.printStackTrace();
        }
        finally {
            System.out.println(method + " took " + (System.currentTimeMillis() - start));
        }
        return null;
    }
}

实现SpringMVC中的AOP机制

实现统计方法的执行时间

public class Agent {
    public static void premain(String arguments,
                               Instrumentation instrumentation) {
        new AgentBuilder.Default()
                .ignore(nameStartsWith("org.aspectj."))
                .or(nameStartsWith("org.groovy."))
                .or(nameStartsWith("com.sun."))
                .or(nameStartsWith("sun."))
                .or(nameStartsWith("jdk."))
                .or(nameStartsWith("org.springframework.asm."))
                .or(nameStartsWith("com.p6spy."))
                .or(nameStartsWith("net.bytebuddy."))
                .type(nameStartsWith("com.test")) //以com.开头的包会注入
                .transform((builder, type, classLoader, module) ->
                        builder.method(ElementMatchers.any())
                                .intercept(MethodDelegation.to(TimingInterceptor.class))
                ).installOn(instrumentation);
    }
}

public class TimingInterceptor {
    @RuntimeType
    public static Object intercept(@Origin Method method,  @SuperCall Callable<?> callable) {
        long start = System.currentTimeMillis();
        try {
            return callable.call();
        }catch (Exception e){
            e.printStackTrace();
        }
        finally {
            System.out.println(method + " took " + (System.currentTimeMillis() - start));
        }
        return null;
    }
}