Dubbo引用Javassist外部框架

Javaassist 就是一个用来处理 Java 字节码的类库。它可以在一个已经编译好的类中添加新的方法，或者是修改已有的方法，并且不需要对字节码方面有深入的了解。同时也可以去生成一个新的类对象，通过完全手动的方式。

 

引入依赖

<dependency>
    <groupId>org.javassist</groupId>
    <artifactId>javassist</artifactId>
    <version>3.25.0-GA</version>
</dependency>

 

在 Javassist 中，类 Javaassit.CtClass 表示 class 文件。一个 GtClass (编译时类）对象可以处理一个 class 文件，ClassPool是 CtClass 对象的容器。它按需读取类文件来构造 CtClass 对象，并且保存 CtClass 对象以便以后使用。

 

需要注意的是 ClassPool 会在内存中维护所有被它创建过的 CtClass，当 CtClass 数量过多时，会占用大量的内存，API中给出的解决方案是有意识的调用CtClass的detach()方法以释放内存。

 

ClassPool常用方法：

• getDefault : 返回默认的ClassPool 是单例模式的，一般通过该方法创建我们的ClassPool；
• appendClassPath, insertClassPath : 将一个ClassPath加到类搜索路径的末尾位置 或 插入到起始位置。通常通过该方法写入额外的类搜索路径，以解决多个类加载器环境中找不到类的尴尬；
• toClass : 将修改后的CtClass加载至当前线程的上下文类加载器中，CtClass的toClass方法是通过调用本方法实现。需要注意的是一旦调用该方法，则无法继续修改已经被加载的class；
• get , getCtClass : 根据类路径名获取该类的CtClass对象，用于后续的编辑。

 

CtClass常用方法：

• freeze : 冻结一个类，使其不可修改；
• isFrozen : 判断一个类是否已被冻结；
• prune : 删除类不必要的属性，以减少内存占用。调用该方法后，许多方法无法将无法正常使用，慎用；
• defrost : 解冻一个类，使其可以被修改。如果事先知道一个类会被defrost， 则禁止调用 prune 方法；
• detach : 将该class从ClassPool中删除；
• writeFile : 根据CtClass生成 .class 文件；
• toClass : 通过类加载器加载该CtClass。

上面我们创建一个新的方法使用了CtMethod类。CtMthod代表类中的某个方法，可以通过CtClass提供的API获取或者CtNewMethod新建，通过CtMethod对象可以实现对方法的修改。

 

CtMethod常用方法：

• insertBefore : 在方法的起始位置插入代码；
• insterAfter : 在方法的所有 return 语句前插入代码以确保语句能够被执行，除非遇到exception；
• insertAt : 在指定的位置插入代码；
• setBody : 将方法的内容设置为要写入的代码，当方法被 abstract修饰时，该修饰符被移除；
• make : 创建一个新的方法。

 

 

一、生成class文件

 

使用示例

ClassPool pool = ClassPool.getDefault();

// 1.创建一个类
CtClass cc = pool.makeClass("com.test.Student");

// 2.新增一个字段 
CtField param = new CtField(pool.get("java.lang.String"), "username", cc);
param.setModifiers(Modifier.PRIVATE);
cc.addField(param, CtField.Initializer.constant("zhangshan"));

// 3.无参构造
CtConstructor cons = new CtConstructor(new CtClass[] {}, cc);
cons.setBody("{username = \"lisi\";}");
cc.addConstructor(cons);

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

// 5.getter、setter方法
cc.addMethod(CtNewMethod.setter("setUsername", param));
cc.addMethod(CtNewMethod.getter("getUsername", param));

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

// 这里会将这个创建的类对象编译为.class文件
cc.writeFile("D:\\workspace-neno\\spring\\target");

 

生成一个Student.class文件，经过反编译

public class Student {
  private String username = "zhangshan";
  
  public Student() {
    this.username = "lisi";
  }
  
  public Student(String paramString) {
    this.username = paramString;
  }
  
  public void setUsername(String paramString) {
    this.username = paramString;
  }
  
  public String getUsername() {
    return this.username;
  }
  
  public void print() {
    System.out.println("username : " + this.username);
  }
}

 

 

 

二、如何使用

 

这里不写入文件，直接实例化

（1）通过反射方式调用

// 实例化
Object student = cc.toClass().newInstance();
System.out.println(student); // com.test.Student@59690aa4
// 调用方法
Method setUsername = student.getClass().getMethod("setUsername", String.class);
setUsername.invoke(student, "caoxiaobo");
Method print = student.getClass().getMethod("print");
print.invoke(student);

 

（2）通过读取 .class 文件的方式调用

// ClassPool pool = ClassPool.getDefault();
// 设置类路径
pool.appendClassPath("D:\\workspace-neno\\spring\\target");
CtClass ctClass = pool.get("com.test.Student");
Object student = ctClass.toClass().newInstance();
System.out.println(student);

 

 

（3）通过接口的方式

public interface StudentIF {
    public String getUsername();
    public void setUsername(String paramString);    
    public void print();
}

 

// ClassPool pool = ClassPool.getDefault();
pool.appendClassPath("D:\\workspace-neno\\spring\\target");

// 获取接口
CtClass codeClassI = pool.get("com.javassist.StudentIF");
// 获取上面生成的类
CtClass ctClass = pool.get("com.test.Student");
// 使代码生成的类，实现 StudentIF 接口
ctClass.setInterfaces(new CtClass[]{codeClassI});

// 以下通过接口直接调用 强转
StudentIF student = (StudentIF)ctClass.toClass().newInstance();
System.out.println(student.getUsername());
student.setUsername("caoxiaobo");
student.print();

 

 

 

三、修改操作

public class StudentService {
    
    public void getStudent() {
        System.out.println("get student");
    }

    public void study() {
        System.out.println("learn javassist");
    }
}

 

 

1.调用AOP功能的方法

    insertBefore

    insertAfter

2.新增方法

    addMethod

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("com.javassist.StudentService");

CtMethod study = cc.getDeclaredMethod("study");
study.insertBefore("System.out.println(\"学习之前...\");");
study.insertAfter("System.out.println(\"学习之后...\");");

// 新增一个方法
CtMethod ctMethod = new CtMethod(CtClass.voidType, "sleep", new CtClass[] {}, cc);
ctMethod.setModifiers(Modifier.PUBLIC);
ctMethod.setBody("{System.out.println(\"准备睡觉，晚安！\");}");
cc.addMethod(ctMethod);

Object studentService = cc.toClass().newInstance();
// 调用 study 方法
Method _study = studentService.getClass().getMethod("study");
_study.invoke(studentService);
// 调用 joinFriend 方法
Method sleep = studentService.getClass().getMethod("sleep");
sleep.invoke(studentService);