Spring Boot AOP After Advice

After advice is used in Aspect-Oriented Programming to achieve the cross-cutting. It is an advice type which ensures that an advice runs after the method execution. We use @After annotation to implement the after advice.

Let's understand after advice through an example.

Spring Boot After Advice Example

Step 1: Open Spring Initializr http://start.spring.io.

Step 2: Provide the Group name. We have provided the Group name com.javatpoint.

Step 3: Provide the Artifact Id. We have provided the Artifact Id aop-after-advice-example.

Step 4: Add the Spring Web dependency.

Step 5: Click on the Generate button. When we click on the Generate button, it wraps all the specifications in a jar file and downloads it to the local system.

Step 6: Extract the downloaded jar file.

Step 7: Import the folder by using the following steps:

File -> Import -> Existing Maven Projects -> Next -> Browse the Folder aop-after-advice-example -> Finish.

Step 8: Open the pom.xml file and add the following AOP dependency. It is a starter for aspect-oriented programming with Spring AOP and AspectJ.

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>
</dependencies>

pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.javatpoint</groupId>
<artifactId> aop-after-advice-example</artifactId>
<version>0.0.1-SNAPSHOT</version>  
<packaging>jar</packaging>	
<name>aop-after-advice-example</name>
	<description>Demo project for Spring Boot</description>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.2.2.RELEASE</version>
		<relativePath /> <!-- lookup parent from repository -->
	</parent>
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
	<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-aop</artifactId>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

Step 9: Open AopAfterAdviceExampleApplication.java file and add an annotation @EnableAspectJAutoProxy.

It enables support for handling components marked with AspectJ's @Aspect annotation. It is used with @Configuration annotation. We can control the type of proxy by using the proxyTargetClass attribute. Its default value is false.

AopAfterAdviceExampleApplication.java

package com.javatpoint;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
@SpringBootApplication
@EnableAspectJAutoProxy(proxyTargetClass=true)
public class AopAfterAdviceExampleApplication 
{
public static void main(String[] args) {
SpringApplication.run(AopAfterAdviceExampleApplication.class, args);
}
}

Step 10: Create a package with the name com.javatpoint.model.

Step 11: Create a model class under the package com.javatpoint.model. We have created a class with the name Employee. In the class, define the following:

Define three variables empId, firstName, and secondName of type String.
Generate Getters and Setters.
Create a default

Employee.java

package com.javatpoint.model;
public class Employee 
{
private String empId;
private String firstName;
private String secondName;
//default constructor
public Employee() 
{
}
public String getEmpId() 
{
return empId;
}
public void setEmpId(String empId) 
{
this.empId = empId;
}
public String getFirstName() 
{
return firstName;
}
public void setFirstName(String firstName) 
{
this.firstName = firstName;
}
public String getSecondName() 
{
return secondName;
}
public void setSecondName(String secondName) 
{
this.secondName = secondName;
}
}

Step 12: Create a package with the name com.javatpoint.controller.

Step 13: Create a controller class under the package com.javatpoint.controller. We have created a class with the name EmployeeController.

In the controller class, we have defined the two mappings one for adding an employee and the other for removing an employee.

EmployeeController.java

package com.javatpoint.controller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.javatpoint.model.Employee;
import com.javatpoint.service.EmployeeService;
@RestController
public class EmployeeController 
{
@Autowired
private EmployeeService employeeService;
@RequestMapping(value = "/add/employee", method = RequestMethod.GET)
public com.javatpoint.model.Employee addEmployee(@RequestParam("empId") String empId, @RequestParam("firstName") String firstName, @RequestParam("secondName") String secondName) 
{
return employeeService.createEmployee(empId, firstName, secondName);
}
@RequestMapping(value = "/remove/employee", method = RequestMethod.GET)
public String removeEmployee( @RequestParam("empId") String empId) 
{
employeeService.deleteEmployee(empId);
return "Employee removed";
}
}

Step 14: Create a package with the name com.javatpoint.service.

Step 15: Create a Service class under the package com.javatpoint.service. We have created a class with the name EmployeeService.

In the Service class, we have defined two methods createEmployee and deleteEmployee.

EmployeeService.java

package com.javatpoint.service;
import org.springframework.stereotype.Service;
import com.javatpoint.model.Employee;
@Service
public class EmployeeService 
{
public Employee createEmployee( String empId, String fname, String sname) 
{
Employee emp = new Employee();
emp.setEmpId(empId);
emp.setFirstName(fname);
emp.setSecondName(sname);
return emp;
}
public void deleteEmployee(String empId) 
{
}
}

Step 16: Create a package with the name com.javatpoint.aspect.

Step 17: Create an aspect class under the package com.javatpoint.aspect. We have created a class with the name EmployeeServiceAspect.

In the aspect class, we have defined the after-advice logic.

EmployeeServiceAspect.java

package com.javatpoint.aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.After;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class EmployeeServiceAspect 
{
@After(value = "execution(* com.javatpoint.service.EmployeeService.*(..)) and args(empId, fname, sname)")
public void afterAdvice(JoinPoint joinPoint, String empId, String fname, String sname) {
System.out.println("After method:" + joinPoint.getSignature());
System.out.println("Creating Employee with first name - " + fname + ", second name - " + sname + " and id - " + empId);
}
}

In the above class:

execution(expression): The expression is a method on which advice is to be applied.
@After: The method annotated with @After executes after all the methods that matched with the pointcut expression.

After creating all the modules, the project directory looks like the following:

We have set-up all the modules. Now we will run the application.

Step 18: Open the AopAfterAdviceExampleApplication.java file and run it as Java Application.

Step 19: Open the browser and invoke the following URL : http://localhost:8080/add/employee?empId={id}&firstName={fname}&secondName={sname}

In the above URL, /add/employee is the mapping that we have created in the Controller class. We have used two separators (?) and (&) for separating two values.

In the above output, we have assigned emId 102, firstName=Sachin, and secondName=Bansal.

Let's have a look at the console. We see that after invoking the createEmployee() method of EmployeeService class, the method afterAdvice() of EmployeeServiceAspect class invokes, as shown below.

Similarly, we can also remove an employee by invoking the URL http://localhost:8080/remove/employee?empId=102. It returns a message Employee removed, as shown in the following figure.