前言

基于上文，统计代码执行耗时，会发现很多代码越来越不会写，这些代码的原理是什么。此时我们就需要补充一些简单的ASM字节码相关的知识。

ASM知识点汇总

类访问ClassVisitor

�这里是类访问的入口，我们的所有方法都是以此为切入点的，这里定义了一个类访问的标准流程，我们可以直接看代码注释

/**
 * A visitor to visit a Java class. The methods of this class must be called in the following order:
 * {@code visit} [ {@code visitSource} ] [ {@code visitModule} ][ {@code visitNestHost} ][ {@code
 * visitOuterClass} ] ( {@code visitAnnotation} | {@code visitTypeAnnotation} | {@code
 * visitAttribute} )* ( {@code visitNestMember} | {@code visitInnerClass} | {@code visitField} |
 * {@code visitMethod} )* {@code visitEnd}.
 *
 * @author Eric Bruneton
 */
public abstract class ClassVisitor {

我们基于此，给出一些关键方法的使用场景

visit:Visits the header of the class
visitSource:Visits the source of the class
visitModule:Visit the module corresponding to the class.
visitNestHost:Visits the nest host class of the class. A nest is a set of classes of the same package that share access to their private members. One of these classes, called the host, lists the other members of the nest, which in turn should link to the host of their nest. This method must be called only once and only if the visited class is a non-host member of a nest. A class is implicitly its own nest, so it's invalid to call this method with the visited class name as argument.
visitOuterClass:Visits the enclosing class of the class. This method must be called only if the class has an enclosing class.
visitAnnotation:Visits an annotation of the class.
visitTypeAnnotation:Visits an annotation on a type in the class signature.
visitAttribute:Visits a non standard attribute of the class.
visitNestMember:Visits a member of the nest. A nest is a set of classes of the same package that share access to their private members. One of these classes, called the host, lists the other members of the nest, which in turn should link to the host of their nest. This method must be called only if the visited class is the host of a nest. A nest host is implicitly a member of its own nest, so it's invalid to call this method with the visited class name as argument.
visitInnerClass:Visits information about an inner class. This inner class is not necessarily a member of the class being visited.
visitField:Visits a field of the class.
visitMethod:Visits a method of the class. This method must return a new MethodVisitor instance (or null) each time it is called, i.e., it should not return a previously returned visitor.
visitEnd:Visits the end of the class. This method, which is the last one to be called, is used to inform the visitor that all the fields and methods of the class have been visited.

以上是一个类的字节码标准访问顺序，我们主要是在这个流程中带入自己的逻辑，简称插桩。我们再回头看看之前的代码TimeCoster的实现原理

定义一个特殊的字段ASM_TIME_COST，把这个字段插入到各个要关注的类中，然后围绕它把相关数据收集起来，最后打印出来。
怎么存储上述字段，我们使用了本地变量表，先写成java代码，然后借助ASM的插件编译为字节码指令
由于插入了新的代码，栈帧发生了变化，调整栈帧大小，确保新的字节码文件符合标准规范

基于此，我们会发现功能实现有些冗余，有没有更好的方法呢？
当然有！！！

插入静态代码，在方法进入前做一个时间点，在方法返回前做一个时间差
在1的基础上可以功能增强，比如使用注解

我们现在就实现第一个方案，第二个方案留给广大读者

package com.deer.agent.sandbox;
import java.util.HashMap;
import java.util.Map;
/**
 *
 * 计算耗时，fullMethodName = className.methodName
 */
public class TimeUtil {
    public static Map<String, Long> sStartTime = new HashMap<>();
    public static Map<String, Long> sEndTime = new HashMap<>();
    public static void setStartTime(String fullMethodName, long time) {
        sStartTime.put(fullMethodName, time);
    }
    public static void setEndTime(String fullMethodName, long time) {
        sEndTime.put(fullMethodName, time);
    }
    public static String getCostTime(String fullMethodName) {
        long start = sStartTime.get(fullMethodName);
        long end = sEndTime.get(fullMethodName);
        return "method: " + fullMethodName + " -cost- " + Long.valueOf(end - start) + " ns";
    }
}

package com.deer.agent.sandbox;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.commons.AdviceAdapter;
public class TimeCoster2 extends ClassVisitor implements Opcodes {
    private String clazzName;
    public TimeCoster2(ClassVisitor classVisitor) {
        super(ASM7, classVisitor);
    }
    @Override
    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
        super.visit(version, access, name, signature, superName, interfaces);
        clazzName = name;
    }
    @Override
    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
        MethodVisitor mv = cv.visitMethod(access, name, descriptor, signature, exceptions);
        mv = new AdviceAdapter(ASM7,mv,access,name,descriptor) {
            @Override
            protected void onMethodEnter() {
                TimeUtil.setStartTime(clazzName+"."+name,System.nanoTime());
                super.onMethodEnter();
            }
            @Override
            protected void onMethodExit(int opcode) {
                TimeUtil.setEndTime(clazzName+"."+name,System.nanoTime());
                System.out.println(TimeUtil.getCostTime(clazzName+"."+name));
                super.onMethodExit(opcode);
            }
        };
        return mv;
    }
}

此处，我们只需要关注和TimeUtil有关的相关代码，让ASM插件帮我们转换为字节码即可

如图所示，我们只需要用类名方法名替换掉字符串abc即可得到全部代码
最后我们拿到最终的代码如下

package com.deer.agent.sandbox;
import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.commons.AdviceAdapter;
public class TimeCoster2 extends ClassVisitor implements Opcodes {
    private String clazzName;
    public TimeCoster2(ClassVisitor classVisitor) {
        super(ASM7, classVisitor);
    }
    @Override
    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
        super.visit(version, access, name, signature, superName, interfaces);
        clazzName = name;
    }
    @Override
    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
        MethodVisitor mv = cv.visitMethod(access, name, descriptor, signature, exceptions);
        //跳过java原生相关的类
        if (!clazzName.startsWith("com/deer/base")
        ) {
            return mv;
        }
        mv = new AdviceAdapter(ASM7,mv,access,name,descriptor) {
            @Override
            protected void onMethodEnter() {
                mv.visitLdcInsn(clazzName+"."+name);
                mv.visitMethodInsn(INVOKESTATIC, "java/lang/System", "nanoTime", "()J", false);
                mv.visitMethodInsn(INVOKESTATIC, "com/deer/agent/sandbox/TimeUtil", "setStartTime", "(Ljava/lang/String;J)V", false);
                super.onMethodEnter();
            }
            @Override
            protected void onMethodExit(int opcode) {
                mv.visitLdcInsn(clazzName+"."+name);
                mv.visitMethodInsn(INVOKESTATIC, "java/lang/System", "nanoTime", "()J", false);
                mv.visitMethodInsn(INVOKESTATIC, "com/deer/agent/sandbox/TimeUtil", "setEndTime", "(Ljava/lang/String;J)V", false);
                mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
                mv.visitLdcInsn(clazzName+"."+name);
                mv.visitMethodInsn(INVOKESTATIC, "com/deer/agent/sandbox/TimeUtil", "getCostTime", "(Ljava/lang/String;)Ljava/lang/String;", false);
                mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
                super.onMethodExit(opcode);
            }
        };
        return mv;
    }
}

执行后得到结果

此时看代码逻辑，比之前清晰很多，具有非常明确的思路和方法。
那么，之前的代码写那么长是吓退一众观众的吗，是的没错。
假如借助javaassist来修改字节码，那是不是更方便了，那么借助注解，是不是也可以实现？
这里给一个思路，借助我们的类名+方法名，重写 visitAnnotation�方法，识别出来要处理的类和方法即可。

方法访问MethodVisitor

�根据上述示例，我们知道了方法访问的一般用法，在此，我们回忆并思考一下之前的代码com.deer.base.service.impl.HelloServiceImpl，为什么没有被拦截执行。
首先，测试项目是一个普通的spring项目，HelloServiceImpl会变成一个普通的spring bean，众所周知，spring中的bean是通过代理或者字节码的形式转的，因此类名已经面目全非了，默认情况下是一个jdk的代理类，格式如下
java.lang.reflect.Proxy#56
那么，我们怎么才能正确的拦截呢

package com.deer.agent;
import com.deer.agent.sandbox.AgentClazzTransformer;
import java.lang.instrument.Instrumentation;
import java.util.Arrays;
public class AgentMain {
    public static void premain(String agentArgs, Instrumentation inst) {
        System.out.println("premain");
    }
    public static void agentmain(String agentArgs, Instrumentation inst){
        System.out.println("load agent...");
        Class[] clazzList = inst.getAllLoadedClasses();
        Arrays.stream(clazzList).forEach(clazz->{
            if(clazz.getName().startsWith("com.deer.base.service.impl")){
                //
                try {
                    inst.addTransformer(new AgentClazzTransformer(), true);
                    inst.retransformClasses(clazz);
                }catch (Exception e){
                    //
                }
            }
        });
    }
}

到此，我们去测试一下执行的结果

符合预期，我们期待的spring bean方法也被监控到了。
那么，我们在最开头提出的最初级的功能——>在代码入口处加代码

System.out.println("hello, i come in ...");

现在应该也能实现了，留给读者自己实现。
那么到现在为止，我们开始进行代码插桩的思路设计。

代码插桩

通过前面那些完整的例子，进一步思考：

在字节码中插入简单的代码：打日志，记录方法耗时，本质上是在利用字节码规范在字节码中填充我们自己需要的逻辑，如果这个诉求比较复杂，比如：记录一个方法调用的顺序，更进一步可以实现全链路监控。比如，现在线上接口受限，不能debug，我们需要知道具体的方法耗时，调用链路，出入参，是否可以灵活挂载一个java agent直接实现。比如，现在线上有个紧急问题，不能停机，也没有热启动，是否可以灵活挂载一个java agent直接把代码逻辑替换掉。
asm这种纯字节码的属于技术研究，怎么把它提升到更高的维度，做成生产级产品，比如流量录制与回放，轻量级debug。

我们带着上述问题，设计几个目标，然后一步步实现。

记录方法入参出参
类似java远程debug的形式，打印出一个方法调用链路，出入参
类似skywalking，做一个全链路的调用监控
类似阿里巴巴的jvm-sandbox-repeater做一个流量录制与回放工具
类似阿里巴巴的混沌工程，做一个故障注入与修复的系统

Java 沙箱技术

类增强之---代码插桩

前言

ASM知识点汇总

类访问ClassVisitor

方法访问MethodVisitor

代码插桩