字节码进阶之javassist字节码操作类库详解

字节码进阶之javassist字节码操作类库详解

前言

Javassist（Java programming assistant）是一个开源的分析、编辑和创建Java字节码的库。它是Java反射API的一个替代品，用于动态创建和操纵Java类。本章我们聊聊如何使用Javassist字节码操作类库。

使用教程

添加Javassist依赖库

要使用Javassist，我们首先需要在项目中添加Javassist依赖库。如果你使用Maven，可以在pom.xml中添加以下依赖：

<dependency>
    <groupId>org.javassistgroupId>
    <artifactId>javassistartifactId>
    <version>LATEST_VERSIONversion>
dependency>
1
2
3
4
5

创建和修改类

使用Javassist创建和修改类的基本步骤如下：

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.makeClass("com.example.SampleClass");

// 添加私有变量
CtField privateField = new CtField(pool.get("java.lang.String"), "privateField", cc);
privateField.setModifiers(Modifier.PRIVATE);
cc.addField(privateField);

// 添加公共方法
CtMethod publicMethod = new CtMethod(CtClass.voidType,"publicMethod",new CtClass[]{},cc);
publicMethod.setModifiers(Modifier.PUBLIC);
publicMethod.setBody("{ System.out.println(\"Public method called\"); }");
cc.addMethod(publicMethod);

cc.writeFile("/path/to/write/bytecode"); // 将字节码写入文件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

方法拦截

使用Javassist可以拦截方法的调用，例如，我们可以在方法调用前后添加日志代码：

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("com.example.SampleClass");
CtMethod m = cc.getDeclaredMethod("sampleMethod");

m.insertBefore("{ System.out.println(\"Before method execution\"); }");
m.insertAfter("{ System.out.println(\"After method execution\"); }");
1
2
3
4
5
6

创建新的方法

Javassist也可以用来创建新的方法并添加到现有的类中：

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("com.example.SampleClass");

CtMethod newMethod = new CtMethod(CtClass.voidType, "newMethod", new CtClass[]{}, cc);
newMethod.setBody("{ System.out.println(\"New method created\"); }");

cc.addMethod(newMethod);
1
2
3
4
5
6
7

这只是Javassist的基本使用。Javassist还有许多其他功能和高级技术，例如创建新的注解、创建新的接口等。总的来说，Javassist是一个非常强大的字节码操作库，它能提供直接操作字节码的能力，让Java开发者可以更深入地理解和使用Java字节码。

进阶用法

Javassist是一个强大的字节码操作库，除了基础的创建和修改类、方法拦截和创建新的方法等功能外，还有一些高级用法，如创建新的注解、创建新的接口、创建新的构造器、生成动态代理等。这篇文章将详细介绍这些高级用法。

创建新的注解

使用Javassist创建新的注解的基本步骤如下：

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.makeClass("com.example.SampleAnnotation");

cc.setModifiers(Modifier.PUBLIC | Modifier.ABSTRACT | Modifier.INTERFACE | Modifier.ANNOTATION);

// 添加注解属性
CtMethod method = CtMethod.make("public abstract String value();", cc);
cc.addMethod(method);
1
2
3
4
5
6
7
8

这段代码将创建一个名为SampleAnnotation的注解，并添加一个返回字符串的value()方法。

创建新的接口

使用Javassist创建新的接口的基本步骤如下：

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.makeInterface("com.example.SampleInterface");

// 添加接口方法
CtMethod method = CtMethod.make("public void sampleMethod();", cc);
cc.addMethod(method);
1
2
3
4
5
6

这段代码将创建一个名为SampleInterface的接口，并添加一个名为sampleMethod的方法。

创建新的构造器

使用Javassist创建新的构造器的基本步骤如下：

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("com.example.SampleClass");

// 添加构造器
CtConstructor ctConstructor = new CtConstructor(new CtClass[]{pool.get("java.lang.String")}, cc);
ctConstructor.setBody("{this.field = $1;}");
cc.addConstructor(ctConstructor);
1
2
3
4
5
6
7

这段代码将在SampleClass类中添加一个接收一个字符串参数的构造器，并将输入的字符串赋值给field字段。

生成动态代理

Javassist也可以用来生成动态代理：

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.makeClass("com.example.SampleProxy");
cc.setInterfaces(new CtClass[]{pool.get("com.example.SampleInterface")});

// 添加方法
CtMethod method = CtMethod.make("public void sampleMethod() { System.out.println(\"Method executed\"); }", cc);
cc.addMethod(method);

// 实例化并调用方法
Object instance = cc.toClass().newInstance();
((SampleInterface) instance).sampleMethod();
1
2
3
4
5
6
7
8
9
10
11

这段代码将创建一个实现SampleInterface接口的动态代理类SampleProxy，并添加一个实现sampleMethod的方法。

以上就是Javassist的一部分高级用法。通过Javassist，我们不仅可以在运行时动态修改类和方法，还可以创建新的注解、接口、构造器和动态代理，无论是用于代码生成，还是动态AOP，都非常方便。

修改方法

演示如何使用 Javassist 创建一个简单的 “Person” 类，并向其中添加一个带有 getter 和 setter 的 name 属性，以及一个打印出 "Hello, my name is " 和 name 属性值的 sayHello 方法。

import javassist.*;

public class JavassistExample {
    public static void main(String[] args) throws Exception {
        // 1. 获取 ClassPool
        ClassPool pool = ClassPool.getDefault();

        // 2. 创建 Person 类
        CtClass personClass = pool.makeClass("Person");

        // 3. 添加一个私有 name 字段
        CtField nameField = new CtField(pool.get("java.lang.String"), "name", personClass);
        nameField.setModifiers(Modifier.PRIVATE);
        personClass.addField(nameField);

        // 4. 添加一个 getter 方法
        personClass.addMethod(CtNewMethod.getter("getName", nameField));

        // 5. 添加一个 setter 方法
        personClass.addMethod(CtNewMethod.setter("setName", nameField));

        // 6. 添加一个 sayHello 方法
        CtMethod sayHelloMethod = CtNewMethod.make(
                "public void sayHello() { System.out.println(\"Hello, my name is \" + name); }",
                personClass);
        personClass.addMethod(sayHelloMethod);

        // 7. 将修改后的 Person 类字节码写入文件
        personClass.writeFile();

        // 8. 使用反射加载并实例化 Person 类
        Class<?> personJavaClass = personClass.toClass();
        Object personInstance = personJavaClass.getDeclaredConstructor().newInstance();

        // 9. 通过反射调用 setName 方法
        personJavaClass.getMethod("setName", String.class).invoke(personInstance, "John Doe");

        // 10. 通过反射调用 sayHello 方法
        personJavaClass.getMethod("sayHello").invoke(personInstance);

        // 11. 通过反射调用 getName 方法并输出
        String name = (String) personJavaClass.getMethod("getName").invoke(personInstance);
        System.out.println("Name from getter: " + name);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

运行此代码后，您将看到以下输出：

Hello, my name is John Doe
Name from getter: John Doe
1
2

这个示例创建了一个名为 “Person” 的类，并向其中添加了一个名为 “name” 的私有字符串字段，以及 getName 和 setName 的 getter 和 setter 方法。此外，还添加了一个 sayHello 方法，该方法在调用时将输出 “Hello, my name is” 和 name 字段的值。然后使用反射实例化创建的类，并调用其方法来演示如何使用 Javassist 生成的类。

示例2

假设我们有一个场景：我们需要创建一个动态代理，代理的接口名为"com.example.SampleInterface"，接口中有一个无参数的方法"display"，动态代理类需要实现该方法，并在方法调用时打印"Hello, world!"。

使用Javassist，我们可以这样实现：

import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;
import javassist.CtNewMethod;

public class JavassistExample {
    public static void main(String[] args) throws Exception {
        // 创建ClassPool
        ClassPool pool = ClassPool.getDefault();

        // 创建接口
        CtClass ctInterface = pool.makeInterface("com.example.SampleInterface");
        // 为接口添加方法
        CtMethod interfaceMethod = CtNewMethod.make("public void display();", ctInterface);
        ctInterface.addMethod(interfaceMethod);
        // 把接口写入文件，以便我们可以看到它
        ctInterface.writeFile("./");

        // 创建代理类
        CtClass ctProxyClass = pool.makeClass("com.example.SampleProxy");
        // 设置接口
        ctProxyClass.setInterfaces(new CtClass[]{ctInterface});
        // 为动态代理类创建方法
        CtMethod proxyMethod = CtNewMethod.make("public void display() { System.out.println(\"Hello, world!\"); }", ctProxyClass);
        ctProxyClass.addMethod(proxyMethod);
        // 把代理类写入文件
        ctProxyClass.writeFile("./");

        // 加载并实例化代理类
        Class<?> proxyClass = ctProxyClass.toClass();
        Object proxyInstance = proxyClass.newInstance();

        // 调用代理类的方法
        SampleInterface sampleInterface = (SampleInterface) proxyInstance;
        sampleInterface.display();
    }
}

interface SampleInterface {
    void display();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

运行这个程序，我们可以看到控制台打印出"Hello, world!"。

使用Javassist创建接口和动态代理，以及如何实现接口的方法。虽然这个例子比较简单，但是它展示了Javassist的基本使用方法。在实际项目中，我们可以根据需要创建更复杂的接口和动态代理。