<?xml versinotallow="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocatinotallow="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.yian</groupId>
    <artifactId>springboot-debug-agent</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <asm.version>9.3</asm.version>
    </properties>

    <dependencies>
        <!-- ASM字節(jié)碼操作庫 -->
        <dependency>
            <groupId>org.ow2.asm</groupId>
            <artifactId>asm</artifactId>
            <version>${asm.version}</version>
        </dependency>
        <dependency>
            <groupId>org.ow2.asm</groupId>
            <artifactId>asm-commons</artifactId>
            <version>${asm.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>3.3.0</version>
                <configuration>
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                    <archive>
                        <manifestEntries>
                            <!-- 啟動時加載的入口類 -->
                            <Premain-Class>com.yian.agent.DebugAgent</Premain-Class>
                            <!-- 運行時加載的入口類 -->
                            <Agent-Class>com.yian.agent.DebugAgent</Agent-Class>
                            <!-- 允許重定義類 -->
                            <Can-Redefine-Classes>true</Can-Redefine-Classes>
                            <!-- 允許重轉(zhuǎn)換類 -->
                            <Can-Retransform-Classes>true</Can-Retransform-Classes>
                        </manifestEntries>
                    </archive>
                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

/**
 * Java Agent入口類，實現(xiàn)無痕調(diào)試注入功能
 */
public class DebugAgent {
    private static final Logger logger = Logger.getLogger(DebugAgent.class.getName());
    private static Instrumentation instrumentation;

    /**
     * JVM啟動時加載Agent的入口方法
     */
    public static void premain(String agentArgs, Instrumentation inst) {
        logger.info("DebugAgent premain 啟動...");
        initialize(agentArgs, inst);
    }

    /**
     * 運行時動態(tài)加載Agent的入口方法
     */
    public static void agentmain(String agentArgs, Instrumentation inst) {
        logger.info("DebugAgent agentmain 啟動...");
        initialize(agentArgs, inst);
        
        // 運行時加載需要觸發(fā)類重轉(zhuǎn)換
        try {
            Class<?>[] allLoadedClasses = inst.getAllLoadedClasses();
            for (Class<?> clazz : allLoadedClasses) {
                if (AgentConfig.shouldTransform(clazz.getName())) {
                    inst.retransformClasses(clazz);
                    logger.info("已重新轉(zhuǎn)換類: " + clazz.getName());
                }
            }
        } catch (Exception e) {
            logger.severe("類重轉(zhuǎn)換失敗: " + e.getMessage());
        }
    }

    /**
     * 初始化Agent
     */
    private static void initialize(String agentArgs, Instrumentation inst) {
        instrumentation = inst;
        // 解析Agent參數(shù)
        AgentConfig.parse(agentArgs);
        // 添加類轉(zhuǎn)換器
        inst.addTransformer(new MethodMonitorTransformer(), true);
        logger.info("DebugAgent 初始化完成，配置: " + AgentConfig.getConfigInfo());
    }

    public static Instrumentation getInstrumentation() {
        return instrumentation;
    }
}

/**
 * Agent配置類，解析和存儲注入規(guī)則
 */
public class AgentConfig {
    private static final Logger logger = Logger.getLogger(AgentConfig.class.getName());
    
    // 包含規(guī)則（正則表達式）
    private static final List<Pattern> includePatterns = new ArrayList<>();
    // 排除規(guī)則（正則表達式）
    private static final List<Pattern> excludePatterns = new ArrayList<>();
    // 日志文件路徑
    private static String logFile;
    
    /**
     * 解析Agent參數(shù)
     * 格式: include=com.yian.*;exclude=com.yian.test.*;logFile=/tmp/agent.log
     */
    public static void parse(String agentArgs) {
        if (agentArgs == null || agentArgs.trim().isEmpty()) {
            logger.info("未指定Agent參數(shù)，使用默認配置");
            // 添加默認規(guī)則，監(jiān)控所有Spring組件
            includePatterns.add(Pattern.compile("com\\.yian\\..*"));
            return;
        }
        
        String[] configItems = agentArgs.split(";");
        for (String item : configItems) {
            String[] keyValue = item.split("=", 2);
            if (keyValue.length != 2) continue;
            
            String key = keyValue[0].trim();
            String value = keyValue[1].trim();
            
            switch (key) {
                case"include":
                    includePatterns.add(Pattern.compile(convertToRegex(value)));
                    break;
                case"exclude":
                    excludePatterns.add(Pattern.compile(convertToRegex(value)));
                    break;
                case"logFile":
                    logFile = value;
                    break;
                default:
                    logger.warning("未知的配置項: " + key);
            }
        }
        
        // 如果沒有指定包含規(guī)則，添加默認規(guī)則
        if (includePatterns.isEmpty()) {
            includePatterns.add(Pattern.compile("com\\.yian\\..*"));
        }
    }
    
    /**
     * 將通配符表達式轉(zhuǎn)換為正則表達式
     */
    private static String convertToRegex(String wildcard) {
        return wildcard.replace(".", "\\.").replace("*", ".*").replace("?", ".");
    }
    
    /**
     * 判斷類是否需要被轉(zhuǎn)換
     */
    public static boolean shouldTransform(String className) {
        // 將類名轉(zhuǎn)換為全限定名格式（例如：com/yian/MyClass -> com.yian.MyClass）
        String qualifiedName = className.replace("/", ".");
        
        // 檢查是否匹配排除規(guī)則
        for (Pattern pattern : excludePatterns) {
            if (pattern.matcher(qualifiedName).matches()) {
                returnfalse;
            }
        }
        
        // 檢查是否匹配包含規(guī)則
        for (Pattern pattern : includePatterns) {
            if (pattern.matcher(qualifiedName).matches()) {
                returntrue;
            }
        }
        
        returnfalse;
    }
    
    public static String getLogFile() {
        return logFile;
    }
    
    public static String getConfigInfo() {
        return String.format("include=%s, exclude=%s, logFile=%s",
                includePatterns, excludePatterns, logFile);
    }
}

/**
 * 類轉(zhuǎn)換器，負責將監(jiān)控邏輯注入到目標類中
 */
public class MethodMonitorTransformer implements ClassFileTransformer {
    private static final Logger logger = Logger.getLogger(MethodMonitorTransformer.class.getName());
    
    @Override
    public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,
                           ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
        // 判斷是否需要轉(zhuǎn)換該類
        if (!AgentConfig.shouldTransform(className)) {
            return null;
        }
        
        try {
            logger.info("開始轉(zhuǎn)換類: " + className);
            
            // 讀取類字節(jié)碼
            ClassReader cr = new ClassReader(classfileBuffer);
            ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_FRAMES);
            
            // 使用自定義的ClassVisitor處理類
            DebugClassVisitor cv = new DebugClassVisitor(cw, className.replace("/", "."));
            
            // 處理類，SKIP_DEBUG可以提高性能，不處理調(diào)試信息
            cr.accept(cv, ClassReader.SKIP_DEBUG);
            
            // 返回修改后的字節(jié)碼
            return cw.toByteArray();
        } catch (Exception e) {
            logger.severe("轉(zhuǎn)換類 " + className + " 失敗: " + e.getMessage());
            e.printStackTrace();
            return null;
        }
    }
}

/**
 * 自定義ClassVisitor，用于訪問類的方法并注入監(jiān)控邏輯
 */
public class DebugClassVisitor extends ClassVisitor {
    private final String className;
    
    public DebugClassVisitor(ClassVisitor classVisitor, String className) {
        super(Opcodes.ASM9, classVisitor);
        this.className = className;
    }
    
    @Override
    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
        MethodVisitor mv = super.visitMethod(access, name, descriptor, signature, exceptions);
        
        // 過濾掉構造方法和靜態(tài)初始化方法
        if (name.equals("<init>") || name.equals("<clinit>")) {
            return mv;
        }
        
        // 過濾掉native方法
        if ((access & Opcodes.ACC_NATIVE) != 0) {
            return mv;
        }
        
        // 使用自定義的MethodVisitor處理方法
        return new DebugMethodVisitor(mv, className, name, descriptor, access);
    }
}

/**
 * 自定義MethodVisitor，用于在方法執(zhí)行前后注入監(jiān)控邏輯
 */
public class DebugMethodVisitor extends AdviceAdapter {
    private static final Logger logger = Logger.getLogger(DebugMethodVisitor.class.getName());
    
    private final String className;
    private final String methodName;
    private final String methodDesc;
    
    // 局部變量索引，用于存儲方法開始時間
    private int startTimeVar;
    // 用于標識是否是靜態(tài)方法
    private final boolean isStatic;

    protected DebugMethodVisitor(MethodVisitor methodVisitor, String className, 
                                String methodName, String methodDesc, int access) {
        super(Opcodes.ASM9, methodVisitor, access, methodName, methodDesc);
        this.className = className;
        this.methodName = methodName;
        this.methodDesc = methodDesc;
        this.isStatic = (access & Opcodes.ACC_STATIC) != 0;
    }
    
    /**
     * 在方法進入時插入代碼
     */
    @Override
    protected void onMethodEnter() {
        // 記錄方法開始時間
        mv.visitMethodInsn(INVOKESTATIC, "java/lang/System", "currentTimeMillis", "()J", false);
        startTimeVar = newLocal(Type.LONG_TYPE);
        mv.visitVarInsn(LSTORE, startTimeVar);
        
        // 打印方法調(diào)用信息
        mv.visitLdcInsn(className);
        mv.visitLdcInsn(methodName);
        mv.visitMethodInsn(INVOKESTATIC, "com/yian/agent/MethodMonitor", 
                         "logMethodEnter", "(Ljava/lang/String;Ljava/lang/String;)V", false);
        
        // 打印方法參數(shù)
        printParameters();
    }
    
    /**
     * 打印方法參數(shù)
     */
    private void printParameters() {
        Type[] argumentTypes = Type.getArgumentTypes(methodDesc);
        
        // 創(chuàng)建參數(shù)數(shù)組
        mv.visitIntInsn(BIPUSH, argumentTypes.length);
        mv.visitTypeInsn(ANEWARRAY, "java/lang/Object");
        int paramsArrayVar = newLocal(Type.getType(Object[].class));
        mv.visitVarInsn(ASTORE, paramsArrayVar);
        
        // 填充參數(shù)數(shù)組
        int paramIndex = isStatic ? 0 : 1; // 非靜態(tài)方法第一個參數(shù)是this
        for (int i = 0; i < argumentTypes.length; i++) {
            Type type = argumentTypes[i];
            int size = type.getSize();
            
            // 加載數(shù)組和索引
            mv.visitVarInsn(ALOAD, paramsArrayVar);
            mv.visitIntInsn(BIPUSH, i);
            
            // 加載參數(shù)值并裝箱
            loadArg(paramIndex);
            box(type);
            
            // 存入數(shù)組
            mv.visitInsn(AASTORE);
            
            paramIndex += size;
        }
        
        // 調(diào)用日志方法記錄參數(shù)
        mv.visitLdcInsn(className);
        mv.visitLdcInsn(methodName);
        mv.visitVarInsn(ALOAD, paramsArrayVar);
        mv.visitMethodInsn(INVOKESTATIC, "com/yian/agent/MethodMonitor", 
                         "logMethodParameters", "(Ljava/lang/String;Ljava/lang/String;[Ljava/lang/Object;)V", false);
    }
    
    /**
     * 在方法退出時插入代碼
     */
    @Override
    protected void onMethodExit(int opcode) {
        // 計算方法執(zhí)行時間
        mv.visitMethodInsn(INVOKESTATIC, "java/lang/System", "currentTimeMillis", "()J", false);
        mv.visitVarInsn(LLOAD, startTimeVar);
        mv.visitInsn(LSUB);
        int durationVar = newLocal(Type.LONG_TYPE);
        mv.visitVarInsn(LSTORE, durationVar);
        
        // 如果是正常返回，記錄返回值
        if ((opcode >= IRETURN && opcode <= RETURN)) {
            // 復制返回值到棧頂（因為onMethodExit時返回值已經(jīng)在棧上）
            if (opcode != RETURN) { // 不是void返回
                dupReturnValue(opcode);
                box(Type.getReturnType(methodDesc));
                
                // 記錄返回值
                mv.visitLdcInsn(className);
                mv.visitLdcInsn(methodName);
                mv.visitVarInsn(LLOAD, durationVar);
                mv.visitMethodInsn(INVOKESTATIC, "com/yian/agent/MethodMonitor", 
                                 "logMethodReturn", "(Ljava/lang/String;Ljava/lang/String;JLjava/lang/Object;)V", false);
            } else {
                // void返回
                mv.visitLdcInsn(className);
                mv.visitLdcInsn(methodName);
                mv.visitVarInsn(LLOAD, durationVar);
                mv.visitInsn(ACONST_NULL);
                mv.visitMethodInsn(INVOKESTATIC, "com/yian/agent/MethodMonitor", 
                                 "logMethodReturn", "(Ljava/lang/String;Ljava/lang/String;JLjava/lang/Object;)V", false);
            }
        } 
        // 如果是異常退出，記錄異常信息
        elseif (opcode == ATHROW) {
            // 復制異常引用
            mv.visitInsn(DUP);
            
            // 記錄異常
            mv.visitLdcInsn(className);
            mv.visitLdcInsn(methodName);
            mv.visitVarInsn(LLOAD, durationVar);
            mv.visitMethodInsn(INVOKESTATIC, "com/yian/agent/MethodMonitor", 
                             "logMethodException", "(Ljava/lang/String;Ljava/lang/String;JLjava/lang/Throwable;)V", false);
        }
    }
    
    /**
     * 復制返回值到棧頂
     */
    private void dupReturnValue(int opcode) {
        switch (opcode) {
            case IRETURN:
            case FRETURN:
                mv.visitInsn(DUP);
                break;
            case LRETURN:
            case DRETURN:
                mv.visitInsn(DDUP);
                break;
            case ARETURN:
                mv.visitInsn(DUP);
                break;
            default:
                // 不處理void返回
        }
    }
}

/**
 * 方法監(jiān)控工具類，提供日志記錄功能
 */
public class MethodMonitor {
    private static final Logger logger = Logger.getLogger(MethodMonitor.class.getName());
    private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    private static FileWriter logWriter;
    
    static {
        // 初始化日志寫入器
        String logFile = AgentConfig.getLogFile();
        if (logFile != null && !logFile.isEmpty()) {
            try {
                File file = new File(logFile);
                // 創(chuàng)建父目錄
                if (!file.getParentFile().exists()) {
                    file.getParentFile().mkdirs();
                }
                // 追加模式
                logWriter = new FileWriter(file, true);
            } catch (IOException e) {
                logger.severe("初始化日志文件失敗: " + e.getMessage());
                logWriter = null;
            }
        }
    }
    
    /**
     * 記錄方法進入
     */
    public static void logMethodEnter(String className, String methodName) {
        String message = String.format("[%s] 方法進入: %s.%s()", 
                DATE_FORMAT.format(new Date()), className, methodName);
        writeLog(message);
    }
    
    /**
     * 記錄方法參數(shù)
     */
    public static void logMethodParameters(String className, String methodName, Object[] params) {
        StringBuilder sb = new StringBuilder();
        sb.append("[參數(shù)]: ");
        if (params != null) {
            for (int i = 0; i < params.length; i++) {
                sb.append("param").append(i).append("=")
                  .append(params[i] != null ? params[i].toString() : "null");
                if (i < params.length - 1) {
                    sb.append(", ");
                }
            }
        } else {
            sb.append("無參數(shù)");
        }
        
        String message = String.format("[%s] %s.%s(): %s", 
                DATE_FORMAT.format(new Date()), className, methodName, sb.toString());
        writeLog(message);
    }
    
    /**
     * 記錄方法返回
     */
    public static void logMethodReturn(String className, String methodName, long duration, Object returnValue) {
        String returnStr = returnValue != null ? returnValue.toString() : "void";
        String message = String.format("[%s] 方法返回: %s.%s() 執(zhí)行時間: %dms, 返回值: %s", 
                DATE_FORMAT.format(new Date()), className, methodName, duration, returnStr);
        writeLog(message);
    }
    
    /**
     * 記錄方法異常
     */
    public static void logMethodException(String className, String methodName, long duration, Throwable throwable) {
        String exceptionMsg = throwable != null ? throwable.getClass().getName() + ": " + throwable.getMessage() : "未知異常";
        String message = String.format("[%s] 方法異常: %s.%s() 執(zhí)行時間: %dms, 異常: %s", 
                DATE_FORMAT.format(new Date()), className, methodName, duration, exceptionMsg);
        writeLog(message);
        
        // 打印異常堆棧
        if (throwable != null) {
            throwable.printStackTrace();
        }
    }
    
    /**
     * 寫入日志到文件或控制臺
     */
    private static void writeLog(String message) {
        System.out.println(message); // 同時輸出到控制臺
        
        if (logWriter != null) {
            try {
                logWriter.write(message + "\n");
                logWriter.flush();
            } catch (IOException e) {
                logger.severe("寫入日志失敗: " + e.getMessage());
            }
        }
    }
}

java -javaagent:/path/to/springboot-debug-agent-1.0-SNAPSHOT-jar-with-dependencies.jar="include=com.yian.service.*;logFile=/tmp/debug.log" -jar your-springboot-app.jar

# 安裝jattach（如果未安裝）
# Ubuntu: sudo apt install jattach
# CentOS: yum install jattach

# 動態(tài)附加Agent
jattach <pid> load instrument false "/path/to/springboot-debug-agent-1.0-SNAPSHOT-jar-with-dependencies.