Java核心: 使用asm操作字节码

在上一篇<Java核心: 注解处理器>中我们提到，通过实现AbstractProcessor，并调用javac -processor能够生成代码来实现特殊逻辑。不过它存在两个明显的问题:

1. 只能新增源文件来扩展逻辑，无法修改现有的类或方法
2. 必须有一个单独的编译过程，调用javac -processor或者用Maven的annotationProcessor，不适用于已经编译好的jar

这一篇我们讲解ASM的目的就是解决问题1，它不但能建新类，还能修改已有类，比如为POJO类生成toString方法，为Service类的业务方法提供类似AOP的增强。本文的讲解思路如下

1. asm的能力在于分析、生成和修改字节码，class文件的结构和字节码对使用和理解asm会有帮助，所以我们从讲解Class文件结构开始
2. 理解asm对字节码操作建立的抽象模型，核心组件和工作流程
3. 对类字节码和asm抽象都有概念后，从实战出发，解决3个实际问题:  生成类、生成toString方法、打印方法入参和执行耗时

1. Class文件结构

通过javap -v Account.class能够查看Class文件的详细信息，为了方便查看，我们做了删减，它看起是这样的

整个Class文件的内容包含很多内容，这里我们只列出其中的核心部分

1. 类信息，包括类的访问标志(public、abstract)、名称、父类、接口、版本(编译.java文件的JDK版本)
2. 常量池，包括类/方法/字段的引用和名称，以及代码中使用的字面常量等
3. 类属性，通过类属性提供，如SourceFile表示源文件名称，RuntimeInvisibleAnnotations表示运行时注解、外部引用等
4. 内部类，通过属性InnerClasses提供
5. 字段，常量池保存字段引用Fieldref，记录了字段所属的类、字段类型和名称
6. 方法，常量池保存方法引用Methodref，记录了方法所属的类、名称、参数和描述符等等
7. 字节码，通过方法引用关联，能找到这个方法内的字节码，本地变量表(LocalVariableTable)、异常表(ExceptionTable)、注解信息(RuntimeVisibleAnnotations)等等

2. ASM工作模式

ASM提供了字节码的分析、生成和修改能力，它的能力当然是基于它对字节码的理解之上构建的。ASM支持两类API，一类是基于事件的(类型XML解析的SAX)，一类是基于语法树的(类似于XML的DOM)。事件模型的性能会更好一些，这里我们主要讲解和使用事件模型。事件模型将ASM抽象成3个核心组件，ClassReader、Visitor(ClassVisitor、MethodVisitor等)、ClassWriter，整个字节码的处理过程可以想象成这样一张处理的数据流图，整个处理过程分为3步:

1. 生成事件流，图中CR节点，表示ClassReader，用于读取类定义解析并触发事件
2. 过滤和转换，图中空白节点，被抽象为Visitor，常见的有ClassVisitor、MethodVisitor、FieldVisitor等，接收事件触发，过滤/修改事件传递给CW，同时它还支持生成新事件
3. 终结操作符，图中CW节点，表示ClassWriter，起始ClassWriter也是Visitor接口的实现，不同的是它的visit方法会生成类的字节码，比如调用ClassWriter.visitMethod会在类中新增方法

1. ClassVisitor

要使用asm的事件模型API，我们的核心任务就是定义和提供这个处理流程中的核心组件。我们来看看ClassVisitor的核心接口，它实际上是和Class文件结构对应的，它的抽象是基于Class文件的

1. 类信息 - visit(int version, int access, String name, String signature, String superName, String[] interfaces)

这个ClassReader开始访问某个类的起点，我们来看看每个参数的定义

下面是我们举例的一组参数，各个参数值大概是长这样的

visit(V1_8, ACC_PUBLIC, "com/keyniu/shop/Product", null, "java/lang/Object", new String[]{"java/io/Serializable"});

2. 源文件 - visitSource(String source, String debug)

用于获取javap -v输出里的SourceFile和SourceDebugExtension，前一个字段是.java文件的名称，后一个是额外的调试信息，比如JSP编译为字节码

下面是我们举例的一组参数

visitSource("Account.java", null);

3. 访问外部类 - visitOuterClass(String owner, String name, String descriptor)

下面是我们举例的一组参数

visitOuterClass("com/keyniu/asm/Outer", "Outer", "Lcom/keyniu/asm/Outer;");

4. 访问类上的注解 - visitAnnotation(String descriptor, boolean visible)

下面是我们举例的一组参数

visitAnnotation("Lcom/keyniu/asm/ToString;", true);

5. 访问字段 - visitField(int access, String name, String desc, String signature, Object value)

下面是我们举例的一组参数

visitField(ACC_PUBLIC + ACC_FINAL, "remain", "I", null, null);

6. 访问方法 - visitMethod(int access, String name, String descriptor, String signature, String[] exceptions)

2. MethodVisitor

ClassVisitor有点像设计模式里的抽象工厂，除了处理由ClassReader触发的类读取上的事件，它还需要在访问注解、字段、方法是调用工厂方法创建其他的Visitor实例，涉及Visitor如下:

1. ModuleVisitor，支持模块/包的读取写入操作
2. AnnotationVisitor，支持处理类/方法/字段(visitAnnotation)和参数/返回值/异常/泛型类型(visitTypeAnnotation)的注解
3. MethodVisitor，支持方法的处理
4. FieldVisitor，支持字段的处理
5. RecordComponentVisitor，支持record类型的字段处理

3. 实战: 准备工作

学习一大堆理论并不能搞明白如何游泳，有了基本的概念后，现在是时候下水实践一下了。实践之前，我们先准备好实践的材料

1. 定义业务类Account，后续我们会对Account进行编辑，生成一个toString方法返回所有字段值的拼接；修改transfer方法，打印入参和执行耗时
2. 注解@ToString，标注了@ToString的类生成toString方法
3. 注解@Diagnostic，标注了@Diagnositc的方法，打印入参和执行耗时
4. 自定义类加载器SingleClassClassLoader，将保存在byte[]的字节码加载为Class对象

1.  Account

package com.keyniu.asm;
@ToString
public class Account {
    private int remain = 99;
    @Diagnostic
    public void transfer(String sb, int amount) {
        System.out.println("transfer to " + sb + " amount: " + amount);
        try {
            Thread.sleep((int) (Math.random() * 1000));
        } catch (InterruptedException e) {
        }
    }
}

2. ToString

package com.keyniu.asm;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.CLASS)
public @interface ToString {
}

3. Diagnostic

package com.keyniu.asm.diagnostic;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Diagnostic {
}

4. SingleClassClassLoader

public class SingleClassClassLoader extends ClassLoader {
    private String name;
    private byte[] codes;

    public SingleClassClassLoader(String name, byte[] code) {
        this.name = name;
        this.codes = code;
    }

    public Class<?> findClass(String name) throws ClassNotFoundException {
        if (this.name.equals(name)) {
            return defineClass(name, codes, 0, codes.length);
        }
        throw new ClassNotFoundException(name);
    }
}

4. 实战: 新建类

万事俱备，我们开始第一个实战，从0到1的生成一个全新的类，提供默认构造函数。这个过程可以拆解为5步，对应代码里的"步骤x"阅读

1. 创建ClassWriter，这里必要重要的是参数里的ClassWriter.COMPUTE_FRAMES，表示让asm自动计算局部变量表、操作数栈的大小
2. 创建SimpleClass类，这一步执行完相当于class SimpleClass已经定义
3. 使用MethodVisitor创建<init>方法(构造函数)，创建字节码调用父类(java.lang.Object)的默认构造函数。这一点和Java代码里不同，ClassWriter不会自动生成默认构造函数
4. 方法和类创建完成后，需要调用MethodVisitor.visitMaxs、MethodVisitor.visitEnd以及ClassWriter(ClassVisitor)的visitEnd方法，结束写入
5. 使用自定义类加载器加载字节码，创建并使用对象，当然我们也可以将它写入到.class文件

public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {

    ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_FRAMES);                                             // 步骤1
    // 创建Class
    cw.visit(Opcodes.V17, Opcodes.ACC_PUBLIC, "com/keyniu/asm/SimpleClass", null, "java/lang/Object", null);  // 步骤2
    // 创建方法
    MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);                       // 步骤3
    mv.visitVarInsn(Opcodes.ALOAD, 0); // this入栈
    mv.visitMethodInsn(Opcodes.INVOKESPECIAL,"java/lang/Object","<init>","()V",false); // 调用父类<init>
    mv.visitInsn(Opcodes.RETURN); // 退出方法
    mv.visitMaxs(0,0); // 触发计算局部变量表、操作数栈大小
    mv.visitEnd(); // 结束方法写入                                                                             // 步骤4
    cw.visitEnd(); // 结束类写入

    byte[] bs = cw.toByteArray();

    SingleClassClassLoader cl = new SingleClassClassLoader("com.keyniu.asm.SimpleClass", bs);                 // 步骤5
    Class<?> clazz = cl.findClass("com.keyniu.asm.SimpleClass");
    Object instance = clazz.newInstance();

    System.out.println(clazz.getName() + ": " + instance);
}

5. 实战: 生成toString方法

通过asm能够实现类似于lombok的操作，对于注解了@ToString的类自动生成toString方法，这个方法读取每个字段值拼接后返回。实现过程粗略的讲是这样的:

1. 使用ClassReader读取并解析一个现有的类，触发事件，这里我们用的Account类
2. 自定义ClassVisitor处理visitAnnotation事件，确认Account类上是否有@ToString注解
3. 自定义ClassVisitor处理visitField事件，记录Account上所有的字段
4. 自定义ClassVisitor处理visitEnd事件，使用MethodVisitor创建toString方法，编辑字节码，拼接字段值后返回

我们需要定义自己的ClassVisitor，判断类是否ToString标注，收集类中的字段，创建toString方法，核心操作步骤如下，对应代码的”步骤x"来阅读

1. 回调visit，记录当前的类名，这里的值是: com/keyniu/asm/Account
2. 回调visitAnnotation，记录当前类十分有标注@ToString注解
3. 回调visitField，记录类中的所有字段和描述符
4. 回调visitEnd，在类遍历结束时，根据之前收集的信息，是否注解@ToString、类名、字段信息，生成toString方法的定义和字节码
   1. 创建StringBuilder，用于拼接toString的结果
   2. 拼类名和左括号，Account(
   3. 拼字段值，多个字段直接用","分隔
   4. 拼右括号，StringBuilder最终值的格式是:   Account(字段值1,字段值2）
5. 调用StringBuilder.toString，将这个结果作为方法返回值返回

package com.keyniu.asm.lombok;

import org.objectweb.asm.*;

import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;

public class ToStringClassVisitor extends ClassVisitor {

    private boolean isAnnotated = false;
    private Map<String, String> fields = new LinkedHashMap<>();
    private String className;

    protected ToStringClassVisitor(ClassVisitor classVisitor) { // classVisitor接收一个ClassWriter用于生成字节码
        super(Opcodes.ASM9, classVisitor);
    }
    
    @Override
    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
        this.className = name;  // 步骤1，记录类名，格式com/keyniu/asm/Account

        super.visit(version, access, name, signature, superName, interfaces);
    }



    @Override
    public AnnotationVisitor visitAnnotation(String descriptor, boolean visible) {
        if ("Lcom/keyniu/asm/lombok/ToString;".equals(descriptor)) {
            isAnnotated = true; // 步骤2，记录是否有标记@ToString注解
        }
        return super.visitAnnotation(descriptor, visible);
    }

    @Override
    public FieldVisitor visitField(int access, String name, String descriptor, String signature, Object value) {
        fields.put(name, descriptor); // 步骤3，记录所有字段信息
        return super.visitField(access, name, descriptor, signature, value);
    }

    @Override
    public void visitEnd() {
        if (isAnnotated && fields.size() > 0) { // 步骤4，创建toString方法
            MethodVisitor mv = cv.visitMethod(Opcodes.ACC_PUBLIC, "toString", "()Ljava/lang/String;", null, null);
            mv.visitCode();
            // 步骤4.a 创建StringBuilder
            mv.visitTypeInsn(Opcodes.NEW, "java/lang/StringBuilder");
            mv.visitInsn(Opcodes.DUP);
            mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/StringBuilder", "<init>", "()V", false);

            // 步骤4.b 拼接类名，执行完后StringBuilder="Account("
            mv.visitLdcInsn(className.substring(className.lastIndexOf("/") + 1) + "(");
            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false);

            Iterator<Map.Entry<String, String>> it = fields.entrySet().iterator();
            while (it.hasNext()) {
                Map.Entry<String, String> kv = it.next();
                String fieldName = kv.getKey();
                String fieldDesc = kv.getValue();
                mv.visitVarInsn(Opcodes.ALOAD, 0); // 载入this
                mv.visitFieldInsn(Opcodes.GETFIELD, className, fieldName, fieldDesc); // 步骤4.c 加载字段到操作数栈
                // 步骤4.c 拼接字段值到StringBuilder="Account(字段值"
                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(" + fieldDesc + ")Ljava/lang/StringBuilder;", false);
                if (it.hasNext()) { // 步骤4.c 如果不是最后一个字段，拼接","， StringBuilder="Account(字段值,"
                    mv.visitLdcInsn(",");
                    mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false);
                }
            }

            // 步骤4.d 拼接右括号， StringBuilder="Account(字段值1,字段值2)"
            mv.visitLdcInsn(")");
            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false);
            // 步骤5，将StringBuilder转为String，使用ARETURN返回             
            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false);

            mv.visitInsn(Opcodes.ARETURN);
            // 步骤6，计算本地变量表、操作数栈的大小
            mv.visitMaxs(0, 0);
            mv.visitEnd();

        }
        super.visitEnd();
    }
}

ToStringClassVisitor也准备好了之后，剩下要做的就是读取Account类，触发事件调用ToStringClassVisitor，生成字节码，并通过类加载器加载，测试toString方法了

public static void main(String[] args) throws Exception {
    System.out.println(Path.of(""));

    String className = "com.keyniu.asm.Account";
    // 读字节码
    ClassReader cr = new ClassReader(className);
    // 写字节码
    ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_FRAMES);
    ClassVisitor cv = new ToStringClassVisitor(cw);
    // 跑事件流
    cr.accept(cv, ClassWriter.COMPUTE_FRAMES); // 0表示不计算最大堆栈大小和最大局部变量表大小

    // 获取修改后的字节码并写入到文件
    byte[] transformedBytes = cw.toByteArray();
    SingleClassClassLoader cl = new SingleClassClassLoader(className, transformedBytes);
    Class<?> clazz = cl.findClass(className);

    Object instance = clazz.newInstance();
    Method toString = clazz.getDeclaredMethod("toString");
    System.out.println(toString.invoke(instance));
}

执行main方法查看输出，可以确定我们的实现已经生效，如果在Account里新增一个String字段，值等于"randy"，那么输出会自动变成Account(99,randy)

6. 实战: 打印参数和执行耗时

打印参数和执行耗时对于我们排查问题很有帮助。我们定义一个@Diagnostic注解，使用asm对注解了@Diagnostic的方法进行修改，打印入参，记录调用耗时。处理过程可以的分为4步:

1. 准备测试用类Account和注解Diagnostic
2. 实现ClassVisitor，覆盖visitMethod方法，目的是注入自己的MethodVisitor实现
3. 实现MethodVisitor，在visitAnnotation中判断当前方法是否有@Diagnostic注解，在visitCode时打印参数，记录开始执行时间
4. 实现MethodVisitor，在visitInsn中判断是否是方法执行的最后一条指令(返回或抛异常)，是的话计算耗时并打印

第1步是准备测试类，Account和Diagnostic的定义在之前已经给出。第2步是实现自己的ClassVisitor，内部逻辑也相当简单，只需要覆写visitMethod方法，返回我们的DiagnosticMethodVisitor即可。

package com.keyniu.asm.diagnostic;

import org.objectweb.asm.*;

public class DiagnosticClassVisitor extends ClassVisitor {

    protected DiagnosticClassVisitor(ClassVisitor classVisitor) {
        super(Opcodes.ASM9, classVisitor);
    }

    @Override
    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
        MethodVisitor mv = super.visitMethod(access, name, descriptor, signature, exceptions);
        return new DiagnosticMethodVisitor(name, mv);
    }
}

第3步是实现DiagnosticMethodVisitor，在visitAnnotation时判断方法是否标注@Diagnostic，在visitCode中读取并打印入参，记录方法开始执行的时间(System.currentTimeMillis)到本地变量中

package com.keyniu.asm.diagnostic;

import org.objectweb.asm.AnnotationVisitor;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;

import java.util.UUID;

public class DiagnosticMethodVisitor extends MethodVisitor {

    private boolean isDiagnostic = false;
    private String methodName;
    private String traceId = UUID.randomUUID().toString();

    protected DiagnosticMethodVisitor(String methodName, MethodVisitor methodVisitor) {
        super(Opcodes.ASM9, methodVisitor);
        this.methodName = methodName;
    }

    @Override
    public AnnotationVisitor visitAnnotation(String descriptor, boolean visible) {
        if ("Lcom/keyniu/asm/diagnostic/Diagnostic;".equals(descriptor)) {  // 判断注解是否为我们感兴趣的@Diagnostic
            isDiagnostic = true;
        }
        return super.visitAnnotation(descriptor, visible);
    }

    @Override
    public void visitCode() {
        if (isDiagnostic) {
            mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");   // 将System.out放入操作数栈，后续会调用out.println

            mv.visitTypeInsn(Opcodes.NEW, "java/lang/StringBuilder");                                   // 创建StringBuilder，并调用构造函数<init>

            mv.visitInsn(Opcodes.DUP);
            mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/StringBuilder", "<init>", "()V", false);
            
   
            mv.visitLdcInsn("traceId: " + traceId + " call <" + this.methodName + "> with params: ");   // 使用ldc指令，放入字符常量，打印参数的前置
            // 弹出栈顶的两个元素(StringBuilder的引用、要拼接的参数)调用append方法，将返回值(StringBuilder自己)压入栈顶，后续类似命令不再解释，参照这里
            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false);
            
            mv.visitVarInsn(Opcodes.ALOAD, 1); // 加载index=1的值(第1个参数), index=0是this引用
            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false);
            
            mv.visitLdcInsn(" , "); // 插入分隔符
            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false);

            mv.visitVarInsn(Opcodes.ILOAD, 2); // 加载index=2的值(第2个参数)
            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(I)Ljava/lang/StringBuilder;", false);
            // 将StringBuilder转为String，压入栈顶，为输出做好准备                                       
            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false);
            // 输出内容
            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
            // 获取当前时间，记录到本地变量
            mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/System", "currentTimeMillis", "()J");
            mv.visitVarInsn(Opcodes.LSTORE, 4);
            mv.visitMaxs(0, 0);
        }
        super.visitCode();
    }

}

第4步是在方法结束前，重新取一个当前时间，减去开始时间，就是方法的执行时间并打印。在visitInst回调，我们能取得方法中的每个指令，在方法返回(RETURN)或抛异常(ATHROW)前，正是插入这段逻辑的合适位置。

public class DiagnosticMethodVisitor extends MethodVisitor {

    ...
    @Override
    public void visitInsn(int opcode) {
        if (isDiagnostic) {
            if ((Opcodes.IRETURN <= opcode && opcode <= Opcodes.RETURN) || Opcodes.ATHROW == opcode) { // 方法返回之前
                mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
                mv.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/System", "currentTimeMillis", "()J");
                mv.visitVarInsn(Opcodes.LLOAD, 4);
                mv.visitInsn(Opcodes.LSUB);

                mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
                mv.visitLdcInsn("traceId: " + traceId + " call <" + this.methodName + "> timeCost: ");
                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "print", "(Ljava/lang/String;)V", false);
                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(J)V", false);
            }
        }
        super.visitInsn(opcode);
    }

}

到这里整个Diagnostic工具已经开发完成了，下面我们创建一段测试代码，来看看怎么用，是否能达成预期的效果

package com.keyniu.asm.diagnostic;

import com.keyniu.asm.utils.SingleClassClassLoader;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.util.TraceClassVisitor;

import java.io.PrintWriter;
import java.lang.reflect.Method;
import java.nio.file.Path;

public class DiagnosticMain {

    public static void main(String[] args) throws Exception {
        System.out.println(Path.of(""));

        String className = "com.keyniu.asm.Account";
        // 读字节码
        ClassReader cr = new ClassReader(className);
        // 写字节码
        ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_FRAMES);
        ClassVisitor cv = new TraceClassVisitor(new DiagnosticClassVisitor(cw), new PrintWriter(System.out));
        // 跑事件流
        cr.accept(cv, ClassWriter.COMPUTE_FRAMES); // 0表示不计算最大堆栈大小和最大局部变量表大小

        // 获取修改后的字节码并写入到文件
        byte[] transformedBytes = cw.toByteArray();
        SingleClassClassLoader cl = new SingleClassClassLoader(className, transformedBytes);
        Class<?> clazz = cl.findClass(className);

        Object instance = clazz.newInstance();
        Method toString = clazz.getDeclaredMethod("transfer", String.class, int.class);
        System.out.println(toString.invoke(instance, "randy", 9));
    }

}

看输出我们确定想要的目标已经实现了。额外要提一下的是这里我们用TraceClassVisitor包装了DiagnosticClassVisitor目的是打印最终的字节码(如下图)，并不影响实际的执行。

A. 参考资料

1. The Class File Format，Chapter 4. The class File Format
2. JMV Instruction Set，Chapter 6. The Java Virtual Machine Instruction Set
3. ASM Guide，https://asm.ow2.io/asm4-guide.pdf