程序员经验分享-hwhale

JavaAgent的那点秘密

2023-10-27

JavaAgent的那点秘密

前言

大家都知道Java文件编译成Class文件之后才能在Jvm中运行的，而Class文件自有一套规范:

  • 不必一定是Java文件经由javac编译产生；
  • 其它编程语言也可以直接生成Class文件交由Jvm运行；

既然其它语言都可以生成Class文件，理论上Java语言自己是不是也可以修改/篡改Class文件呢？答案是肯定的。那么是否有这方面的需求呢（用Java语法去直接修改Class文件） 我举个例子：

  • 需要去增强别人的二方包，需要针对其中大量的方法进行增强
  • 程序运行期间，动态去修改某个类（有点类似于ide中的热编译热部署）从而达到线上快速调试的目的公司级别基础框架，应用层毫不感知地进行慢sql监控，traceid链路跟踪

ASM

目前市面上还有很多字节码技术基本上都是这么做的，而他们都是利用的jdk5官方提供JavaAgent技术 字节码技术
直接操纵字节码技术有目前已经有很多工具了，比如asm，javaassist，arthas，这里的示例选用的是asm来进行举例讲解

asm maven坐标：

<dependency>
    <groupId>org.ow2.asm</groupId>
    <artifactId>asm-all</artifactId>
    <version>6.0_BETA</version>
</dependency>

基于asm生成一个class文件

这个示例中，可以学到：

  • 演示了生成类变量的生成
  • for循环的编写方式
  • 组装集合对象ArrayList，并作为出参返回
  • 集合对象ArrayList作为入参进行遍历
package com.example.lzcjavaagent;

import org.objectweb.asm.*;

import java.io.File;
import java.io.FileOutputStream;
import java.lang.reflect.Method;
import java.util.List;

/**
 * 通过ASM生成类的字节码
 *
 * @author Administrator
 */
public class HelloGeneratorClass implements Opcodes {

    /**
     * 使用构造Hello类class字节码
     */
    public static byte[] generatorHelloClass() throws Exception {

        ClassWriter cw = new ClassWriter(0);
        FieldVisitor fv;
        MethodVisitor mv;

        cw.visit(V1_7, ACC_PUBLIC + ACC_SUPER, "com/lzc/Hello", null, "java/lang/Object", null);

        cw.visitSource("Hello.java", null);

        {
            fv = cw.visitField(ACC_PUBLIC + ACC_FINAL + ACC_STATIC, "FLAG", "Ljava/lang/String;", null, "\u6211\u662f\u5e38\u91cf");
            fv.visitEnd();
        }
        {
            mv = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
            mv.visitCode();
            Label l0 = new Label();
            mv.visitLabel(l0);
            mv.visitVarInsn(ALOAD, 0);
            mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
            mv.visitInsn(RETURN);
            Label l1 = new Label();
            mv.visitLabel(l1);
            mv.visitMaxs(1, 1);
            mv.visitEnd();
        }
        {
            mv = cw.visitMethod(ACC_PUBLIC, "display", "()V", null, null);
            mv.visitCode();
            Label l0 = new Label();
            mv.visitLabel(l0);
            mv.visitLineNumber(16, l0);
            mv.visitInsn(ICONST_0);
            mv.visitVarInsn(ISTORE, 1);
            Label l1 = new Label();
            mv.visitLabel(l1);
            mv.visitFrame(Opcodes.F_APPEND, 1, new Object[]{Opcodes.INTEGER}, 0, null);
            mv.visitVarInsn(ILOAD, 1);
            mv.visitIntInsn(BIPUSH, 6);
            Label l2 = new Label();
            mv.visitJumpInsn(IF_ICMPGE, l2);
            Label l3 = new Label();
            mv.visitLabel(l3);
            mv.visitLineNumber(17, l3);
            mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
            mv.visitLdcInsn(">>>>>>>>>>\u6211\u662f\u5e38\u91cf");
            mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
            Label l4 = new Label();
            mv.visitLabel(l4);
            mv.visitLineNumber(16, l4);
            mv.visitIincInsn(1, 1);
            mv.visitJumpInsn(GOTO, l1);
            mv.visitLabel(l2);
            mv.visitLineNumber(20, l2);
            mv.visitFrame(Opcodes.F_CHOP, 1, null, 0, null);
            mv.visitInsn(RETURN);
            Label l5 = new Label();
            mv.visitLabel(l5);
            mv.visitLocalVariable("var1", "I", null, l1, l2, 1);
            mv.visitLocalVariable("this", "Ldemo/Hello;", null, l0, l5, 0);
            mv.visitMaxs(2, 2);
            mv.visitEnd();

        }
        {
            mv = cw.visitMethod(ACC_PUBLIC, "testList", "()Ljava/util/List;", "()Ljava/util/List<Ljava/lang/String;>;", null);
            mv.visitCode();
            Label l0 = new Label();
            mv.visitLabel(l0);
            mv.visitTypeInsn(NEW, "java/util/ArrayList");
            mv.visitInsn(DUP);
            mv.visitMethodInsn(INVOKESPECIAL, "java/util/ArrayList", "<init>", "()V", false);
            mv.visitVarInsn(ASTORE, 1);
            Label l1 = new Label();
            mv.visitLabel(l1);
            mv.visitVarInsn(ALOAD, 1);
            mv.visitLdcInsn("Tome");
            mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "add", "(Ljava/lang/Object;)Z", true);
            mv.visitInsn(POP);
            Label l2 = new Label();
            mv.visitLabel(l2);
            mv.visitVarInsn(ALOAD, 1);
            mv.visitLdcInsn("Jack");
            mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "add", "(Ljava/lang/Object;)Z", true);
            mv.visitInsn(POP);
            Label l3 = new Label();
            mv.visitLabel(l3);
            mv.visitVarInsn(ALOAD, 1);
            mv.visitLdcInsn("Lily");
            mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "add", "(Ljava/lang/Object;)Z", true);
            mv.visitInsn(POP);
            Label l4 = new Label();
            mv.visitLabel(l4);
            mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
            mv.visitTypeInsn(NEW, "java/lang/StringBuilder");
            mv.visitInsn(DUP);
            mv.visitLdcInsn(">>>>>>>>>>testList > list.size = ");
            mv.visitMethodInsn(INVOKESPECIAL, "java/lang/StringBuilder", "<init>", "(Ljava/lang/String;)V", false);
            mv.visitVarInsn(ALOAD, 1);
            mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "size", "()I", true);
            mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(I)Ljava/lang/StringBuilder;",
                    false);
            mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false);
            mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
            Label l5 = new Label();
            mv.visitLabel(l5);
            mv.visitVarInsn(ALOAD, 1);
            mv.visitInsn(ARETURN);
            Label l6 = new Label();
            mv.visitLabel(l6);
            mv.visitMaxs(4, 2);
            mv.visitEnd();
        }
        {
            mv = cw.visitMethod(ACC_PUBLIC, "testMap", "(Ljava/util/List;)Ljava/util/Map;", "(Ljava/util/List<Ljava/lang/String;>;)Ljava/util/Map<Ljava/lang/String;Ljava/lang/String;>;", null);
            mv.visitCode();
            Label l0 = new Label();
            mv.visitLabel(l0);
            mv.visitLineNumber(32, l0);
            mv.visitTypeInsn(NEW, "java/util/HashMap");
            mv.visitInsn(DUP);
            mv.visitMethodInsn(INVOKESPECIAL, "java/util/HashMap", "<init>", "()V", false);
            mv.visitVarInsn(ASTORE, 2);
            Label l1 = new Label();
            mv.visitLabel(l1);
            mv.visitLineNumber(34, l1);
            mv.visitInsn(ICONST_0);
            mv.visitVarInsn(ISTORE, 3);
            Label l2 = new Label();
            mv.visitLabel(l2);
            mv.visitFrame(Opcodes.F_APPEND, 2, new Object[]{"java/util/Map", Opcodes.INTEGER}, 0, null);
            mv.visitVarInsn(ILOAD, 3);
            mv.visitVarInsn(ALOAD, 1);
            mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "size", "()I", true);
            Label l3 = new Label();
            mv.visitJumpInsn(IF_ICMPGE, l3);
            Label l4 = new Label();
            mv.visitLabel(l4);
            mv.visitLineNumber(35, l4);
            mv.visitVarInsn(ALOAD, 1);
            mv.visitVarInsn(ILOAD, 3);
            mv.visitMethodInsn(INVOKEINTERFACE, "java/util/List", "get", "(I)Ljava/lang/Object;", true);
            mv.visitTypeInsn(CHECKCAST, "java/lang/String");
            mv.visitVarInsn(ASTORE, 4);
            Label l5 = new Label();
            mv.visitLabel(l5);
            mv.visitLineNumber(36, l5);
            mv.visitVarInsn(ALOAD, 2);
            mv.visitVarInsn(ALOAD, 4);
            mv.visitTypeInsn(NEW, "java/lang/StringBuilder");
            mv.visitInsn(DUP);
            mv.visitMethodInsn(INVOKESPECIAL, "java/lang/StringBuilder", "<init>", "()V", false);
            mv.visitVarInsn(ALOAD, 4);
            mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false);
            mv.visitVarInsn(ALOAD, 4);
            mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false);
            mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false);
            mv.visitMethodInsn(INVOKEINTERFACE, "java/util/Map", "put", "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", true);
            mv.visitInsn(POP);
            Label l6 = new Label();
            mv.visitLabel(l6);
            mv.visitLineNumber(34, l6);
            mv.visitIincInsn(3, 1);
            mv.visitJumpInsn(GOTO, l2);
            mv.visitLabel(l3);
            mv.visitLineNumber(39, l3);
            mv.visitFrame(Opcodes.F_CHOP, 1, null, 0, null);
            mv.visitVarInsn(ALOAD, 2);
            mv.visitInsn(ARETURN);
            Label l7 = new Label();
            mv.visitLabel(l7);
            mv.visitLocalVariable("str", "Ljava/lang/String;", null, l5, l6, 4);
            mv.visitLocalVariable("i", "I", null, l2, l3, 3);
            mv.visitLocalVariable("this", "Ldemo/Hello;", null, l0, l7, 0);
            mv.visitLocalVariable("list", "Ljava/util/List;", "Ljava/util/List<Ljava/lang/String;>;", l0, l7, 1);
            mv.visitLocalVariable("map", "Ljava/util/Map;", "Ljava/util/Map<Ljava/lang/String;Ljava/lang/String;>;", l1, l7, 2);
            mv.visitMaxs(4, 5);
            mv.visitEnd();
        }
        cw.visitEnd();

        return cw.toByteArray();
    }

    /**
     * 生成保存class文件
     */
    public static byte[] createClass() {
        try {
            byte[] data = generatorHelloClass();
//            File file = new File("/Users/mac/Download/classes/com/lzc/Hello.class");
            File file = new File("/Users/mac/work/gitstudy/lzcjavaagent/target/classes/com/lzc/Hello.class");
            File parent1 = new File(file.getParent());
            boolean mkdirs = parent1.mkdirs();
            System.out.println("mkdirs=" + mkdirs + ",exist=" + file.exists());
            boolean createNewFile = file.createNewFile();
            System.out.println("createNewFile=" + createNewFile + ",exist=" + file.exists());

            FileOutputStream fos = new FileOutputStream(file);
            fos.write(data);
            fos.close();

            return data;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }


    /**
     * 基于反射生成的class文件生成java对象
     */
    public static void useClass(byte[] data) {
        try {
            MyClassLoader myClassLoader = new MyClassLoader();
            Class<?> helloClass = myClassLoader.defineClass("com.lzc.Hello", data);
            Object obj = helloClass.newInstance();
            Method method = helloClass.getMethod("display", null);
            method.invoke(obj, null);

            method = helloClass.getMethod("testList", null);
            Object result = method.invoke(obj, null);
            System.out.println(result);

            method = helloClass.getMethod("testMap", List.class);
            Object result2 = method.invoke(obj, result);
            System.out.println(result2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    static class MyClassLoader extends ClassLoader {


        public MyClassLoader() {
            super();
        }

        @Override
        public Class<?> loadClass(String name) throws ClassNotFoundException {
            return super.loadClass(name);
        }

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

    }


    /**
     * AOP测试
     *
     * @param args
     * @author SHANHY
     * @create 2016年2月3日
     */
    public static void main(String[] args) {
        try {
            byte[] data = createClass();

            useClass(data);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

生成的class文件，反编译之后的java文件如下：

package com.lzc;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Hello {
public static final String FLAG = "我是常量";

    public Hello() {
    }

    public void display() {
        for(int var1 = 0; var1 < 6; ++var1) {
            System.out.println(">>>>>>>>>>我是常量");
        }

    }

    public List<String> testList() {
        ArrayList var1 = new ArrayList();
        var1.add("Tome");
        var1.add("Jack");
        var1.add("Lily");
        System.out.println(">>>>>>>>>>testList > list.size = " + var1.size());
        return var1;
    }

    public Map<String, String> testMap(List<String> list) {
        Map<String, String> map = new HashMap();

        for(int i = 0; i < list.size(); ++i) {
            String str = (String)list.get(i);
            map.put(str, str + str);
        }

        return map;
    }
}

基于asm篡改一个class文件

本文将以一个实际案例进行讲解，在这里我们假设无法直接去修改MathGame.java，但是我们有MathGame.class文件，计划将MathGame.class进行增强。

package com.example.lzcjavaagent;

import org.objectweb.asm.*;
import org.objectweb.asm.commons.AnalyzerAdapter;
import org.objectweb.asm.commons.LocalVariablesSorter;
import org.objectweb.asm.util.TraceClassVisitor;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;

public class TimeCountAdpter extends ClassVisitor implements Opcodes {
private String owner;
private boolean isInterface;

    private String methodName;

    private String filedName = "UDASMCN";
    private int acc = Opcodes.ACC_PUBLIC + Opcodes.ACC_STATIC + Opcodes.ACC_FINAL;
    private boolean isPresent = false;


    public TimeCountAdpter(ClassVisitor classVisitor) {
        super(ASM6, 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);
        owner = name;
        isInterface = (access & ACC_INTERFACE) != 0;
    }

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

        if (!isInterface && mv != null && !name.equals("<init>") && !name.equals("<cinit>") && !name.startsWith("java")) {
            methodName = name;

            AddTimerMethodAdapter ca = new AddTimerMethodAdapter(mv);
            AnalyzerAdapter aa = new AnalyzerAdapter(owner, access, name, descriptor, ca);
            LocalVariablesSorter lvs = new LocalVariablesSorter(access, descriptor, aa);

            ca.aa = aa;
            ca.lvs = lvs;

            return ca.lvs;

        }

        return mv;
    }


    @Override
    public FieldVisitor visitField(int access, String name, String descriptor, String signature, Object value) {
        if (name.equals(filedName)) {
            isPresent = true;
        }
        return super.visitField(access, name, descriptor, signature, value);
    }


    @Override
    public void visitEnd() {
        if (!isInterface) {
            FieldVisitor fv = cv.visitField(acc, filedName, "Ljava/lang/String;", null, owner);
            if (fv != null) {
                fv.visitEnd();
            }
        }
        cv.visitEnd();
    }

    class AddTimerMethodAdapter extends MethodVisitor {
        private int time;
        private int maxStack;
        public LocalVariablesSorter lvs;
        public AnalyzerAdapter aa;

        public AddTimerMethodAdapter(MethodVisitor methodVisitor) {
            super(ASM6, methodVisitor);
        }


        @Override
        public void visitCode() {
            mv.visitCode();
            mv.visitMethodInsn(INVOKESTATIC, "java/lang/System", "nanoTime", "()J", false);
            time = lvs.newLocal(Type.LONG_TYPE);
            mv.visitVarInsn(LSTORE, time);
            maxStack = 4;
        }

        @Override
        public void visitInsn(int opcode) {
            if ((opcode >= IRETURN && opcode <= RETURN) || opcode == ATHROW) {

                mv.visitMethodInsn(INVOKESTATIC, "java/lang/System", "nanoTime", "()J", false);
                mv.visitVarInsn(LLOAD, time);
                mv.visitInsn(LSUB);
                mv.visitVarInsn(LSTORE, time);

                mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
                mv.visitTypeInsn(NEW, "java/lang/StringBuilder");
                mv.visitInsn(DUP);
                mv.visitMethodInsn(INVOKESPECIAL, "java/lang/StringBuilder", "<init>", "()V", false);

                mv.visitLdcInsn("    " + owner.replaceAll("/", "\\."));
                mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false);

                mv.visitLdcInsn("#" + methodName + ":");
                mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false);

                mv.visitVarInsn(LLOAD, time);
                mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(J)Ljava/lang/StringBuilder;", false);

                mv.visitLdcInsn("(ns)");
                mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "append", "(Ljava/lang/String;)Ljava/lang/StringBuilder;", false);

                mv.visitMethodInsn(INVOKEVIRTUAL, "java/lang/StringBuilder", "toString", "()Ljava/lang/String;", false);
                mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);

                maxStack = Math.max(aa.stack.size() + 4, maxStack);
            }
            mv.visitInsn(opcode);
        }

        @Override
        public void visitMaxs(int maxStack, int maxLocals) {
            super.visitMaxs(Math.max(maxStack, this.maxStack), maxLocals);
        }
    }


    public static void main(String[] args) {
        try {
            ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
            TraceClassVisitor traceClassVisitor = new TraceClassVisitor(classWriter, new PrintWriter(System.out));

            TimeCountAdpter timeCountAdpter = new TimeCountAdpter(traceClassVisitor);

            ClassReader classReader = new ClassReader("demo.MathGame");
            classReader.accept(timeCountAdpter, ClassReader.EXPAND_FRAMES);

            File file = new File("/Users/mac/Download/classes/demo/MathGame.class");
            String parent = file.getParent();
            File parent1 = new File(parent);
            boolean mkdirs = parent1.mkdirs();
            System.out.println("mkdirs=" + mkdirs + ",exist=" + file.exists());
            boolean createNewFile = file.createNewFile();
            System.out.println("mkdirs=" + mkdirs + ",createNewFile=" + createNewFile + ",exist=" + file.exists());
            FileOutputStream fileOutputStream = new FileOutputStream(file);
            fileOutputStream.write(classWriter.toByteArray());
            fileOutputStream.flush();
            fileOutputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

增强前的MathGame完整代码

package demo;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;
import java.util.concurrent.TimeUnit;

//-javaagent:/Users/mac/work/gitstudy/lzcjavaagent/target/lzcjavaagent-0.0.1-SNAPSHOT.jar
public class MathGame {
private static Random random = new Random();

    private int illegalArgumentCount = 0;

    public static void main(String[] args) throws InterruptedException {
        MathGame game = new MathGame();
        while (true) {
            game.run();
            TimeUnit.SECONDS.sleep(2);
        }
    }

    public void run() throws InterruptedException {
        try {
            int x=5;
            int y=2;
            int z=x-y;
            int number = random.nextInt()/1000;
            List<Integer> primeFactors = primeFactors(number);
            print(number, primeFactors);

        } catch (Exception e) {
            System.out.println(String.format("debug illegalArgumentCount:%3d, ", illegalArgumentCount) + e.getMessage());
        }
    }

    public static void print(int number, List<Integer> primeFactors) {
        StringBuffer sb = new StringBuffer(number + "=");
        for (int factor : primeFactors) {
            sb.append(factor).append('*');
        }
        if (sb.charAt(sb.length() - 1) == '*') {
            sb.deleteCharAt(sb.length() - 1);
        }
        System.out.println("debug=="+sb);
    }

    public List<Integer> primeFactors(int number) {
        if (number < 2) {
            illegalArgumentCount++;
            throw new IllegalArgumentException("debug number is: " + number + ", need >= 2");
        }

        List<Integer> result = new ArrayList<Integer>();
        int i = 2;
        while (i <= number) {
            if (number % i == 0) {
                result.add(i);
                number = number / i;
                i = 2;
            } else {
                i++;
            }
        }

        return result;
    }
}

增强后的MathGame

package demo;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
import java.util.concurrent.TimeUnit;

public class MathGame {
private static Random random;
private int illegalArgumentCount = 0;
public static final String UDASMCN = "demo/MathGame";

    public MathGame() {
    }

    public static void main(String[] var0) throws InterruptedException {
        long var1 = System.nanoTime();
        MathGame game = new MathGame();

        while(true) {
            game.run();
            TimeUnit.SECONDS.sleep(2L);
        }
    }

    public void run() throws InterruptedException {
        long var1 = System.nanoTime();

        try {
            int x = 5;
            int y = 2;
            int var10000 = x - y;
            int number = random.nextInt() / 1000;
            List<Integer> primeFactors = this.primeFactors(number);
            print(number, primeFactors);
        } catch (Exception var8) {
            System.out.println(String.format("debug illegalArgumentCount:%3d, ", this.illegalArgumentCount) + var8.getMessage());
        }

        var1 = System.nanoTime() - var1;
        System.out.println("    demo.MathGame" + "#run:" + var1 + "(ns)");
    }

    public static void print(int number, List<Integer> primeFactors) {
        long var2 = System.nanoTime();
        StringBuffer sb = new StringBuffer(number + "=");
        Iterator var5 = primeFactors.iterator();

        while(var5.hasNext()) {
            int factor = (Integer)var5.next();
            sb.append(factor).append('*');
        }

        if (sb.charAt(sb.length() - 1) == '*') {
            sb.deleteCharAt(sb.length() - 1);
        }

        System.out.println("debug==" + sb);
        var2 = System.nanoTime() - var2;
        System.out.println("    demo.MathGame" + "#print:" + var2 + "(ns)");
    }

    public List<Integer> primeFactors(int number) {
        long var2 = System.nanoTime();
        if (number < 2) {
            ++this.illegalArgumentCount;
            IllegalArgumentException var10000 = new IllegalArgumentException("debug number is: " + number + ", need >= 2");
            var2 = System.nanoTime() - var2;
            System.out.println("    demo.MathGame" + "#primeFactors:" + var2 + "(ns)");
            throw var10000;
        } else {
            List<Integer> result = new ArrayList();
            int i = 2;

            while(i <= number) {
                if (number % i == 0) {
                    result.add(i);
                    number /= i;
                    i = 2;
                } else {
                    ++i;
                }
            }

            var2 = System.nanoTime() - var2;
            System.out.println("    demo.MathGame" + "#primeFactors:" + var2 + "(ns)");
            return result;
        }
    }

    static {
        long var0 = System.nanoTime();
        random = new Random();
        var0 = System.nanoTime() - var0;
        System.out.println("    demo.MathGame" + "#<clinit>:" + var0 + "(ns)");
    }
}

JavaAgent

前面已经演示了基于asm增强class文件，接下来进一步演示运行期增强class文件。

Java Agent定义

从本质上讲，Java Agent 是一个遵循一组严格约定的常规 Java 类。 上面说到 javaagent命令要求指定的类中必须要有premain()方法，并且对premain方法的签名也有要求，签名必须满足以下两种格式：

public static void premain(String agentArgs, Instrumentation inst)      
public static void premain(String agentArgs)

JVM 会优先加载 带 Instrumentation 签名的方法，加载成功忽略第二种，如果第一种没有，则加载第二种方法。简单来讲，就是 premain 方法，在 main 方法之前执行。

如何使用javaagent？

使用 javaagent 需要几个步骤：

  1. 定义一个 MANIFEST.MF 文件，必须包含 Premain-Class 选项，通常也会加入Can-Redefine-Classes 和 Can-Retransform-Classes 选项。
  2. 创建一个Premain-Class 指定的类，类中包含 premain 方法，方法逻辑由用户自己确定（就是下面示例中的类TraceAgent）。
  3. 将 premain 的类和 MANIFEST.MF 文件打成 jar 包。
  4. 使用参数 -javaagent: jar包路径 启动要代理的方法。（示例： -javaagent:
    /Users/mac/work/gitstudy/lzcjavaagent/target/lzcjavaagent-0.0.1-SNAPSHOT.jar）
package com.example.lzcjavaagent;

import java.lang.instrument.Instrumentation;

public class TraceAgent {

    public static void premain(String agentArgs, Instrumentation instrumentation){
        instrumentation.addTransformer(new LogTransformer());
    }
}

package com.example.lzcjavaagent;


import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassWriter;

import java.io.IOException;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.security.ProtectionDomain;

public class LogTransformer implements ClassFileTransformer {
    @Override
    public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
        try {
            if(className.startsWith("java")||className.startsWith("sun")||className.startsWith("com/intellij/rt/debugger")){
                return classfileBuffer;
            }

            ClassReader cr = new ClassReader(className);
            ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
            TimeCountAdpter timeCountAdpter = new TimeCountAdpter(cw);
            cr.accept(timeCountAdpter, ClassReader.EXPAND_FRAMES);

            return cw.toByteArray();
        } catch (IOException e) {
            System.out.println("alioo IOException:"+className+":"+e.getMessage());
            e.printStackTrace();
        } catch (Error e) {
            System.out.println("alioo Error:"+className+":"+e.getMessage());
            e.printStackTrace();
        }
        return classfileBuffer;
    }
}

除了上述类之外，生成的jar文件中的META-INF/MANIFEST.MF中还需要增加如下内容：
Premain-Class: com.example.lzcjavaagent.TraceAgent

示例：

~/work/gitstudy/lzcjavaagent/target>more  lzcjavaagent-0.0.1-SNAPSHOT/META-INF/MANIFEST.MF
Manifest-Version: 1.0
Premain-Class: com.example.lzcjavaagent.TraceAgent
Archiver-Version: Plexus Archiver
Built-By: mac
Created-By: Apache Maven 3.6.3
Build-Jdk: 1.8.0_192

如果嫌手写比较麻烦的话可以使用maven插件maven-shade-plugin

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-shade-plugin</artifactId>
    <executions>
        <execution>
            <phase>package</phase>
            <goals>
                <goal>shade</goal>
            </goals>
            <configuration>
                <transformers>
                    <transformer
                            implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                        <manifestEntries>
                            <Premain-Class>com.example.lzcjavaagent.TraceAgent</Premain-Class>
                        </manifestEntries>
                    </transformer>
                </transformers>
            </configuration>
        </execution>
    </executions>
</plugin>

javaagent除了刚才介绍的伴随应用一同启动外，还可以在应用启动之后根据进程id进行attach

package com.example.lzcjavaagent;

import com.sun.tools.attach.*;

import java.io.IOException;
import java.util.List;

/**
 * @time: 2021/11/2 11:10
 * @description:
 */
public class AttachAfterAppRun {
    public static void main(String[] args) throws AgentLoadException, IOException, AgentInitializationException, AttachNotSupportedException, InterruptedException {
        //获取当前系统中所有 运行中的 虚拟机
        System.out.println("show jvm list");
        List<VirtualMachineDescriptor> list = VirtualMachine.list();
        for (VirtualMachineDescriptor vmd : list) {
            //如果虚拟机的名称为 xxx 则 该虚拟机为目标虚拟机，获取该虚拟机的 pid
            //然后加载 agent.jar 发送给该虚拟机
            System.out.println(">>" + vmd.displayName());
            if (vmd.displayName().endsWith("demo.MathGame")) {

                System.out.println("demo.MathGame matched,pid:" + vmd.id());
                VirtualMachine virtualMachine = VirtualMachine.attach(vmd.id());
                virtualMachine.loadAgent("/Users/mac/work/gitstudy/lzcjavaagent/target/lzcjavaagent-0.0.1-SNAPSHOT.jar");
                virtualMachine.detach();
                System.out.println("attach done");
            }
        }
        Thread.sleep(15000L);
    }
}

几个注意事项：

  • pom.xml中需要添加tools.jar的依赖

<dependency>
    <groupId>com.sun</groupId>
    <artifactId>tools</artifactId>
    <version>1.8.0</version>
    <scope>system</scope>
    <systemPath>/Library/Java/JavaVirtualMachines/jdk1.8.0_192.jdk/Contents/Home/lib/tools.jar</systemPath>
</dependency>
  • pom.xml中插件maven-shade-plugin添加如下内容
<manifestEntries>
   <Premain-Class>com.example.lzcjavaagent.TraceAgent</Premain-Class>
   <Agent-Class>com.example.lzcjavaagent.TraceAgent</Agent-Class>
   <Can-Redefine-Classes>true</Can-Redefine-Classes>
   <Can-Retransform-Classes>true</Can-Retransform-Classes>
</manifestEntries>
  • 增强逻辑中之前是有添加类变量的逻辑,需要去掉一下，否则会报下面这个错误
Caused by: java.lang.UnsupportedOperationException: class redefinition failed: attempted to change the schema (add/remove fields)

手工执行attach（在demo.MathGame启动之后运行）

java -cp .:/Library/Java/JavaVirtualMachines/jdk1.8.0_192.jdk/Contents/Home/lib/tools.jar   com.example.lzcjavaagent.AttachAfterAppRun

本文完整的代码git地址：https://github.com/lzc-alioo/lzcjavaagent，欢迎下载运行。

参考文章：
https://www.cnblogs.com/rickiyang/p/11368932.html
https://blog.csdn.net/catoop/article/details/50629921
https://blog.csdn.net/wenwen513/article/details/86498687

20211119更新

增强：如何以树状形式展示调用栈结果

示例：

  ----[5615.408ms] demo.MathGame:run() 
  --------[4684.296ms] demo.MathGame:primeFactors() 
  --------[830.13ms] demo.MathGame:print() 
  ------------[14.601ms] java.lang.StringBuffer:append() 
  ------------[16.627ms] java.lang.StringBuffer:length() 
  ------------[19.281ms] java.lang.StringBuffer:charAt() 
  ------------[15.498ms] java.lang.StringBuffer:deleteCharAt() 
  ------------[19.878ms] java.lang.StringBuffer:toString() 
  ------------[221.849ms] demo.Hello:testList() 
  ----------------[114.481ms] demo.Hello:printList()

监控的入口方法是demo.MathGame:run 这个方法中调用2个子方法demo.MathGame:primeFactors()，demo.MathGame:print()会在下一层展示 依此类推，子方法均会在下一级进行展示
堆栈信息中也包含了其它类的子方法，以及jdk自带的类

参见示例代码
lzc-javaagent-asm2
https://github.com/lzc-alioo/lzcjavaagent/tree/main/lzc-javaagent-asm2

启动待注入进程

java demo.MathGame
java -Xbootclasspath/a:/Users/mac/work/gitstudy/lzcjavaagent/lzc-javaagent-asm2/target/lzc-javaagent-asm2-0.0.1-SNAPSHOT.jar demo.MathGame

执行注入

java -cp .:/Library/Java/JavaVirtualMachines/jdk1.8.0_192.jdk/Contents/Home/lib/tools.jar com.example.lzcjavaagent2.AttachAfterAppRun

注意事项：

  1. 如果希望字节码注入到jdk自带的类中，则需要启动Java进程时增加参数 java -Xbootclasspath/a: /Users/mac/work/gitstudy/lzcjavaagent/lzc-javaagent-asm2/target/lzc-javaagent-asm2-0.0.1-SNAPSHOT.jar demo.MathGame
    然后再注入即可java -cp .:/Library/Java/JavaVirtualMachines/jdk1.8.0_192.jdk/Contents/Home/lib/tools.jar com.example.lzcjavaagent2.AttachAfterAppRun

当然上述方式不是最好的，既然是在进程之后插桩，所以不可能进程启动时提前想到需要增加-Xbootclasspath/a参数，还有另外一种方式
agentmain方法入口处，调用instrumentation.appendToBootstrapClassLoaderSearch达到跟上述命令一样的效果

public static void agentmain(String agentArgs, Instrumentation instrumentation) throws UnsupportedEncodingException { 
try {
    instrumentation.appendToBootstrapClassLoaderSearch(new JarFile("/Users/mac/work/gitstudy/lzcjavaagent/lzc-javaagent-asm/target/lzc-javaagent-asm-0.0.1-SNAPSHOT.jar")); 
} catch (IOException e) {
    System.out.println("appendToSystemClassLoaderSearch这里出异常了..." + e.getMessage()); e.printStackTrace(); 
}

抛个问题，为啥字节码注入到jdk自带的类中需要这么做，注入到项目中其它类不需要？
猜测是jdk自带的类重新加载时使用的classloader，不会扫描项目中的classpath，而项目中类的重新加载时，-javaagent这里的jar包也会被扫描到

  1. 注入类，以及依赖的类均不能进行增强,否则会出现递归调用，报堆栈溢出错误

  2. 如何标记本次调用结束？ raceEntity.deep == 0

//TODO 记录调用栈行号？
//TODO 当前结果直接输出到目标进程中了，如果希望将日志输出到注入进程侧呢
//TODO 除了记录耗时，把出入参，异常也打印出来
//TODO 循环调用的问题

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Java

javaagent

后端

JavaAgent的那点秘密 的相关文章

  • Java 中等效的并行扩展

    我在 Net 开发中使用并行扩展有一些经验 但我正在考虑在 Java 中做一些工作 这些工作将受益于易于使用的并行库 JVM 是否提供任何与并行扩展类似的工具 您应该熟悉java util concurrent http java sun

  • java.lang.NoClassDefFoundError：org.apache.batik.dom.svg.SVGDOMImplementation

    我在链接到我的 Android LibGDX 项目的 Apache Batik 库时遇到了奇怪的问题 但让我们从头开始 在 IntelliJ Idea 中我有一个项目 其中包含三个模块 Main Android 和 Desktop 我强调的

  • Grails 3.x bootRun 失败

    我正在尝试在 grails 3 1 11 中运行一个项目 但出现错误 失败 构建失败并出现异常 什么地方出了错 任务 bootRun 执行失败 进程 命令 C Program Files Java jdk1 8 0 111 bin java

  • 在画布上绘图

    我正在编写一个 Android 应用程序 它可以在视图的 onDraw 事件上直接绘制到画布上 我正在绘制一些涉及单独绘制每个像素的东西 为此我使用类似的东西 for int x 0 x lt xMax x for int y 0 y lt

  • Android：捕获的图像未显示在图库中（媒体扫描仪意图不起作用）

    我遇到以下问题 我正在开发一个应用程序 用户可以在其中拍照 附加到帖子中 并将图片保存到外部存储中 我希望这张照片也显示在图片库中 并且我正在使用媒体扫描仪意图 但它似乎不起作用 我在编写代码时遵循官方的Android开发人员指南 所以我不

  • 操作错误不会显示在 JSP 上

    我尝试在 Action 类中添加操作错误并将其打印在 JSP 页面上 当发生异常时 它将进入 catch 块并在控制台中打印 插入异常时出错 请联系管理员 在 catch 块中 我添加了它addActionError 我尝试在jsp页面中打

  • 斯坦福 NLP - 处理文件列表时 OpenIE 内存不足

    我正在尝试使用斯坦福 CoreNLP 中的 OpenIE 工具从多个文件中提取信息 当多个文件 而不是一个 传递到输入时 它会给出内存不足错误 All files have been queued awaiting termination

  • 在两个活动之间传输数据[重复]

    这个问题在这里已经有答案了 我正在尝试在两个不同的活动之间发送和接收数据 我在这个网站上看到了一些其他问题 但没有任何问题涉及保留头等舱的状态 例如 如果我想从 A 类发送一个整数 X 到 B 类 然后对整数 X 进行一些操作 然后将其发送

  • 如何将 pfx 文件转换为 jks，然后通过使用 wsdl 生成的类来使用它来签署传出的肥皂请求

    我正在寻找一个代码示例 该示例演示如何使用 PFX 证书通过 SSL 访问安全 Web 服务 我有证书及其密码 我首先使用下面提到的命令创建一个 KeyStore 实例 keytool importkeystore destkeystore

  • 总是使用 Final？

    我读过 将某些东西做成最终的 然后在循环中使用它会带来更好的性能 但这对一切都有好处吗 我有很多地方没有循环 但我将 Final 添加到局部变量中 它会使速度变慢还是仍然很好 还有一些地方我有一个全局变量final 例如android Pa

  • 加密 JBoss 配置中的敏感信息

    JBoss 中的标准数据源配置要求数据库用户的用户名和密码位于 xxx ds xml 文件中 如果我将数据源定义为 c3p0 mbean 我会遇到同样的问题 是否有标准方法来加密用户和密码 保存密钥的好地方是什么 这当然也与 tomcat

  • Java执行器服务线程池[关闭]

    很难说出这里问的是什么 这个问题是含糊的 模糊的 不完整的 过于宽泛的或修辞性的 无法以目前的形式得到合理的回答 如需帮助澄清此问题以便重新打开 访问帮助中心 help reopen questions 如果我使用 Executor 框架在

  • Java列表的线程安全

    我有一个列表 它将在线程安全上下文或非线程安全上下文中使用 究竟会是哪一个 无法提前确定 在这种特殊情况下 每当列表进入非线程安全上下文时 我都会使用它来包装它 Collections synchronizedList 但如果不进入非线程安

  • 玩！框架：运行“h2-browser”可以运行，但网页不可用

    当我运行命令时activator h2 browser它会使用以下 url 打开浏览器 192 168 1 17 8082 但我得到 使用 Chrome 此网页无法使用 奇怪的是它以前确实有效 从那时起我唯一改变的是JAVA OPTS以启用

  • 捕获的图像分辨率太大

    我在做什么 我允许用户捕获图像 将其存储到 SD 卡中并上传到服务器 但捕获图像的分辨率为宽度 4608 像素和高度 2592 像素 现在我想要什么 如何在不影响质量的情况下获得小分辨率图像 例如我可以获取或设置捕获的图像分辨率为原始图像分

  • 当我从 Netbeans 创建 Derby 数据库时，它存储在哪里？

    当我从 netbeans 创建 Derby 数据库时 它存储在哪里 如何将它与项目的其余部分合并到一个文件夹中 右键单击Databases gt JavaDB in the Service查看并选择Properties This will

  • JGit 检查分支是否已签出

    我正在使用 JGit 开发一个项目 我设法删除了一个分支 但我还想检查该分支是否已签出 我发现了一个变量CheckoutCommand但它是私有的 private boolean isCheckoutIndex return startCo

  • java.lang.IllegalStateException：驱动程序可执行文件的路径必须由 webdriver.chrome.driver 系统属性设置 - Similiar 不回答

    尝试学习 Selenium 我打开了类似的问题 但似乎没有任何帮助 我的代码 package seleniumPractice import org openqa selenium WebDriver import org openqa s

  • 节拍匹配算法

    我最近开始尝试创建一个移动应用程序 iOS Android 它将自动击败比赛 http en wikipedia org wiki Beatmatching http en wikipedia org wiki Beatmatching 两

  • Spring Boot @ConfigurationProperties 不从环境中检索属性

    我正在使用 Spring Boot 1 2 1 并尝试创建一个 ConfigurationProperties带有验证的bean 如下所示 package com sampleapp import java net URL import j

随机推荐

  • CentOS 7.6镜像下载

    目前在国内使用最多的两个Linux发行版本一个是CentOS 另外一个是Ubuntu CentOS是一个可以重新分发的开源操作系统 也是企业Linux发行版的领头羊 官方目前发布的最新CentOS版本为CentOS 9 那么如何到下载旧版本

  • 一个数组有 N 个元素，求连续子数组的最大和。 例如：[-1,2,1]，和最大的连续子数组为[2,1]，其和为 3

    1 题目描述 一个数组有 N 个元素 求连续子数组的最大和 例如 1 2 1 和最大的连续子数组为 2 1 其和为 3 输入描述 输入为两行 第一行一个整数n 1 lt n lt 100000 表示一共有n个元素 第二行为n个数 即每个元素

  • 从利用Arthas排查线上Fastjson问题到Java动态字节码技术(中)

    上一篇文章 中通过对一次线上事故的复盘 引出了福报厂的Arthas 一个建立在Java动态字节码技术之上的Java诊断工具 关于Arthas的使用方式就不赘述了 查看官方文档可以很快上手 玩法也特别多 上一篇中也仅仅只介绍了一种使用场景 即

  • c++ 建立链表并实现合并

    创建两个链表并实现两个链表相加 include

  • 《大型网站技术架构》序

    推荐序一 1 传统企业应用于大型网站应用的区别 传统的企业应用系统主要面对的技术挑战是处理复杂凌乱 干变万化的所谓业务逻辑 而大型网站主要面对的技术挑战是处理超大量的用户访问和海量的数据处理 前者的挑战来自功能性需求 后者的挑战来自非功能性

  • 树-广度优先和深度优先搜索算法

    广度优先和深度优先搜索算法 本章主要讲述广度优先搜索算法BFS Breadth First Search 和深度优先算法DFS Depth First Search 广度优先 从起点开始由近及远进行广泛搜索 一般使用队列实现 深度优先 从起

  • Django表单系统

    目录 使用Form对象定义表单 Form对象的特性 表单字段的基类Field 常用的表单字段类型 基于Model定制的表单 ModelForm定义方式 表单中的常用方法 在Web站点中与后端服务进行交互 通常使用表单提交的方式 表单提交数据

  • 辐射神经场算法——NeRF算法详解

    辐射神经场算法 NeRF算法详解 辐射神经场算法 NeRF算法详解 1 Volume Rendering方法 2 NeRF中的积分公式推导 3 NeRF中应用的技巧 3 1 Positional Encoding 3 2 Hierarchi

  • （一）Wireshark 抓包解析出视频流ts

    这里简单介绍下Wireshark WS 解析出视频流的方法 其他过滤方法可以百度搜到更具体的 打开一个网络封包 一般是 pcap 或者 cap 抓包方式多样 若在嵌入式设备上面抓包 可以用工具TCPDUMP这个工具 若是android手机抓

  • settimeout、promise、async的执行顺序

    用一段代码来说明 async function async1 console log async1 start await async2 console log async1 end async function async2 consol

  • 生产制造业ERP管理系统

    什么是生产制造业ERP管理系 生产制造业ERP管理系统的建设本身作为企业在发展过程当中重要的战略布局建设 涉及到各个不同的企业部门 涵盖了研发 生产 物流 财务等等 需要对这些团队进行一把手的领导 而且在企业整体发展过程当中 可以做好综合性

  • MongoDB以及MongoVUE的安装和使用

    环境安装 MongoDB的安装 下载mongoDB MongoDB官网地址 个人百度云盘地址 版本为 mongodb win32 x86 64 2008plus ssl v3 0 latest signed msi 安装 到这里mongod

  • Spring源码------IoC源码分析详解

    Spring源码 IoC源码分析详解 目录 Spring源码 IoC源码分析详解 1 控制反转 IoC 2 Spring IoC 源码时序图 详细版 3 源码追踪 3 1详细版链接 3 2 个人总结浓缩版 方便记忆 4 总结 1 控制反转

  • Oracle练习

    一 找到员工表中工资最高的前三名 降序排序 select from emp order by sal desc rownum 伪列 系统自动生成的一列 用来表示行号 rownum是Oracle中特有的用来表示行号的 默认值 起始值是 1 在

  • 打包神器webpack的一键式操作

    创建基本的webpack4 x项目 运行npm init y 快速初始化项目 在项目根目录创建src源代码目录和dist产品目录 在 src 目录下创建 index html 使用 cnpm 安装 webpack 运行cnpm i webp

  • ifconfig报错：SIOCSIFFLAGS: Operation not permitted

    insmod mt7601Usta ko rtusb init rt2870 gt usbcore registered new interface driver rt2870 iwconfiglo no wireless extensio

  • 深度学习实战29-AIGC项目：利用GPT-2(CPU环境)进行文本续写与生成歌词任务

    大家好 我是微学AI 今天给大家介绍一下深度学习实战29 AIGC项目 利用GPT 2 CPU环境 进行文本续写与生成歌词任务 在大家没有GPU算力的情况 大模型可能玩不动 推理速度慢 那么我们怎么才能跑去生成式的模型呢 我们可以试一下GP

  • AWS SAA-C03 #99

    A company is implementing a shared storage solution for a gaming application that is hosted in an on premises data cente

  • 宝塔部署前后端分离项目（Vue+SpringBoot）

    目录 后端部分 配置Redis 前端部分 后端部分 1 先修改自己的speingboot配置文件 我的是yml文件 保证宝塔上建的数据库和自己代码里 就是配置文件中所建的数据库的名字是一致的密码也要保持一致 Redis也一样 如果有的话 2

  • JavaAgent的那点秘密

    JavaAgent的那点秘密 前言 大家都知道Java文件编译成Class文件之后才能在Jvm中运行的 而Class文件自有一套规范 不必一定是Java文件经由javac编译产生 其它编程语言也可以直接生成Class文件交由Jvm运行 既然

热门标签