字节码进阶之ASM字节码操作类库详解

1. 前言

在Java的世界里，一切都围绕着字节码进行。字节码，作为Java源代码到Java虚拟机（JVM）的中间表示，扮演了重要的角色。然而，直接操作字节码并非易事，需要深入理解JVM的工作原理以及字节码的细节。这就是ASM类库登场的地方。

ASM是一个在Java中广泛使用的字节码操作和分析框架。它提供了直接操作字节码的能力，从而可以实现一些Java语言本身无法实现或者难以实现的功能。通过使用ASM，开发者可以动态生成类，修改已存在的类，优化代码性能，以及进行深度的代码分析。

在这篇博客文章中，我们将深入解析ASM字节码操作类库。我们会从ASM的基础知识开始，逐步探讨其强大的功能，以及如何使用ASM来操作字节码。我们会通过实例演示如何使用ASM生成类，如何修改类，以及如何使用ASM进行性能优化和代码分析。

最后章节，我们学以致用，使用ASM来实现一个简单的APM应用，记录方法调用情况。
希望这篇文章能帮助大家深入理解ASM，以及如何使用ASM来操作和分析字节码，从而更好地利用Java的强大功能。

2. ASM简介

ASM（Abstract Syntax Tree Method）是一个通用的Java字节码操纵和分析框架。它可以用于修改已存在的类或者动态生成新的类。ASM提供了一些高级的抽象，比如"Visitor"或者"Adapter"，这些抽象使得操作字节码变得更加容易。ASM是一个强大的工具，它为Java开发者提供了直接操作字节码的能力，从而可以实现一些Java语言本身无法实现或者难以实现的功能。

ASM框架的主要用途 ：

1. 动态生成类：可以在运行时动态生成新的类。这对于实现一些动态行为的需求，比如代理模式，非常有用。

2. 类修改：可以修改已存在的类，比如添加、修改或者删除方法和字段。这对于实现一些高级的代码分析和优化功能非常有用。

3. 性能优化：由于ASM直接操作字节码，所以它可以用于实现一些高级的性能优化，比如方法内联、死代码消除等。

4. 代码分析：ASM提供了一套强大的API来分析和操作字节码，这对于实现一些代码分析和度量工具非常有用。

3. 字节码基础知识回顾

• 什么是字节码

字节码，也称为p-code（portable code），是一种在特定软件解释器环境下执行的计算机指令集。这种指令集通常被设计用于通过堆栈机或寄存器机执行。Java字节码是Java虚拟机（JVM）的指令集，其是Java语言编译后的中间表示形式，它降低了系统间的依赖性，为Java的跨平台特性提供支持。

• 字节码的结构和格式

Java字节码文件主要由四个部分组成：魔数与版本信息，常量池，类信息，类的方法和属性。魔数与版本信息是文件的头部，用于标识这是一个可以被JVM读取的字节码文件。常量池存储了Java程序中所有的文字和符号引用，类信息包括这个类的名字，父类，接口等信息，类的方法和属性是Java类的主体部分，里面包括了方法的声明和实现。

• 字节码指令集

Java字节码指令集是一套完整的操作集，包括了操作数栈，局部变量，类的字段和方法，对象创建和操作，控制转移，异常处理等指令。这些指令分别对应了Java中的各种语言特性，比如算术运算，逻辑运算，循环，条件跳转，方法调用，对象操作等。

4. ASM的核心概念

• ClassVisitor和MethodVisitor

在ASM框架中，ClassVisitor和MethodVisitor是两个核心的接口，它们为访问和处理字节码提供了方法。

ClassVisitor提供了用于访问Java类的方法，它在访问到类的头部，字段，方法和接口等信息时被调用。在实践中，我们通常通过继承ClassVisitor并覆盖需要的方法来实现我们自己的类访问逻辑。

MethodVisitor则提供了用于访问Java方法的字节码的方法。我们可以通过继承MethodVisitor并覆盖其中的方法来处理方法中的各种字节码指令。

• ClassReader和ClassWriter

ClassReader是ASM提供的一个用于读取字节码的工具，它能够解析Java类文件，并将解析的结果传递给ClassVisitor。

ClassWriter则是ASM提供的一个用于生成新的字节码或者修改已有字节码的工具。它是一个ClassVisitor，会将接收到的所有访问操作转换为字节码。

• 字节码增强和修改的原理

在ASM中，字节码的增强和修改主要通过ClassVisitor和MethodVisitor接口进行。首先使用ClassReader读入一个类的字节码，然后通过传入ClassVisitor（通常是一个ClassWriter或者其子类）来访问这个类的字节码。在访问的过程中，通过覆盖ClassVisitor和MethodVisitor的方法，可以在相应的地方插入新的字节码指令，或者修改已有的指令，从而实现字节码的增强和修改。

最后，通过ClassWriter的toByteArray()方法可以得到修改后的字节码，这个字节码可以直接被JVM加载并执行，也可以保存到文件中，形成一个新的Java类文件。

5. ASM的基本用法

5.1. 读取和分析字节码

• 使用ClassReader解析字节码

  ClassReader是一个可以解析Java类的组件，它接受一个类的字节码作为输入，分析类中的所有元素（包括类名，父类，接口，构造函数，方法，字段等）。

  使用ClassReader很简单，只需要将字节码（以byte[]的形式）传递给ClassReader的构造函数，然后调用其accept方法，将一个ClassVisitor对象作为参数传入，ClassReader就会按照类的结构，按照顺序访问到类的每一个元素，并调用相应的ClassVisitor的方法。

  示例如下：

  byte[] bytecode = ...;
  ClassReader cr = new ClassReader(bytecode);
  ClassVisitor cv = new MyClassVisitor();
  cr.accept(cv, 0);

• 使用ClassVisitor访问和处理类的结构

  ClassVisitor是ASM中的一个接口，定义了一系列的方法供我们在访问类的结构时使用。我们可以创建一个ClassVisitor的子类，覆盖其中的方法，来处理类的各个部分。

  例如，如果我们想在访问到类的方法时做一些处理，可以覆盖visitMethod方法：

  class MyClassVisitor extends ClassVisitor {
      @Override
      public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
          System.out.println("Visiting method: " + name);
          return super.visitMethod(access, name, desc, signature, exceptions);
      }
  }

• 使用MethodVisitor访问和处理方法的指令

  类似于ClassVisitor，MethodVisitor也提供了一系列的方法，供我们在访问方法的字节码时使用。我们可以创建一个MethodVisitor的子类，覆盖其中的方法，来处理方法的字节码。

  例如，如果我们想在访问到方法的每一个指令时打印出指令的信息，可以覆盖visitInsn方法：

  class MyMethodVisitor extends MethodVisitor {
      @Override
      public void visitInsn(int opcode) {
          System.out.println("Visiting instruction: " + opcode);
          super.visitInsn(opcode);
      }
  }

5.2. 修改和生成字节码

• 使用ClassWriter生成新的字节码

  ClassWriter是ASM提供的一个强大的组件，它可以用来生成新的字节码。ClassWriter继承自ClassVisitor，可以作为ClassReader的visitor来生成一个和已有类结构完全相同的新类，也可以独立使用，来生成完全新的类。

  例如，以下是一个简单的ClassWriter使用例子，生成了一个新的类"Example"，该类有一个无参构造函数和一个方法hello:

  ClassWriter cw = new ClassWriter(0);
  cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Example", null, "java/lang/Object", null);

  MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
  mv.visitVarInsn(Opcodes.ALOAD, 0);
  mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
  mv.visitInsn(Opcodes.RETURN);
  mv.visitMaxs(1, 1);
  mv.visitEnd();

  mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "hello", "()V", null, null);
  mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
  mv.visitLdcInsn("Hello, world!");
  mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
  mv.visitInsn(Opcodes.RETURN);
  mv.visitMaxs(2, 1);
  mv.visitEnd();

  cw.visitEnd();

  byte[] bytecode = cw.toByteArray();

• 使用ClassVisitor修改已有的字节码

  我们可以通过覆盖ClassVisitor的方法来修改已有的字节码。例如，我们可以覆盖visitMethod方法，对每个方法的名字进行修改：

  class MyClassVisitor extends ClassVisitor {
      @Override
      public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
          return super.visitMethod(access, "prefix_" + name, desc, signature, exceptions);
      }
  }

• 使用MethodVisitor生成和修改方法的指令

  我们也可以通过覆盖MethodVisitor的方法来生成新的方法字节码，或者修改已有的字节码。例如，我们可以在方法的开始和结束时添加一些指令：

  class MyMethodVisitor extends MethodVisitor {
      @Override
      public void visitCode() {
          super.visitCode();
          // Add instructions at the beginning of the method
      }

      @Override
      public void visitInsn(int opcode) {
          if (opcode == Opcodes.RETURN) {
              // Add instructions before return
          }
          super.visitInsn(opcode);
      }
  }

6. ASM的用法示例

6.1 使用步骤

使用ASM操作字节码通常涉及以下几个步骤：

• 创建 ClassWriter 对象：ClassWriter 是用来生成类或者接口的字节码的。创建它时，可以传入参数来控制生成的字节码的版本以及一些其他选项。

   ClassWriter cw = new ClassWriter(0);

• 定义类或接口：这一步通常是通过调用 ClassWriter 的 visit 方法来实现的。这个方法接收许多参数，包括版本，访问标志，类名，签名，父类和接口。

   cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "MyClass", null, "java/lang/Object", null);

• 定义字段和方法：接着，你可以使用 ClassWriter 的 visitField 和 visitMethod 方法来定义字段和方法。这些方法返回的 FieldWriter 和 MethodWriter 对象可以被用来定义字段的详细信息以及方法的字节码。

   FieldVisitor fv = cw.visitField(Opcodes.ACC_PUBLIC, "myField", "I", null, null);
   fv.visitEnd();

   MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "myMethod", "()V", null, null);
   mv.visitCode();
   mv.visitInsn(Opcodes.RETURN);
   mv.visitMaxs(0, 0);
   mv.visitEnd();

• 生成字节码：最后，调用 ClassWriter 的 toByteArray 方法就可以得到这个类的字节码了。这个字节码可以被直接写入文件，也可以被加载到JVM中。

   byte[] b = cw.toByteArray();

6.2 完整示例

使用ASM库创建一个简单Java类的字节码的实例。这个类包括一个public字段和一个public方法。
创建了一个名为"MyClass"的类，这个类有一个public字段myField，有一个public方法myMethod，以及默认的构造函数。

代码生成的"MyClass.class"文件可以用Java命令加载和执行，当然前提是myMethod方法需要有具体的实现。在这个例子中，myMethod方法什么都没有做，直接返回了。

运行这个程序，会在其所在目录下生成"MyClass.class"文件。

import org.objectweb.asm.*;

public class ASMHelloWorld {
    public static void main(String[] arg) throws Exception {
        // 创建一个ClassWriter对象，并设置ASM可以自动计算栈和局部变量大小
        ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);

        // 定义类的基本信息
        cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "MyClass", null, "java/lang/Object", null);

        // 创建构造函数
        MethodVisitor constructor = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
        constructor.visitCode();
        constructor.visitVarInsn(Opcodes.ALOAD, 0);
        constructor.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
        constructor.visitInsn(Opcodes.RETURN);
        constructor.visitMaxs(0, 0);
        constructor.visitEnd();

        // 定义一个public字段
        FieldVisitor fv = cw.visitField(Opcodes.ACC_PUBLIC, "myField", "I", null, null);
        fv.visitEnd();

        // 创建一个public方法
        MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "myMethod", "()V", null, null);
        mv.visitCode();
        mv.visitInsn(Opcodes.RETURN);
        mv.visitMaxs(0, 0);
        mv.visitEnd();

        // 生成字节码并写入到文件
        byte[] bytes = cw.toByteArray();
        java.nio.file.Files.write(java.nio.file.Paths.get("./MyClass.class"), bytes);
    }
}

6.3 使用ASM生成类

上面已经给出了使用ASM创建类的例子，现在给出一个更具体的例子，这个例子中的类包含一个可以打印"Hello, world!"的方法。

import org.objectweb.asm.*;

public class ASMGenerationExample {
    public static void main(String[] args) throws Exception {
        ClassWriter cw = new ClassWriter(0);
        cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC + Opcodes.ACC_SUPER, "HelloWorld", null, "java/lang/Object", null);

        MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
        mv.visitVarInsn(Opcodes.ALOAD, 0);
        mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
        mv.visitInsn(Opcodes.RETURN);
        mv.visitMaxs(1, 1);
        mv.visitEnd();

        mv = cw.visitMethod(Opcodes.ACC_PUBLIC + Opcodes.ACC_STATIC, "main", "([Ljava/lang/String;)V", null, null);
        mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
        mv.visitLdcInsn("Hello, world!");
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
        mv.visitInsn(Opcodes.RETURN);
        mv.visitMaxs(2, 1);
        mv.visitEnd();

        byte[] b = cw.toByteArray();

        // Write the output to a class file
        java.nio.file.Files.write(java.nio.file.Paths.get("HelloWorld.class"), b);
    }
}

6.4. 使用ASM修改类

下面的例子展示了如何使用ASM载入一个已经存在的类并对其进行修改。我们将在HelloWorld类的main方法中添加一行打印"Modified by ASM"的代码。

import org.objectweb.asm.*;

public class ASMModificationExample {
    public static void main(String[] args) throws Exception {
        ClassReader cr = new ClassReader("HelloWorld");
        ClassWriter cw = new ClassWriter(cr, 0);
        ClassVisitor cv = new ClassVisitor(Opcodes.ASM5, cw) {
            @Override
            public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
                MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);

                if (name.equals("main")) {
                    return new MethodVisitor(Opcodes.ASM5, mv) {
                        @Override
                        public void visitCode() {
                            super.visitCode();
                            visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
                            visitLdcInsn("Modified by ASM");
                            visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
                        }
                    };
                }
                return mv;
            }
        };

        cr.accept(cv, 0);
        byte[] b2 = cw.toByteArray();

        // Write the output to a class file
        java.nio.file.Files.write(java.nio.file.Paths.get("HelloWorldModified.class"), b2);
    }
}

6.5. 使用ASM进行性能优化和代码分析

使用ASM进行字节码级别的性能优化和代码分析的例子。这个例子中我们将会分析方法的访问次数。

通过ASM分析了HelloWorld类中每个方法的访问次数。当每个方法被访问时，都会打印出"Method [methodName] is visited"。通过这种方式，我们可以对程序的性能进行优化和分析。

import org.objectweb.asm.*;

public class ASMOptimizationAndAnalysisExample {
    public static void main(String[] args) throws Exception {
        ClassReader cr = new ClassReader("HelloWorld");
        ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_FRAMES);
        ClassVisitor cv = new ClassVisitor(Opcodes.ASM5, cw) {
            @Override
            public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
                MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
                return new MethodVisitor(Opcodes.ASM5, mv) {
                    @Override
                    public void visitCode() {
                        super.visitCode();
                        System.out.println("Method " + name + " is visited");
                    }
                };
            }
        };

        cr.accept(cv, 0);
        byte[] b2 = cw.toByteArray();

        // Write the output to a class file
        java.nio.file.Files.write(java.nio.file.Paths.get("HelloWorldAnalyzed.class"), b2);
    }
}

6. ASM的高级用法

6.1. 字节码增强技术

字节码增强技术通常被用于监控、性能优化、动态代理、热替换等场景。ASM提供了丰富的接口和工具来实现这些功能。

6.1.1 方法注入

方法注入是在某个方法的字节码中添加新的字节码，从而改变该方法的行为。这种技术可以用于添加日志、捕获异常、检查参数等操作。ASM的方法注入主要通过MethodVisitor实现。

  class AddTimerMethodAdapter extends MethodVisitor {
      private String owner;

      public AddTimerMethodAdapter(MethodVisitor mv, String owner) {
          super(ASM5, mv);
          this.owner = owner;
      }

      @Override
      public void visitCode() {
          mv.visitCode();
          mv.visitFieldInsn(GETSTATIC, owner, "timer", "J");
          mv.visitMethodInsn(INVOKESTATIC, "java/lang/System", "currentTimeMillis", "()J", false);
          mv.visitInsn(LSUB);
          mv.visitFieldInsn(PUTSTATIC, owner, "timer", "J");
      }

      @Override
      public void visitInsn(int opcode) {
          if ((opcode >= IRETURN && opcode <= RETURN) || opcode == ATHROW) {
              mv.visitFieldInsn(GETSTATIC, owner, "timer", "J");
              mv.visitMethodInsn(INVOKESTATIC, "java/lang/System", "currentTimeMillis", "()J", false);
              mv.visitInsn(LADD);
              mv.visitFieldInsn(PUTSTATIC, owner, "timer", "J");
          }
          mv.visitInsn(opcode);
      }
  }

6.1.2 字节码插入和替换

字节码插入是在现有的字节码中插入新的字节码，而字节码替换是将现有的字节码替换为新的字节码。这两种操作可以通过ASM的ClassVisitor和MethodVisitor实现。

字节码插入示例：

  class MethodInsertAdapter extends MethodVisitor {
      public MethodInsertAdapter(MethodVisitor mv) {
          super(ASM5, mv);
      }

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

6.1.3 字节码删除和重排

字节码删除就是移除某些不需要的字节码，而字节码重排则是改变字节码的顺序。这两种操作也可以通过ASM的ClassVisitor和MethodVisitor实现。

字节码删除示例：

  class MethodRemoveAdapter extends MethodVisitor {
      public MethodRemoveAdapter(MethodVisitor mv) {
          super(ASM5, mv);
      }

      @Override
      public void visitInsn(int opcode) {
          // Remove the RETURN instruction
          if (opcode == RETURN) {
              return;
          }
          mv.visitInsn(opcode);
      }
  }

6.2. 自定义类加载器和类定义

ASM提供了丰富的接口和工具类来生成和定义新的字节码，同时我们还可以使用自定义的类加载器来加载和使用这些生成的字节码。

6.2.1 通过ASM生成和定义新的类

我们可以使用ASM的`ClassWriter`类来生成新的字节码，然后通过`ClassVisitor`和`MethodVisitor`来定义类的结构和方法。

下面的代码定义了一个名为`Example`的类，包含一个无参数构造方法和一个`hello`方法。

    ClassWriter cw = new ClassWriter(0);
    ClassVisitor cv = new ClassVisitor(ASM5, cw) {};
    
    String className = "Example";
    String classDesc = "L" + className + ";";
    
    cv.visit(V1_5, ACC_PUBLIC + ACC_SUPER, className, null, "java/lang/Object", null);
    
    // define constructor
    MethodVisitor mv = cv.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
    mv.visitCode();
    mv.visitVarInsn(ALOAD, 0);
    mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
    mv.visitInsn(RETURN);
    mv.visitMaxs(1, 1);
    mv.visitEnd();
    
    // define hello method
    mv = cv.visitMethod(ACC_PUBLIC, "hello", "()V", null, null);
    mv.visitCode();
    mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
    mv.visitLdcInsn("Hello, world!");
    mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
    mv.visitInsn(RETURN);
    mv.visitMaxs(2, 1);
    mv.visitEnd();
    
    cv.visitEnd();
    
    byte[] b = cw.toByteArray();

6.2.2 自定义类加载器加载和使用生成的类

我们可以定义一个自定义的类加载器，通过该类加载器加载字节码生成的类。

    class MyClassLoader extends ClassLoader {
        public Class<?> defineClass(String name, byte[] b) {
            return defineClass(name, b, 0, b.length);
        }
    }

    MyClassLoader cl = new MyClassLoader();
    Class<?> c = cl.defineClass("Example", b);
    
    Object obj = c.newInstance();
    Method m = c.getMethod("hello");
    m.invoke(obj);

将会打印出Hello, world!。

7. 实例演示：使用ASM实现简单的字节码增强

首先创建了一个TimeLogger类，用于记录方法执行的开始和结束时间。然后， 创建了一个TimeLoggerClassAdapter，它扩展了ASM的ClassVisitor，并覆盖了visitMethod方法。在visitMethod中，创建了一个新的MethodVisitor，这个MethodVisitor会在每个方法的开始处插入对TimeLogger类的start方法的调用，并在每个方法的结束处插入对end方法的调用。

7.1. 在Maven项目中添加ASM的依赖

<dependencies>
    <dependency>
        <groupId>org.ow2.asm</groupId>
        <artifactId>asm</artifactId>
        <version>9.2</version>
    </dependency>
</dependencies>

7.2. 定义一个简单的类，该类在结束时记录方法的执行时间

public class TimeLogger {
    private long startTime;

    public void start() {
        startTime = System.currentTimeMillis();
    }

    public void end() {
        long endTime = System.currentTimeMillis();
        System.out.println("Method executed in " + (endTime - startTime) + " milliseconds");
    }
}

7.3. 创建一个用于添加时间记录功能的字节码增强器

import org.objectweb.asm.*;

public class TimeLoggerClassAdapter extends ClassVisitor {

    public TimeLoggerClassAdapter(int api, ClassVisitor classVisitor) {
        super(api, classVisitor);
    }

    @Override
    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
        MethodVisitor mv = cv.visitMethod(access, name, descriptor, signature, exceptions);

        return new MethodVisitor(api, mv) {
            @Override
            public void visitCode() {
                super.visitCode();

                // 在方法入口处插入 "start" 方法的调用
                mv.visitMethodInsn(
                        Opcodes.INVOKEVIRTUAL,
                        "TimeLogger",
                        "start",
                        "()V",
                        false
                );
            }

            @Override
            public void visitInsn(int opcode) {
                if ((opcode >= Opcodes.IRETURN && opcode <= Opcodes.RETURN)
                        || opcode == Opcodes.ATHROW) {
                    // 在方法退出前插入 "end" 方法的调用
                    mv.visitMethodInsn(
                            Opcodes.INVOKEVIRTUAL,
                            "TimeLogger",
                            "end",
                            "()V",
                            false
                    );
                }
                super.visitInsn(opcode);
            }
        };
    }
}

7.4. 在Maven项目中使用ASM的API加载和修改一个现有的类：

在Main类中，我们使用ASM的API读取"com.example.MyClass"类，将其传递给我们的TimeLoggerClassAdapter进行处理，然后将增强后的字节码写入文件。这样，当我们运行增强后的"com.example.MyClass"类时，将会在控制台上打印出每个方法的执行时间。

import org.objectweb.asm.*;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;

public class Main {
    public static void main(String[] args) throws IOException {
        ClassReader cr = new ClassReader("com.example.MyClass");
        ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_FRAMES);
        ClassVisitor cv = new TimeLoggerClassAdapter(Opcodes.ASM8, cw);
        cr.accept(cv, ClassReader.EXPAND_FRAMES);

        byte[] enhancedClass = cw.toByteArray();

        // 把增强后的类写入到文件
        try (OutputStream fos = new FileOutputStream("target/classes/com/example/MyClass.class")) {
            fos.write(enhancedClass);
        }
    }
}