Java Agent

import java.lang.instrument.Instrumentation;

public class AgentMain {

    // JVM启动时agent
    public static void premain(String args, Instrumentation inst) {
        agent0(args, inst);
    }

    public static void agent0(String args, Instrumentation inst) {
        System.out.println("agent is running!");
        // 添加一个类转换器
        inst.addTransformer(new ClassFileTransformer() {
            @Override
            public byte[] transform(ClassLoader loader, 
                                    String className, 
                                    Class<?> classBeingRedefined, 
                                    ProtectionDomain protectionDomain, 
                                    byte[] classfileBuffer) {
                // JVM加载的所有类会流经这个类转换器
                // 这里找到自定义的测试类
                if (className.endsWith("WorkerMain")) {
                    System.out.println("transform class WorkerMain");
                }
                // 直接返回原本的字节码
                return classfileBuffer;
            }
        });
    }
}

PreMain-Class: AgentMain
Can-Redefine-Classes: true
Can-Retransform-Classes: true

import java.util.Random;

class WorkerMain {

    public static void main(String[] args) throws InterruptedException {
        for (; ; ) {
            int x = new Random().nextInt();
            new WorkerMain().test(x);
        }
    }

    public void test(int x) throws InterruptedException {
        Thread.sleep(2000);
        System.out.println("i'm working " + x);
    }
}

public class AttachUtil {

  public static void main(String[] args) throws IOException, AgentLoadException, AgentInitializationException, AttachNotSupportedException {

      // 获取运行中的JVM列表
      List<VirtualMachineDescriptor> vmList = VirtualMachine.list();
      // 需要agent的jar包路径
      String agentJar = "xxxx/agent-test.jar";
      for (VirtualMachineDescriptor vmd : vmList) {
          // 找到测试的JVM
          if (vmd.displayName().endsWith("WorkerMain")) {
              // attach到目标ID的JVM上
              VirtualMachine virtualMachine = VirtualMachine.attach(vmd.id());
              // agent指定jar包到已经attach的JVM上
              virtualMachine.loadAgent(agentJar);
              virtualMachine.detach();
          }
      }
}

public class AgentMain {

    // JVM启动时agent
    public static void premain(String args, Instrumentation inst) {
        agent0(args, inst);
    }

    // JVM运行时agent
    public static void agentmain(String args, Instrumentation inst) {
        agent0(args, inst);
    }

    public static void agent0(String args, Instrumentation inst) {
        System.out.println("agent is running!");
        inst.addTransformer(new ClassFileTransformer() {
            @Override
            public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) {
                // 打印transform的类名
                System.out.println(className);
                return classfileBuffer;
            }
        },true);

        try {
            // 找到WorkerMain类，对其进行重定义
            Class<?> c = Class.forName("test.WorkerMain");
            inst.retransformClasses(c);
        } catch (Exception e) {
            System.out.println("error!");
        }
    }
}

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

public class MyClassTransformer implements ClassFileTransformer {

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

        // 对类字节码进行操作
        // 这里需要注意，不能对classfileBuffer这个数组进行修改操作
        try {
            // 创建ASM ClassReader对象，导入需要增强的对象字节码
            ClassReader reader = new ClassReader(classfileBuffer);
            ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_MAXS);
            
            // 自己实现的代码增强器
            MyEnhancer myEnhancer = new MyEnhancer(classWriter);

            // 增强字节码
            reader.accept(myEnhancer, ClassReader.SKIP_FRAMES);

            // 返回MyEnhancer增强后的字节码
            return classWriter.toByteArray();
        } catch (Exception e) {
            e.printStackTrace();
        }

        // return null 则不会对类进行转换
        return null;
    }
}

public class MyEnhancer extends ClassVisitor implements Opcodes {

    public MyEnhancer(ClassVisitor classVisitor) {
        super(ASM7, classVisitor);
    }

    /**
     * 对字节码中的方法定义进行修改
     */
    @Override
    public MethodVisitor visitMethod(int access, final String name, String descriptor, String signature, String[] exceptions) {
        MethodVisitor mv = super.visitMethod(access, name, descriptor, signature, exceptions);
        if (isIgnore(mv, access, name)) {
            return mv;
        }
        return new AdviceAdapter(Opcodes.ASM7, new JSRInlinerAdapter(mv, access, name, descriptor, signature, exceptions), access, name, descriptor) {

            private final Type METHOD_CONTAINER = Type.getType(MethodContainer.class);
            private int timeIdentifier;
            private int argsIdentifier;

            /**
             * 进入方法前
             */
            @Override
            protected void onMethodEnter() {
                // 调用System.nanoTime()方法，将方法出参推入栈顶
                invokeStatic(Type.getType(System.class), Method.getMethod("long nanoTime()"));
                // 构造一个Long类型的局部变量，然后返回这个变量的标识符
                timeIdentifier = newLocal(Type.LONG_TYPE);

                // 存储栈顶元素也就是System.nanoTime()返回值，到指定位置本地变量区
                storeLocal(timeIdentifier);

                // 加载入参数组，将入参数组ref推入栈顶
                loadArgArray();
                // 构造一个Object[]类型的局部变量，返回这个变量的标识符
                argsIdentifier = newLocal(Type.getType(Object[].class));
                // 存储入参到指定位置本地变量区
                storeLocal(argsIdentifier);
            }

            @Override
            protected void onMethodExit(int opcode) {
                // 加载指定位置的本地变量到栈顶
                loadLocal(timeIdentifier);
                loadLocal(argsIdentifier);
                // 相当于调用MethodContainer.showMethod(long, Object[])方法
                invokeStatic(METHOD_CONTAINER, Method.getMethod("void showMethod(long,Object[])"));
            }
        };
    }


    /**
     * 方法是否需要被忽略（静态构造函数和构造函数）
     */
    private boolean isIgnore(MethodVisitor mv, int access, String methodName) {
        return null == mv
                || isAbstract(access)
                || isFinalMethod(access)
                || "<clinit>".equals(methodName)
                || "<init>".equals(methodName);
    }
  
    private boolean isAbstract(int access) {
        return (ACC_ABSTRACT & access) == ACC_ABSTRACT;
    }

    private boolean isFinalMethod(int methodAccess) {
        return (ACC_FINAL & methodAccess) == ACC_FINAL;
    }
}

public class MethodContainer {

    // 实现静态方法
    public static void showMethod(long startTime, Object[] Args) {
        System.out.println("方法耗时:" + (System.nanoTime() - startTime) / 1000000 + "ms, 方法入参：" + Arrays.toString(Args));
    }
}

// ASM操作字节码需要一定的学习才能理解，如果把上述字节码增强前后用Java代码表示大体入下：
// ASM代码增强前
public void test(int x) throws InterruptedException {
  	Thread.sleep(2000L);
    System.out.println("i'm working " + x);
}

// ASM代码增强后
public void test(int x) throws InterruptedException {
    long var2 = System.nanoTime();
    Object[] var4 = new Object[]{new Integer(x)};
    Thread.sleep(2000L);
    System.out.println("i'm working " + x);
    MethodContainer.showMethod(var2, var4);
}