Annotations are a powerful feature of Java that allow developers to add metadata information to their code. While Java provides several built-in annotations, it is also possible to create custom annotations specific to your application needs. In this blog post, we will explore how to create and use custom annotations with Java objects.

Creating Custom Annotations

To create a custom annotation in Java, you need to define an annotation type using the @interface keyword. Let’s say we want to create a custom annotation to mark certain methods as deprecated in our codebase. Here’s an example:

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.METHOD)
public @interface DeprecatedMethod {
    String reason() default "";
    String version() default "1.0";
}

In the code snippet above, we define a custom annotation DeprecatedMethod. We specify @Retention(RetentionPolicy.RUNTIME) to indicate that the annotation should be retained at runtime and @Target(ElementType.METHOD) to indicate that it can be applied to methods.

We also declare two elements in the annotation type: reason and version. These elements can be used to provide additional information when annotating methods.

Using Custom Annotations

Once we have created our custom annotation, we can use it to annotate methods in our Java classes. Here’s an example of how to use the DeprecatedMethod annotation:

public class MyClass {
    
    @DeprecatedMethod(reason = "This method is no longer needed", version = "2.0")
    public void deprecatedMethod() {
        // Method implementation
    }
    
    public void nonDeprecatedMethod() {
        // Method implementation
    }
}

In the above code snippet, we annotate the deprecatedMethod() with the @DeprecatedMethod annotation, providing a reason and version. This annotation marks the method as deprecated and provides additional information about why it is deprecated and in which version it was deprecated.

Retrieving Annotations at Runtime

One of the advantages of using custom annotations is the ability to retrieve annotation information at runtime. Let’s see how we can retrieve and process annotations using reflections:

import java.lang.reflect.Method;

public class AnnotationProcessor {
    
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        
        Class<?> clazz = myClass.getClass();
        
        for (Method method : clazz.getDeclaredMethods()) {
            DeprecatedMethod annotation = method.getAnnotation(DeprecatedMethod.class);
            
            if (annotation != null) {
                System.out.println("Method: " + method.getName());
                System.out.println("Reason: " + annotation.reason());
                System.out.println("Version: " + annotation.version());
            }
        }
    }
}

In the above example, we use reflections to get the DeprecatedMethod annotation from the methods of the MyClass object. We then print out the method name, reason, and version specified in the annotation.

Conclusion

Custom annotations provide a flexible way to add metadata and additional information to your Java code. In this blog post, we learned how to create and use custom annotations with Java objects. We also explored how to retrieve and process annotations at runtime using reflections. Custom annotations can be a powerful tool in designing clean and reusable code in Java.

#Java #CustomAnnotations