一、前言

Javassist 定制化开发是一个开源，用于分析、定制化开发编辑和创建Java定制化开发字节码的类库，定制化开发由东京工业大学数学和定制化开发计算机科学系的 Shigeru Chiba （千叶滋）所创建。定制化开发目前已加入了开放源代码定制化开发应用服务器项目，通过使用Javassist定制化开发对字节码操作为JBoss实现动态"AOP"框架。

通过使用Javassist可以使Java定制化开发程序在运行时定义一个新的类，并且在JVM定制化开发加载类文件时修改它

Javassist定制化开发提供两个级别的API：定制化开发源码级别和字节码级别。

定制化开发如果使用源码级的API，定制化开发开发人员可以在不知道Java定制化开发字节码的情况下编辑Java类文件，定制化开发就像我们编写Java定制化开发源代码一样方便。定制化开发如果使用字节码级别的API，定制化开发那么需要详细了解Java定制化开发字节码和类文件格式，定制化开发因为字节码级别的API定制化开发允许我们对类文件进行任意修改。

官网地址：

二、Javassist 定制化开发中几个重要的类

在使用javassist定制化开发进行编码之前，有必要对javassist定制化开发理论知识做一个全面的定制化开发了解和学习；

Javassist 定制化开发中最为重要的是 ClassPool，CtClass ，CtMethod 以及 CtField 这几个类；

ClassPool：基于Hashtable 实现的CtClass 对象容器，定制化开发其中键是类名称，定制化开发值是表示该类的 CtClass 对象；
CtClass：CtClass 表示类，一个 CtClass (编译时类）定制化开发对象可以处理一个 class 文件，这些 CtClass 定制化开发对象可以从 ClassPool 获得；
CtMethods：定制化开发表示类中的方法；
CtFields ：定制化开发表示类中的字段；

ClassPool

CtClass定制化开发对象的容器，常用的API如下：

getDefault () —— 定制化开发返回默认的ClassPool ，单例模式，定制化开发一般通过该方法创建ClassPool；
appendClassPath(ClassPath cp), insertClassPath(ClassPath cp) —— 将一个ClassPath定制化开发加到定制化开发类搜索路径末尾位置，定制化开发或插入到起始位置。定制化开发通过该方法写入额外的类搜索路径，以解决多个类加载器环境中找不到类问题；
importPackage(String packageName) —— 导入包；
makeClass(String classname) —— 创建一个空类，里面没有变量或方法，后面通过CtClass函数进行添加；
get(String classname)、getCtClass(String classname) —— 根据类路径名获取该类的CtClass对象，用于后续编辑；

1、获取 ClassPool 对象操作


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

2、获取类操作


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

3、创建新类操作


// 复制一个类，创建一个新类
CtClass ctClass2 = pool.getAndRename("com.congge.DemoService", "com.congge.DemoCopyService");
// 通过类名，创建一个新类
CtClass ctClass3 = pool.makeClass("com.congge.NewDemoService");
// 通过文件流，创建一个新类，注意文件必须是编译后的 class 文件，不是源代码文件。
CtClass ctClass4 = pool.makeClass(new FileInputStream(new File("./customize/DemoBeforeHandler.class")));

CtClass

通过 CtClass 对象，开发人员可以得到很多关于类的信息，就可以对类进行修改等操作，常用的API如下：

debugDump;String类型，如果生成。class文件，保存在这个目录下；
setName(String name):给类重命名;
setSuperclass(CtClass clazz):设置父类;
addField(CtField f, Initializer init):添加字段（属性），初始值见CtField；
addMethod(CtMethod m):添加方法（函数）；
toBytecode(): 返回修改后的字节码。需要注意的是一旦调用该方法，则无法继续修改CtClass；
toClass(): 将修改后的CtClass加载至当前线程的上下文类加载器中，CtClass的toClass方法是通过调用本方法实现。需要注意的是一旦调用该方法，则无法继续修改已经被加载的CtClass；
writeFile(String directoryName):根据CtClass生成 .class 文件；
defrost():解冻类，用于使用了toclass()、toBytecode、writeFile()，类已经被JVM加载，Javassist冻结CtClass后；
detach():避免内存溢出，从ClassPool中移除一些不需要的CtClass；

获取类属性


// 类名
String simpleName = ctClass.getSimpleName();
// 类全名
String name = ctClass.getName();
// 包名
String packageName = ctClass.getPackageName();
// 接口
CtClass[] interfaces = ctClass.getInterfaces();
// 继承类
CtClass superclass = ctClass.getSuperclass();
// 获取字节码文件，可以通过 ClassFile 对象进行字节码级操作
ClassFile classFile = ctClass.getClassFile();
// 获取带参数的方法，第二个参数为参数列表数组，类型为 CtClass
CtMethod ctMethod = ctClass.getDeclaredMethod("selectOrder", new CtClass[] {pool.get(String.class.getName()), pool.get(String.class.getName())});
// 获取字段
CtField ctField = ctClass.getField("salary");

类型判断


// 判断数组类型
ctClass.isArray();
// 判断原生类型
ctClass.isPrimitive();
// 判断接口类型
ctClass.isInterface();
// 判断枚举类型
ctClass.isEnum();
// 判断注解类型
ctClass.isAnn

添加类属性


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

编译类


// 编译成字节码文件，使用当前线程上下文类加载器加载类，如果类已存在或者编译失败将抛出异常
Class clazz = ctClass.toClass();
// 编辑成字节码文件，返回 byte 数组
byte[] bytes = ctClass.toBytecode();

CtMethod

方法相关相关，常用的API如下：

insertBefore(String src) —— 在方法的起始位置插入代码；
insertAfter(String src) —— 在方法的所有 return 语句前插入代码以确保语句能够被执行，除非遇到exception；
insertAt(int lineNum, String src): —— 在指定的位置插入代码；
addCatch(String src, CtClass exceptionType) —— 将方法内语句作为try的代码块，插入catch代码块src;
setBody(String src) —— 将方法的内容设置为要写入的代码，当方法被 abstract修饰时，该修饰符被移除；
setModifiers(int mod) —— 设置访问级别，一般使用Modifier调用常量;
invoke(Object obj, Object... args) —— 反射调用字节码生成类的方法；

获取方法属性


CtClass ctClass5 = pool.get(TestService.class.getName());
CtMethod ctMethod = ctClass5.getDeclaredMethod("selectOrder");
// 方法名
String methodName = ctMethod.getName();
// 返回类型
CtClass returnType = ctMethod.getReturnType();
// 方法参数，通过此种方式得到方法参数列表 格式：com.congge.UserService.selectUser(java.lang.String,java.util.List,com.entity.User)
ctMethod.getLongName();
// 方法签名 格式：(Ljava/lang/String;Ljava/util/List)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");
// 设置方法体
ctMethod.setBody("");

对于setBody $0代表this $1、$2、...代表方法的第几个参数，$符号含义总结如下：

符号	含义
$0, $1, $2, ...	this,第几个参数
$args	参数列表. $args的类型是Object[].
$$	所有实参.例如, m($$) 等价于 m($1,$2,...)
$cflow(...)	cflow变量
$r	结果类型. 用于表达式转换.
$w	包装类型. 用于表达式转换.
$_	结果值
$sig	java.lang.Class列表，代表正式入参类型
$type	java.lang.Class对象，代表正式入参值.
$class	java.lang.Class对象，代表传入的代码段.

CtField

字段相关，常用的API如下：

CtField(CtClass type, String name, CtClass declaring) —— 构造函数，添加字段类型，名称，所属的类;
CtField.Initializer constant() —— CtClass使用addField时初始值的设置;
setModifiers(int mod) —— 设置访问级别，一般使用Modifier调用常量；

Javassist API操作综合使用案例

导入依赖


        <dependency>
            <groupId>org.javassist</groupId>
            <artifactId>javassist</artifactId>
            <version>3.27.0-GA</version>
        </dependency>

1、使用javassist创建类


public static void main(String[] args) throws Exception {
        ClassPool pool = new ClassPool(true);
        CtClass targetClass = pool.get("com.congge.test.HelloServiceImpl");
        CtMethod method = targetClass.getDeclaredMethod("sayHello");
        // 复制方法生成一个新的代理方法
        CtMethod agentMethod = CtNewMethod.copy(method, method.getName()+"$agent", targetClass, null);
        agentMethod.setModifiers(Modifier.PRIVATE);
        // 添加方法
        targetClass.addMethod(agentMethod);
        // 构建新的方法体，并使用代理方法
        String source = "{"
                + "System.out.println(\"before handle >  ...\" + $type);"
                + method.getName() + "$agent($$);"
                + "System.out.println(\"after handle ...\");"
                + "}"
                ;
        // 设置方法体
        method.setBody(source);
        targetClass.toClass();
        IHello hello = new HelloServiceImpl();
        hello.sayHello("javassist");
    }

运行上面的代码，观察输出结果，通过该案例就动态创建出了一个接口实现类

2、创建代理方法


import javassist.*;
 
public class JavaSisstWord {
 
    public static void main(String[] args) throws NotFoundException, CannotCompileException, IllegalAccessException, InstantiationException {
        ClassPool pool = new ClassPool(true);
        pool.insertClassPath(new LoaderClassPath(JavaSisstWord.class.getClassLoader()));
 
        //构建一个新的类
        CtClass targetClass = pool.makeClass("com.congge.hello");
        targetClass.addInterface(pool.get(IHello.class.getName()));
 
        //将方法添加进去
        CtClass returnType = pool.get(void.class.getName());
        String name = "sayHello";
        CtClass[] parameters = new CtClass[]{pool.get(String.class.getName())};
        CtMethod method = new CtMethod(returnType,name,parameters,targetClass);
        String src = "{System.out.println(\"hello :\" + $1);}";
        method.setBody(src);
        targetClass.addMethod(method);
 
        //装载class
        Class aClass = targetClass.toClass();
        IHello hello = (IHello) aClass.newInstance();
        hello.sayHello("新的class的参数");
    }
 
    public interface IHello{
        void sayHello(String name);
    }
 
}

可以结合下面这张图总结一下javassist的运行流程

三、Javaagent

在上一篇，用较大的篇幅总结了javaagent的使用，，对于Java 程序员来说，Java Intrumentation、Java agent 这些技术可能平时接触的很少。事实上，在我们日常开发中接触到的各种工具中，有很多都是基于javaagent原理实现的，如（JRebel, spring-loaded）、IDE debug、各种线上诊断工具（btrace,Arthas，skywalking）等。

java agent实现技术也很多，比如本篇接下去要讲的javassist，asm等，都是可以实现的，关于java agent，先介绍几个重要的底层接口类；

Instrumentation

使用 java.lang.instrument.Instrumentation，开发者可以构建一个独立于应用程序的代理程序（Agent），用来监测和协助运行在 JVM 上的程序，甚至能够替换和修改某些类的定义。

有了这样的功能，开发者就可以实现更为灵活的运行时虚拟机监控和 Java 类操作，这样的特性实际上提供了一种虚拟机级别支持的 AOP 实现方式，使得开发者无需对 JDK 做任何升级和改动，就可以实现某些 AOP 的功能了。

Instrumentation 的最大作用，就是类定义动态改变和操作

Instrumentation的一些主要方法如下：


public interface Instrumentation {
    /**
     * 注册一个Transformer，从此之后的类加载都会被 transformer 拦截。
     * ClassFileTransformer 的 transform 方法可以直接对类的字节码进行修改，但是只能修改方法体，不能变更方法签名、增加和删除方法/类的成员属性
     */
    void addTransformer(ClassFileTransformer transformer);
    
    /**
     * 对JVM已经加载的类重新触发类加载，使用上面注册的 ClassFileTransformer 重新对类进行修饰。
     */
    void retransformClasses(Class<?>... classes) throws UnmodifiableClassException;
 
    /**
     * 重新定义类，不是使用 transformer 修饰，而是把处理结果(bytecode)直接给JVM。
     * 调用此方法同样只能修改方法体，不能变更方法签名、增加和删除方法/类的成员属性
     */
    void redefineClasses(ClassDefinition... definitions) throws  ClassNotFoundException, UnmodifiableClassException;
 
    /**
     * 获取一个对象的大小
     */
    long getObjectSize(Object objectToSize);
    
    /**
     * 将一个jar加入到bootstrap classloader 的 classpath 里
     */
    void appendToBootstrapClassLoaderSearch(JarFile jarfile);
 
    /**
     * 将一个jar加入到 system classloader 的 classpath 里
     */
    void appendToSystemClassLoaderSearch(JarFile jarfile);
 
    /**
     * 获取当前被JVM加载的所有类对象
     */
    Class[] getAllLoadedClasses();
}

Javaagent

Java agent 是一种特殊的Java程序（Jar文件），它是 Instrumentation 的客户端具体实现；
与普通 Java 程序通过main方法启动不同，agent 并不是一个可以单独启动的程序，而必须依附在一个Java应用程序（JVM）上，与它运行在同一个进程中，通过 Instrumentation API 与虚拟机交互；
Java agent 与 Instrumentation 密不可分，二者也需要在一起使用。因为JVM 会把 Instrumentation 的实例会作为参数注入到 Java agent 的启动方法中。因此如果想使用 Instrumentation 功能，拿到 Instrumentation 实例，我们必须通过Java agent；

Java agent 有两个启动时机，一个是在程序启动时通过 -javaagent 参数启动代理程序，另一个是在程序运行期间通过 Java Tool API 中的 attach api 动态启动代理程序；

JVM启动时静态加载

对于JVM启动时加载的 agent，Instrumentation 会通过 premain 方法传入代理程序，premain 方法会在程序 main 方法执行之前被调用。

此时大部分Java类都没有被加载（“大部分”是因为，agent类本身和它依赖的类还是无法避免的会先加载的），是一个对类加载埋点做手脚（addTransformer）的好机会。但这种方式有很大的局限性，Instrumentation 仅限于 main 函数执行前，此时有很多类还没有被加载，如果想为其注入 Instrumentation 就无法办到。

这种方式的应用：例如在 IDEA 启动 debug 模式时，就是以 -javaagent 的形式启动 debug 代理程序实现的


/**
 * agentArgs 是 premain 函数得到的程序参数，通过 -javaagent 传入。这个参数是个字符串，如果程序参数有多个，需要程序自行解析这个字符串。
 * inst 是一个 java.lang.instrument.Instrumentation 的实例，由 JVM 自动传入。
 */
public static void premain(String agentArgs, Instrumentation inst) {
    
}
 
/**
 * 带有 Instrumentation 参数的 premain 优先级高于不带此参数的 premain。
 * 如果存在带 Instrumentation 参数的 premain，不带此参数的 premain 将被忽略。
 */
public static void premain(String agentArgs) {
    
}

如下面这段代码，按照上一篇文章，将MyPreMainAgent 配置并打包后，其他类启动参数配置了这个jar就会先于方法输出这段结果；


public class MyPreMainAgent {
 
    public static void premain(String agentArgs, Instrumentation inst) {
        System.out.println("hello javaAgent");
    }
 
}

JVM 启动后动态加载

对于VM启动后动态加载的 agent，Instrumentation 会通过 agentmain 方法传入代理程序，agentmain 在 main 函数开始运行后才被调用；

这种方式，比如在使用 Arthas 进行诊断线上问题时，通过 attach api，来动态加载代理程序到目标VM；


/**
 * agentArgs 是 agentmain 函数得到的程序参数，在 attach 时传入。这个参数是个字符串，如果程序参数有多个，需要程序自行解析这个字符串。
 * inst 是一个 java.lang.instrument.Instrumentation 的实例，由 JVM 自动传入。
 */
public static void agentmain(String agentArgs, Instrumentation inst) {
 
}
 
/**
 * 带有 Instrumentation 参数的 agentmain 优先级高于不带此参数的 agentmain。
 * 如果存在带 Instrumentation 参数的 agentmain，不带此参数的 agentmain 将被忽略。
 */
public static void agentmain(String agentArgs) {
 
}

MANIFEST.MF

编写好的代理类想要运行，在打 jar 包前，还需在 MANIFEST.MF 中指定代理程序入口（当然，也可以在maven的pom文件中进行插件化形式的配置，效果类似）；

大多数 JAR 文件会包含一个 META-INF 目录，它用于存储包和扩展的配置数据，如安全性和版本信息。其中会有一个 MANIFEST.MF 文件，该文件包含了该 Jar 包的版本、创建人和类搜索路径等信息，如果是可执行Jar 包，会包含Main-Class属性，表明 Main 方法入口；

例如下面是通过 mvn clean package 命令打包后的 Jar 包中的 MANIFEST.MF 文件，从中可以看出 jar 的版本、创建者、SpringBoot 版本、程序入口、类搜索路径等信息。

其中涉及到与agent相关的参数

Premain-Class：JVM 启动时指定了代理，此属性指定代理类，即包含 premain 方法的类；
Agent-Class：JVM动态加载代理，此属性指定代理类，即包含 agentmain 方法的类；
Boot-Class-Path：设置引导类加载器搜索的路径列表，列表中的路径由一个或多个空格分开；
Can-Redefine-Classes：布尔值（true 或 false）。是否能重定义此代理所需的类；
Can-Retransform-Classes：布尔值（true 或 false）。是否能重转换此代理所需的类；
Can-Set-Native-Method-Prefix：布尔值（true 或 false）。是否能设置此代理所需的本机方法前缀；

四、基于javassit实现对coontroller层的监控

通常在实际的业务开发中，我们可能会碰到类似下面这样的需求

拦截指定包下的所有业务类，进行方法参数合规性校验；
对特定的接口请求进行限流；
对特定的方法进行参数的日志审计；
...

遇到这样的需求，很多同学第一反应大多会想到AOP，没毛病，使用aop来解决这个问题是个不错的思路，但还是那句话，有了javaagent之后，可以尽可能的让开发人员少改动现有的代码，接下来，考虑下如果在业务中要实现对某个controller进行参数，返回值的监控，该如何做呢？接下来看完整的实现步骤；

1、导入相关依赖


    <dependencies>
 
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
 
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
 
        <dependency>
            <groupId>org.javassist</groupId>
            <artifactId>javassist</artifactId>
            <version>3.27.0-GA</version>
        </dependency>
 
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.67</version>
        </dependency>
 
    </dependencies>
 
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.1.0</version>
                <configuration>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                        </manifest>
                        <manifestEntries>
                            <Premain-Class>com.congge.agent.jvm.AgentMain2</Premain-Class>
                            <Can-Redefine-Classes>true</Can-Redefine-Classes>
                            <Can-Retransform-Classes>true</Can-Retransform-Classes>
                            <Can-Set-Native-Method-Prefix>true</Can-Set-Native-Method-Prefix>
                        </manifestEntries>
                    </archive>
                </configuration>
            </plugin>
        </plugins>
    </build>

2、提供一个测试用的接口类


import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class UserController {
 
    @GetMapping("/queryUserInfo")
    public String queryUserInfo(String userId){
        return "hello :" + userId;
    }
 
}

3、编写agent类


import java.io.IOException;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.lang.instrument.Instrumentation;
import java.security.ProtectionDomain;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
 
public class AgentMain2 {
 
    private static final Set<String> classNameSet = new HashSet<>();
 
    static {
        classNameSet.add("com.congge.controller.UserController");
    }
 
    public static void premain(String agentArgs, Instrumentation instrumentation) {
 
        final ClassPool pool = new ClassPool();
        pool.appendSystemPath();
 
        //基于工具，在运行的时候修改class字节码，即动态插装
        instrumentation.addTransformer(new ClassFileTransformer() {
            @Override
            public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
 
                String currentClassName = className.replaceAll("/", ".");
                if (!classNameSet.contains(currentClassName)) { // 提升classNameSet中含有的类
                    return null;
                }
 
                if(classNameSet.contains(currentClassName)){
                    // 获取类
                    //CtClass ctClass = ClassPool.getDefault().get(currentClassName);
                    CtClass ctClass = null;
                    try {
                        ctClass = pool.getDefault().get(currentClassName);
                    } catch (NotFoundException e) {
                        e.printStackTrace();
                    }
                    String clazzName = ctClass.getName();
 
                    // 获取方法
                    CtMethod ctMethod = null;
                    try {
                        ctMethod = ctClass.getDeclaredMethod("queryUserInfo");
                    } catch (NotFoundException e) {
                        e.printStackTrace();
                    }
                    String methodName = ctMethod.getName();
 
                    // 方法信息：methodInfo.getDescriptor();
                    MethodInfo methodInfo = ctMethod.getMethodInfo();
 
                    // 方法：入参信息
                    CodeAttribute codeAttribute = methodInfo.getCodeAttribute();
                    LocalVariableAttribute attr = (LocalVariableAttribute) codeAttribute.getAttribute(LocalVariableAttribute.tag);
                    CtClass[] parameterTypes = new CtClass[0];
                    try {
                        parameterTypes = ctMethod.getParameterTypes();
                    } catch (NotFoundException e) {
                        e.printStackTrace();
                    }
 
 
                    boolean isStatic = (methodInfo.getAccessFlags() & AccessFlag.STATIC) != 0;  // 判断是否为静态方法
                    int parameterSize = isStatic ? attr.tableLength() : attr.tableLength() - 1; // 静态类型取值
                    List<String> parameterNameList = new ArrayList<>(parameterSize);            // 入参名称
                    List<String> parameterTypeList = new ArrayList<>(parameterSize);            // 入参类型
                    StringBuilder parameters = new StringBuilder();                             // 参数组装；$1、$2...，$$可以获取全部，但是不能放到数组初始化
 
                    for (int i = 0; i < parameterSize; i++) {
                        parameterNameList.add(attr.variableName(i + (isStatic ? 0 : 1))); // 静态类型去掉第一个this参数
                        parameterTypeList.add(parameterTypes[i].getName());
                        if (i + 1 == parameterSize) {
                            parameters.append("$").append(i + 1);
                        } else {
                            parameters.append("$").append(i + 1).append(",");
                        }
                    }
 
                    // 方法：出参信息
                    CtClass returnType = null;
                    try {
                        returnType = ctMethod.getReturnType();
                    } catch (NotFoundException e) {
                        e.printStackTrace();
                    }
                    String returnTypeName = returnType.getName();
 
                    // 方法：生成方法唯一标识ID
                    int idx = Monitor.generateMethodId(clazzName, methodName, parameterNameList, parameterTypeList, returnTypeName);
 
                    // 定义属性
                    try {
                        ctMethod.addLocalVariable("startNanos", CtClass.longType);
                    } catch (CannotCompileException e) {
                        e.printStackTrace();
                    }
                    try {
                        ctMethod.addLocalVariable("parameterValues", ClassPool.getDefault().get(Object[].class.getName()));
                    } catch (CannotCompileException e) {
                        e.printStackTrace();
                    } catch (NotFoundException e) {
                        e.printStackTrace();
                    }
 
                    // 方法前加强
                    try {
                        ctMethod.insertBefore("{ startNanos = System.nanoTime(); parameterValues = new Object[]{" + parameters.toString() + "}; }");
                    } catch (CannotCompileException e) {
                        e.printStackTrace();
                    }
 
                    // 方法后加强
                    try {
                        ctMethod.insertAfter("{ com.congge.agent.jvm.Monitor.point(" + idx + ", startNanos, parameterValues, $_);}", false); // 如果返回类型非对象类型，$_ 需要进行类型转换
                    } catch (CannotCompileException e) {
                        e.printStackTrace();
                    }
 
                    // 方法；添加TryCatch
                    try {
                        ctMethod.addCatch("{ com.congge.agent.jvm.Monitor.point(" + idx + ", $e); throw $e; }", ClassPool.getDefault().get("java.lang.Exception"));   // 添加异常捕获
                    } catch (CannotCompileException e) {
                        e.printStackTrace();
                    } catch (NotFoundException e) {
                        e.printStackTrace();
                    }
 
                    try {
                        return ctClass.toBytecode();
                    } catch (IOException e) {
                        e.printStackTrace();
                    } catch (CannotCompileException e) {
                        e.printStackTrace();
                    }
                }
                return null;
            }
        });
 
    }
 
}

该类的主要实现思路，就是重写premain方法，并覆盖其中的instrumentation的实现，在instrumentation的实现中，充分利用javassist提供的相关API，拦截并获取目标UserController的方法的参数，以及执行结果；

4、将上面的agent所在的类配置到pom下并打包

5、启动springboot工程并在VM中配置如下参数

-javaagent:E:\code-self\spi\java-agent\target\java-agent-1.0-SNAPSHOT.jar=com.congge.agent.User

6、测试结果

启动完成后，浏览器访问下接口，并观察控制台输出结果；

通过控制台结果输出，在agent中需要监控拦截的信息就可以拿到了，那么拿到这些信息之后，理论上来说，就可以做更多的事情了，比如，上报异常参数，执行结果等等；

本段代码中，逻辑是写在一起的，而且只监控了UserController这一个类，在实际开发中，可以通过更灵活的方式去做，比如写到配置文件读取，通过自定义注解，或者扫描某个包路径等等；

代码优化改进

按照上面的思路，为了让这段代码更具通用性，我们可以直针对特定注解的类进行监控，同时对这样的目标类下的所有方法进行拦截，改进后的代码如下：


import javassist.*;
import javassist.bytecode.AccessFlag;
import javassist.bytecode.CodeAttribute;
import javassist.bytecode.LocalVariableAttribute;
import javassist.bytecode.MethodInfo;
 
import java.io.IOException;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.lang.instrument.Instrumentation;
import java.security.ProtectionDomain;
import java.util.*;
 
public class AgentMain3 {
 
    private static final Set<String> classNameSet = new HashSet<>();
 
    static {
        classNameSet.add("com.congge.controller.UserController");
    }
 
    public static void premain(String agentArgs, Instrumentation instrumentation) {
 
        final ClassPool pool = new ClassPool();
        pool.appendSystemPath();
 
        //基于工具，在运行的时候修改class字节码，即动态插装
        instrumentation.addTransformer(new ClassFileTransformer() {
            @Override
            public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
 
                String currentClassName = className.replaceAll("/", ".");
                if (!classNameSet.contains(currentClassName)) { // 提升classNameSet中含有的类
                    return null;
                }
 
                if(classNameSet.contains(currentClassName)){
                    // 获取类
                    //CtClass ctClass = ClassPool.getDefault().get(currentClassName);
                    CtClass ctClass = null;
                    try {
                        ctClass = pool.getDefault().get(currentClassName);
                        try {
                            Object[] annotations = ctClass.getAnnotations();
                            for (Object obj : annotations) {
                                if (!obj.toString().startsWith("@org.springframework.web.bind.annotation.RestController")) {
                                    continue;
                                }
                            }
                        } catch (ClassNotFoundException e) {
                            e.printStackTrace();
                        }
                    } catch (NotFoundException e) {
                        e.printStackTrace();
                    }
                    String clazzName = ctClass.getName();
                    // 获取方法
                    //CtMethod ctMethod = null;
                    try {
                        CtMethod[] declaredMethods = ctClass.getDeclaredMethods();
                        if(Objects.nonNull(declaredMethods) && declaredMethods.length >0){
                            for(CtMethod ctMethod1 : declaredMethods){
                                CtMethod ctMethod = ctClass.getDeclaredMethod(ctMethod1.getName());
                                doHandleMethod(clazzName, ctMethod);
                            }
                        }
                    } catch (NotFoundException e) {
                        e.printStackTrace();
                    }
                    try {
                        return ctClass.toBytecode();
                    } catch (IOException e) {
                        e.printStackTrace();
                    } catch (CannotCompileException e) {
                        e.printStackTrace();
                    }
                }
                return null;
            }
        });
 
    }
 
    private static void doHandleMethod(String clazzName, CtMethod ctMethod) {
        String methodName = ctMethod.getName();
        // 方法信息：methodInfo.getDescriptor();
        MethodInfo methodInfo = ctMethod.getMethodInfo();
 
        // 方法：入参信息
        CodeAttribute codeAttribute = methodInfo.getCodeAttribute();
        LocalVariableAttribute attr = (LocalVariableAttribute) codeAttribute.getAttribute(LocalVariableAttribute.tag);
        CtClass[] parameterTypes = new CtClass[0];
        try {
            parameterTypes = ctMethod.getParameterTypes();
        } catch (NotFoundException e) {
            e.printStackTrace();
        }
 
        boolean isStatic = (methodInfo.getAccessFlags() & AccessFlag.STATIC) != 0;  // 判断是否为静态方法
        int parameterSize = isStatic ? attr.tableLength() : attr.tableLength() - 1; // 静态类型取值
        List<String> parameterNameList = new ArrayList<>(parameterSize);            // 入参名称
        List<String> parameterTypeList = new ArrayList<>(parameterSize);            // 入参类型
        StringBuilder parameters = new StringBuilder();                             // 参数组装；$1、$2...，$$可以获取全部，但是不能放到数组初始化
 
        for (int i = 0; i < parameterSize; i++) {
            parameterNameList.add(attr.variableName(i + (isStatic ? 0 : 1))); // 静态类型去掉第一个this参数
            parameterTypeList.add(parameterTypes[i].getName());
            if (i + 1 == parameterSize) {
                parameters.append("$").append(i + 1);
            } else {
                parameters.append("$").append(i + 1).append(",");
            }
        }
 
        // 方法：出参信息
        CtClass returnType = null;
        try {
            returnType = ctMethod.getReturnType();
        } catch (NotFoundException e) {
            e.printStackTrace();
        }
        String returnTypeName = returnType.getName();
 
        // 方法：生成方法唯一标识ID
        int idx = Monitor.generateMethodId(clazzName, methodName, parameterNameList, parameterTypeList, returnTypeName);
 
        // 定义属性
        try {
            ctMethod.addLocalVariable("startNanos", CtClass.longType);
        } catch (CannotCompileException e) {
            e.printStackTrace();
        }
        try {
            ctMethod.addLocalVariable("parameterValues", ClassPool.getDefault().get(Object[].class.getName()));
        } catch (CannotCompileException e) {
            e.printStackTrace();
        } catch (NotFoundException e) {
            e.printStackTrace();
        }
 
        // 方法前加强
        try {
            ctMethod.insertBefore("{ startNanos = System.nanoTime(); parameterValues = new Object[]{" + parameters.toString() + "}; }");
        } catch (CannotCompileException e) {
            e.printStackTrace();
        }
 
        // 方法后加强
        try {
            ctMethod.insertAfter("{ com.congge.agent.jvm.Monitor.point(" + idx + ", startNanos, parameterValues, $_);}", false); // 如果返回类型非对象类型，$_ 需要进行类型转换
        } catch (CannotCompileException e) {
            e.printStackTrace();
        }
 
        // 方法；添加TryCatch
        try {
            ctMethod.addCatch("{ com.congge.agent.jvm.Monitor.point(" + idx + ", $e); throw $e; }", ClassPool.getDefault().get("java.lang.Exception"));   // 添加异常捕获
        } catch (CannotCompileException e) {
            e.printStackTrace();
        } catch (NotFoundException e) {
            e.printStackTrace();
        }
    }
 
}

为了模拟出效果，我们在UserController中再增加一个方法


@RestController
public class UserController {
 
    @GetMapping("/queryUserInfo")
    public String queryUserInfo(String userId){
        return "hello :" + userId;
    }
 
    @GetMapping("/queryUserInfo2")
    public String queryUserInfo2(String userName){
        return "hello :" + userName;
    }
 
}

按照上面的步骤再次完成配置之后，再次启动工程进行测试，依次访问下面的接口,，观察控制台输出效果：


http://localhost:8087/queryUserInfo?userId=222
http://localhost:8087/queryUserInfo2?userName=javassist

如果需要监控更多的业务类，或者特定注解的类，也可以尝试类似的思路，比如我们要监控业务实现层的方法等，均可借鉴。

定制化开发【微服务】springboot 整合javassist详解