Annotation processor is an extended mechanism in the Java compilation stage, used to scan and process annotations in the source code, and can generate new code or preprocess it. Its core functions include: 1. When defining annotations, you need to specify the retention policy and target element type; 2. Implement the AbstractProcessor class and rewrite key methods such as getSupportedAnnotationTypes, getSupportedSourceVersion and process; 3. Register the processor to declare a fully qualified name through a configuration file in the META-INF/services directory. Annotation processors are widely used in frameworks, such as Dagger, Butter Knife and Room, and are used for dependency injection, database access and other functions. When using it, you should pay attention to avoid dependency order, modifying existing code, complex logic and testing difficulties. If the annotation does not take effect, check the @Retention setting, processor registration status, and whether the annotation processing is enabled by the build tool.

The annotation processing mechanism in Java is actually not mysterious. It is essentially an expansion capability provided by the Java compiler during the compilation stage. Through the Annotation Processor, we can read the annotation information in the code during the compilation period, generate a new Java file or perform other preprocessing operations. Many frameworks such as Dagger, Butter Knife and Room rely on this mechanism to implement dependency injection or database access.

What is an annotation processor?

Annotation processor is a special tool that runs during the Java compilation phase and can scan and process annotations in the source code. Its core interface is javax.annotation.processing.Processor , which we can customize the processor by inheriting AbstractProcessor class.

The Java compiler will call these processors, pass in all elements marked by specific annotations (such as classes, methods, fields, etc.), and then the developer will decide how to handle this information.

To give a simple example: When you use the @Override annotation, the Java compiler will check at the compilation stage whether the method actually overrides the parent class's method. This is a built-in annotation processing logic.

How to write a custom annotation processor?

To implement an annotation processor, the following steps are usually required:

• Definition annotation
• Implement AbstractProcessor
• Register the processor

Definition annotation

You can create a runtime reserved annotation, or it can be used only for compilation processing. For example:

 @Retention(RetentionPolicy.SOURCE)
@Target(ElementType.TYPE)
public @interface MyAnnotation {
    String value();
}

Implement AbstractProcessor

Next, you need to inherit AbstractProcessor and rewrite the key methods:

 public class MyAnnotationProcessor extends AbstractProcessor {
    @Override
    public Set<String> getSupportedAnnotationTypes() {
        return Collections.singleton(MyAnnotation.class.getCanonicalName());
    }

    @Override
    public SourceVersion getSupportedSourceVersion() {
        return SourceVersion.RELEASE_8;
    }

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        for (TypeElement annotation : annotations) {
            Set<? extends Element> elements = roundEnv.getElementsAnnotatedWith(annotation);
            for (Element element : elements) {
                // Handle classes, methods, etc. with annotations}
        }
        return true;
    }
}

Register the processor

You can create a META-INF/services/javax.annotation.processing.Processor file in the resource directory, and write your processor's fully qualified name, so that the compiler knows which processor to load.

What can annotation processors do?

The most common uses of annotation processors include:

• Automatically generate code (such as ButterKnife)
• Verify code structure (such as Lombok's non-null check)
• Do some configuration processing in advance (such as Dagger's dependency graph construction)

For example, Dagger analyzes @Inject annotation through an annotation processor during compilation, generates corresponding dependency injection code to avoid performance losses caused by runtime reflection.

In addition, if you are developing Android applications, the Room framework also generates database-related code through annotation processors at compile time, so you do not need to parse SQL statements at runtime.

Notes and FAQs

There are several error-prone places to pay attention to when using annotation processors:

• Don't rely on order : The order of execution between multiple processors is uncertain.
• Try not to modify existing code : annotation processors are more suitable for generating new code rather than modifying existing classes.
• Avoid complex logic : The processor is running at the compilation stage, and complex calculations may affect the compilation speed.
• Testing difficulty : Because it runs during the compilation period, debugging is not as convenient as ordinary code.

If you find that the annotation is not effective, you can check the following points:

• Is the annotated @Retention set to SOURCE or CLASS
• Is the annotation processor registered correctly?
• Is there any annotation processing enabled for building tools (such as Gradle)

Basically that's it. Mastering the principles and usage of annotation processors can give you a deeper understanding of the mechanisms behind many modern Java frameworks.

The above is the detailed content of How Annotation Processing Works in Java. For more information, please follow other related articles on the PHP Chinese website!