如何利用编译器插件在编译阶段修改Java字节码实现自定义invokedynamic？

1. 编译后直接修改生成的.class文件 #

这是最直接且兼容性强的方案。在你的编译器插件中，通过JavacTask获取编译输出目录，遍历目录下的.class文件，使用ASM、ByteBuddy或Javassist等字节码操作库修改字节码后写回。

实现思路： #

• 在finished方法中，通过JavacTask.getOptions()获取-d参数指定的输出目录；
• 递归遍历该目录下所有.class文件；
• 用字节码库读取文件内容，修改invokedynamic指令的引导方法；
• 将修改后的字节码写回原文件。

代码示例片段： #

@Override
public void finished(TaskEvent e) {
    if (TaskEvent.Kind.GENERATE.equals(e.getKind())) {
        JavacTask task = (JavacTask) e.getTask();
        String outputDir = null;
        // 遍历编译选项获取输出目录
        for (Option opt : task.getOptions()) {
            if ("-d".equals(opt.getKind())) {
                outputDir = opt.getValue();
                break;
            }
        }
        if (outputDir != null) {
            processClassFiles(new File(outputDir));
        }
    }
}

private void processClassFiles(File dir) {
    if (!dir.exists()) return;
    for (File file : dir.listFiles()) {
        if (file.isDirectory()) {
            processClassFiles(file);
        } else if (file.getName().endsWith(".class")) {
            try {
                // 用ASM读取字节码
                ClassReader cr = new ClassReader(new FileInputStream(file));
                ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_FRAMES);
                ClassVisitor cv = new MyClassVisitor(cw); // 自定义ClassVisitor修改invokedynamic
                cr.accept(cv, 0);
                // 写回修改后的字节码
                Files.write(file.toPath(), cw.toByteArray());
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
    }
}

// 自定义ClassVisitor示例，修改invokedynamic指令
static class MyClassVisitor extends ClassVisitor {
    public MyClassVisitor(ClassVisitor cv) {
        super(Opcodes.ASM9, cv);
    }

    @Override
    public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
        MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
        return new MyMethodVisitor(mv);
    }

    static class MyMethodVisitor extends MethodVisitor {
        public MyMethodVisitor(MethodVisitor mv) {
            super(Opcodes.ASM9, mv);
        }

        @Override
        public void visitInvokeDynamicInsn(String name, String desc, Handle bsm, Object... bsmArgs) {
            // 替换为自定义引导方法
            Handle customBsm = new Handle(Opcodes.H_INVOKESTATIC, "com/yourpackage/Bootstrap", "myBootstrap", 
                "(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;", false);
            super.visitInvokeDynamicInsn(name, desc, customBsm, bsmArgs);
        }
    }
}

2. 使用Java Instrumentation代理在类加载时修改字节码 #

通过Java代理机制，在类被JVM加载前拦截字节码并修改，无需依赖javac内部API，适用于编译后打包前的测试或运行时修改场景。

实现步骤： #

• 编写实现ClassFileTransformer接口的代理类，在transform方法中修改字节码；
• 打包代理类为JAR，在MANIFEST.MF中指定Premain-Class属性；
• 编译时或运行前通过-javaagent:your-agent.jar参数启动JVM，触发代理执行字节码修改。

核心代码示例： #

public class BytecodeAgent implements ClassFileTransformer {
    @Override
    public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,
                            ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
        // 只处理目标类
        if ("com/yourpackage/TargetClass".equals(className)) {
            ClassReader cr = new ClassReader(classfileBuffer);
            ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_FRAMES);
            ClassVisitor cv = new MyClassVisitor(cw); // 同上面的自定义ClassVisitor
            cr.accept(cv, 0);
            return cw.toByteArray();
        }
        return classfileBuffer;
    }

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

3. 借助javac内部非公开API（兼容性风险高） #

如果必须在编译阶段直接操作字节码流，可以通过反射访问javac的内部类（如ClassWriter）来获取和修改字节码，但这种方式依赖JDK内部实现，不同版本可能失效，不推荐生产环境使用。

代码示例片段： #

@Override
public void finished(TaskEvent e) {
    if (TaskEvent.Kind.GENERATE.equals(e.getKind())) {
        try {
            // 反射获取javac内部的TaskImpl实例
            Field taskImplField = JavacTask.class.getDeclaredField("taskImpl");
            taskImplField.setAccessible(true);
            Object taskImpl = taskImplField.get(e.getTask());
            
            // 获取ClassWriter（不同JDK版本字段名可能不同）
            Field classWriterField = taskImpl.getClass().getDeclaredField("classWriter");
            classWriterField.setAccessible(true);
            Object classWriter = classWriterField.get(taskImpl);
            
            // 获取生成的字节码
            Method getBytesMethod = classWriter.getClass().getMethod("getBytes");
            byte[] byteCode = (byte[]) getBytesMethod.invoke(classWriter);
            
            // 修改字节码
            byte[] modifiedByteCode = modifyByteCode(byteCode);
            
            // 将修改后的字节码写回（需适配内部API）
            Method setBytesMethod = classWriter.getClass().getMethod("setBytes", byte[].class);
            setBytesMethod.invoke(classWriter, modifiedByteCode);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

4. 结合注解处理器标记目标类 #

如果只需要修改特定注解标记的类，可以编写注解处理器，在编译阶段记录目标类的全限定名，编译完成后再按名称找到对应的.class文件进行修改，比盲目遍历更高效。

实现思路： #

• 定义一个自定义注解（如@ModifyInvokedDynamic）；
• 编写注解处理器，在process方法中收集被注解的类名；
• 在编译器插件的GENERATE阶段完成后，根据收集的类名定位到对应的.class文件进行修改。

内容的提问来源于stack exchange，提问作者Mikhas