Java Language - 66 - Custom Annotations

Annotations and Reflection – Custom Annotations

Introduction to Custom Annotations

In Java, custom annotations are a powerful way to add metadata to your code, allowing you to provide additional information and instructions to tools, frameworks, and other developers. Custom annotations are defined using the @interface keyword and can include elements that provide various parameters and values. In this article, we will explore the creation and usage of custom annotations in Java.

Defining Custom Annotations

To define a custom annotation in Java, you use the @interface keyword. Let’s create an example custom annotation called @AuthorInfo that can be used to annotate classes, indicating the author’s name and creation date:


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface AuthorInfo {
    String author();
    String date();
}

In this example, we have defined a custom annotation @AuthorInfo. The annotation can be applied to types (classes, interfaces, enums) and includes two elements: author and date, which are used to provide the author’s name and the creation date when annotating a class.

Using Custom Annotations

Once you’ve defined a custom annotation, you can apply it to classes, interfaces, or enums by using the “@” symbol followed by the annotation’s name. Let’s annotate a class using the @AuthorInfo annotation:


@AuthorInfo(author = "John Doe", date = "2023-10-15")
public class MySampleClass {
    // Class implementation
}

In this example, the @AuthorInfo annotation is used to provide the author’s name as “John Doe” and the creation date as “2023-10-15” for the MySampleClass.

Retrieving Annotation Information

To access annotation information at runtime, Java provides reflection mechanisms. You can use reflection to retrieve and process annotations on annotated elements. Let’s create a simple class that demonstrates how to retrieve the @AuthorInfo annotation information:


import java.lang.annotation.Annotation;

@AuthorInfo(author = "Alice Smith", date = "2023-09-28")
public class AnnotationProcessor {
    public static void main(String[] args) {
        Class<MySampleClass> clazz = MySampleClass.class;

        if (clazz.isAnnotationPresent(AuthorInfo.class)) {
            AuthorInfo authorInfo = clazz.getAnnotation(AuthorInfo.class);
            System.out.println("Author: " + authorInfo.author());
            System.out.println("Date: " + authorInfo.date());
        }
    }
}

In this example, we access the @AuthorInfo annotation on the MySampleClass using reflection. We check if the annotation is present, retrieve it, and then print the author’s name and creation date.

Real-World Use Cases

Custom annotations are commonly used in Java frameworks, libraries, and tools to provide configuration, documentation, and instructions. Some real-world use cases for custom annotations include:

Dependency Injection: Frameworks like Spring use custom annotations to mark classes for dependency injection.
Object-Relational Mapping (ORM): ORM frameworks like Hibernate use annotations to map Java classes to database tables.
RESTful Web Services: JAX-RS annotations are used to define RESTful web services and endpoints.

Conclusion

Custom annotations in Java provide a flexible and extensible way to add metadata to your code. They enable you to document your code, configure frameworks, and enhance your development process. By defining and using custom annotations, you can make your code more expressive and self-descriptive, improving its overall quality and maintainability.

Java Language – 66 – Custom Annotations