javassist实例

我们常用到的动态特性主要是反射，在运行时查找对象属性、方法，修改作用域，通过方法名称调用方法等。在线的应用不会频繁使用反射，因为反射的性能开销较大。其实还有一种和反射一样强大的特性，但是开销却很低，它就是Javassist。

Javassist其实就是一个二方包，提供了运行时操作Java字节码的方法。Java代码编译完会生成.class文件，就是一堆字节码。JVM(准确说是JIT)会解释执行这些字节码(转换为机器码并执行)，由于字节码的解释执行是在运行时进行的，那我们能否手工编写字节码，再由JVM执行呢？答案是肯定的，而Javassist就提供了一些方便的方法，让我们通过这些方法生成字节码。

 

重要的类：

ClassPool：javassist的类池，使用ClassPool 类可以跟踪和控制所操作的类,它的工作方式与 JVM 类装载器非常相似，
CtClass： CtClass提供了检查类数据（如字段和方法）以及在类中添加新字段、方法和构造函数、以及改变类、父类和接口的方法。不过，Javassist 并未提供删除类中字段、方法或者构造函数的任何方法。
CtField：用来访问域
CtMethod ：用来访问方法
CtConstructor：用来访问构造器

实例：

Example1:

public class Example1 {
    public static void main(String[] args) throws Exception {
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.makeClass("bean.User");

        //创建属性
        CtField field01 = CtField.make("private int id;",cc);
        CtField field02 = CtField.make("private String name;", cc);
        cc.addField(field01);
        cc.addField(field02);

        //创建方法
        CtMethod method01 = CtMethod.make("public String getName(){return name;}", cc);
        CtMethod method02 = CtMethod.make("public void setName(String name){this.name = name;}", cc);
        cc.addMethod(method01);
        cc.addMethod(method02);

        //添加有参构造器
        CtConstructor constructor = new CtConstructor(new CtClass[]{CtClass.intType, pool.get("java.lang.String")}, cc);
        constructor.setBody("{this.id=id;this.name=name;}");
        cc.addConstructor(constructor);
        //无参构造器
        CtConstructor cons = new CtConstructor(null, cc);
        cons.setBody("{}");
        cc.addConstructor(cons);

        cc.writeFile("E:/workspace/TestCompiler/src");
    }
}

 

Person:

public class Person {

    public Person() {}

    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }

    private int id;

    private String name;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String hello(String name) {
        return name;
    }

}

 

Example2:

public class Example2 {

    //获取类的简单信息
    public static void test01() throws Exception{
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.get("com.code.javassistdemo.example.Person");
        //得到字节码
        byte[] bytes = cc.toBytecode();
        System.out.println(Arrays.toString(bytes));
        System.out.println(cc.getName());//获取类名
        System.out.println(cc.getSimpleName());//获取简要类名
        System.out.println(cc.getSuperclass());//获取父类
        System.out.println(cc.getInterfaces());//获取接口
        System.out.println(cc.getMethods());//获取
    }
    //新生成一个方法
    public static void test02() throws Exception{
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.get("com.code.javassistdemo.example.Person");
        //第一种
        //CtMethod cm = CtMethod.make("public String getName(){return name;}", cc);
        //第二种
        //参数：返回值类型，方法名，参数，对象
        CtMethod cm = new CtMethod(CtClass.intType,"add", new CtClass[]{CtClass.intType, CtClass.intType}, cc);
        cm.setModifiers(Modifier.PUBLIC);//访问范围
        cm.setBody("{return $1+$2;}");
        //cc.removeMethod(m) 删除一个方法
        cc.addMethod(cm);
        //通过反射调用方法
        Class clazz = cc.toClass();
        Object obj = clazz.newInstance();//通过调用无参构造器，生成新的对象
        Method m = clazz.getDeclaredMethod("add", int.class, int.class);
        Object result = m.invoke(obj, 2, 3);
        System.out.println(result);
    }

    //修改已有的方法
    public static void test03() throws Exception{
        ClassPool pool  = ClassPool.getDefault();
        CtClass cc = pool.get("com.code.javassistdemo.example.Person");

        CtMethod cm = cc.getDeclaredMethod("hello",new CtClass[]{pool.get("java.lang.String")});
        cm.insertBefore("System.out.println(\"调用前\");");//调用前
        cm.insertAt(31, "System.out.println(\"31\");");//行号
        cm.insertAfter("System.out.println(\"调用后\");");//调用后

        //通过反射调用方法
        Class clazz = cc.toClass();
        Object obj = clazz.newInstance();
        Method m = clazz.getDeclaredMethod("hello", String.class);
        Object result = m.invoke(obj, "张三");
        System.out.println(result);
    }

    //修改已有属性
    public static void test04() throws Exception{
        ClassPool pool  = ClassPool.getDefault();
        CtClass cc = pool.get("com.code.javassistdemo.example.Person");

        //属性
        CtField cf = new CtField(CtClass.intType,"age",cc);
        cf.setModifiers(Modifier.PRIVATE);
        cc.addField(cf);
        //增加响应的get set方法
        cc.addMethod(CtNewMethod.getter("getAge",cf));
        cc.addMethod(CtNewMethod.setter("setAge",cf));

        //访问属性
        Class clazz = cc.toClass();
        Object obj = clazz.newInstance();
        Field field = clazz.getDeclaredField("age");
        System.out.println(field);
        Method m = clazz.getDeclaredMethod("setAge", int.class);
        m.invoke(obj, 16);
        Method m2 = clazz.getDeclaredMethod("getAge", null);
        Object resutl = m2.invoke(obj,null);
        System.out.println(resutl);
    }

    //操作构造方法
    public static void test05() throws Exception{
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.get("com.code.javassistdemo.example.Person");

        CtConstructor[] cons = cc.getConstructors();
        for(CtConstructor con:cons){
            System.out.println(con);
        }
    }
    public static void main(String[] args) throws Exception {
        test01();
//        test02();
//        test03();
//        test04();
//        test05();
    }
}