Processing Annotations Using Reflection in Java

Question

Ravi Vishwakarma · Answer

Once you've got defined and carried out custom annotations, you may use Java reflection to system them at runtime. This is especially useful in frameworks where you scan metadata to drive behavior (for example, dependency injection, configuration, validation).
1. Custom Annotation Example
Let's say we have a custom annotation for marking methods to be executed:
import java.lang.annotation.*;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RunMe {
    String message() default "Executing";
}
2. Class with Annotated Methods
public class TaskRunner {
    @RunMe(message = "Start Task")
    public void start() {
        System.out.println("Starting...");
    }
    @RunMe
    public void process() {
        System.out.println("Processing...");
    }
    public void skipThis() {
        System.out.println("Not annotated");
    }
}
3. Processing Annotations with Reflection
You can now write a class that scans for methods with @RunMe and invokes them.
import java.lang.reflect.Method;
public class AnnotationProcessor {
    public static void main(String[] args) {
        try {
            TaskRunner runner = new TaskRunner();
            Classandlt;?andgt; clazz = runner.getClass();
            for (Method method : clazz.getDeclaredMethods()) {
                if (method.isAnnotationPresent(RunMe.class)) {
                    RunMe annotation = method.getAnnotation(RunMe.class);
                    System.out.println("Invoking: " + method.getName());
                    System.out.println("  Message: " + annotation.message());
                    method.invoke(runner);  // Call the method dynamically
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
Output:
Invoking: start
  Message: Start Task
Starting...
Invoking: process
  Message: Executing
Processing...
4. Key Reflection APIs Used
Method
Description
Class.getDeclaredMethods()
Gets all declared methods in the class
method.isAnnotationPresent()
Checks if an annotation is present
method.getAnnotation()
Retrieves the annotation object
method.invoke(obj)
Dynamically calls the method on the object
5. Use Cases in Real Projects
JUnit: Uses @Test to identify test methods.Spring: Uses annotations like @Autowired, 
@RequestMapping and processes them at runtime.Hibernate: Reads @Entity, @Table, etc., to map Java classes to database tables.
and

interview

Processing Annotations Using Reflection in Java

Ravi Vishwakarma

Can you answer this question?

1 Answers

1. Custom Annotation Example

2. Class with Annotated Methods

3. Processing Annotations with Reflection

Output:

4. Key Reflection APIs Used

5. Use Cases in Real Projects

Liked By

Method	Description
`Class.getDeclaredMethods()`	Gets all declared methods in the class
`method.isAnnotationPresent()`	Checks if an annotation is present
`method.getAnnotation()`	Retrieves the annotation object
`method.invoke(obj)`	Dynamically calls the method on the object