package com.example.demo.agent;
import lombok.extern.slf4j.Slf4j;
@Slf4j
public class Test {
    public static void main(String[] args) {
        try {
            int i = 1 / 0;
        } catch (Exception e) {
            // 由字節(jié)碼增強來輸出
        }
    }
}

package com.example.demo.agent;
import java.lang.instrument.Instrumentation;
import java.util.Set;
public class MyAgent {
    public static void premain(String agentArgs, Instrumentation inst) {
        // 獲取需要掃描的包名
        Set<String> basePackages = ConfigService.getBasePackages();
        // 構造 MyClassTransformer
        MyClassTransformer transformer = new MyClassTransformer(basePackages);
        inst.addTransformer(transformer);
    }
}

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-jar-plugin</artifactId>
    <configuration>
        <archive>
            <manifestEntries>
                <Premain-Class>com.example.demo.agent.MyAgent</Premain-Class>
            </manifestEntries>
        </archive>
    </configuration>
</plugin>

package com.example.demo.agent;
import aj.org.objectweb.asm.Opcodes;
import org.objectweb.asm.*;
import java.io.File;
import java.lang.instrument.ClassFileTransformer;
import java.security.ProtectionDomain;
import java.util.HashSet;
import java.util.Set;
import static org.objectweb.asm.Opcodes.*;
public class MyClassTransformer implements ClassFileTransformer {
    // basePackages是需要增強的類所在的包的集合
    private final Set<String> basePackages;
    // 獲取該ClassTransformer類的全限定名，將包名中的點號替換為文件路徑中的分隔符
    private static final String OWNER = MyClassTransformer.class.getCanonicalName().replace(".", File.separator);
    public MyClassTransformer(Set<String> basePackages) {
        this.basePackages = basePackages;
    }
    public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,
                            ProtectionDomain protectionDomain, byte[] classfileBuffer) {
        // 判斷是否需要對該類進行增強，如果不需要直接返回原字節(jié)碼數據
        if (!needEnhance(className)) {
            return classfileBuffer;
        }
        System.out.println("Transforming class: " + className);
        // 利用ASM對字節(jié)碼進行增強
        try {
            // 創(chuàng)建ClassReader對象
            ClassReader cr = new ClassReader(className);
            // 創(chuàng)建ClassWriter對象
            ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
            // 創(chuàng)建ClassVisitor對象，對字節(jié)碼進行訪問
            ClassVisitor cv = new ClassVisitor(Opcodes.ASM5, cw) {
                @Override
                public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
                    // 對每個方法進行訪問，返回MethodVisitor對象進行訪問
                    MethodVisitor mv = super.visitMethod(access, name, descriptor, signature, exceptions);
                    // 創(chuàng)建MethodVisitor對象，對方法字節(jié)碼進行訪問
                    return new MethodVisitor(Opcodes.ASM5, mv) {
                        // 存儲try-catch處理器的標簽
                        private final Set<Label> tryCatchBlockHandlers = new HashSet<>();
                        @Override
                        public void visitTryCatchBlock(Label start, Label end, Label handler, String type) {
                            // 對visitTryCatchBlock方法進行訪問，在訪問方法中存儲try-catch處理器的標簽
                            tryCatchBlockHandlers.add(handler);
                            super.visitTryCatchBlock(start, end, handler, type);
                        }
                        @Override
                        public void visitLineNumber(int line, Label start) {
                            // 對visitLineNumber方法進行訪問，在訪問方法中插入方法調用指令
                            if (tryCatchBlockHandlers.contains(start)) {
                                // 當該行代碼處于try-catch塊中時，在該行代碼前插入方法調用指令
                                mv.visitMethodInsn(INVOKESTATIC, OWNER, "logStackTrace", "(Ljava/lang/Throwable;)V", false);
                            }
                            super.visitLineNumber(line, start);
                        }
                    };
                }
            };
            // 開始訪問ClassReader中的字節(jié)碼
            cr.accept(cv, ClassReader.EXPAND_FRAMES);
            // 返回增強后的字節(jié)碼數據
            return cw.toByteArray();
        } catch (Exception e) {
            System.out.println("MyClassTransformer e=" + e);
        }
        // 出現異常時返回原字節(jié)碼數據
        return classfileBuffer;
    }
    // 定義方法
    public static void logStackTrace(Throwable throwable) {
        System.out.println("統(tǒng)一打印堆棧：");
        throwable.printStackTrace();
    }
    private boolean needEnhance(String className) {
        for (String basePackage : basePackages) {
            if (className.startsWith(basePackage)) {
                return true;
            }
        }
        return false;
    }
}

package com.example.demo.agent;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Properties;
import java.util.Set;
public class ConfigService {
    private static final String CONFIG_FILE_PATH = "demo/src/main/resources/application.properties";
    private static final String BASE_PACKAGES_PROPERTY = "basePackages";
    private static Set<String> basePackages;
    static {
        Properties props = new Properties();
        try (InputStream is = new FileInputStream(CONFIG_FILE_PATH)) {
            props.load(is);
            String basePackagesStr = props.getProperty(BASE_PACKAGES_PROPERTY);
            basePackages = new HashSet<>(Arrays.asList(basePackagesStr.split(",")));
            System.out.println("basePackages=" + basePackages);
        } catch (IOException e) {
            // 處理異常
        }
    }
    public static Set<String> getBasePackages() {
        return basePackages;
    }
}