相比自己的代码里用Spring AOP添加某些功能，字节码增强更适配无侵入式的Java Agent场景。比如下面写个Java Agent打印 任意Java程序中方法执行的耗时：

1、ASM

• ASM是Java字节码操作和分析框架
• 直接以二进制形式修改现有类或动态生成类
• ASM性能好（修改或生成类快）但代码书写复杂
• 官网：https://asm.ow2.io/

2、ASM字节码增强

引入依赖：

<dependency>
    <groupId>org.ow2.asm</groupId>
    <artifactId>asm</artifactId>
    <version>9.6</version>
</dependency>

使用框架的固定写法代码，注意继承MethodVisitor

继承MethodVisitor的类描述如何去增强原来的类：

• visitCode：被增强的方法执行开始前做的操作
• visitInsn：被增强的方法产生特定的操作时，想增加的操作，比如出现return语句时
• visitEnd：设置被增强的方法的最大栈深度和局部变量表的大小

最后，实现MethodVisitor类用于增强方法，修改属性等其他方法类似，写对应类的实现类即可。

3、ASM入门案例

用ASM框架，实现一下插入一行字节码

import org.apache.commons.io.FileUtils;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.MethodVisitor;

import java.io.File;
import java.io.IOException;

import static org.objectweb.asm.Opcodes.*;

//ASM入门案例，向每个方法添加一行字节码指令
public class ASMDemo {
    
    public static void main(String[] args) throws IOException {
    
        //1.从本地读取一个字节码文件，byte[]
        byte[] bytes = FileUtils.readFileToByteArray(new File("D:\\jmh2\\llg-agent\\target\\classes\\com\\llg\\AgentMain.class"));

        //2.通过ASM修改字节码文件
        //数据转换成可以解析内容
        ClassReader classReader = new ClassReader(bytes);

        //创建visitor对象，修改字节码信息
        ClassWriter classWriter = new ClassWriter(0);
        //参数一和JDK版本对应，详见官方文档
        ClassVisitor classVisitor = new ClassVisitor(ASM6,classWriter){
    
            //重写visitMethod，即说明怎么修改方法，重写visitField即说明怎么改属性，以此类推
            @Override
            public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
    

                MethodVisitor mv = super.visitMethod(access, name, descriptor, signature, exceptions);
                //返回自定义的MethodVisitor，this.api即上面的ASM6
                MethodVisitor methodVisitor = new MethodVisitor(this.api,mv){
    
                    //修改字节码指令

                    @Override
                    public void visitCode() {
    
                        //调用ASM的API，插入一行字节码指令 ICONST_0
                        visitInsn(ICONST_0);
                    }
                };

                return methodVisitor;
            }
        };

        classReader.accept(classVisitor,0);


        //3.将修改完的字节码信息写入文件中，进行替换
        FileUtils.writeByteArrayToFile(new File("D:\\jmh2\\llg-agent\\target\\classes\\com\\llg\\AgentMain.class"),classWriter.toByteArray());

    }
}

4、ASM + Java Agent实现增强类的方法

以下用ASM实现增强类的方法，执行开始前、return后，打印一句话：

import org.objectweb.asm.*;

import static org.objectweb.asm.Opcodes.*;

public class AsmEnhancer {
    

    public static byte[] enhanceClass(byte[] bytes){
    
        ClassWriter classWriter = new ClassWriter(0);
        ClassVisitor classVisitor = new ClassVisitor(ASM7, classWriter){
    
            @Override
            public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
    
                MethodVisitor methodVisitor = super.visitMethod(access, name, descriptor, signature, exceptions);
                return new MyMethodVisitor(this.api,methodVisitor);
            }
        };

        ClassReader classReader = new ClassReader(bytes);
        classReader.accept(classVisitor,0);

        //返回结果
        return classWriter.toByteArray();
    }
}

/**
 * 实现MethodVisitor类，描述怎么增强
 */
class MyMethodVisitor extends MethodVisitor {
    

    public MyMethodVisitor(int api, MethodVisitor methodVisitor) {
    
        super(api, methodVisitor);
    }

    //方法执行一开始，调用System.out.println（"开始执行"）方法
    @Override
    public void visitCode() {
    
        mv.visitFieldInsn(Opcodes.GETSTATIC,"java/lang/System","out","Ljava/io/PrintStream;");
        mv.visitLdcInsn("开始执行");
        mv.visitMethodInsn(INVOKEVIRTUAL,"java/io/PrintStream","println","(Ljava/lang/String;)V",false);
        super.visitCode();
    }

    //返回时，执行System.out.println("结束执行")
    @Override
    public void visitInsn(int opcode) {
    
        if(opcode == ARETURN || opcode == RETURN ) {
    
            mv.visitFieldInsn(Opcodes.GETSTATIC,"java/lang/System","out","Ljava/io/PrintStream;");
            mv.visitLdcInsn("结束执行");
            mv.visitMethodInsn(INVOKEVIRTUAL,"java/io/PrintStream","println","(Ljava/lang/String;)V",false);
        }
        super.visitInsn(opcode);
    }

    //指定最大栈深度20，最大局部变量表大小是50
    @Override
    public void visitEnd() {
    
        mv.visitMaxs(20,50);
        super.visitEnd();
    }

}

Java Agent中，根据用户输入的类名找到class进行增强：

public class ClassCommand {
    

    //对类进行增强
    public static void enhanceClass(Instrumentation inst){
    
        System.out.println("请输入类名:");
        //让用户输入类名
        Scanner scanner = new Scanner(System.in);
        String className = scanner.next();

        //根据类名找到class对象
        Class[] allLoadedClasses = inst.getAllLoadedClasses();
        for (Class allLoadedClass : allLoadedClasses) {
    
            if(allLoadedClass.getName().equals(className)){
    
                //找到了
                ClassFileTransformer transformer = new ClassFileTransformer() {
    
                    @Override
                    public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
    
                        //通过ASM对类进行增强，返回字节码信息
                        byte[] bytes = AsmEnhancer.enhanceClass(classfileBuffer);
                        //返回增强后的字节码信息
                        return bytes;
                    }
                };

                //1.添加转换器
                inst.addTransformer(transformer,true);

                //2.手动触发转换
                try {
    
                    inst.retransformClasses(allLoadedClass);
                } catch (UnmodifiableClassException e) {
    
                    e.printStackTrace();
                }finally {
    
                    //3.删除转换器
                    inst.removeTransformer(transformer);
                }


            }
        }
    }
}

动态代理的agentmain中调用一下：

public class AgentMain {
    

    public static void agentmain(String agentArgs,Instrumentation inst){
    
        ClassCommand.enhanceClass(inst);
    }

}

Java Agent打成jar包，写客户端，连接用户输入的Java进程的PID并加载jar：

public class AttachMain {
    
    public static void main(String[] args) throws Exception {
    
        //获取进程列表，让用户自己选择连接哪个PID
        //执行jps指令
        Process process = Runtime.getRuntime().exec("jps");
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(process.getInputStream()));
        try (bufferedReader) {
    
            String line;
            while ((line = bufferedReader.readLine()) != null) {
    
                System.out.println(line);
            }
        }
        //用户输入进程ID
        Scanner scanner = new Scanner(System.in);
        String pid = scanner.next();
        //连接用户输入的进程
        VirtualMachine vm = VirtualMachine.attach(pid);
        //执行Java Agent的里的agentmain方法
        vm.loadAgent("D:\\jmh2\\llg-agent\\target\\llg-agent-1.0-SNAPSHOT-jar-with-dependencies.jar");

    }
}

效果：

输入要增强的类：

调用TestController类中的方法：

增强成功：

5、Byte Buddy

上面的ASM，写增强代码的逻辑很繁琐。Byte Buddy：

• 底层基于ASM，提供了更简单的API供调用
• 用于在Java程序运行时创建和修改Java类，而无需编译器的帮助
• 和Java Agent整合的更好，提供了对应的依赖
• 官网：https://bytebuddy.net/#/

同一增强，与ASM相比：

Byte Buddy的用法为引入依赖后：指定增强哪个类，以及怎么增强（类似AOP的一个通知类）

通知类中，用注解写方法进入和退出时要新增的逻辑：

注意上面用到的另外两个注解：@Advice.AllArguments拿到方法的所有参数，@Advice.Enter拿到上面enter方法返回的结果。

6、Byte Buddy案例

引入依赖：

<dependency>
    <groupId>net.bytebuddy</groupId>
    <artifactId>byte-buddy</artifactId>
    <version>1.14.10</version>
</dependency>
<dependency>
    <groupId>net.bytebuddy</groupId>
    <artifactId>byte-buddy-agent</artifactId>
    <version>1.14.10</version>
</dependency>

在Java Agent中定义方法，接收用户输入的类名，JMX获取已加载的类，并找到用户要增强的类的class对象，用Byte Buddy的固定API调用进行增强：

public class ClassCommand {
    

   //Byte Buddy
    //对类进行增强
    public static void enhanceClassByByteBuddy(Instrumentation inst) {
    
        System.out.println("请输入类名:");
        //让用户输入类名
        Scanner scanner = new Scanner(System.in);
        String className = scanner.next();

        //根据类名找到class对象
        Class[] allLoadedClasses = inst.getAllLoadedClasses();
        for (Class allLoadedClass : allLoadedClasses) {
    
            if (allLoadedClass.getName().equals(className)) {
    
                //找到了
                //使用byte buddy增强类
                new AgentBuilder.Default()
                        //禁止byte buddy处理时修改类名
                        .disableClassFormatChanges()
                        //处理时使用retransform增强
                        .with(AgentBuilder.RedefinitionStrategy.RETRANSFORMATION)
                        //打印出增强过程中的错误日志（官网固定写法）
                        .with(new AgentBuilder.Listener.WithTransformationsOnly(AgentBuilder.Listener.StreamWriting
                                .toSystemOut()))
                        //匹配哪些类，这里只增强用户传入的类
                        .type(ElementMatchers.named(className))
                        //增强，使用MyAdvice通知，ElementMatchers.any()即对所有方法都进行增强
                        .transform((builder, classLoader, module, protectionDomain) ->
                                builder.visit(Advice.to(MyAdvice.class).on(ElementMatchers.any())))
                        .installOn(inst);


            }
        }
    }
}

MyAdvice的增强逻辑：

mport net.bytebuddy.asm.Advice;

public class MyAdvice {
    
    //方法进入时，打印所有参数，返回开始时间
    @Advice.OnMethodEnter
    static long enter(@Advice.AllArguments Object[] ary){
    
        if(null != ary){
    
            for (int i = 0; i < ary.length; i++) {
    
                System.out.println("参数:" + i + " 内容:" + ary[i]);
            }
        }
        //返回毫秒值
        return System.nanoTime();
    }

    //方法退出时候，统计方法执行耗时
    @Advice.OnMethodExit
    static void exit(@Advice.Enter long value){
    
        System.out.println("耗时为: " + (System.nanoTime() - value) + "纳秒");
    }
}

同ASM，加载Java Agent的Jar：

输入类名：

增强成功：