THECODEPROGRAM

Let's get started

What is the annotation in Java?

Annotations provide metadatas for the code blocks. With annotation some additional informations will be passed to compiler and these informations are being used for compiling for sometimes they are working also at runtime and we can perform some operations.

We put annotations before or above line of decleration and annotations starts with @. Below you can see an the syntax:

@Annotation
public void methodName(...){
     //......
}

• @Service annotation specifys that is the related class is an service class and business logic will be defined within.
• @Repository annotate the object will be used to access to database directly and manage database operations.
• @Controller annotation specify the class contains the endpoints with through the url configured with @RequestMapping annotation
• @SpringBootApplication specifies that a class is initializing a spring boot application, it initialize enablin configuration and component scanning for spring boot application initialization.

Firstly we need to create an interface for for the annotation BUT this is not a regulare interface so we will need to define it with @interface keyword. With this decleration also we will need to specify our annotation configurations like target element type or where it will be considered.

Below you can see the decleration of an annotation interface.

package com.thecodeprogram.annotation;

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

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface CheckLevel {
	int level() default 0;
}

In above example as you can see we have created a an annotation which named as CheckLevel and it is taking parameter as level. Also we defined default value for level is 0. Also we defined target as element is methods and it will be there during the program Runtime also.

So now we need to create the logic for this annotation to define what it will do.

package com.thecodeprogram.annotation;

import java.lang.reflect.Method;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class CheckLevelLogic {
	ProceedingJoinPoint proceedingJoinPoint;
	
	@Around("@annotation(CheckLevel)")
	public Object validateAspect(ProceedingJoinPoint pjp) throws Throwable {
		this.proceedingJoinPoint = pjp;
		MethodSignature signature = (MethodSignature) this.proceedingJoinPoint.getSignature();
		Method method = signature.getMethod();

		PermissionLevel validateAction = method.getAnnotation(CheckLevel.class);
		int level = validateAction.level();

		System.out.println("Level is: " + level);
	}
}

• Firstly we have created a class for logic implementation of our annotation and we used Aspect and Component annotations for this class.
• Then we implementad aour validateAspect method for our annotation, with Around annotation we specified that this method is for our custom annotation.
• Then we Used ProceedingJoinPoint and Medhat signature to access related method and we will call our check function before related method invoked.

Now lets see how our custom annotation is being used below:

package com.thecodeprogram.controller;

import com.thecodeprogram.annotation.CheckLevel;

public class UserController {
	
	@CheckLevel(level = 2)
	public void deleteData(@PathVariable String id) {
		// ......
		// Logic implementation
		// .....
	}
}

That is all

Burak Hamdi TUFAN