All 15 Annotations questions
More in Annotations
What are annotations in Java, and what purpose do they serve? What do the built-in @Override, @Deprecated, and @SuppressWarnings annotations do? How do you apply multiple different annotations to the same element, and does their order matter? How do you create a custom annotation in Java, and what role do @Retention and @Target play? What are Java's meta-annotations (@Retention, @Target, @Documented, @Inherited), and what does each control? What is the purpose of the @FunctionalInterface annotation, and is it required for an interface to actually be treated as a functional interface? How do annotations with elements (parameters) work, including default values and the special `value` element? What is the difference between the @Nullable/@NonNull annotations (from libraries like JetBrains or JSR-305) and Java's built-in Optional type for expressing nullability? How would you read custom annotations at runtime using reflection to implement annotation-driven behavior, such as a simple dependency injection or validation framework? How do repeatable annotations work in Java (using @Repeatable), and what problem do they solve?
Advertisement
Back to results for “Build Tools: Maven & Gradle”
Java › Annotations

What is the difference between compile-time annotation processing (via javax.annotation.processing.Processor) and runtime reflection-based annotation reading?

Intermediate

Answer

Compile-time annotation processing runs during compilation itself (implementing AbstractProcessor, registered via META-INF/services), generating new source files or validating code structure before the .class files even exist -- used by tools like Lombok (generating getters/setters) or Dagger (generating dependency injection code) -- while runtime reflection reads already-compiled annotation metadata during program execution, incurring reflection's inherent performance overhead but requiring no separate build step, making compile-time processing generally preferred for performance-sensitive, code-generation scenarios.
@SupportedAnnotationTypes("com.example.GenerateBuilder")
@SupportedSourceVersion(SourceVersion.RELEASE_17)
public class BuilderProcessor extends AbstractProcessor {
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        // generates new .java source files at compile time
        return true;
    }
}
Real-world example Lombok's @Data annotation is processed entirely at compile time via an annotation processor, generating getter/setter/equals/hashCode methods directly into the bytecode before the JVM ever runs the program, avoiding any runtime reflection overhead that a similar reflection-based approach would incur on every method call.

Common follow-ups: Why do frameworks like Dagger prefer compile-time code generation over Spring's runtime reflection-based approach?;What are the debugging challenges specific to compile-time generated code?

Reflection API;Build Tools: Maven & Gradle
All 15 Annotations questions