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, , );
         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(, "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, );
         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();
     }
 }