Spring Boot AOP 返回后建议

2025年1月17日 | 阅读时长：4分钟

返回后是 Spring AOP 中的一个建议，它在连接点执行完毕（执行）后调用。如果抛出异常，它不会调用。我们可以使用 @AfterReturning 注解在应用程序中实现返回后建议。该注解将一个函数标记为在 PointCut 涵盖的方法之前执行的建议。

返回后建议在匹配的方法执行正常返回值时运行。我们在 return 属性中定义的名称必须与建议方法中参数的名称相对应。当方法返回值时，该值将作为相应的参数值传递给建议方法。

让我们在应用程序中实现返回后建议。

Spring Boot 返回后建议示例

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

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

步骤 3： 提供 Artifact Id。 我们提供了 Artifact Id aop-after-returning-advice-example。

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

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

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

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

文件 -> 导入 -> 现有 Maven 项目 -> 下一步 -> 浏览文件夹 aop-after-returning-advice-example -> 完成。

步骤 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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.javatpoint</groupId>
<artifactId>aop-after-returning-advice-example</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>aop-after-returning-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-aop</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>

步骤 9： 在 src/main/java 文件夹中创建一个名为 com.javatpoint.model 的包。

步骤 10： 在包 com.javatpoint.model 中创建一个名为 Account 的类。

在 Account 类中，执行以下操作

定义了两个类型为 String 的变量 accountNumber 和 accountType。
右键单击文件 -> 源代码 -> 使用字段生成构造函数
生成 Getter 方法。
右键单击文件 -> 源代码 -> 生成 Getter 和 Setter 方法 -> 选择 Getter 方法 -> 生成
生成一个 toString() 方法
右键单击文件 -> 源代码 -> 生成 toString()…

Account.java

package com.javatpoint.model;
public class Account 
{
private String accountNumber;
private String accountType;
public Account(String accountNumber, String accountType) 
{
super();
this.accountNumber = accountNumber;
this.accountType = accountType;
}
public String getAccountType() 
{
return accountType;
}
public String getAccountNumber() 
{
return accountNumber;
}
@Override
public String toString()
{
return "Account [accountNumber=" + accountNumber+ ", accountType=" + accountType + "]";
}
}

步骤 11： 创建另一个名为 com.javatpoint.service.impl. 的包。

步骤 12： 在此包中，创建一个名为 AccountServiceImple 的类。

在此类中，我们定义了帐户服务。

AccountServiceImpl.java

package com.javatpoint.service.impl;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import org.springframework.stereotype.Service;
import com.javatpoint.model.Account;
@Service
public class AccountServiceImpl implements AccountService 
{
//storing account detail in the HashMap
private static Map<String,Account> map = null;
static
{
map = new HashMap<>();
//adding account detail in the map
map.put("M4546779", new Account("10441117000", "Saving Account"));
map.put("K2434567", new Account("10863554577", "Current Account"));
}
@Override
public Account getAccountByCustomerId(String customerId) throws Exception
{
if(customerId ==null)
{
throw new Exception("Invalid! Customer Id");
}
Account account= null;
Set<Entry<String, Account>> entrySet = map.entrySet();
for (Entry<String, Account> entry : entrySet) 
{
if(entry.getKey().equals(customerId))
{
account= entry.getValue();
}
}
return account;
}
}

步骤 13： 在包 com.javatpoint.service.impl. 中创建一个名为 AccountService 的接口。

AccountService.java

package com.javatpoint.service.impl;
import com.javatpoint.model.Account;
//creating interface that throws exception if the customer id not found 
public interface AccountService 
{
public abstract Account getAccountByCustomerId(String customerId)
throws Exception;
}

步骤 14： 创建一个名为 com.javatpoint.aspect. 的包。

步骤 15： 在包 com.javatpoint.aspect 中创建一个名为 AccountAspect 的类。

在此类中，我们使用注解 @AfterReturning 实现了返回后建议。我们还定义了一个方法 afterReturningAdvice() 方法。

注意： 我们在 returning 属性中定义的名称（帐户）必须与 建议方法 中参数的名称相对应。

AccountAspect.java

package com.javatpoint.aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
import com.javatpoint.model.Account;
@Aspect
@Component
public class AccountAspect 
{
//implementing after returning advice	
@AfterReturning(value="execution(* com.javatpoint.service.impl.AccountServiceImpl.*(..))",returning="account")
public void afterReturningAdvice(JoinPoint joinPoint, Account account)
{
System.out.println("After Returing method:"+joinPoint.getSignature());
System.out.println(account);
}
}

步骤 16： 打开 AopAfterReturningAdviceExampleApplication.java 文件并添加注解 @EnableAspectJAutoProxy。

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

我们使用了注解 @EnableAspectJAutoProxy 的 proxyTargetClass 属性。属性 proxyTargetClass=true 允许我们使用 CGLIB（代码生成库）代理而不是默认的基于接口的 JDK 代理方法。

ConfigurableApplicationContext 是一个接口，它提供了一些功能来配置应用程序上下文，以及 ApplicationContext 中的应用程序上下文客户端方法。

AopAfterReturningAdviceExampleApplication.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.model.Account;
import com.javatpoint.service.impl.AccountService;
import com.javatpoint.service.impl.AccountServiceImpl;
@SpringBootApplication
//@EnableAspectJAutoProxy annotation enables support for handling the components marked with @Aspect annotation. It is similar to tag in the xml configuration.
@EnableAspectJAutoProxy(proxyTargetClass=true)
public class AopAfterReturningAdviceExampleApplication
{
public static void main(String[] args)  
{
ConfigurableApplicationContext ac = SpringApplication.run(AopAfterReturningAdviceExampleApplication.class, args);
//Fetching the account object from the application context
AccountService accountService = ac.getBean("accountServiceImpl", AccountServiceImpl.class);
Account account;
try 
{
account = accountService.getAccountByCustomerId("K2434567");
if(account != null)
System.out.println(account.getAccountNumber()+"\t"+account.getAccountType());
} 
catch (Exception e) 
{
System.out.println(e.getMessage());
}
}
}

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