基于javassist处理java字节码（一）

0 前言

为了用更少的代码响应多样的、易变的外部需求，java提供了运行时生成、修改、增强java类字节码的能力，这一项能力在很多框架（如spring framework）、中间件（如hikariCP）软件中大放异彩。相比于ASM（assemble的缩写，名称来自于C语言的asm关键字）、CGLIB（Code Generation LIBrary）等老牌且广泛流行的字节码查看和编辑工具，javassist（Java Programming Assistant）提供了更易于学习、使用的接口和方式来处理java字节码。使用者通过自己非常熟悉的java语言代码、基于类对象交互方式来操作字节码，从而屏蔽了底层class文件的结构细节，就像开发普通程序一样实现字节码编辑的高级功能。javassist极大的提高了基于字节码开发的效率，降低了学习曲线，且保证了较高的性能。性能仅略低于ASM，高于CGLIB，远远高于JDK自带的动态代理（dynamic proxy，几十倍的差距）

1 javassist包

要使用javassist，只要在项目中添加相应的依赖即可，maven依赖（当前最新版本是3.28.0-GA）如下：

        
        
            org.javassist
            javassist
            3.28.0-GA
        

2 创建一个类

下面的代码创建了一个Animal类，并给这个类添加了一个name字段，以及name字段的setter()、getter()方法，同时分别添加了一个无参和有参构造函数，添加了一个void printName()方法，实现打印Animal类对象name字段值的功能。最后将创建的类写入class file文件

package com.javatest.javassist;

import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtConstructor;
import javassist.CtField;
import javassist.CtMethod;
import javassist.CtNewMethod;
import javassist.Modifier;


public class JavassistMain {

    public static void main(String []args) {

        try {
         // 1. ClassPool相当于一个存储、管理javassist class字节码的容器
        ClassPool pool = ClassPool.getDefault();

        // 2. 创建一个空类，类的全限定名为 com.javatest.javassist.Animal
        CtClass cc = pool.makeClass("com.javatest.javassist.Animal");

        // 3. 新增一个字段
        CtField nameField = CtField.make("private String name;", cc);
        cc.addField(nameField);

        // 4. 添加无参的构造函数
        CtConstructor cons = new CtConstructor(new CtClass[]{}, cc);
        // 构造函数的内容
        cons.setBody("{name = \"tiger\";}");
        cc.addConstructor(cons);

        // 5. 添加有参的构造函数
        cons = new CtConstructor(new CtClass[]{pool.get("java.lang.String")}, cc);
        // $0=this / $1,$2,$3... 代表方法参数
        cons.setBody("{$0.name = $1;}");
        cc.addConstructor(cons);

        // 6. 添加字段的getter、setter方法
        cc.addMethod(CtNewMethod.setter("setName", nameField));
        cc.addMethod(CtNewMethod.getter("getName", nameField));

        // 7. 创建一个名为printName方法，无参数，无返回值，输出name值
        CtMethod ctMethod = new CtMethod(CtClass.voidType, "printName", new CtClass[]{}, cc);
        ctMethod.setModifiers(Modifier.PUBLIC);
        ctMethod.setBody("{System.out.println(name);}");
        cc.addMethod(ctMethod);

        // 8. 生成class file文件，写入项目当前工作目录下
        cc.writeFile("./");

        } catch (Exception e) {
            // 
        }

    }
}

执行上面的代码，会在当前目录的子目录com/javatest/javassist下生成一个名为Animal.class的文件，通过反编译可查看class文件对应的代码如下：

package com.javatest.javassist;

public class Animal {
    private String name;

    public Animal() {
        this.name = "tiger";
    }

    public Animal(String var1) {
        this.name = var1;
    }

    public void setName(String var1) {
        this.name = var1;
    }

    public String getName() {
        return this.name;
    }

    public void printName() {
        System.out.println(this.name);
    }
}

3 加载使用创建的class

class完成编辑后，我们可以像上面例子一样将字节码写入class file中：

cc.writeFile("./");

也可以转成字节码序列，提供给应用程序其他部分使用（比如一个类加载器）或通过网络发送给一个远程服务，下面的例子跟上面的效果相同

    // 转换成字节码
    byte[] b = cc.toBytecode();
    OutputStream o = new FileOutputStream("./javassist");
    o.write(b);
    o.close();

或者通过当前线程的上下文类加载器直接将CtClass代表的class file加载到JVM中：

    Class clazz = cc.toClass();

这样我们可以通过反射的方式创建类的实例和调用实例方法：

    Object tiger = clazz.newInstance();
    Method method = clazz.getMethod("printName");
    method.invoke(tiger);

但是通过反射调用一方面编码比较繁琐，性能也不理想，更好的方式是先定义一个接口：

package com.javatest.javassist;

public interface AnimalPrinter {

    void printName();
}

然后让创建的class实现这个接口，在上面的例子中增加创建CtClass后设置它实现的接口：

    CtClass cc = pool.makeClass("com.javatest.javassist.Animal");
    cc.addInterface(pool.get("com.javatest.javassist.AnimalPrinter"));

然后便可以通过接口直接调用

    AnimalPrinter printer = (AnimalPrinter) clazz.newInstance();
    printer.printName();

4 javassist基本使用方法

我们知道，一个java类由类声明本身、字段、构造函数、方法等元素组成。从上面的基本例子可以看出，javassist为java类的这些组成元素分别设计了相应的类CtClass、CtField、CtConstructor、CtMethod，我们就是通过这些类来处理java class字节码的。这些类名的前缀Ct是compile time的缩写，表示这些类代表的是javassist管理的编译时的字节码，需要加载到JVM中才能使用。

4.1 ClassPool

ClassPool用来存储和管理class字节码对象，它相当于一个容器，里面维护了一个Map，key为class的全限定名，value为CtClass对象。熟悉spring的朋友可以用spring容器这个概念来做类比。

我们可以通过静态方法ClassPool.getDefault()获取一个单例的ClassPool对象，也可以通过ClassPool pool = new ClassPool()创建新的ClassPool对象；如果需要，我们还可以创建一个ClassPool链，这样可以重用一些ClassPool的内容，如下所示：

ClassPool parent = new ClassPool();
ClassPool child = new ClassPool(parent)

4.2 CtClass

4.2.1 创建CtClass对象，并添加到ClassPool中

我们可以通过ClassPool的makeClass()系列方法创建一个类的CtClass对象并自动添加到ClassPool中，同样的，可以通过ClassPool的makeInterface()系列方法创建一个接口的CtClass对象。典型方法举例如下：

CtClass makeClass(InputStream classfile);
CtClass makeClass(ClassFile classfile);
CtClass makeClass(String classname);
CtClass makeClass(String classname, CtClass superclass);
CtClass makeInterface(String name);
CtClass makeInterface(String name, CtClass superclass);

我们更经常使用ClassPool的get(String classname)方法获取CtClass对象，get()方法传入的参数是类的全限定名，ClassPool会先在自己当中查找相应的CtClass对象，如果不存在，则会到ClassPool配置的类搜索路径（class search path）中查找相应的class file，然后创建CtClass对象并加载到ClassPool中。

当我们像上面的例子中那样通过ClassPool pool = ClassPool.getDefault()方式获取ClassPool对象时，pool中已经添加了系统类搜索路径（system search path），系统类搜索路径包括JVM platform库、扩展库、以及应用程序的CLASSPATH路径，所以如果为pool添加了系统类搜索路径，我们可以通过改变应用程序的CLASSPATH从而改变class搜索路径。我们还可以ClassPool pool = new ClassPool(true)方式在创建ClassPool对象时为pool添加系统类搜索路径。或者像下面这样是同样的效果：

ClassPool pool = new ClassPool();
// 为pool添加系统类搜索路径
pool.appendSystemPath();

在某些环境下，如Web容器、OSGI等，应用有多个类加载器（ClassLoader），这时可能需要添加相应的类搜索路径，我们还可以通过ClassPool提供的以下方法添加：

ClassPath appendClassPath(ClassPath cp);
ClassPath insertClassPath(ClassPath cp);
ClassPath appendClassPath(String pathname);
ClassPath insertClassPath(String pathname);

例如，假设我们有一个类实例Aninal cat，我们希望ClassPool能加载cat类加载器相应加载路径下的class，可以如下为pool添加类搜索路径：

ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new LoaderClassPath(cat.getClass().getClassLoader()));

4.2.2 CtClass基本操作

我们可以通过CtClass的setSuperclass(CtClass clazz)方法为类设置父类，通过setInterfaces(CtClass[] list)或addInterface(CtClass anInterface)方法为类添加实现的接口，通过setModifiers(int mod)方法设置类的修饰符，通过setName()修改类名，例如：

ClassPool pool = ClassPool.getDefault();
CtClass animal = pool.makeClass("com.javatest.javassist.Animal");
CtClass cat = pool.makeClass("com.javatest.javassist.Cat");
cat.setSuperclass(animal);
cat.setModifiers(Modifier.PUBLIC | Modifier.FINAL);
// 将Cat类修改为Dog
cat.setName("Dog");

我们可以通过以下系列方法为CtClass添加和删除字段、构造器、方法：

addField()
addConstructor()
addMethod()
removeField()
removeConstructor()
removeMethod()

当我们调用了CtClass对象的writeFile()，toClass()，toBytecode()等方法，javassist会冻结相应的CtClass；或者如果我们的CtClass已经设计好了，也可以主动通过freeze()方法将CtClass冻结，避免意外修改了CtClass。当然，如果我们确实需要重新修改CtClass，可以通过defrost()方法将CtClass解冻；如果创建的CtClass不再使用了，比如已经加载到了JVM中，可以通过detach()方法释放CtClass在ClassPool中占用的资源。

ClassPool pool = ClassPool.getDefault();
CtClass animal = pool.makeClass("com.javatest.javassist.Animal");

animal.freeze();
// 无法执行，抛出异常
animal.setModifiers(Modifier.FINAL);

animal.defrost();
// 可正常执行
animal.setModifiers(Modifier.FINAL);

// 释放相关资源
animal.detach();

4.3 CtField

我们可以通过CtField的静态方法make()或new一个新的CtField实例来创建CtField对象，CtField的基本使用方法和说明如下例子所示：

    ClassPool pool = ClassPool.getDefault();
    CtClass animal = pool.makeClass("com.javatest.javassist.Animal");

    // 创建一个名字为name的field，可以看到跟我们手写代码是一模一样的
    CtField field = CtField.make("private String name;", animal);

    // 下面两行代码的效果跟上面是一样的
    // CtField field = new CtField(pool.get("java.lang.String"), "name", animal);
    // nameField.setModifiers(Modifier.PRIVATE);

    // 下面两行的效果相当于删除了Animal类的name字段，添加了一个类型为long的age字段
    // 修改字段的名字
    field.setName("age");
    // 修改字段的类型
    field.setType(CtClass.longType);

    // 添加到CtClass中
    animal.addField(field);
    // 添加到CtClass中, 并初始化值为60
    // animal.addField(field, "60L");
    // animal.addField(field, CtField.Initializer.constant(60L));

4.4 CtConstructor

下面的例子展示了为类添加一个无参构造器的方法，有参构造器只要提供一个参数CtClass列表即可：

    ClassPool pool = ClassPool.getDefault();
    CtClass animal = pool.makeClass("com.javatest.javassist.Animal");

    CtField field = CtField.make("private String name;", animal);
    animal.addField(field);

    // 创建一个无参构造器
    CtConstructor cons = new CtConstructor(new CtClass[]{}, animal);
    // 构造器的方法体，多次调用时，会整体替换已经存在的body内容
    cons.setBody("{name = \"Tom\";}");
    animal.addConstructor(cons);

    // 在构造器的body的最前面添加内容
    cons.insertBeforeBody("System.out.println(\"====this is constructor\");");

从上面的例子可以看出，构造器的body内容以及新插入的代码跟我们平常开发代码是一样的。不过需要注意的是，setBody()的内容需要用{}包裹起来

CtNewConstructor工厂类则提供了一些方便的方法来创建构造函数：

// copy其他类的构造方法
CtConstructor copy(CtConstructor c, CtClass declaring,ClassMap map);
// 默认构造方法
CtConstructor defaultConstructor(CtClass declaring);
// make方法系列
CtConstructor make(String src, CtClass declaring);
CtConstructor make(CtClass[] parameters,CtClass[] exceptions, CtClass declaring);
CtConstructor make(CtClass[] parameters,CtClass[] exceptions,String body, CtClass declaring);
CtConstructor make(CtClass[] parameters,
                    CtClass[] exceptions, int howto,
                    CtMethod body, ConstParameter cparam,
                    CtClass declaring);

下面的例子创建的构造方法与上面是一样的：

    CtConstructor cons = CtNewConstructor.make("public Animal() {name = \"Tom\";}", animal);
    animal.addConstructor(cons);

4.5 CtMethod

4.5.1 创建CtMethod

跟创建构造器类似，我们可以new CtMethod()或使用CtNewMethod的工厂方法创建新的类，稍不同的是方法需要提供方法名和返回值类型：

    ClassPool pool = ClassPool.getDefault();
    CtClass animal = pool.makeClass("com.javatest.javassist.Animal");

    // 创建一个 void printInfo() 方法
    CtMethod printInfo = new CtMethod(CtClass.voidType, "printInfo", new CtClass[]{}, animal);
    printInfo.setModifiers(Modifier.PUBLIC);
    printInfo.setBody("{System.out.println(\"====this is constructor\");}");
    animal.addMethod(printInfo);

CtNewMethod提供工厂方法主要有：

// 字段的getter、setter方法
CtMethod getter(String methodName, CtField field);
CtMethod setter(String methodName, CtField field);
// 抽象方法
CtMethod abstractMethod(CtClass returnType,
                        String mname,
                        CtClass[] parameters,
                        CtClass[] exceptions,
                        CtClass declaring);
CtMethod copy(CtMethod src, CtClass declaring,ClassMap map);
CtMethod copy(CtMethod src, String name, CtClass declaring,ClassMap map);
// make系列
CtMethod make(String src, CtClass declaring);
CtMethod make(String src, CtClass declaring,String delegateObj, String delegateMethod);
CtMethod make(CtClass returnType,
              String mname, CtClass[] parameters,
              CtClass[] exceptions,
              String body, CtClass declaring);
CtMethod make(int modifiers, CtClass returnType,
              String mname, CtClass[] parameters,
              CtClass[] exceptions,
              String body, CtClass declaring);

4.5.2 编辑CtMethod方法体内容

除了通过setBody()方法或CtNewMethod.make()系列工厂方法一次提供方法的全部内容，CtMethod提供了一系列丰富的用来编辑方法内容的方式，主要的几个方法如下所示：

// 修改方法名字
setName();
// 添加方法参数
insertParameter();
addParameter();
// 在方法体中插入代码
insertBefore();
insertAfter();
insertAt();
addCatch();

举一个简单的例子

    ClassPool pool = ClassPool.getDefault();
    CtClass animal = pool.makeClass("com.javatest.javassist.Animal");

    // 创建一个 void printInfo() 方法
    CtMethod printInfo = new CtMethod(CtClass.voidType, "printInfo", new CtClass[]{}, animal);
    printInfo.setModifiers(Modifier.PUBLIC);
    printInfo.setBody("{System.out.println(\"====this is a method\");}");
    animal.addMethod(printInfo);

    // 在方法入口处插入代码
    printInfo.insertBefore("System.out.println(\"inserted at method entry point\");");
    // 在方法所有返回点插入代码
    printInfo.insertAfter("System.out.println(\"inserted before method return\");");
    // 在指定行插入代码
    // printInfo.insertAt(10, "System.out.println(\"insert at dedicated line\");");