16.java字节码操作（JAVAssist）

什么是java字节码操作

Java动态性的两种常见实现方式       

• 字节码操作
• 反射

运行时操作字节码可以让我们实现如下功能：

• 在JVM中动态生成新的类
• 在JVM中动态改变某个类的结构（添加/删除/修改  新的属性/方法）

优势：

• 比反射开销小，性能高
• JAVAasist性能高于反射，低于ASM

JAVA中如何操作字节码

常见的字节码操作类库

• BCEL  这是Apache Software Fundation的jakarta项目的一部分。BCEL是javaclassworking广泛使用的一种跨级啊，它可以让你深入JVM汇编语言进行类的操作的细节。BCEL与javassist所强调的是源码级别的工作。
• ASM  是一个轻量及java字节码操作框架，直接涉及到JVM底层的操作和指令。
• CGLIB  是一个强大的，高性能，高质量的Code生成类库，基于ASM实现。
• JAVAssist    是一个开源的分析、编辑和创建java字节码的类库，性能较ASM差，跟cglib差不多，但是使用简单

应用层面来讲一般使用建议优先选择Javassit，如果后续发现Javassit 成为了整个应用的效率瓶颈的话可以再考虑ASM.当然如果开发的是一个基础类库，或者基础平台，还是直接使用ASM吧，相信从事这方面工作的开发者能力应该比较高。

JAVAssist库的API

• javassist最外层的API和Java的反射包中的API颇为类似、
• 它主要有CtClass,CtMethod,以及CtField及各类组成。用以执行和JDK反射API中java.lang.Class，java.lang.reflect.Method，java.lang.reflect.Method.Field相同的操作。

Javassit使用方法

Javassist是一个开源的分析、编辑和创建Java字节码的类库。直接使用java编码的形式，而不需要了解虚拟机指令，就能动态改变类的结构，或者动态生成类。

Javassist中最为重要的是ClassPool，CtClass ，CtMethod 以及 CtField这几个类。

ClassPool：一个基于HashMap实现的CtClass对象容器，其中键是类名称，值是表示该类的CtClass对象。默认的ClassPool使用与底层JVM相同的类路径，因此在某些情况下，可能需要向ClassPool添加类路径或类字节。

CtClass：表示一个类，这些CtClass对象可以从ClassPool获得。

CtMethods：表示类中的方法。

CtFields ：表示类中的字段。

动态生成一个类demo：

package com.company.demo;

import javassist.*;

public class Demo01 {
    public static void main(String[] args) throws Exception {
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.makeClass("com.company.Emp");
        
        //创建属性
        CtField f1 = CtField.make("private int empno;", cc);
        CtField f2 = CtField.make("private String ename;", cc);
        cc.addField(f1);
        cc.addField(f2);
        
        //创建方法
        CtMethod m1 = CtMethod.make("public int getEmpno(){return empno;}", cc);
        CtMethod m2 = CtMethod.make("public void setEmpno(int empno){this.empno=empno;}", cc);
        cc.addMethod(m1);
        cc.addMethod(m2);
        
        //添加构造器
        CtConstructor constructor = new CtConstructor(new CtClass[]{CtClass.intType,pool.get("java.lang.String")}, cc);
        constructor.setBody("{this.empno=empno; this.ename=ename;}");
        cc.addConstructor(constructor);
        
        cc.writeFile("c:/test"); //将上面构造好的类写入到文件中
        System.out.println("生成类，成功！");
    }
}

执行后，可以看到在生成了一个Emp.class字节码文件，使用反编译工具即可查看Emp代码。

javassist官网可以查API http://www.javassist.org/  测试一下其他常用方法

package com.company.demo;

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

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Arrays;

public class Demo02 {
    /**
     * 处理类的基本用法
     */
    public static void test01() throws Exception {
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.get("com.company.demo.Emp");

        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()); //获得接口
    }

    /**
     * 测试产生新的方法
     *
     * @throws Exception
     */
    public static void test02() throws Exception {
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.get("com.company.demo.Emp");

        //CtMethod m = CtNewMethod.make("public int add(int a,int b){return a+b;}", cc);

        CtMethod m = new CtMethod(CtClass.intType, "add",
                new CtClass[]{CtClass.intType, CtClass.intType}, cc);
        m.setModifiers(Modifier.PUBLIC);
        m.setBody("{System.out.println(\"Hello!!!\");return $1+$2;}");  //$1和$2是占位符

        cc.addMethod(m);
        //通过反射调用新生成的方法
        Class clazz = cc.toClass();
        Object obj = clazz.newInstance();  //通过调用Emp无参构造器，创建新的Emp对象
        Method method = clazz.getDeclaredMethod("add", int.class, int.class);
        Object result = method.invoke(obj, 200, 300);
        System.out.println(result);
    }

    /**
     * 修改已有的方法的信息，修改方法体的内容
     *
     * @throws Exception
     */
    public static void test03() throws Exception {
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.get("com.company.demo.Emp");

        CtMethod cm = cc.getDeclaredMethod("sayHello", new CtClass[]{CtClass.intType});
        //方法执行前
        cm.insertBefore("System.out.println($1);System.out.println(\"start!!!\");");
        cm.insertAt(9, "int b=3;System.out.println(\"b=\"+b);");
        //方法执行后
        cm.insertAfter("System.out.println(\"after!!!\");");

        //通过反射调用新生成的方法
        Class clazz = cc.toClass();
        Object obj = clazz.newInstance();  //通过调用Emp无参构造器，创建新的Emp对象
        Method method = clazz.getDeclaredMethod("sayHello", int.class);
        method.invoke(obj, 300);
    }

    /**
     * 属性的操作
     *
     * @throws Exception
     */
    public static void test04() throws Exception {
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.get("com.company.demo.Emp");

//        CtField f1 = CtField.make("private int empno;", cc);
        CtField f1 = new CtField(CtClass.intType, "salary", cc);
        f1.setModifiers(Modifier.PRIVATE);
        cc.addField(f1);

//        cc.getDeclaredField("ename");   //获取指定的属性

        //增加相应的set和get方法
        cc.addMethod(CtNewMethod.getter("getSalary", f1));
        cc.addMethod(CtNewMethod.getter("setSalary", f1));
    }

    /**
     * 构造方法的操作
     *
     * @throws Exception
     */
    public static void test05() throws Exception {
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.get("com.company.demo.Emp");

        CtConstructor[] cs = cc.getConstructors();
        for (CtConstructor c : cs) {
            System.out.println(c.getLongName());
        }
    }

    /**
     * 注解操作
     *
     * @throws Exception
     */


    public static void test06() throws Exception {
        CtClass cc = ClassPool.getDefault().get("com.company.demo.Emp");
        Object[] all = cc.getAnnotations();
        Author a = (Author) all[0];
        String name = a.name();
        int year = a.year();
        System.out.println("name: " + name + ", year: " + year);

    }

    public static void main(String[] args) throws Exception {
        test06();
    }
}

package com.company.demo;

public @interface Author {
    String name();
    int year();
}

 

package com.company.demo;

@Author(name = "chen",year = 2014)
public class Emp {
    private int empno;
    private String ename;

    public Emp(int empno, String ename) {
        this.empno = empno;
        this.ename = ename;
    }

    public Emp() {
    }

    public int getEmpno() {
        return empno;
    }

    public void setEmpno(int empno) {
        this.empno = empno;
    }

    public String getEname() {
        return ename;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }
}

JAVAssist类库的局限性：

• JDK5.0行语法不支持（包括泛型、枚举），不支持注解修改，但可以通过底层的javassist类来解决，具体参考javassist.bytecode.annotation
• 不支持数组的初始化，如String[]{“1”，“2”},除非只有数组的容量为1
• 不支持内部类和匿名类
• 不支持continue和btreak表达式
• 对于继承关系，有些不支持