转载

Java字节码增强库ByteBuddy

1.什么是ByteBuddy ?

ByteBuddy 是一个强大的 Java 字节码操作库,主要应用场景包括以下几个方面:
  1. 动态代理和 AOP(面向切面编程)
    • ByteBuddy 可以用来创建动态代理,替代 Java 自带的 java.lang.reflect.Proxy,并且支持非接口类的代理。
    • 常用于 AOP 框架中,例如在方法执行前后插入逻辑,实现日志记录、事务管理、权限校验等功能。
  2. 字节码增强
    • 可以对已有类的字节码进行增强,比如添加字段、方法或改变方法行为。
    • 适合用在框架和工具开发中,例如 Hibernate、Spring 等框架都可以通过 ByteBuddy 动态生成增强后的类,增加特定功能。
  3. Mock 框架
    • 在测试中,ByteBuddy 可以用于创建类的 Mock 对象,模拟实际业务类的行为。
    • 一些 Mock 框架,如 Mockito 也集成了 ByteBuddy,用于动态代理和方法拦截。
  4. 编写 Java Agent
    • Java Agent 是一种在 JVM 启动时加载的工具,ByteBuddy 非常适合用来编写 Java Agent 进行类的加载时增强。
    • 常用于性能监控、日志记录和诊断工具,可以动态修改和增强应用程序中的类。
  5. 热加载和动态类加载
    • ByteBuddy 可以帮助实现类的热加载,即在运行时动态替换类或方法,这对实现零停机更新、应用调试非常有用。
  6. 自定义序列化和反序列化
    • 可以在序列化和反序列化过程中动态修改类的行为,适合自定义的序列化需求。
  7. 跨语言调用和兼容性处理
    • 在多语言环境中,ByteBuddy 可以用于动态生成和修改类,以便支持特定的跨语言调用需求,或调整应用程序以支持不同版本的 Java。

2.代码工程

实验目的:

  1. 实现类生成
  2. 方法拦截和增强

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>Java-demo</artifactId>
        <groupId>com.et</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>ByteBuddy</artifactId>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>net.bytebuddy</groupId>
            <artifactId>byte-buddy</artifactId>
            <version>1.14.5</version>
        </dependency>
        <dependency>
            <groupId>net.bytebuddy</groupId>
            <artifactId>byte-buddy-agent</artifactId>
            <version>1.14.5</version>
        </dependency>
    </dependencies>
</project>

动态生成类

package com.et;

import net.bytebuddy.ByteBuddy;
import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
import net.bytebuddy.implementation.FixedValue;

import static net.bytebuddy.matcher.ElementMatchers.named;

public class ByteBuddyExample {
    public static void main(String[] args) {
        try {
            // Use ByteBuddy to create a new class
            Class<?> dynamicType = new ByteBuddy()
                .subclass(Object.class) // Inherit from the Object class
                .name("com.example.HelloWorld") // Define the class name
                .method(named("toString")) // Define the method to intercept
                .intercept(FixedValue.value("Hello, ByteBuddy!")) // Method returns a fixed value
                .make()
                .load(ByteBuddyExample.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
                .getLoaded();

            // Create an instance of the class and call the toString method
            Object instance = dynamicType.getDeclaredConstructor().newInstance();
            System.out.println(instance.toString()); // Output: Hello, ByteBuddy!
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

详细解析

  1. new ByteBuddy()
    • 初始化 ByteBuddy 实例,用于创建新的类或修改现有类。
  2. subclass(Object.class)
    • 创建一个动态类并指定它继承自 Object 类。
  3. name("com.example.HelloWorld")
    • 定义新类的完整限定名为 com.example.HelloWorld
  4. method(named("toString"))
    • 使用 named("toString") 匹配器来选择 toString 方法,以便后续对该方法进行拦截和自定义。
    • named 是 ByteBuddy 的方法匹配器,允许按名称匹配方法。
  5. intercept(FixedValue.value("Hello, ByteBuddy!"))
    • 使用 FixedValue 指定 toString 方法的返回值为固定值 "Hello, ByteBuddy!"
    • intercept 表示拦截 toString 方法并定义其新行为。在这里,FixedValue.value("Hello, ByteBuddy!") 表示 toString 方法将始终返回 "Hello, ByteBuddy!"
  6. make()
    • 构建字节码,并生成包含动态类定义的 DynamicType.Unloaded 实例。
  7. load(ByteBuddyExample.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
    • 将动态生成的类加载到 JVM 中,使用 WRAPPER 加载策略确保类加载不会冲突。
    • ClassLoadingStrategy.Default.WRAPPER 创建一个类加载器包装,以安全地加载该类。
  8. getLoaded()
    • 返回已加载的类的 Class 对象,赋值给 dynamicType 变量。
  9. dynamicType.getDeclaredConstructor().newInstance()
    • 使用反射创建 HelloWorld 类的实例。
  10. instance.toString()
  • 调用 toString 方法。
  • 由于 toString 方法已被拦截并固定返回 "Hello, ByteBuddy!",因此输出结果将是 "Hello, ByteBuddy!"

方法拦截和增强

package com.et;

import net.bytebuddy.ByteBuddy;
import net.bytebuddy.implementation.MethodDelegation;
import net.bytebuddy.implementation.bind.annotation.BindingPriority;
import net.bytebuddy.matcher.ElementMatchers;

import java.lang.reflect.InvocationTargetException;

public class ByteBuddyProxyExample {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        // Create an original object
        Foo foo = new Foo();

        // Use ByteBuddy to create a proxy
        Foo proxy = (Foo) new ByteBuddy()
                .subclass(Foo.class)
                .method(ElementMatchers.any()) // Intercept all methods
                .intercept(MethodDelegation.to(new Interceptor())) // Delegate to the Interceptor class
                .make()
                .load(Foo.class.getClassLoader())
                .getLoaded()
                .getDeclaredConstructor()
                .newInstance();

        // Call the method
        System.out.println(proxy.sayHello());
    }

    public static class Foo {
        public String sayHello() {
            return "Hello from Foo";
        }
    }

    public static class Interceptor {
        @BindingPriority(3)
        public String sssintercept() {
            return "ssss";
        }

        @BindingPriority(2)
        public String intercept() {
            return "Hello from Interceptor";
        }

        public String intercept(String sss,String bbbb) {
            return " two parameters";
        }
    }
}

适配过程中的注意事项

  1. 使用 @BindingPriority
    • @BindingPriority 控制了多个候选方法的选择。当 Interceptor 中有多个方法符合条件时,优先级最高的将会执行。
    • 如果去掉 @BindingPriority,ByteBuddy 将根据默认优先级选择方法(通常是方法的声明顺序),或者在多个候选方法不明确时抛出异常。
  2. 方法签名匹配
    • ByteBuddy 根据方法签名匹配拦截方法。在 Interceptor 中添加重载方法时,只有签名精确匹配的方法才能成功拦截。
    • intercept(String, String) 方法有两个参数,但不会匹配 sayHello,因为 sayHello 没有参数。

代码执行流程

  1. 代理类创建:ByteBuddy 生成 Foo 类的代理子类 FooProxy
  2. 方法拦截和委托
    • 代理类的所有方法调用都被拦截,并按照 @BindingPriority 注解的优先级委托给 Interceptor 的方法。
    • 由于 sayHello 没有参数,因此它匹配 sssintercept()intercept(),但 sssintercept() 的优先级更高。
  3. 输出结果:调用 proxy.sayHello(),实际调用的是 Interceptor 中的 sssintercept(),因此输出 "ssss"

3.引用

 
正文到此结束
Loading...