减少内存溢出#

ClassPool 是一个 CtClass objects 的装载容器，当加载了 CtClass object 后，是不会被 ClassPool 释放的（默认情况下），这个是因为 CtClass object 有可能在下个阶段会被用到，当加载过多的 CtClass object 的时候，会造成 OutOfMemory 的异常。为了避免这个异常，javassist 提供几种方法，一种是在上面提到的 ClassPool.doPruning 这个参数，还有一种方法是调用 CtClass.detach() 方法，可以把 CtClass object 从 ClassPool 中移除。例如：

1
CtClass cc = ... ;
2
cc.writeFile();
3
cc.detach();

另外一种方法是不用默认的 ClassPool 即不用 ClassPool.getDefault() 这个方式来生成，这样当 ClassPool 没被引用的时候，JVM 的垃圾收集会收集该类。例如

1
ClassPool cp = new ClassPool(true); //ClassPool(true) 会默认加载Jvm的ClassPath
2
// if needed, append an extra search path by appendClassPath()

级联ClassPools#

javassist 支持级联的 ClassPool，即类似于继承。例如：

1
ClassPool parent = ClassPool.getDefault();
2
ClassPool child = new ClassPool(parent);
3
child.insertClassPath("./classes");

修改已有Class的name以创建一个新的Class#

当调用 setName 方法时，会直接修改已有的 Class 的类名，如果再次使用旧的类名，则会重新在 classpath 路径下加载。例如：

1
ClassPool pool = ClassPool.getDefault();
2
CtClass cc = pool.get("Point");
3
cc.setName("Pair");
4
CtClass cc1 = pool.get("Point"); //重新在 classpath 加载

对于一个被冻结(Frozen)的 CtClass object ，是不可以修改 class name 的，如果需要修改，则可以重新加载，例如：

1
ClassPool pool = ClassPool.getDefault();
2
CtClass cc = pool.get("Point");
3
cc.writeFile(); // has frozened
4
//cc.setName("Pair");//wrong since writeFile() has been called.
5
CtClass cc2 = pool.getAndRename("Point", "Pair");

使用 javassist.Loader#

从上面可以看到，如果在同一个 ClassLoader 加载两次 Class 抛出异常，为了方便，javassist 也提供一个 Classloader 供使用，例如

1
ClassPool pool = ClassPool.getDefault();
2
CtClass ct = pool.get("test.Rectangle");
3
ct.setSuperclass(pool.get("test.Point"));
4

5
Loader cl = new Loader(pool);
6
Class c = cl.loadClass("test.Rectangle");
7
Object rect = c.newInstance();

为了方便监听 Javassist 自带的 ClassLoader 的生命周期，javassist 也提供了一个 listener，可以监听 ClassLoader 的生命周期，例如：

1
public  interface Translator {
2
    void start(ClassPool paramClassPool) throws NotFoundException, CannotCompileException;
3
    void onLoad(ClassPool paramClassPool, String paramString) throws NotFoundException, CannotCompileException;
4
}

1
Loader cl = new Loader();
2
cl.addTranslator(ClassPool, Translator);

修改系统Class#

由JVM规范可知，system classloader 是比其他 classloader 是优先加载的，而 system classloader 主要是加载系统 Class，所以要修改系统 Class，如果默认参数运行程序是不可能修改的，如果需要修改也有一些办法，即在运行时加入-Xbootclasspath/p:，参数的意义可以参考其他文件。下面修改 String 的例子如下：

1
ClassPool pool = ClassPool.getDefault();
2
CtClass cc = pool.get("java.lang.String");
3
CtField f = new CtField(CtClass.intType, "hiddenValue", cc);
4
f.setModifiers(Modifier.PUBLIC);
5
cc.addField(f);
6
cc.writeFile(".");

动态重载Class#

如果JVM运行时开启JPDA（Java Platform Debugger Architecture），则Class是运行被动态重新载入的。具体方式可以参考java.lang.Instrument。javassist也提供了一个运行期重载Class的方法，具体可以看API 中的 javassist.tools.HotSwapper。

插入 source 文本在方法体前或者后#

CtMethod 和 CtConstructor 提供了 insertBefore()、insertAfter() 和 addCatch() 方法，它们可以插入一个 souce 文本到存在的方法的相应的位置。

javassist 包含了一个简单的编译器解析这 souce 文本成二进制插入到相应的方法体里。javassist 还支持插入一个代码段到指定的行数，前提是该行数需要在 class 文件里含有。插入的 source 可以关联 fields 和 methods，也可以关联方法的参数。但是关联方法参数的时，需要在程序编译时加上 -g 选项（该选项可以把本地变量的声明保存在 class 文件中，默认是不加这个参数的）。因为默认一般不加这个参数，所以 Javassist 也提供了一些特殊的变量来代表方法参数：\$1,\$2,\$args…要注意的是，插入的 source 文本中不能引用方法本地变量的声明，但是可以允许声明一个新的方法本地变量，除非在程序编译时加入-g选项。

方法的特殊变量说明：

类型简介#

• $n

\$0代码的是this，\$1代表方法参数的第一个参数、\$2代表方法参数的第二个参数，以此类推。例如实际方法：

1
void move(int dx, int dy)

在此方法前打印两个参数的值：

1
CtMethod m = cc.getDeclaredMethod("move"); //不指定参数时会修改此类中所有方法名为 move 的方法
2
m.insertBefore("{ System.out.println($1); System.out.println($2); }");//打印dx，和dy

• \$args

\$args 指的是方法所有参数的数组，类似Object[]，如果参数中含有基本类型，则会转成其包装类型。需要注意的时候，\$args[0]对应的是\$1,而不是\$0。

• $$

$$是所有方法参数的简写，主要用在方法调用上。 For example, m($$) is equivalent to m(\$1,\$2,...)， 例如原方法 move(String a,String b) 则 move($$) 相当于move(\$1,\$2) 如果新增一个方法，方法含有move的所有参数，则可以这么写：exMove($$, context) ，相当于 exMove(\$1, \$2, context)

• $cflow

$cflow意思为控制流(control flow)，是一个只读的变量，值为一个方法调用的深度。例如：

1
//原方法
2
int fact(int n) {
3
    if (n <= 1) return n;
4
    else return n * fact(n - 1);
5
}

1
//javassist调用
2
CtMethod cm = ...;
3
cm.useCflow("fact");//这里代表使用了cflow
4
//这里用了cflow，说明当深度为0的时候，就是开始当第一次调用fact的方法的时候，打印方法的第一个参数
5
cm.insertBefore("if ($cflow(fact) == 0)"
6
              + "    System.out.println(\"fact \" + $1);");

• $r

$r指的是方法返回值的类型，主要用在类型的转型上。例如：

1
Object result = ... ;
2
$_ = ($r)result;

如果返回值为基本类型的包装类型，则该值会自动转成基本类型；如返回值为Integer，则该值为int；如果返回值为void，则该值为null

• $w代表一个包装类型，主要用在转型上。比如：Integer i = ($w)5; 如果该类型不是基本类型，则会忽略。
• $sig指的是方法参数的类型（Class）数组，数组的顺序为参数的顺序。An array of java.lang.Class objects representing the formal parameter types
• \$class 指的是this的类型（Class）。也就是\$0的类型。A java.lang.Class object representing the class currently edited.

addCatch()#

addCatch() 指的是在方法中加入 try catch 块，需要注意的是，必须在插入的代码中加入 return 值。$e代表异常值。比如：

1
CtMethod m = ...;
2
CtClass etype = ClassPool.getDefault().get("java.io.IOException");
3
m.addCatch("{ System.out.println($e); throw $e; }", etype);

实际代码如下：

1
try {
2
    //the original method body
3
} catch (java.io.IOException e) {
4
    System.out.println(e);
5
    throw e;
6
}

替换方法中存在的 source#

javassist 允许修改方法里的其中一个表达式，javassist.expr.ExprEditor 这个class 可以替换该表达式。例如：

1
CtMethod cm = ..;
2
cm.instrument(new ExprEditor() {
3
    @Override
4
    public void edit(MethodCall m) throws CannotCompileException {
5
        if (m.getClassName().equals("Point") && m.getMethodName().equals("move")) {
6
            m.replace("{ $1 = 0; $_ = $proceed($$); }");
7
        }
8
    }
9
});

注意：替换代码不是表达式而是语句或块。它不能或包含try-catch语句。

方法instrument()可以用来搜索方法体里的内容，比如调用一个方法，field访问，对象创建等。如果你想在某个表达式前后插入方法，则修改的souce如下：

1
{ before-statements;
2
  $_ = $proceed($$);
3
  after-statements; }

MethodCall#

MethodCall 代表的是一个方法的调用。用replace()方法可以对调用的方法进行替换。

注意：$w, \$args 和 $$也是允许的。\$0不是this，是只调用方法的Object。$proceed指的是一个特殊的语法，而不是一个String。

\$0 is not equivalent to this, which represents the caller-side this object. \$0 is null if the method is static.

ConstructorCall#

ConstructorCall 指的是一个构造函数，比如：this()、super()的调用。ConstructorCall.replace()是用来用替换一个块当调用构造方法的时候。

$w, \$args 和 $$ 也是允许的。

FieldAccess#

FieldAccess 代表的是 Field 的访问类。

$w, \$args 和 $$ 也是允许的。

\$0 is not equivalent to this. this represents the object that the method including the expression is invoked on. \$0 is null if the field is static.

NewExpr#

NewExpr 代表的是一个 Object 的操作(但不包括数组的创建)。

$w, \$args 和 $$ 也是允许的。

NewArray#

NewArray 代表的是数组的创建。

$w, \$args 和 $$ 也是允许的。

Instanceof#

Instanceof 代表的是 Instanceof 表达式。

$proceed

• It takes one parameter (the type is java.lang.Object) and returns true
• if the parameter value is an instance of the type on the right hand side of
• the original instanceof operator. Otherwise, it returns false.

$w, \$args 和 $$ 也是允许的。

Cast#

Cast 代表的是一个转型表达式。

• $_：The type of $_ is the same as the type after the explicit casting, that is, the type surrounded by ( ).
• $proceed：It takes one parameter of the type java.lang.Object and returns it after the explicit type casting specified by the original expression.

$w, \$args 和 $$ 也是允许的。

Handler#

Handler 代表的是一个 try catch 声明。

递归方法#

1
CtClass cc = ... ;
2
CtMethod m = CtNewMethod.make("public abstract int m(int i);", cc);
3
CtMethod n = CtNewMethod.make("public abstract int n(int i);", cc);
4
cc.addMethod(m);
5
cc.addMethod(n);
6
m.setBody("{ return ($1 <= 0) ? 1 : (n($1 - 1) * $1); }");
7
n.setBody("{ return m($1); }");
8
cc.setModifiers(cc.getModifiers() & ~Modifier.ABSTRACT);

新增field#

1
CtClass point = ClassPool.getDefault().get("Point");
2
CtField f = new CtField(CtClass.intType, "z", point);
3
point.addField(f); //新增Field
4
//point.addField(f, "0");// initial value is 0.

或者：

1
CtClass point = ClassPool.getDefault().get("Point");
2
CtField f = CtField.make("public int z = 0;", point);
3
point.addField(f);

移除方法或者field#

调用removeField()或者removeMethod()。