Java字节码工程：ASM与Javassist

概述

字节码工程允许在运行时修改Java类。本教程介绍ASM和Javassist框架的使用。

1. ASM框架

import org.objectweb.asm.*;
import org.objectweb.asm.commons.AdviceAdapter;

import static org.objectweb.asm.Opcodes.*;

public class ASMExample {
    public static void main(String[] args) throws Exception {
        // 读取类文件
        ClassReader cr = new ClassReader("com.example.MyClass");
        ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_FRAMES);
        
        ClassVisitor cv = new ClassVisitor(ASM9, cw) {
            @Override
            public MethodVisitor visitMethod(int access, String name, String descriptor, 
                                           String signature, String[] exceptions) {
                MethodVisitor mv = super.visitMethod(access, name, descriptor, signature, exceptions);
                
                if ("myMethod".equals(name)) {
                    return new MethodVisitor(ASM9, mv) {
                        @Override
                        public void visitCode() {
                            super.visitCode();
                            // 在方法开头添加代码
                            mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", 
                                            "Ljava/io/PrintStream;");
                            mv.visitLdcInsn("方法被调用");
                            mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", 
                                             "println", "(Ljava/lang/String;)V", false);
                        }
                    };
                }
                
                return mv;
            }
        };
        
        cr.accept(cv, 0);
        byte[] modifiedClass = cw.toByteArray();
    }
}

2. Javassist框架

import javassist.*;

public class JavassistExample {
    public static void main(String[] args) throws Exception {
        ClassPool pool = ClassPool.getDefault();
        CtClass cc = pool.get("com.example.MyClass");
        
        // 添加方法
        CtMethod newMethod = CtNewMethod.make(
            "public void newMethod() { System.out.println(\"新方法\"); }",
            cc
        );
        cc.addMethod(newMethod);
        
        // 修改方法
        CtMethod method = cc.getDeclaredMethod("existingMethod");
        method.insertBefore("{ System.out.println(\"方法前\"); }");
        method.insertAfter("{ System.out.println(\"方法后\"); }");
        
        // 添加字段
        CtField field = CtField.make("private int count;", cc);
        cc.addField(field, "0");
        
        // 编译修改后的类
        cc.writeFile();
    }
}

3. 实际应用示例

AOP实现

import org.objectweb.asm.*;

public class SimpleAOP {
    public static byte[] addLogging(byte[] classBytes) {
        ClassReader cr = new ClassReader(classBytes);
        ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_FRAMES);
        
        ClassVisitor cv = new ClassVisitor(ASM9, cw) {
            @Override
            public MethodVisitor visitMethod(int access, String name, String descriptor, 
                                           String signature, String[] exceptions) {
                MethodVisitor mv = super.visitMethod(access, name, descriptor, signature, exceptions);
                
                return new MethodVisitor(ASM9, mv) {
                    @Override
                    public void visitCode() {
                        super.visitCode();
                        mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", 
                                        "Ljava/io/PrintStream;");
                        mv.visitLdcInsn("调用方法: " + name);
                        mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", 
                                         "println", "(Ljava/lang/String;)V", false);
                    }
                };
            }
        };
        
        cr.accept(cv, 0);
        return cw.toByteArray();
    }
}

动态代理

import java.lang.reflect.*;

public class DynamicProxyExample {
    public static Object createProxy(Object target) {
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            (proxy, method, args) -> {
                System.out.println("调用前: " + method.getName());
                Object result = method.invoke(target, args);
                System.out.println("调用后: " + method.getName());
                return result;
            }
        );
    }
    
    public static void main(String[] args) {
        UserService realService = new UserServiceImpl();
        UserService proxy = (UserService) createProxy(realService);
        
        proxy.save("Alice");
    }
}

interface UserService {
    void save(String name);
}

class UserServiceImpl implements UserService {
    @Override
    public void save(String name) {
        System.out.println("保存用户: " + name);
    }
}

4. 最佳实践

1. 选择合适的框架：ASM更底层，Javassist更易用
2. 性能考虑：字节码操作有一定性能开销
3. 错误处理：妥善处理字节码操作异常
4. 测试验证：确保修改后的类正确
5. 安全考虑：避免恶意字节码操作

总结

字节码工程是Java高级编程的重要技术。掌握ASM和Javassist的使用，可以实现AOP、动态代理等高级功能。