// 获取ClassPool对象, 使用系统默认类路径
ClassPool pool = new ClassPool(true);
// 效果与 new ClassPool(true) 一致
ClassPool pool1 = ClassPool.getDefault();

// 从ClassPool中删除CtClass对象
ctClass.detach();
// 也可以每次创建一个新的ClassPool, 而不是ClassPool.getDefault(), 避免内存溢出
ClassPool pool2 = new ClassPool(true);

// 通过类名获取 CtClass, 未找到会抛出异常
CtClass ctClass = pool.get("com.kawa.ssist.JustRun");
// 通过类名获取 CtClass, 未找到返回 null, 不会抛出异常
CtClass ctClass1 = pool.getOrNull("com.kawa.ssist.JustRun");

// 复制一个类
CtClass ctClass2 = pool.getAndRename("com.kawa.ssist.JustRun", "com.kawa.ssist.JustRunq");
// 创建一个新类
CtClass ctClass3 = pool.makeClass("com.kawa.ssist.JustRuna");
// 通过class文件创建一个新类
CtClass ctClass4 = pool.makeClass(new FileInputStream(new File("/home/un/test/JustRun.class")));

// 类名
String simpleName = ctClass.getSimpleName();
// 类全名
String name = ctClass.getName();
// 包名
String packageName = ctClass.getPackageName();
// 接口
CtClass[] interfaces = ctClass.getInterfaces();
// 继承类
CtClass superclass = ctClass.getSuperclass();
// 获取类方法
CtMethod ctMethod = ctClass.getDeclaredMethod("getName()", new CtClass[] {pool.get(String.class.getName()), pool.get(String.class.getName())});
// 获取类字段
CtField ctField = ctClass.getField("name");
// 判断数组类型
ctClass.isArray();
// 判断原生类型
ctClass.isPrimitive();
// 判断接口类型
ctClass.isInterface();
// 判断枚举类型
ctClass.isEnum();
// 判断注解类型
ctClass.isAnnotation();
// 冻结一个类，使其不可修改
ctClass.freeze () 
// 判断一个类是否已被冻结
ctClass.isFrozen()
// 删除类不必要的属性，以减少内存占用。调用该方法后，许多方法无法将无法正常使用，慎用
ctClass.prune() 
//解冻一个类，使其可以被修改。如果事先知道一个类会被defrost， 则禁止调用prune方法
ctClass.defrost()

// 添加接口
ctClass.addInterface(...);
// 添加构造器
ctClass.addConstructor(...);
// 添加字段
ctClass.addField(...);
// 添加方法
ctClass.addMethod(...);

// 获取字节码文件 需要注意的是一旦调用该方法，则无法继续修改已经被加载的class
Class clazz = ctClass.toClass();
// 类的字节码文件
ClassFile classFile = ctClass.getClassFile();
// 编译成字节码文件, 使用当前线程上下文类加载器加载类, 如果类已存在或者编译失败将抛出异常
byte[] bytes = ctClass.toBytecode();

CtClass ctClass5 = pool.get(TestService.class.getName());
CtMethod ctMethod = ctClass5.getDeclaredMethod("selectOrder");
// 方法名
String methodName = ctMethod.getName();
// 返回类型
CtClass returnType = ctMethod.getReturnType();
// 方法参数, 通过此种方式得到方法参数列表
// 格式: com.kawa.TestService.getOrder(java.lang.String,java.util.List)
ctMethod.getLongName();
// 方法签名 格式: (Ljava/lang/String;Ljava/util/List;Lcom/test/Order;)Ljava/lang/Integer;
ctMethod.getSignature();

// 获取方法参数名称, 可以通过这种方式得到方法真实参数名称
List<String> argKeys = new ArrayList<>();
MethodInfo methodInfo = ctMethod.getMethodInfo();
CodeAttribute codeAttribute = methodInfo.getCodeAttribute();
LocalVariableAttribute attr = (LocalVariableAttribute) codeAttribute.getAttribute(LocalVariableAttribute.tag);
int len = ctMethod.getParameterTypes().length;
// 非静态的成员函数的第一个参数是this
int pos = Modifier.isStatic(ctMethod.getModifiers()) ? 0 : 1;
for (int i = pos; i < len; i++) {
    argKeys.add(attr.variableName(i));
}

// 在方法体前插入代码块
ctMethod.insertBefore("");
// 在方法体后插入代码块
ctMethod.insertAfter("");
// 在某行 字节码 后插入代码块
ctMethod.insertAt(10, "");
// 添加参数
ctMethod.addParameter(CtClass);
// 设置方法名
ctMethod.setName("newName");
// 设置方法体 $0=this / $1,$2,$3... 代表方法参数
ctMethod.setBody("{$0.name = $1;}");
//创建一个新的方法
ctMethod.make("kawa",CtClass);

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;
}

//默认加载方式如pool.insertClassPath(new ClassClassPath(this.getClass()));
ClassPool pool = ClassPool.getDefault();
//从file加载classpath
pool.insertClassPath("/usr/local/javalib")
//从URL中加载
ClassPath cp = new URLClassPath("www.javassist.org", 80, "/java/", "org.javassist.");
pool.insertClassPath(cp);
//从byte[] 中加载
byte[] b = a byte array;
String name = class name;
cp.insertClassPath(new ByteArrayClassPath(name, b));
//可以从输入流中加载class
InputStream ins = an input stream for reading a class file;
CtClass cc = cp.makeClass(ins);

pool.insertClassPath(new ClassClassPath(Person.getClass()));

// 将classpath插入到指定classpath之前
pool.insertClassPath(new ClassClassPath(this.getClass()));
// 将classpath添加到指定classpath之后
pool.appendClassPath(new ClassClassPath(this.getClass()));
// 将一个目录作为classpath
pool.insertClassPath("/xxx/lib");

ClassPool pool = ClassPool.getDefault();
ClassPath cp = new URLClassPath("www.sample.com", 80, "/out/", "com.test.");
pool.insertClassPath(cp);

ClassPool cp = ClassPool.getDefault();
byte[] buf = 字节数组;
String name = 类名;
cp.insertClassPath(new ByteArrayClassPath(name, buf));
CtClass cc = cp.get(name);

ClassPool cp = ClassPool.getDefault();
InputStream ins =  class文件对应的输入流;
CtClass cc = cp.makeClass(ins);

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

byte[] b = cc.toBytecode();

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

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

CtClasss cc = ...;
cc.stopPruning(true);
    :
cc.writeFile();                             // convert to a class file.
// cc is not pruned.

pool.insertClassPath(new ClassClassPath(this.getClass()));

ClassPool pool = ClassPool.getDefault();
pool.insertClassPath("/usr/local/javalib");

ClassPool pool = ClassPool.getDefault();
ClassPath cp = new URLClassPath("www.javassist.org", 80, "/java/", "org.javassist.");
pool.insertClassPath(cp);

ClassPool cp = ClassPool.getDefault();
byte[] b = a byte array;
String name = class name;
cp.insertClassPath(new ByteArrayClassPath(name, b));
CtClass cc = cp.get(name);

ClassPool cp = ClassPool.getDefault();
InputStream ins = an input stream for reading a class file;
CtClass cc = cp.makeClass(ins);

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

ClassPool cp = new ClassPool(true);
// if needed, append an extra search path by appendClassPath()

ClassPool cp = new ClassPool();
cp.appendSystemPath();  // or append another path by appendClassPath()

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

ClassPool parent = ClassPool.getDefault();
ClassPool child = new ClassPool(parent);
child.appendSystemPath();         // the same class path as the default one.
child.childFirstLookup = true;    // changes the behavior of the child.

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("Point");
cc.setName("Pair");

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("Point");
CtClass cc1 = pool.get("Point");   // cc1 is identical to cc.
cc.setName("Pair");
CtClass cc2 = pool.get("Pair");    // cc2 is identical to cc.
CtClass cc3 = pool.get("Point");   // cc3 is not identical to cc.

ClassPool cp = new ClassPool(true);

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

ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get("Point");
cc.writeFile();
CtClass cc2 = pool.getAndRename("Point", "Pair");

public class Hello {
    public void say() {
        System.out.println("Hello");
    }
}

public class Test {
    public static void main(String[] args) throws Exception {
        ClassPool cp = ClassPool.getDefault();
        CtClass cc = cp.get("Hello");
        CtMethod m = cc.getDeclaredMethod("say");
        m.insertBefore("{ System.out.println(\"Hello.say():\"); }");
        Class c = cc.toClass();
        Hello h = (Hello)c.newInstance();
        h.say();
    }
}

CtClass cc = ...;
Class c = cc.toClass(bean.getClass().getClassLoader());

MyClassLoader myLoader = new MyClassLoader();
Class clazz = myLoader.loadClass("Box");
Object obj = clazz.newInstance();
Box b = (Box)obj;    // this always throws ClassCastException.

public class Point {    // loaded by PL
    private int x, y;
    public int getX() { return x; }
        :
}

public class Box {      // the initiator is L but the real loader is PL
    private Point upperLeft, size;
    public int getBaseX() { return upperLeft.x; }
        :
}

public class Window {    // loaded by a class loader L
    private Box box;
    public int getBaseX() { return box.getBaseX(); }
}

public class Point {
    private int x, y;
    public int getX() { return x; }
        :
}

public class Box {      // the initiator is L but the real loader is PL
    private Point upperLeft, size;
    public Point getSize() { return size; }
        :
}

public class Window {    // loaded by a class loader L
    private Box box;
    public boolean widthIs(int w) {
        Point p = box.getSize();
        return w == p.getX();
    }
}

Point p = box.getSize();

public class Point {
    public int x, y;    // not private
    public int getX() { return x; }
        :
}

import javassist.*;
import test.Rectangle;

public class Main {
  public static void main(String[] args) throws Throwable {
     ClassPool pool = ClassPool.getDefault();
     Loader cl = new Loader(pool);

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

     Class c = cl.loadClass("test.Rectangle");
     Object rect = c.newInstance();
         :
  }
}

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

public class MyTranslator implements Translator {
    void start(ClassPool pool)
        throws NotFoundException, CannotCompileException {}
    void onLoad(ClassPool pool, String classname)
        throws NotFoundException, CannotCompileException
    {
        CtClass cc = pool.get(classname);
        cc.setModifiers(Modifier.PUBLIC);
    }
}

import javassist.*;

public class Main2 {
  public static void main(String[] args) throws Throwable {
     Translator t = new MyTranslator();
     ClassPool pool = ClassPool.getDefault();
     Loader cl = new Loader();
     cl.addTranslator(pool, t);
     cl.run("MyApp", args);
  }
}

import javassist.*;

public class SampleLoader extends ClassLoader {
    /* Call MyApp.main().
     */
    public static void main(String[] args) throws Throwable {
        SampleLoader s = new SampleLoader();
        Class c = s.loadClass("MyApp");
        c.getDeclaredMethod("main", new Class[] { String[].class })
         .invoke(null, new Object[] { args });
    }

    private ClassPool pool;

    public SampleLoader() throws NotFoundException {
        pool = new ClassPool();
        pool.insertClassPath("./class"); // MyApp.class must be there.
    }

    /* Finds a specified class.
     * The bytecode for that class can be modified.
     */
    protected Class findClass(String name) throws ClassNotFoundException {
        try {
            CtClass cc = pool.get(name);
            // modify the CtClass object here
            byte[] b = cc.toBytecode();
            return defineClass(name, b, 0, b.length);
        } catch (NotFoundException e) {
            throw new ClassNotFoundException();
        } catch (IOException e) {
            throw new ClassNotFoundException();
        } catch (CannotCompileException e) {
            throw new ClassNotFoundException();
        }
    }
}

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

% java -Xbootclasspath/p:. MyApp arg1 arg2...

public class MyApp {
    public static void main(String[] args) throws Exception {
        System.out.println(String.class.getField("hiddenValue").getName());
    }
}

void move(int newX, int newY) { x = newX; y = newY; }

void move(int newX, int newY, int newZ) {
    // do what you want with newZ.
    move(newX, newY);
}

System.out.println("Hello");
{ System.out.println("Hello"); }
if (i < 0) { i = -i; }

class Point {
    int x, y;
    void move(int dx, int dy) { x += dx; y += dy; }
}

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

CtMethod cm = ...;
cm.useCflow("fact");

cm.insertBefore("if ($cflow(fact) == 0)"
              + "    System.out.println(\"fact \" + $1);");

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

$_ = ($r)foo();

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

String[][] s = new String[3][4];

String[][] s = new String[3][];

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);

CtClass point = ClassPool.getDefault().get("Point");
CtField f = new CtField(CtClass.intType, "z", point);
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();
}

@Author(name="Chiba", year=2005)
public class Point {
    int x, y;
}

CtClass cc = ClassPool.getDefault().get("Point");
Object[] all = cc.getAnnotations();
Author a = (Author)all[0];
String name = a.name();
int year = a.year();
System.out.println("name: " + name + ", year: " + 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) { .. } 
}

BufferedInputStream fin
    = new BufferedInputStream(new FileInputStream("Point.class"));
ClassFile cf = new ClassFile(new DataInputStream(fin));

ClassFile cf = new ClassFile(false, "test.Foo", null);
cf.setInterfaces(new String[] { "java.lang.Cloneable" });
 
FieldInfo f = new FieldInfo(cf.getConstPool(), "width", "I");
f.setAccessFlags(AccessFlag.PUBLIC);
cf.addField(f);

cf.write(new DataOutputStream(new FileOutputStream("Foo.class")));

package test;
class Foo implements Cloneable {
    public int width;
}

ClassFile cf = ... ;
MethodInfo minfo = cf.getMethod("move");    // we assume move is not overloaded.
CodeAttribute ca = minfo.getCodeAttribute();
CodeIterator i = ca.iterator();

CodeIterator ci = ... ;
while (ci.hasNext()) {
    int index = ci.next();
    int op = ci.byteAt(index);
    System.out.println(Mnemonic.OPCODE[op]);
}

ConstPool cp = ...;    // constant pool table
Bytecode b = new Bytecode(cp, 1, 0);
b.addIconst(3);
b.addReturn(CtClass.intType);
CodeAttribute ca = b.toCodeAttribute();

ClassFile cf = ...
Bytecode code = new Bytecode(cf.getConstPool());
code.addAload(0);
code.addInvokespecial("java/lang/Object", MethodInfo.nameInit, "()V");
code.addReturn(null);
code.setMaxLocals(1);

MethodInfo minfo = new MethodInfo(cf.getConstPool(), MethodInfo.nameInit, "()V");
minfo.setCodeAttribute(code.toCodeAttribute());
cf.addMethod(minfo);

Vector<String> v = new Vector<String>();
  :
String s = v.get(0);

Vector v = new Vector();
  :
String s = (String)v.get(0);

public class Wrapper<T> {
  T value;
  public Wrapper(T t) { value = t; }
}

length(new int[] { 1, 2, 3 });

length(1, 2, 3);

package com.ssdmbbl.javassist;

public class Hello {
    public Hello() {
    }
}

package com.ssdmbbl.javassist;

import javassist.*;


public class JavassistTest2 {


    public static void main(String[] args) throws Exception {
        final ClassPool pool = ClassPool.getDefault();
        //2.新建一个空类，叫Hello类
        final CtClass makeClass = pool.makeClass("com.ssdmbbl.javassist.Hello");
        // 3.新增一个字段 private String name；
        // 字段名为name
        final CtField nameField = new CtField(pool.get("java.lang.String"), "name", makeClass);
        // 设置字段的访问类型为private
        nameField.setModifiers(Modifier.PRIVATE);

        // 新增age字段，也可以使用make方法快速创建
        final CtField ageField = CtField.make("private int age;", makeClass);

        // 给字段进行默认初始化，并添加到Hello类中
        makeClass.addField(nameField, CtField.Initializer.constant("小明"));
        makeClass.addField(ageField, CtField.Initializer.constant(20));

        // 3.生成getter、setter方法
        makeClass.addMethod(CtNewMethod.setter("setName", nameField));
        makeClass.addMethod(CtNewMethod.getter("getName", nameField));
        makeClass.addMethod(CtNewMethod.setter("setAge", ageField));
        makeClass.addMethod(CtNewMethod.getter("getAge", ageField));

        // 4.添加无参数的构造方法
        final CtConstructor constructor = new CtConstructor(new CtClass[]{}, makeClass);
        // 设置构造方法的方法体
        constructor.setBody("{name=\"老王\";age=30;}");
        makeClass.addConstructor(constructor);
        // 5.添加有参的构造函数
        final CtConstructor constructor1 = new CtConstructor(new CtClass[]{pool.get("java.lang.String"), CtClass.intType}, makeClass);
        // $0=this, $1,$2,$3...代表第几个参数
        constructor1.setBody("{$0.name=$1;$0.age=$2;}");
        // 添加到person类中
        makeClass.addConstructor(constructor1);
        

        // 6.创建一个名为printName的方法，无参数，无返回值，输出name值
        final CtMethod printName = new CtMethod(CtClass.voidType, "printName", new CtClass[]{}, makeClass);
        // 设置方法访问类型
        printName.setModifiers(Modifier.PUBLIC);
        printName.setBody("{System.out.println(name);}");
        // 上面的方式可以换成这种快速创建
        final CtMethod printAge = CtMethod.make("public void printAge(){System.out.println(age);}", makeClass);

        // 添加到Hello类中
        makeClass.addMethod(printName);
        makeClass.addMethod(printAge);
        makeClass.writeFile("./aa");
    }
}

// 创建构造方法
       CtConstructor constructor = CtNewConstructor
               .make("public User(String name, String age) { this.name = name;this.age = age;}", ctClass);

CtMethod ctMethod = CtMethod.make("public int calcute(int a,int b){ return a + b ;}", ctClass);

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.ssdmbbl.javassist;

public class Hello {
    private String name = "小明";
    private int age = 20;

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

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

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

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

    public Hello() {
        this.name = "老王";
        this.age = 30;
    }

    public Hello(String var1, int var2) {
        this.name = var1;
        this.age = var2;
    }

    public void printName() {
        System.out.println(this.name);
    }

    public void printAge() {
        System.out.println(this.age);
    }
}

public class ClassUse {
    public static void main(String[] args) throws Exception {
        // 1.创建classPool
        final ClassPool pool = ClassPool.getDefault();
        // 2.添加目标类的搜索路径
        pool.insertClassPath("./aa");
        // 3.获取Hello.class的CtClass对象
        final CtClass ctClass = pool.get("com.ssdmbbl.javassist.Hello");
        // 4.创建Hello对象
        // 先通过CtClass的toClass让类加载器加载该CtClass，然后使用反射创建对象
        Object personObj = ctClass.toClass().newInstance();
        // 5.反射调用setter方法
        Method setName = personObj.getClass().getMethod("setName", String.class);
        setName.invoke(personObj, "老王");
        // 6.反射执行printName方法
        Method printName = personObj.getClass().getMethod("printName");
        printName.invoke(personObj);
    }
}

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package com.ssdmbbl.javassist;

public class Hello {
    private String name = "小明";
    private int age = 20;

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

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

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

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

    public Hello() {
        this.name = "老王";
        this.age = 30;
    }

    public Hello(String var1, int var2) {
        this.name = var1;
        this.age = var2;
    }

    public void printName() {
        System.out.println(this.name);
    }

    public void printAge() {
        System.out.println(this.age);
    }
}

package com.demo;


public interface IPerson {
    void setName(String name);

    String getName();

    void printName();
}

package com;

import com.demo.IPerson;
import javassist.ClassPool;
import javassist.CtClass;

public class JavassistTest2 {


    public static void main(String[] args) throws Exception {
        final ClassPool pool = ClassPool.getDefault();
        // 获取接口
        CtClass codeClassI = pool.get("com.demo.IPerson");
        // 获取上面生成的类
        CtClass ctClass = pool.get("com.ssdmbbl.Hello");
        // 使代码生成的类，实现 PersonI 接口
        ctClass.setInterfaces(new CtClass[]{codeClassI});

        // 以下通过接口直接调用 强转
        IPerson person = (IPerson) ctClass.toClass().newInstance();
        System.out.println(person.getName());

    }
}

package com.ssdmbbl.javassist;

import javassist.*;

public class JavassistTest2 {


    public static void main(String[] args) throws Exception {
        final ClassPool pool = ClassPool.getDefault();
        //2.新建一个空类，叫Hello类
        final CtClass makeClass = pool.makeClass("com.ssdmbbl.javassist.Hello");
        // 3.新增一个字段 private String name；
        // 字段名为name
        final CtField nameField = new CtField(pool.get("java.lang.String"), "name", makeClass);
        // 设置字段的访问类型为private
        nameField.setModifiers(Modifier.PRIVATE);

        // 新增age字段，也可以使用make方法快速创建
        final CtField ageField = CtField.make("private int age;", makeClass);

        // 给字段进行默认初始化，并添加到Hello类中
        makeClass.addField(nameField, CtField.Initializer.constant("小明"));
        makeClass.addField(ageField, CtField.Initializer.constant(20));

        // 3.生成getter、setter方法
        makeClass.addMethod(CtNewMethod.setter("setName", nameField));
        makeClass.addMethod(CtNewMethod.getter("getName", nameField));
        makeClass.addMethod(CtNewMethod.setter("setAge", ageField));
        makeClass.addMethod(CtNewMethod.getter("getAge", ageField));

        // 4.添加无参数的构造方法
        final CtConstructor constructor = new CtConstructor(new CtClass[]{}, makeClass);
        // 设置构造方法的方法体
        constructor.setBody("{name=\"老王\";age=30;}");
        makeClass.addConstructor(constructor);
        // 5.添加有参的构造函数
        final CtConstructor constructor1 = new CtConstructor(new CtClass[]{pool.get("java.lang.String"), CtClass.intType}, makeClass);
        // $0=this, $1,$2,$3...代表第几个参数
        constructor1.setBody("{$0.name=$1;$0.age=$2;}");
        // 添加到person类中
        makeClass.addConstructor(constructor1);

        // 6.创建一个名为printName的方法，无参数，无返回值，输出name值
        final CtMethod printName = new CtMethod(CtClass.voidType, "printName", new CtClass[]{}, makeClass);
        // 设置方法访问类型
        printName.setModifiers(Modifier.PUBLIC);
        printName.setBody("{System.out.println(name);}");
        // 上面的方式可以换成这种快速创建
        final CtMethod printAge = CtMethod.make("public void printAge(){System.out.println(age);}", makeClass);

        // 添加到Hello类中
        makeClass.addMethod(printName);
        makeClass.addMethod(printAge);
        makeClass.writeFile("./aa");
    }
}

package com.ssdmbbl.javassist;

import com.demo.PersonService;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.util.proxy.ProxyFactory;
import javassist.util.proxy.ProxyObject;

/**
 * @author yishui
 * @version 1.0.0
 * @since 1.0.0
 */
public class ClassUse {
    public static void main(String[] args) throws Exception {
        // 1.创建classPool
        final ClassPool pool = ClassPool.getDefault();
        // 2.获取要修改的class
        final CtClass ctClass = pool.get("com.demo.PersonService");
        // // 实例化代理类工厂
        ProxyFactory factory = new ProxyFactory();
        // 设置代理类的父类，ProxyFactory将会动态生成一个类，继承该父类
        factory.setSuperclass(ctClass.toClass());
        // 设置过滤器，判断哪些方法调用需要被拦截
        factory.setFilter(m -> m.getName() == "fly");
        // 创建代理类型
        final Class<?> aClass = factory.createClass();
        // 创建代理实例,强转成父类
        final PersonService personService = (PersonService) aClass.newInstance();
        ((ProxyObject) personService).setHandler((self, thisMethod, proceed, args1) -> {
            //thisMethod为被代理方法 proceed为代理方法 self为代理实例 args为方法参数
            System.out.println((thisMethod.getName() + "被调用前输出"));
            try {
                Object ret = proceed.invoke(self, args1);
                System.out.println(thisMethod.getName() + "正在调用，返回值: " + ret);
                return ret;
            } finally {
                System.out.println(thisMethod.getName() + "被调用后输出");
            }
        });
        // 调用代理类的fly方法
        personService.fly();
    }
}

package com.demo;

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

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

package com.ssdmbbl.javassist;

import javassist.*;

/**
 * @author yishui
 * @version 1.0.0
 * @since 1.0.0
 */
public class ClassUse {
    public static void main(String[] args) throws Exception {
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.get("com.demo.Person");

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

        //方式二
        CtClass[] parameters = new CtClass[]{CtClass.intType, pool.get("java.lang.String")};
        //第二种方式，返回值类型，方法名，参数，对象
        CtMethod cm2 = new CtMethod(CtClass.intType, "add2", parameters, cc);
        //访问范围
        cm2.setModifiers(Modifier.PUBLIC);
        //方法体
        cm2.setBody("{return $1+$2.length();}");
        cc.addMethod(cm2);
        //保存到指定位置
        cc.writeFile("./demo");
    }
}