【微服务】springboot 整合javassist详解

一、前言

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

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

Javassist提供两个级别的API：源码级别和字节码级别。

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

官网地址：Javassist官方教程

二、Javassist 中几个重要的类

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

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

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

ClassPool

CtClass对象的容器，常用的API如下：

1. getDefault () —— 返回默认的ClassPool ，单例模式，一般通过该方法创建ClassPool；
2. appendClassPath(ClassPath cp),  insertClassPath(ClassPath cp)  —— 将一个ClassPath加到类搜索路径末尾位置，或插入到起始位置。通过该方法写入额外的类搜索路径，以解决多个类加载器环境中找不到类问题；
3. importPackage(String packageName) —— 导入包；
4. makeClass(String classname) —— 创建一个空类，里面没有变量或方法，后面通过CtClass函数进行添加；
5. 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 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操作综合使用案例

导入依赖

        
            org.javassist
            javassist
            3.27.0-GA
        

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 agent使用 ，对于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、导入相关依赖

    

        
            junit
            junit
            4.12
        

        
            org.springframework.boot
            spring-boot-starter-web
        

        
            org.javassist
            javassist
            3.27.0-GA
        

        
            com.alibaba
            fastjson
            1.2.67
        

    

    
        
            
                org.apache.maven.plugins
                maven-jar-plugin
                3.1.0
                
                    
                        
                            true
                        
                        
                            com.congge.agent.jvm.AgentMain2
                            true
                            true
                            true
                        
                    
                
            
        
    

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 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 parameterNameList = new ArrayList<>(parameterSize);            // 入参名称
                    List 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 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 parameterNameList = new ArrayList<>(parameterSize);            // 入参名称
        List 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

 

 

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