Java dynamic bytecode injection technology

1. What is Java dynamic bytecode injection technology?

        Java dynamic bytecode injection technology is a technique that modifies Java bytecode at runtime . It allows developers to dynamically inject bytecode into existing Java classes during program execution and change the behavior and functionality of the classes. This technology is usually used to implement AOP (aspect-oriented programming), code enhancement, dynamic proxy and other requirements.

2. The process of Java dynamic bytecode injection

        The process of Java dynamic bytecode injection generally includes the following steps:

1. To obtain the bytecode of the target class that needs to be modified, the target class can be dynamically loaded through ClassLoader or an existing class file can be read.
2. Use a bytecode manipulation library (such as ASM, ByteBuddy, etc.) to generate new bytecode.
3. Insert new bytecode into the method of the target class, you can modify the logic of the method, add new methods, insert calls and other operations.
4. Reload the modified bytecode into the JVM so that the program uses the new bytecode at runtime.

3. Code examples

        Created a custom MyClassLoaderclass, inherited from ClassLoader. This custom class loader overrides defineClassFromBytecodethe method and is used to defineClassload bytecode and define classes through the method. Then, we can use the instance of the custom class loader to call defineClassFromBytecodethe method, passing in the class name and bytecode, and get the loaded Classobject. Finally, we can use reflection to create object instances of this class.

public class MyClassLoader extends ClassLoader {
    public Class<?> defineClassFromBytecode(String className, byte[] bytecode) {
        return defineClass(className, bytecode, 0, bytecode.length);
    }
}

        Note that defineClassthe method converts the bytecode into a new Classobject and adds it to the current class loader's namespace. When loading bytecode, a new class is generated based on the content of the bytecode. 

        Then define a target class and the method to be executed:

public class TargetClass {
    public void add(int a, int b) {
        int result = a + b;
        System.out.println("Result: " + result);
    }
}

        Here is a simple example using the ASM framework for dynamic bytecode injection, replacing the implementation of the target class's add method with code that prints "Hello, World!": 

package com.xxx.xxx;

import org.objectweb.asm.*;

public class BytecodeInjector {
    public static void main(String[] args) throws Exception {
        // 读取目标类的字节码
        ClassReader reader = new ClassReader(TargetClass.class.getName());

        // 创建 ClassWriter，并指定生成的字节码版本
        ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_FRAMES);

        // 创建自定义的 ClassVisitor，生成新的字节码
        ClassVisitor visitor = new ClassVisitor(Opcodes.ASM7, writer) {
            @Override
            public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
                if (name.equals("add")) {
                    MethodVisitor mv = cv.visitMethod(access, name, descriptor, signature, exceptions);

                    // 创建新的方法实现
                    MethodVisitor newMv = new MethodVisitor(Opcodes.ASM7, mv) {
                        @Override
                        public void visitCode() {
                            super.visitCode();

                            // 向方法中插入指令
                            mv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
                            mv.visitLdcInsn("Hello, World!");
                            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
                        }
                    };

                    return newMv;
                }

                return super.visitMethod(access, name, descriptor, signature, exceptions);
            }
        };

        // 开始访问目标类，并触发自定义的 ClassVisitor 生成新的字节码
        reader.accept(visitor, ClassReader.EXPAND_FRAMES);

        // 获取生成的字节码
        byte[] modifiedClass = writer.toByteArray();

        // 使用自定义的类加载器加载修改后的字节码
        MyClassLoader loader = new MyClassLoader();
        Class<?> modifiedClassObj = loader.defineClassFromBytecode(TargetClass.class.getName(), modifiedClass);

        // 创建目标类的实例并调用修改后的方法
        TargetClass target = (TargetClass) modifiedClassObj.getDeclaredConstructor().newInstance();
        target.add(2, 3);
    }
}

        After running the sample code, "Hello, World!" will be output instead of the original addition result. This simple example demonstrates the process of dynamic bytecode injection using the ASM framework and modifies the behavior of the target class.

Code explanation

visitMethod A method is ClassVisitor a method of a class that is used to access methods in the class. It has the following parameters:

• accessOpcodes : Indicates the modifiers and attributes of the method, using constants defined in the  ASM  class, such as Opcodes.ACC_PUBLIC, Opcodes.ACC_PRIVATE, Opcodes.ACC_STATIC etc.
• name: Indicates the name of the method, string type.
• descriptor: Represents the descriptor of a method, which can also be regarded as the signature of the method. It uses a special string format to describe the parameter type and return type of a method, such as  (Ljava/lang/String;I)V a method that accepts a string and an integer parameter and has no return value.
• signature: Represents the signature of generic information, or null if the method is not a generic method.
• exceptions: Indicates the exception types that may be thrown by the method, and expresses the fully qualified name of the exception in the form of a string array.

        visitMethodMethods can be overridden as needed to perform custom actions when accessing the method. In the body of the overridden method, you can use cv.visitMethodCreate or modify the method, and return a MethodVisitorobject to further access the bytecode of the method.

BytecodeInjectorFor example, in the class method         in the above example visitMethod, we determine whether the currently accessed method is the target method add. If so, a new MethodVisitorobject is created and the bytes that print "Hello, World!" are inserted into it. code instructions. In this way, we make modifications in the bytecode of the target method to implement custom functionality.

        It should be noted that the methods introduced here visitMethodare ClassVisitormethods in the class, which are different from MethodVisitorthose in the class visitMethod. ClassVisitorClass visitMethodis mainly used to access the methods of the class, while MethodVisitorClass visitMethodis used to access the bytecode instructions inside the method.

4. The difference between Java dynamic bytecode injection technology and just-in-time compilation

Java dynamic bytecode injection technology and just-in-time compilation are two different concepts.

        Java dynamic bytecode injection technology is a technology that modifies Java bytecode at runtime. It allows developers to programmatically modify the bytecode of classes that have been loaded into the JVM to change the behavior and functionality of the class. This technology is usually used to implement AOP (aspect-oriented programming), code enhancement, dynamic proxy and other requirements. For example, in some frameworks and tools, bytecode injection technology can be used to insert additional logic before and after method execution to implement functions such as logging and performance monitoring.

        Just-In-Time Compilation (JIT) is an important feature of the Java Virtual Machine (JVM). The JIT compiler compiles bytecodes into local machine codes in real time during program execution to improve program execution efficiency. The JIT compiler will dynamically compile the hot code according to the running status of the code, convert it into local machine code and then execute it, thereby accelerating the running of the program. This just-in-time compilation technology plays an important role in Java performance optimization.

        Although both Java dynamic bytecode injection technology and just-in-time compilation involve the processing of bytecode, their purposes and application scenarios are different. Bytecode injection is to modify the behavior and functions of loaded classes at runtime, while just-in-time compilation is to improve program execution efficiency. The two can be used in combination to achieve more powerful and flexible Java program functions and performance optimization.

5. The relationship between Java Agent and bytecode injection technology

        Java Agent is a mechanism implemented through the JVM's Instrumentation API that allows the bytecode of loaded classes to be modified or monitored at runtime . It can be used for various purposes including code injection, performance monitoring, debugging tools, etc. The Java Agent intercepts and modifies the bytecode of the loading class by implementing the ClassFileTransformer interface in the Instrumentation API.

        Bytecode injection technology is an application scenario of Java Agent , which refers to injecting customized bytecode into loaded classes at runtime to achieve dynamic modification of classes. Through bytecode injection technology, functions such as AOP (aspect-oriented programming), dynamic proxy, and code enhancement can be realized. Bytecode injection typically involves the process of reading, modifying, and generating bytecode using a bytecode manipulation library such as ASM, Byte Buddy, or Javassist.

        Therefore, it can be considered that Java Agent is a broader concept, and bytecode injection is one of the specific application methods of Java Agent . Java Agent can be used for other purposes, such as performance monitoring, security checking, etc., while bytecode injection technology focuses more on dynamically modifying the bytecode of loaded classes at runtime to achieve specific purposes.