Java自定义注解的Processor代码什么时候调用？ （运行时保留）

Question

I know that Custom Java Annotations need a semi interface declaration with @interface and a processor code (in some text it's called the consumer code) which defines the actual business logic behind the annotation. So far so clear, but my question is that, where/when exactly the processor code is called and by whom ? I mean, does Java compiler generate the code which invokes all the annotation processors, for example, at class loading time? or the programmer themselves decide when to call their processor codes for their custom annotations? for example, @GetMapping("/users") on some method, tells the servlet API to map the requests with /users in their request path, should be delivered to this method. so it has some processor behind the scene which should be called to store this Mapping configuration somewhere , but when and who calls that processor? I guess my question makes sense only on the annotations with @Retention(RetentionPolicy.RUNTIME) . Thanks

Answer 1

An annotation processor runs at compile time. When invoking javac , the user passes the -processor command-line option, and then javac invokes the processor. An annotation processor can issue errors, create files (including files of Java code), and even modify existing code. In addition to the Oracle documentation linked above, you might want to see a tutorial, such as Baeldung's .

Some frameworks directly interpret annotations, so you don't need to write your own annotation processor.

To affect run-time behavior, your code can reflectively read annotations; in this case no annotation processor is run at compile time.

Answer 2

An Annotation as the name suggests, is additional information (or behavior). By default, this information is not processed or used to alter any behavior. There has to be some entity to process the annotation.

The retention policy tells the Java compiler about the scope of the annotation. That is, whether the extra information is needed to be processed at runtime or compile-time.

For compile-time processing, the annotation processors are hooked into the compilation process using the -processor flag. For run-time processing, reflection (such as this ) is used to access the additional information.

@GetMapping("/users") on some method, tells the servlet API to map the requests with /users in their request path,

Just the presence of the annotation does not result in this behavior. The spring framework (simplifying a lot) -

• installs itself as the servlet endpoint for /* . See FrameworkServlet
• enumerates the methods annotated with GetMapping using reflection
• uses the annotated information to populate the mapping of URLs to methods.
• while handling the requests, uses the mapping to route to the intended method.

One easy trick to understand the flow (yes, Java is too magicy sometimes) is to install breakpoints and look at the callstack.