客户端能否向注解提供可被注解处理器直接执行的代码？

核心限制 #

注解处理阶段（Annotation Processing Time）处于Java编译流程的早期，此时被注解的客户端代码（比如示例中的MyHelper类）还未完成编译，没有生成可加载的字节码，因此无法直接实例化或执行这些未编译的类——这是Java编译模型的固有限制，没有直接绕过的机制。

不过可以通过以下几种变通方案实现类似需求：

1. 嵌入可执行脚本字符串 #

在注解中定义字符串类型的参数，用来存放脚本表达式，然后在注解处理器中通过Java的脚本引擎（如GraalVM JavaScript、Nashorn）解析执行这段代码。

示例注解定义：

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

@Retention(RetentionPolicy.SOURCE)
public @interface MyAnnotation {
    // 存放判断逻辑的脚本字符串
    String filterScript();
}

客户端使用：

@MyAnnotation(filterScript = "element.getSimpleName().startsWith(\"Foo\")")
public class Foo {}

注解处理器中的执行逻辑：

import javax.annotation.processing.AbstractProcessor;
import javax.annotation.processing.RoundEnvironment;
import javax.lang.model.element.Element;
import javax.lang.model.element.TypeElement;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import java.util.Set;

public class MyAnnotationProcessor extends AbstractProcessor {
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        ScriptEngine engine = new ScriptEngineManager().getEngineByName("graal.js");
        for (Element element : roundEnv.getElementsAnnotatedWith(MyAnnotation.class)) {
            MyAnnotation anno = element.getAnnotation(MyAnnotation.class);
            try {
                // 绑定Element变量到脚本上下文
                engine.put("element", element);
                // 执行脚本并获取结果
                boolean result = (boolean) engine.eval(anno.filterScript());
                if (result) {
                    // 处理符合条件的元素
                }
            } catch (Exception e) {
                // 处理脚本执行异常
            }
        }
        return true;
    }
}

这种方式灵活度高，允许使用者直接编写逻辑表达式；缺点是脚本语法与Java不完全一致，且存在性能和安全风险。

2. 预编译辅助类并放入处理器类路径 #

如果使用者愿意提前编译辅助类（比如MyHelper），并将编译后的字节码加入注解处理器的类路径，那么处理器就可以通过Class.forName()加载并实例化这个类，调用其方法。

但这种方案灵活性极差，要求使用者额外处理编译依赖，实际项目中很少采用。

3. 基于注解参数构建DSL #

不直接编写代码，而是定义一套简单的领域特定语言（DSL），通过注解的多个参数组合来表达逻辑，注解处理器解析这些参数并执行对应的内置逻辑。

示例注解定义：

@Retention(RetentionPolicy.SOURCE)
public @interface MyAnnotation {
    // 目标元素的名称前缀
    String namePrefix() default "";
    // 是否要求元素为公共访问级别
    boolean requirePublic() default false;
}

客户端使用：

@MyAnnotation(namePrefix = "Foo", requirePublic = true)
public class FooService {}

注解处理器中的执行逻辑：

@Override
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
    for (Element element : roundEnv.getElementsAnnotatedWith(MyAnnotation.class)) {
        MyAnnotation anno = element.getAnnotation(MyAnnotation.class);
        // 解析参数并执行判断
        boolean matches = true;
        if (!anno.namePrefix().isEmpty()) {
            matches &= element.getSimpleName().startsWith(anno.namePrefix());
        }
        if (anno.requirePublic()) {
            matches &= element.getModifiers().contains(java.lang.reflect.Modifier.PUBLIC);
        }
        if (matches) {
            // 处理符合条件的元素
        }
    }
    return true;
}

这种方案类型安全、性能好；缺点是逻辑表达能力有限，只能覆盖预定义的场景。

4. AST注入（类似Lombok的方案） #

虽然不能在注解处理阶段直接执行代码，但可以将使用者提供的代码片段注入到编译后的AST（抽象语法树）中，让代码在运行时执行。Lombok就是通过这种方式实现注解驱动的代码生成。

比如可以让使用者在注解中指定代码模板，处理器将模板代码注入到目标类中：

@Retention(RetentionPolicy.SOURCE)
public @interface MyAnnotation {
    String validationCode() default "";
}

// 客户端使用
@MyAnnotation(validationCode = "if (name == null) throw new IllegalArgumentException(\"Name cannot be null\");")
public class User {}

处理器会将这段代码注入到User类的构造方法或指定方法中，编译后这段代码就会在运行时执行。但这不属于“在注解处理阶段执行代码”，而是生成代码供后续运行。

总结 #

Java没有原生机制允许注解处理器直接执行未编译的客户端代码，因为编译阶段的类加载限制。上述几种变通方案可以根据需求选择：

• 需要灵活逻辑：优先选择脚本字符串方案
• 追求类型安全和性能：选择DSL参数方案
• 需要生成运行时代码：选择AST注入方案

内容的提问来源于stack exchange，提问作者I was in the neighborhood