Spring Boot AOP Around Advice

Around advice is represented by @Around annotation. It executes before and after a join point. It is the most powerful advice. It also provides more control for end-user to get deal with ProceedingJoinPoint.

Let's implement around advice in an application.

Spring Boot Around 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-around-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-around-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

<?xml version="1.0" encoding="UTF-8"?>
<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.2.2.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.javatpoint</groupId>
<artifactId>aop-around-advice-example</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>aop-around-advice-example</name>
<description>Demo project for Spring Boot</description>
<properties>
<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>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>

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

Step 10: Create a class in the above package with the name BankService.

In this class, we have defined a method named displayBalance(). It checks the account number. If the account number is matched returns total amount, else returns a message.

BankService.java

package com.javatpoint.service;
import org.springframework.stereotype.Service;
@Service
public class BankService 
{
public void displayBalance(String accNum) 
{
System.out.println("Inside displayBalance() method");
if(accNum.equals("12345")) 
{
System.out.println("Total balance: 10,000");
}
else 
{
System.out.println("Sorry! wrong account number.");
}
}
}

Step 11: Create another package with the name com.javatpoint.aspect.

Step 12: Create a class in the above package with the name BankAspect.

In the following class, we have defined two methods named logDisplayingBalance() and aroundAdvice() method.

BankAspect.java

package com.javatpoint.aspect;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
//Enables the spring AOP functionality in an application
@Aspect
@Component
public class BankAspect
{
//Displays all the available methods i.e. the advice will be called for all the methods
@Pointcut(value= "execution(* com.javatpoint.service.BankService.*(..))")
private void logDisplayingBalance() 
{ 
}
//Declares the around advice that is applied before and after the method matching with a pointcut expression
@Around(value= "logDisplayingBalance()")
public void aroundAdvice(ProceedingJoinPoint jp) throws Throwable 
{
System.out.println("The method aroundAdvice() before invokation of the method " + jp.getSignature().getName() + " method");
try 
{
jp.proceed();
} 
finally 
{

}
System.out.println("The method aroundAdvice() after invokation of the method " + jp.getSignature().getName() + " method");
}
}

Step 13: Open AopAroundAdviceExampleApplication.java file and add an annotation @EnableAspectJAutoProxy.

The annotation enables support for handling components marked with AspectJ's @Aspect annotation. It is used with @Configuration annotation.

ConfigurableApplicationContext is an interface that provides facilities to configure an application context in addition to the application context client methods in the ApplicationContext.

AopAroundAdviceExampleApplication.java

package com.javatpoint;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import com.javatpoint.service.BankService;
@SpringBootApplication
//@EnableAspectJAutoProxy annotation enables support for handling the components marked with @Aspect annotation. It is similar to tag in the xml configuration.
@EnableAspectJAutoProxy
public class AopAroundAdviceExampleApplication 
{
public static void main(String[] args) 
{
ConfigurableApplicationContext context = SpringApplication.run(AopAroundAdviceExampleApplication.class, args);
// Fetching the employee object from the application context.
BankService bank = context.getBean(BankService.class);
// Displaying balance in the account
String accnumber = "12345";
bank.displayBalance(accnumber);
// Closing the context object
context.close();
}
}

After creating all the packages and classes the project directory looks like the following:

Now, run the application.

Step 14: Open the AopAroundAdviceExampleApplication.java and run it as Java Application.

In the above output, we see that the method aroundAdvice() invokes two times. First, before the execution of the displayBalance() method and second, after the execution of the displayBalance() method. It is called around advice.

Download AOP Around Advice Example Project

Next TopicAOP After Returning Advice

← prev next →