Creating custom class transformers with ASM Library

20 Oct 2023

References

In the world of Java bytecode manipulation, the ASM library stands out as a powerful and widely-used tool. It provides a flexible and efficient framework for analyzing, modifying, and generating bytecode. One of the common use cases for ASM is creating custom class transformers.

What is a class transformer?

A class transformer is a component that can modify the bytecode of a class at runtime. This can be useful in a variety of scenarios, such as adding additional functionality to existing classes, dynamically generating classes, or implementing performance optimizations.

Getting started with ASM

To begin, you’ll need to include the ASM library in your project’s dependencies. You can either download the JAR file or use a build tool like Maven or Gradle to fetch the library for you.

Once you have ASM added to your project, you can start creating custom class transformers.

Creating a basic class transformer

To create a class transformer, you’ll need to implement the ClassVisitor interface provided by ASM. This interface contains various methods that are invoked as the visitor walks through the bytecode of a class.

Here’s an example of a simple class transformer that adds a hello method to every class it visits:

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

public class HelloMethodClassTransformer extends ClassVisitor {
    
    public HelloMethodClassTransformer(ClassVisitor cv) {
        super(Opcodes.ASM9, cv);
    }

    @Override
    public MethodVisitor visitMethod(int access, String name, String descriptor,
                                     String signature, String[] exceptions) {
        MethodVisitor mv = super.visitMethod(access, name, descriptor, signature, exceptions);
        if ("hello".equals(name)) {
            // We don't want to modify the existing hello method
            return mv;
        }
        
        // Add a new hello method
        MethodVisitor newMv = cv.visitMethod(access, "hello", "()V", null, null);
        newMv.visitCode();
        newMv.visitFieldInsn(Opcodes.GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
        newMv.visitLdcInsn("Hello, ASM!");
        newMv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);
        newMv.visitInsn(Opcodes.RETURN);
        newMv.visitMaxs(2, 0);
        newMv.visitEnd();
        
        return mv;
    }
}

This class transformer extends the ClassVisitor class and overrides the visitMethod method. The visitMethod method is invoked for each method in the class. In this example, we check if the method name is hello and skip modification if it matches. Otherwise, we create a new hello method that prints “Hello, ASM!” to the console.

Applying the class transformer

To apply the class transformer, you’ll need to use a bytecode manipulation framework such as Byte Buddy or AgentSmith. These frameworks provide a way to intercept classloading and apply transformations on the fly.

Here’s an example of using Byte Buddy to apply the HelloMethodClassTransformer:

import net.bytebuddy.agent.builder.AgentBuilder;
import net.bytebuddy.asm.Advice;

public class HelloMethodTransformerExample {

    public static void main(String[] args) {
        new AgentBuilder.Default()
                .type(type -> type.getName().equals("com.example.MyClass"))
                .transform((builder, typeDescription, classLoader, module) ->
                        builder.visit(Advice.to(HelloMethodClassTransformer.class).on(any()))
                )
                .installOnByteBuddyAgent();
    }
}

In this example, we use the AgentBuilder class from Byte Buddy to intercept the class com.example.MyClass and apply the HelloMethodClassTransformer.

Conclusion

Creating custom class transformers with the ASM library opens up a world of possibilities for bytecode manipulation in Java. With ASM, you can modify existing classes, dynamically generate new classes, and implement advanced optimizations. By combining ASM with bytecode manipulation frameworks like Byte Buddy, you can easily apply your custom transformations on the fly.

#References