java----字节码操做

Java动态性的两种常见方式

　　-反射

　　-字节码操做：所谓字节码操做就是当xx.class文件被加载到虚拟机后，咱们可使用类库来操做这些字节码

运行时操做字节码可让咱们实现以下功能　

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

优点：

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

常见的字节码操做类库

　　BCEL

　　ASM

　　CGLIB(Code Generation Library)

　　Javassist

Javassist使用

若是须要详细了解：能够下载框架

maven依赖jar包

<!-- https://mvnrepository.com/artifact/org.javassist/javassist -->
<dependency>
    <groupId>org.javassist</groupId>
    <artifactId>javassist</artifactId>
    <version>3.25.0-GA</version>
</dependency>

简单使用

字节码不能操做对象，若是须要操做对象还须要借助反射

建立新类

public static void main(String[] args) throws IOException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException, ScriptException, CannotCompileException, NotFoundException {
        //得到类池
        ClassPool aDefault = ClassPool.getDefault();

        //建立类的名字 能够指定包名 例如：com.zy.Dog
        CtClass ctClass = aDefault.makeClass("Dog");

        //添加属性（能够new CtField，和添加方法相似（在test01中说起））
        CtField public_int_age = CtField.make("public int age;", ctClass);
        CtField public_string_like= CtField.make("public String like;", ctClass);
        ctClass.addField(public_int_age);
        ctClass.addField(public_string_like);

        //添加方法
        CtMethod test = CtMethod.make("public void test(){System.out.println(\"添加成功\");}", ctClass);
        ctClass.addMethod(test);

        //添加构造器
        CtConstructor ctConstructor = new CtConstructor(new CtClass[]{CtClass.intType,aDefault.get("java.lang.String")}, ctClass);
        ctConstructor.setBody("{this.age=$1;this.like=$2;}");
        ctClass.addConstructor(ctConstructor);

        //开始建立一个Dog.class文件,能够指定Dog.class文件路径
        ctClass.writeFile();
    }

操做已经存在的类

一、给存在的.class文件追加方法.让对象去执行这个方法

public static void test01(){
        try {
            ClassPool aDefault = ClassPool.getDefault();
            CtClass ctClass = aDefault.get("com.zy.Dog");
            //byte[] bytes = ctClass.toBytecode();
            //获取类名
            System.out.println(ctClass.getName());
            //获取简单类名
            System.out.println(ctClass.getSimpleName());

            //添加方法
            //CtMethod test1 = CtMethod.make("public void test(int a,int b){System.out.println(\"添加成功\");}", ctClass);
            //另外一种添加方法的方式
            CtMethod ctMethod = new CtMethod(CtClass.intType, "t", new CtClass[]{CtClass.intType,CtClass.intType}, ctClass);
            ctMethod.setModifiers(Modifier.PUBLIC);
            ctMethod.setBody("return $1+$2;");
            ctClass.addMethod(ctMethod);

            //经过反射调用方法
            Class<?> aClass = ctClass.toClass();
            Method test = aClass.getDeclaredMethod("t",int.class,int.class);
            //对象0能够是外部传递进来,此时test方法就是一个代理方法
            Object o = aClass.getConstructor().newInstance();
            Object invoke = test.invoke(o, 1,1);
            System.out.println(invoke);
        } catch (NotFoundException e) {
            e.printStackTrace();
        } catch (CannotCompileException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        }
    }

二、经过字节码实现AOP编程

此时test02必须是一个代理类的方法。咱们将本身的对象经过test02传递进去

public static void test02(){
        try {
            ClassPool aDefault = ClassPool.getDefault();
            CtClass ctClass = aDefault.get("com.zy.Dog");
            CtMethod play = ctClass.getDeclaredMethod("play");
            //能够对已经存在的方法进行修改
            //play.setBody("System.out.println(\"Dog没有play\");");
            //执行方法以前能够执行其余的方法;
            play.insertBefore("System.out.println(\"Dog在吃东西\");");
            
            //反射执行该方法
            Class<?> aClass = ctClass.toClass();
            Method test = aClass.getDeclaredMethod("play");
            Object o = aClass.getConstructor().newInstance();
            Object invoke = test.invoke(o);
        } catch (NotFoundException e) {
            e.printStackTrace();
        } catch (CannotCompileException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }