如何使用Java Instrumentation API

Java Instrumentation API是Java平台提供的一个高级工具，用于在运行时修改或监视Java应用程序的字节码。具体来说，Instrumentation API允许我们在JVM启动应用程序之前动态地修改类定义和字节码。这使得我们能够增强应用程序的功能，例如在应用程序执行过程中收集性能指标或执行代码纠错。下面是如何使用Java Instrumentation API的完整攻略。

1. 创建 Java Agent

Java Agent是一种特殊类型的Java应用程序，可以以jar文件的形式加载到Java应用程序中，并在JVM启动应用程序之前运行。在Java Agent中使用Instrumentation API可以修改Java应用程序的字节码。下面是创建Java Agent的步骤：

1. 创建一个Java项目并将其导出为jar文件
2. 创建一个META-INF/MANIFEST.MF文件，并在文件中指定Java Agent的类。例如：Premain-Class: com.example.agent.MyAgent
3. 将jar文件放置在要修改的Java应用程序的classpath中

2. 实现 Agent 类

创建完Java Agent之后，我们需要实现Agent类，并在其中使用Instrumentation API。这是使用Instrumentation API的基本步骤：

1. 在Agent类中实现public static premain(String agentArgs, Instrumentation inst)方法，此方法在Java应用程序启动之前被调用
2. 在实现的premain方法中，我们可以通过调用inst.addTransformer(ClassFileTransformer)注册一个ClassFileTransformer，并使用它修改Java类的字节码

下面是一个简单的Java Agent实现示例，它使用Instrumentation API来修改应用程序中所有类的toString()方法，并在原始方法调用前后输出日志：

public class MyAgent {

    public static void premain(String agentArgs, Instrumentation inst) {
        inst.addTransformer(new ToStringTransformer());
    }

    static class ToStringTransformer implements ClassFileTransformer {

        @Override
        public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,
                ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {

            // 只修改java.lang.Object类及其子类的toString()方法
            if (!className.startsWith("java/lang")) {
                return null;
            }

            ClassReader reader = new ClassReader(classfileBuffer);
            ClassWriter writer = new ClassWriter(reader, ClassWriter.COMPUTE_MAXS);

            ClassVisitor visitor = new ClassVisitor(Opcodes.ASM5, writer) {

                @Override
                public MethodVisitor visitMethod(int access, String name, String desc, String signature,
                        String[] exceptions) {

                    MethodVisitor visitor = super.visitMethod(access, name, desc, signature, exceptions);
                    if (name.equals("toString") && desc.equals("()Ljava/lang/String;")) {
                        visitor = new ToStringAdvice(visitor);
                    }
                    return visitor;
                }
            };

            reader.accept(visitor, 0);
            return writer.toByteArray();
        }
    }

    static class ToStringAdvice extends MethodVisitor {

        public ToStringAdvice(MethodVisitor mv) {
            super(Opcodes.ASM5, mv);
        }

        @Override
        public void visitCode() {
            mv.visitCode();
            mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
            mv.visitLdcInsn("Before invoking Object.toString()");
            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
        }

        @Override
        public void visitInsn(int opcode) {
            if (opcode == Opcodes.RETURN) {
                mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
                mv.visitLdcInsn("After invoking Object.toString()");
                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
            }
            mv.visitInsn(opcode);
        }
    }
}

3. 测试

最后，在启动Java应用程序时，需要指定要使用的Java Agent。以下是启动Java应用程序时如何指定Java Agent的命令：

java -javaagent:/path/to/agent.jar <main class>

在执行命令后，Java Agent将被加载并运行，我们将在应用程序启动之前使用Instrumentation API来修改应用程序的字节码。

4. 更多示例

除了上述示例之外，下面是另一个示例，该示例使用Java Instrumentation API修改应用程序中的类，以便将所有执行的方法的运行时间记录到日志中：

public class MyAgent {

    public static void premain(String agentArgs, Instrumentation inst) {
        inst.addTransformer(new TimingTransformer());
    }

    static class TimingTransformer implements ClassFileTransformer {

        @Override
        public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,
                ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
            ClassReader reader = new ClassReader(classfileBuffer);
            ClassWriter writer = new ClassWriter(reader, ClassWriter.COMPUTE_MAXS);
            ClassVisitor visitor = new ClassVisitor(Opcodes.ASM5, writer) {

                @Override
                public MethodVisitor visitMethod(int access, String name, String desc, String signature,
                        String[] exceptions) {
                    MethodVisitor visitor = super.visitMethod(access, name, desc, signature, exceptions);
                    return new TimingAdvice(visitor, access, name, desc);
                }
            };
            reader.accept(visitor, 0);
            return writer.toByteArray();
        }
    }

    static class TimingAdvice extends MethodVisitor {

        private final int access;
        private final String name;
        private final String desc;

        public TimingAdvice(MethodVisitor mv, int access, String name, String desc) {
            super(Opcodes.ASM5, mv);
            this.access = access;
            this.name = name;
            this.desc = desc;
        }

        @Override
        public void visitCode() {
            mv.visitCode();
            mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/System", "nanoTime", "()J", false);
            mv.visitFieldInsn(Opcodes.PUTSTATIC, "com/example/agent/Timing", "startTime", "J");
        }

        @Override
        public void visitInsn(int opcode) {
            if (opcode >= Opcodes.IRETURN && opcode <= Opcodes.RETURN) {
                mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/System", "nanoTime", "()J", false);
                mv.visitFieldInsn(Opcodes.GETSTATIC, "com/example/agent/Timing", "startTime", "J");
                mv.visitInsn(Opcodes.LSUB);
                mv.visitLdcInsn(name + desc);
                mv.visitMethodInsn(Opcodes.INVOKESTATIC, "com/example/agent/Timing", "logTiming", "(Ljava/lang/String;J)V", false);
            }
            mv.visitInsn(opcode);
        }
    }
}

public class Timing {

    static volatile long startTime = 0;

    public static void logTiming(String methodName, long elapsedTime) {
        System.out.println(methodName + " took " + (elapsedTime / 1000000) + " ms.");
    }
}

这个示例修改了所有类中的方法，以记录它们的运行时间并将其输出到日志中。