Spring Boot AOP Around Advice

17 Jan 2025 | 3 分钟阅读

Around advice 由 @Around 注解表示。它在连接点之前和之后执行。它是最强大的 advice。它还为最终用户提供了更多的控制权来处理 ProceedingJoinPoint。

让我们在一个应用程序中实现 around advice。

Spring Boot Around Advice 示例

步骤1： 打开Spring Initializr http://start.spring.io。

步骤 2: 提供 Group 名称。我们提供的 Group 名称是 com.javatpoint。

步骤 3: 提供 Artifact Id。 我们提供的 Artifact Id 是 aop-around-advice-example。

步骤4： 添加Spring Web依赖项。

步骤 5: 点击 Generate 按钮。当我们点击 Generate 按钮时，它将所有规范包装在一个 jar 文件中，并将其下载到本地系统。

步骤 6: 解压 下载的 jar 文件。

步骤 7: 导入 文件夹，按照以下步骤

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

步骤 8: 打开 pom.xml 文件并添加以下 AOP 依赖。它是面向切面编程的启动器，具有 Spring AOP 和 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>

步骤 9: 创建一个名为 com.javatpoint.service 的包。

步骤 10: 在上述包中创建一个名为 BankService 的类。

在此类中，我们定义了一个名为 displayBalance() 的方法。它检查帐户号码。如果帐户号码匹配，则返回总金额，否则返回一条消息。

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.");
}
}
}

步骤 11: 创建另一个名为 com.javatpoint.aspect 的包。

步骤 12: 在上述包中创建一个名为 BankAspect 的类。

在以下类中，我们定义了两个名为 logDisplayingBalance() 和 aroundAdvice() 的方法。

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");
}
}

步骤 13: 打开 AopAroundAdviceExampleApplication.java 文件并添加一个注解 @EnableAspectJAutoProxy。

该注解启用对处理使用 AspectJ 的 @Aspect 注解标记的组件的支持。它与 @Configuration 注解一起使用。

ConfigurableApplicationContext 是一个接口，除了 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();
}
}

创建所有包和类后，项目目录如下所示