java本身动态性的两种实现方式：反射和字节码操作

字节码操作：可以实现动态生成一个类（.class文件）和动态的修改类的结构；可以去改变一个类。
反射：去动态的执行类的内容，不能改变类。一个是改变，一个是执行；多数情况下两者配合使用。

反射中有Class、 Method、Field、Constructor等类，相似在字节码操作中有CtClass、CtMethod、CtField、CtConstructor等与之相对应。 Ct（Compile time）。

MakeNewClass：利用动态字节码操作生成一个新的类；
ChangeClass ：去改变一个类的结构
User: 需要改变的类

package com.test.byteCode;

import java.io.IOException;

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

/**
 * java的动态性中对字节码的操作，
 * 利用javasisit生成一个新的.class文件
 * @author zhb
 *
 */
public class MakeNewClass {
    
    public static void main(String[] args) throws CannotCompileException, IOException {
        
        ClassPool pool = ClassPool.getDefault();
        String className = "com.test.reflect.User";
        // 用类的全路径创建一个类
        CtClass ctClass = pool.makeClass(className);
        
        // 给类创建属性
        CtField ctField = CtField.make("private int id;", ctClass);
        // 给类添加属性
        ctClass.addField(ctField);
        
        // 给类创建构造方法
        // 创建有参的构造方法
        CtConstructor ctConstructor = new CtConstructor(new CtClass[]{CtClass.intType}, ctClass);
        ctConstructor.setBody("this.id = id;");
        // 给类添加构造方法
        ctClass.addConstructor(ctConstructor);
            
        // 给类创建方法
        CtMethod ctMethod1 = CtMethod.make("private void setId(String id){this.id = id;}", ctClass);
        CtMethod ctMethod2 = CtMethod.make("private String getId(){return id;}", ctClass);
        CtMethod ctMethod3 = CtMethod.make("public void sayHello(){System.out.println(\"你好\");}", ctClass);
        // 给类添加方法
        ctClass.addMethod(ctMethod1);
        ctClass.addMethod(ctMethod2);
        ctClass.addMethod(ctMethod3);
        
        // 生成class文件，到D盘Myclass的文件夹下
        ctClass.writeFile("E:/Myclass");
        System.out.println("class文件创建成功");
    }

}

package com.test.byteCode;

import java.lang.reflect.Method;

import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;

/**
 * 更改User的class文件的内容
 * @author zhb
 *
 */
public class ChangeClass {
    
    /**
     * 用字节码动态添加一个方法，并且执行这个方法
     * @throws Exception
     */
    public static void test1() throws Exception{

        ClassPool classPool = ClassPool.getDefault();
        String path = "com.test.reflect.User";
        CtClass ctClass = classPool.get(path);
        
        // 给类添加一个新方法
        CtMethod ctMethod = CtMethod.make("public int add(int a, int b){return a+b;}", ctClass);
        ctClass.addMethod(ctMethod);
        
        // 通过反射执行刚刚加入的add方法
        // ctClass转成反射类
        Class clazz = ctClass.toClass();
        Object obj = clazz.newInstance();
        Method method = clazz.getMethod("add", int.class, int.class);
        // 执行刚刚加入的add方法
        Object result = method.invoke(obj, 8, 4);
        ctClass.defrost();
        System.out.println(result);
    }
    
    /**
     * 用字节码动态添加动态给一个方法的前面或者后面添加方法，并且执行这个方法
     * @throws Exception
     */
    public static void test2() throws Exception{
        
        ClassPool classPool = ClassPool.getDefault();
        String path = "com.test.reflect.User";
        CtClass ctClass = classPool.get(path);
        // 修改方法，在某个方法的前面或者后面加入新的方法；像spring AOP
        // 获取原有的方法，hello
        CtMethod ctMethod = ctClass.getDeclaredMethod("hello", new CtClass[]{classPool.get("java.lang.String")});
        ctMethod.insertBefore("System.out.println(\"方法之前执行\");");
        ctMethod.insertAfter("System.out.println(\"方法之后执行\");");
                
        Class clazz = ctClass.toClass();
        Object obj = clazz.newInstance();
        Method method = clazz.getMethod("hello", String.class);
        method.invoke(obj,"张三");
    }   

    public static void main(String[] args) throws Exception {
        test1();
//      test2();
    }
        
}

package com.test.reflect;

public class User {
    
    private int id;
    private String name;
    
    // 无参的构造方法，容易被忘记
    public User(){      
    }
    
    //有参的构造方法
    public User(int id, String name){
        this.id = id;
        this.name = name;
    }
    
    // 类中一个普通的方法
    public String hello(String name){
        System.out.println("hello:"+ name);
        return "方法调用成功";
    }
    
    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;
    }
    
}