Java annotations have a wide range of functions, providing both metadata and affecting tool behavior. Annotations are additional information of the code that is read by the compiler or framework, such as @Override, @Deprecated, etc. Its uses include code analysis, framework configuration (such as Spring's @Component), code generation (such as Lombok), and runtime processing (such as Spring's @GetMapping). To define custom annotations, you need to use @interface to declare elements and use them with the processor. The annotation life cycle is controlled by @Retention and is divided into three levels: SOURCE, CLASS, and RUNTIME. The action target is defined by @Target, such as ElementType.METHOD restriction for methods. Rationally using annotations can improve code simplicity and framework efficiency.

The role and usage of Java annotations in code are actually much wider than many people think. It's not just adding a few @Override or @Deprecated, but it runs through everything from code structure to framework behavior.

What are Java annotations?

Java annotations are essentially metadata that provide additional information to the code. This information will not directly affect the execution logic of the program, but can be read by the compiler, tool or runtime and processed accordingly.

For example, the most common annotations:

• @Override : means that the current method is a method that overrides the parent class.
• @Deprecated : Marking a method or class is outdated and is not recommended.
• @SuppressWarnings : Suppress some compiler warnings.

These annotations do not do any "operation" themselves, but their existence will change the behavior of the tool, for example, the IDE will give a prompt when you call a method marked by @Deprecated .

What are the common uses of annotations?

Java annotations are important because they allow developers to express intentions in a more concise way, and many modern frameworks rely on annotations to achieve automatic configuration and behavioral binding.

Common usage scenarios include:

• Code analysis and verification : For example, the Lint tool uses annotations to check null values, resource types, etc.
• Framework-driven development : Spring uses annotations such as @Component and @RestController to automatically register beans; JUnit uses @Test to identify test methods.
• Generate code : Library such as Dagger and Lombok will automatically generate code based on annotations during the compilation stage.
• Runtime processing : In combination with the reflection mechanism, annotation content can be read and specific logic can be executed at runtime.

If you have written Spring Boot interface, you know that adding @GetMapping can directly map the URL. Behind this is the framework reading annotations to complete the routing registration.

How to define and use custom annotations?

In addition to using built-in annotations, Java allows us to customize annotations. Although it looks a bit "high-end", it is not difficult to use.

The basic steps to define an annotation:

 public @interface MyAnnotation {
    String value() default "default";
    int count() default 1;
}

Then you can use it like this:

 @MyAnnotation("hello")
public void doSomething() { ... }

Or specify multiple parameters:

 @MyAnnotation(value = "custom", count = 5)

Note:

• Annotation elements cannot have method bodies, they can only declare default values.
• Annotations need to be used with the processor to make sense, such as reading through reflection.

If you have done Android development, you may have seen ButterKnife or similar view binding libraries. Early versions of them relied on custom annotation and annotation processors to generate binding code.

The life cycle and function objectives of annotation

Not all annotations can be accessed at runtime, depending on its @Retention policy.

• RetentionPolicy.SOURCE : Only exists in the source code and is discarded at compile time (suitable for code analysis tools).
• RetentionPolicy.CLASS : Retained in the class file, but the JVM does not load (suitable for compilation-time processing).
• RetentionPolicy.RUNTIME : Retained until runtime, can be read by reflection (suitable for dynamic behavior control).

At the same time, annotations can also limit the scope of use, such as only annotation of classes, methods, or fields, etc., which is controlled by @Target .

For example, if you want to make annotation that can only be used on methods:

 @Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface LogExecution {}

This way it cannot be added to classes or variables.

Basically that's it. Annotations are not magic, but it does change the way we write code, especially in large projects and frameworks, understanding and using annotations will make you more effective with half the effort.

The above is the detailed content of The Role and Usage of Java Annotations in Code. For more information, please follow other related articles on the PHP Chinese website!