Understanding Java Bytecode and Using ASM for Bytecode Manipulation

Java achieves "write once, run anywhere" because source code is compiled into a fixed‑format .class bytecode file that is independent of any specific platform; each JVM interprets and executes this bytecode.

Compilation uses javac [options] <sourcefiles> to produce a .class file. The class file follows a strict structure defined by the JVM specification, consisting of magic number, version, constant pool, access flags, this_class, super_class, interfaces, fields, methods, and attributes.

Bytecode can be inspected with tools such as the JDK javap command, the IDEA plugin "Bytecode Viewer", and the IDEA plugin "Jclasslib Bytecode Viewer".

Bytecode Enhancement

Bytecode enhancement refers to techniques that modify existing bytecode or dynamically generate new bytecode files. Common Java bytecode libraries include ASM, Byte Buddy, Javassist, CGLib, BCEL, and JBC.

ASM

ASM is a lightweight Java bytecode manipulation and analysis framework. It provides a Core API (asm.jar, asm‑util.jar, asm‑commons.jar) and a Tree API (asm‑tree.jar, asm‑analysis.jar). The Core API uses a visitor pattern with ClassReader , ClassWriter , and ClassVisitor to process bytecode sequentially.

Typical transformation flow with the Core API is:

ClassReader → ClassVisitor[1] → … → ClassVisitor[N] → ClassWriter

The Tree API builds an in‑memory tree representation where ClassNode is the root node, containing child nodes such as MethodNode , FieldNode , and InsnList . After modifications, the tree is written back using ClassWriter .

Core API Demo

import org.objectweb.asm.ClassVisitor;
import org.objectweb.asm.MethodVisitor;
import org.objectweb.asm.Opcodes;

public class ByteCodeDemoClassVisitor extends ClassVisitor implements Opcodes {
    public ByteCodeDemoClassVisitor(ClassVisitor cv) {
        super(ASM9, cv);
    }
    @Override
    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces) {
        super.visit(version, access, name, signature, superName, interfaces);
    }
    @Override
    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions) {
        MethodVisitor mv = super.visitMethod(access, name, descriptor, signature, exceptions);
        if (name.equals("
") && mv != null) {
            return mv; // do not enhance constructors
        }
        return new ByteCodeDemoMethodVisitor(mv);
    }
    private class ByteCodeDemoMethodVisitor extends MethodVisitor implements Opcodes {
        public ByteCodeDemoMethodVisitor(MethodVisitor mv) {
            super(ASM9, mv);
        }
        @Override
        public void visitCode() {
            super.visitCode();
            mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
            mv.visitLdcInsn("start");
            mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
        }
        @Override
        public void visitInsn(int opcode) {
            if ((opcode >= Opcodes.IRETURN && opcode <= Opcodes.RETURN) || opcode == Opcodes.ATHROW) {
                mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
                mv.visitLdcInsn("end");
                mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
            }
            super.visitInsn(opcode);
        }
    }
}

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassWriter;

public class ByteCodeCodeGenerator {
    public static void main(String[] args) throws IOException {
        ClassReader classReader = new ClassReader("com/shsf/demo02/asm/demo/ByteCodeDemo");
        ClassWriter classWriter = new ClassWriter(classReader, ClassWriter.COMPUTE_MAXS);
        ByteCodeDemoClassVisitor visitor = new ByteCodeDemoClassVisitor(classWriter);
        classReader.accept(visitor, ClassReader.SKIP_DEBUG);
        byte[] data = classWriter.toByteArray();
        File file = new File("demo02-proj06-asm/target/classes/com/shsf/demo02/asm/demo/ByteCodeDemo.class");
        System.out.println("file absolute path:" + file.getAbsolutePath());
        FileOutputStream fos = new FileOutputStream(file);
        fos.write(data);
        fos.close();
        System.out.println("success");
    }
}

Tree API Demo

import org.objectweb.asm.ClassReader;
import org.objectweb.asm.ClassWriter;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.FieldNode;

public class ByteCodeTreeGenerator01 {
    public static void main(String[] args) throws IOException {
        ClassReader classReader = new ClassReader(ByteCodeDemo.class.getName());
        ClassNode classNode = new ClassNode(Opcodes.ASM9);
        classReader.accept(classNode, ClassReader.SKIP_DEBUG);
        // Add a public field "name" of type String
        FieldNode fieldNode = new FieldNode(Opcodes.ACC_PUBLIC, "name", "Ljava/lang/String;", null, null);
        classNode.fields.add(fieldNode);
        ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_MAXS);
        classNode.accept(classWriter);
        byte[] data = classWriter.toByteArray();
        File file = new File("demo02-proj06-asm/target/classes/com/shsf/demo02/asm/demo/ByteCodeDemo.class");
        System.out.println("file absolute path:" + file.getAbsolutePath());
        FileOutputStream fos = new FileOutputStream(file);
        fos.write(data);
        fos.close();
        System.out.println("success");
    }
}

ASM provides low‑level methods such as VisitXXXXInsn() for direct bytecode emission. The ASM Bytecode Outline plugin (available for IDEA) can convert Java source into ASM syntax, simplifying the creation of VisitMethod() and VisitInsn() implementations.

Application Scenarios

Bytecode enhancement for AOP, logging, performance monitoring.

Dynamic code generation for proxies and runtime class creation.

Static analysis of existing bytecode.

References

ASM official site: https://asm.ow2.io/

Java ASM series – Tree Based Class Transformation: https://blog.51cto.com/lsieun/4278784