ClassPool pool = ClassPool.getDefault();

//默认加载方式如 pool.insertClassPath(new ClassClassPath(this.getClass()));
pool.insertClassPath("D:/test/gson-2.8.1.jar");//从文件加载
pool.insertClassPath(new URLClassPath("www.javassist.org", 80, "/java/", "org.javassist."));//从URL中加载
pool.insertClassPath(new ByteArrayClassPath("name", new byte[0]));//从byte[] 中加载

CtClass cc = cp.makeClass(inputStream);//可以从输入流中加载class

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("test.Rectangle"); //会从classpath中查询该类
cc.setSuperclass(pool.get("test.Point"));//设置Rectangle的父类
cc.writeFile("c://");//输出Rectangle.class文件到该目录中
//byte[] b=cc.toBytecode(); //输出成二进制格式
//Class clazz=cc.toClass();//输出并加载class 类，默认加载到当前线程的ClassLoader中，也可以选择输出的ClassLoader

CtClasss cc = ...;
//...
cc.writeFile();
cc.defrost();
cc.setSuperclass(...);    // OK since the class is not frozen.

CtClasss cc = ...;
cc.stopPruning(true);
cc.writeFile();
// cc没有被释放

CtClass cc = ... ;
cc.writeFile();
cc.detach();

ClassPool cp = new ClassPool(true); //ClassPool(true) 会默认加载Jvm的ClassPath
// if needed, append an extra search path by appendClassPath()

ClassPool parent = ClassPool.getDefault();
ClassPool child = new ClassPool(parent);
child.insertClassPath("./classes");

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("Point");
cc.setName("Pair");
CtClass cc1 = pool.get("Point"); //重新在 classpath 加载

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("Point");
cc.writeFile(); // has frozened
//cc.setName("Pair");//wrong since writeFile() has been called.
CtClass cc2 = pool.getAndRename("Point", "Pair");

// 当Hello未加载的时候，下面是可以运行的。
ClassPool cp = ClassPool.getDefault();
CtClass cc = cp.get("Hello");
Class c = cc.toClass();

//下面这种情况，由于Hello2已加载，所以会出错
Hello2 h = new Hello2();
CtClass cc2 = cp.get("Hello2");
Class c2 = cc.toClass();//这里会抛出java.lang.LinkageError 异常

//解决加载问题，可以指定一个未加载的ClassLoader
Class c3 = cc.toClass(new MyClassLoader());

ClassPool pool = ClassPool.getDefault();
CtClass ct = pool.get("test.Rectangle");
ct.setSuperclass(pool.get("test.Point"));

Loader cl = new Loader(pool);
Class c = cl.loadClass("test.Rectangle");
Object rect = c.newInstance();

public  interface Translator {
    void start(ClassPool paramClassPool) throws NotFoundException, CannotCompileException;
    void onLoad(ClassPool paramClassPool, String paramString) throws NotFoundException, CannotCompileException;
}

Loader cl = new Loader();
cl.addTranslator(ClassPool, Translator);

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("java.lang.String");
CtField f = new CtField(CtClass.intType, "hiddenValue", cc);
f.setModifiers(Modifier.PUBLIC);
cc.addField(f);
cc.writeFile(".");

void move(int dx, int dy) 

CtMethod m = cc.getDeclaredMethod("move"); //不指定参数时会修改此类中所有方法名为 move 的方法
m.insertBefore("{ System.out.println($1); System.out.println($2); }");//打印dx，和dy

//原方法
int fact(int n) {
    if (n <= 1) return n;
    else return n * fact(n - 1);
}

//javassist调用
CtMethod cm = ...;
cm.useCflow("fact");//这里代表使用了cflow
//这里用了cflow，说明当深度为0的时候，就是开始当第一次调用fact的方法的时候，打印方法的第一个参数
cm.insertBefore("if ($cflow(fact) == 0)"
              + "    System.out.println(\"fact \" + $1);");

Object result = ... ;
$_ = ($r)result;

CtMethod m = ...;
CtClass etype = ClassPool.getDefault().get("java.io.IOException");
m.addCatch("{ System.out.println($e); throw $e; }", etype);

try {
    //the original method body
} catch (java.io.IOException e) {
    System.out.println(e);
    throw e;
}

CtMethod cm = ..;
cm.instrument(new ExprEditor() {
    @Override
    public void edit(MethodCall m) throws CannotCompileException {
        if (m.getClassName().equals("Point") && m.getMethodName().equals("move")) {
            m.replace("{ $1 = 0; $_ = $proceed($$); }");
        }
    }
});

{ before-statements;
  $_ = $proceed($$);
  after-statements; }

CtClass point = ClassPool.getDefault().get("Point");
CtMethod m = CtNewMethod.make("public int xmove(int dx) { x += dx; }", point);
point.addMethod(m);//新增方法

CtClass point = ClassPool.getDefault().get("Point");
CtMethod m = CtNewMethod.make("public int ymove(int dy) { $proceed(0, dy); }", point, "this", "move");

public int ymove(int dy) {
    this.move(0, dy);
}

CtClass cc = ... ;
CtMethod m = new CtMethod(CtClass.intType, "move", new CtClass[] { CtClass.intType }, cc);
cc.addMethod(m);
m.setBody("{ x += $1; }");
cc.setModifiers(cc.getModifiers() & ~Modifier.ABSTRACT);

CtClass cc = ... ;
CtMethod m = CtNewMethod.make("public abstract int m(int i);", cc);
CtMethod n = CtNewMethod.make("public abstract int n(int i);", cc);
cc.addMethod(m);
cc.addMethod(n);
m.setBody("{ return ($1 <= 0) ? 1 : (n($1 - 1) * $1); }");
n.setBody("{ return m($1); }");
cc.setModifiers(cc.getModifiers() & ~Modifier.ABSTRACT);

CtClass point = ClassPool.getDefault().get("Point");
CtField f = new CtField(CtClass.intType, "z", point);
point.addField(f); //新增Field
//point.addField(f, "0");// initial value is 0.

CtClass point = ClassPool.getDefault().get("Point");
CtField f = CtField.make("public int z = 0;", point);
point.addField(f);

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

CtClass cc = ClassPool.getDefault().get("Point");
Object[] all = cc.getAnnotations(); //获取注解信息：
Author a = (Author)all[0];
System.out.println("name: " + a.name() + ", year: " + a.year());

ClassPool pool = ClassPool.getDefault();
pool.importPackage("java.awt"); //引用包
CtClass cc = pool.makeClass("Test");
CtField f = CtField.make("public Point p;", cc);
cc.addField(f);

class A {} 
class B extends A {} 
class C extends B {} 

class X { 
    void foo(A a) { .. } 
    void foo(B b) { .. } 
}

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.makeClass("bean.User");

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

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

//添加有参构造器  
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("d:/test");

package bean;

public class User {
    private int id;
    private String name;

    public User() {
    }

    public User(int paramInt, String paramString) {
        this.id = this.id;
        this.name = this.name;
    }

    public String getName() {
        return this.name;
    }

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

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

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

public class Test {

    public static void main(String[] args) throws Exception {
        //        test01();
        //        test02();
        test03();
        //        test04();
        //        test05();
    }

    //获取类的简单信息  
    public static void test01() throws Exception {
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.get("com.bqt.test.Person");
        //得到字节码  
        byte[] bytes = cc.toBytecode();
        System.out.println(bytes.length);
        System.out.println(cc.getName());//获取类名  
        System.out.println(cc.getSimpleName());//获取简要类名  
        System.out.println(cc.getSuperclass().getName());//获取父类  
        System.out.println(Arrays.toString(cc.getInterfaces()));//获取接口  
        for (CtMethod method : cc.getMethods()) {//获取方法
            System.out.println(method.getLongName());
        }
    }

    //添加方法  
    public static void test02() throws Exception {
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.get("com.bqt.test.Person");

        CtMethod cm1 = CtMethod.make("public int add1(int a, int b){return a+b;}", cc);//第一种方式，完整的方法以字符串形式传递过去
        cc.addMethod(cm1); //cc.removeMethod(cm3) 删除一个方法

        CtClass[] parameters = new CtClass[] { CtClass.intType, CtClass.intType };
        CtMethod cm2 = new CtMethod(CtClass.intType, "add2", parameters, cc);//第二种方式，返回值类型，方法名，参数，对象  
        cm2.setModifiers(Modifier.PUBLIC);//访问范围  
        cm2.setBody("{return $1+$2;}");
        cc.addMethod(cm2);

        //通过反射调用方法  
        Class clazz = cc.toClass(); //注意，如果使用 JDK9 以下的JDK ，同时使用 3.20.0-GA 以上版本的 Javassist，会报 StackWalker 异常
        Object obj = clazz.newInstance();//通过调用无参构造器，生成新的对象

        Method m1 = clazz.getDeclaredMethod("add1", int.class, int.class);
        System.out.println(m1.invoke(obj, 1, 2));

        Method m2 = clazz.getDeclaredMethod("add2", int.class, int.class);
        System.out.println(m2.invoke(obj, 2, 3));

        cc.writeFile("D:/test");//保存到指定位置
    }

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

        CtMethod cm = cc.getDeclaredMethod("hello", new CtClass[] { pool.get("java.lang.String") });
        cm.insertBefore("System.out.println(\"调用前\");");//调用前
        cm.insertAt(20094, "System.out.println(\"在指定行插入代码\");");//貌似行号胡乱写也可以
        cm.insertAfter("System.out.println(\"调用后\");");//调用后

        CtMethod cm2 = cc.getDeclaredMethod("hello2", new CtClass[] { pool.get("java.lang.String") });
        cm2.setBody("{" + // 你只需要正常写代码逻辑就可以了，复制过来时，一些IDE，比如AS会自动帮你添加转义字符
                "if ($1 == null) {\n" + //$0代表的是this，$1代表方法参数的第一个参数、$2代表方法参数的第二个参数
                "\treturn \"\";\n" + //
                "}\n" + //
                "return  \"你好：\" + $1;" + //
                "}"); //修改方法

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

        Method m2 = clazz.getDeclaredMethod("hello2", String.class);
        System.out.println(m2.invoke(obj, "张三"));

        cc.writeFile("D:/test");//保存到指定位置
    }

    //添加属性  
    public static void test04() throws Exception {
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.get("com.bqt.test.Person");

        CtField cf = new CtField(CtClass.intType, "age", cc);
        cf.setModifiers(Modifier.PRIVATE);
        cc.addField(cf);
        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);

        cc.writeFile("D:/test");//保存到指定位置
    }

    //构造方法  
    public static void test05() throws Exception {
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.get("com.bqt.test.Person");

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

package com.bqt.test;

public class Person {

    public int hello(String s) {
        return s.length();
    }

    public String hello2(String s) {
        return s;
    }
}

package com.bqt.test;

public class Person {
    public int hello(String s) {
        return s.length();
    }

    public String hello2(String s) {
        return s;
    }

    public int add1(int paramInt1, int paramInt2) {
        return paramInt1 + paramInt2;
    }

    public int add2(int paramInt1, int paramInt2) {
        return paramInt1 + paramInt2;
    }
}

package com.bqt.test;

public class Person {
    public int hello(String s) {
        System.out.println("调用前");
        System.out.println("在指定行插入代码");
        int i = s.length();
        System.out.println("调用后");
        return i;
    }

    public String hello2(String paramString) {
        if (paramString == null) {
            return "";
        }
        return "你好：" + paramString;
    }
}

package com.bqt.test;

public class Person {
    private int age;

    public int hello(String s) {
        return s.length();
    }

    public String hello2(String s) {
        return s;
    }

    public int getAge() {
        return this.age;
    }

    public void setAge(int paramInt) {
        this.age = paramInt;
    }
}