How to create Annotation in Spring boot

 To create Custom Annotation in JAVA, @interface keyword is used.

The annotation contains : 

1. Retention : @Retention(RetentionPolicy.RUNTIME)

It specifies that annotation should be available at runtime.

2. Target : @Target({ElementType.METHOD})

It specifies that the annotation can only be applied to method. The target cane be modified to:

 @Target({ElementType.TYPE}) for class level annotation

@Target({ElementType.FIELD}) for field level annotation

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
public @interface CustomAnnotation {
String value() default "default value";
}

value attribute is defined with @CustomAnnotation annotation. If you want to use the
 attribute in annotation. 
A single attribute value.

Example : 
public class Books {
    
    
    @CustomAnnotation(value = "myBook")
    public void updateBookDetail() {
        // update book category name by annotation value
    }
}

HOW THIS CAN BE USED

1. Using Spring AOP :

import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class CustomAnnotationProcess {

    @Pointcut("@annotation(customAnnotation)")
    public void customAnnotationPointcut(final CustomAnnotation customAnnotation) {

    }


    @AfterReturning(pointcut = "customAnnotationPointcut(customAnnotation)", 
returning = "transactionResponse")
    public void updateBookCategory(final CustomAnnotation customAnnotation, 
final Object transactionResponse) {
        final String bookCategory = customAnnotation.value();
        // Update book details
    }
}

A). Aspect-Oriented Programming (AOP) with Spring and AspectJ annotations. Here's a 
breakdown of the key annotations and their purpose:

B). @Aspect: Indicates that the class is an aspect, which is a module that 
encapsulates behaviors affecting multiple classes.

C). @Pointcut: Declares a pointcut, which is a predicate that matches join points 
(points in the execution of the program, such as method calls) where advice 
(additional behavior) should be applied. In this case, the pointcut matches methods annotated with @CustomAnnotation.

D). @AfterReturning: Declares advice to be executed after a join point completes 
normally and returns a value. The pointcut attribute specifies the pointcut expression 
that defines where the advice should be applied, and the returning attribute specifies 
the name of the parameter in the advice method that will receive the return value of 
the join point.

E). @Component: Indicates that the class is a Spring component and should be 
automatically detected and registered as a bean in the Spring application context.

In this example, 
the CustomAnnotationProcess class serves as an aspect that processes methods annotated 
with @CustomAnnotation. The customAnnotationPointcut method defines a pointcut that 
matches such annotated methods. The updateBookCategory method is the advice that will
 be executed after the annotated methods return, and it receives the CustomAnnotation
 and the return value of the annotated method as parameters.


2. Process the Annotation
If your annotation requires special processing, you can use reflection to access and process the annotation at runtime

public class AnnotationProcessor {
    public void processAnnotations(Object obj) {
        Class<?> clazz = obj.getClass();
        MyAnnotation annotation = clazz.getAnnotation(MyAnnotation.class);
        if (annotation != null) {
            String value = annotation.value();
            System.out.println("Annotation value: " + value);
        }
    }
}