All 15 Annotations questions
More in Annotations
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? How would you implement annotation-based validation (similar to Bean Validation's @NotNull, @Size) using a custom annotation and a reflection-based validator? How would you design a custom annotation-driven caching mechanism (similar to Spring's @Cacheable) using a dynamic proxy combined with reflection? How do type annotations (introduced in Java 8, JSR 308) differ from traditional declaration annotations, and what new locations can they target?
Advertisement
Java › Annotations

How does Java's annotation processing API (javax.annotation.processing) enable compile-time code generation frameworks like Lombok or Dagger, and what are its key limitations?

Advanced

Answer

The Processor SPI lets a library register a class implementing AbstractProcessor, invoked automatically by javac during compilation for any annotations it declares support for via @SupportedAnnotationTypes -- it can generate entirely new source files (via the Filer API) that then get compiled alongside the original code in the same compilation round, but critically, standard annotation processors cannot modify existing source files (only generate new ones), which is why Lombok's field/method injection into existing classes actually relies on a lower-level, officially unsupported compiler API hack rather than the standard processor mechanism.
@SupportedAnnotationTypes("com.example.AutoValue")
@SupportedSourceVersion(SourceVersion.RELEASE_17)
public class AutoValueProcessor extends AbstractProcessor {
    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        for (Element element : roundEnv.getElementsAnnotatedWith(AutoValue.class)) {
            // generates a NEW source file implementing the value class, via processingEnv.getFiler()
        }
        return true;
    }
}
Real-world example Google's AutoValue library uses the standard annotation processing API to generate a complete new immutable implementation class alongside an abstract class marked @AutoValue, whereas Lombok (needing to inject code into the existing class itself rather than generate a new file) has to rely on unofficial compiler internals, explaining why Lombok has historically had more compiler-version compatibility issues than AutoValue.

Common follow-ups: Why can't a standard annotation processor modify the source file it's processing?;What alternative approaches exist for frameworks that need to modify existing classes, like AspectJ's compile-time weaving?

Build Tools: Maven & Gradle;Design Patterns in Java
All 15 Annotations questions