Spring Boot AOP Before Advice（Spring Boot AOP 前置通知）

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

Before advice（前置通知）用于面向切面编程，以实现横切关注点。它是一种在方法执行之前运行通知的通知类型。我们使用 @Before 注解来实现前置通知。

让我们通过一个例子来理解前置通知。

Spring Boot Before Advice Example（Spring Boot 前置通知示例）

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

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

步骤 3： 提供 Artifact Id (构件 ID)。 我们提供了 Artifact Id aop-before-advice-example。

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

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

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

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

File（文件） -> Import（导入） -> Existing Maven Projects（现有 Maven 项目） -> Next（下一步） -> Browse the Folder（浏览文件夹） aop-before-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

<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-before-advice-example</artifactId>
<version>0.0.1-SNAPSHOT</version>  
<packaging>jar</packaging>	
<name>aop-before-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>

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

它支持处理使用 AspectJ 的 @Aspect 注解标记的组件。它与 @Configuration 注解一起使用。我们可以使用 proxyTargetClass 属性来控制代理的类型。它的默认值是 false。

AopBeforeAdviceExampleApplication.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 AopBeforeAdviceExampleApplication 
{
public static void main(String[] args) {
SpringApplication.run(AopBeforeAdviceExampleApplication.class, args);
}
}

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

步骤 11： 在包 com.javatpoint.model. 下创建一个模型类。我们创建了一个名为 Employee 的类。在类中，定义以下内容

定义三个类型为 String 的变量 empId、firstName 和 secondName。
生成 Getters 和 Setters（Getter 和 Setter 方法）。
创建 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;
}
}

步骤 12： 创建一个名为 com.javatpoint.controller. 的包。

步骤 13： 在包 com.javatpoint.controller. 下创建一个控制器类。我们创建了一个名为 EmployeeController 的类。

在控制器类中，我们定义了两个映射，一个用于添加员工，另一个用于删除员工。

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

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

步骤 15： 在包 com.javatpoint.service. 下创建一个服务类。我们创建了一个名为 EmployeeService 的类。

在服务类中，我们定义了两个方法 createEmployee 和 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) 
{
}
}

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

步骤 17： 在包 com.javatpoint.aspect. 下创建一个切面类。我们创建了一个名为 EmployeeServiceAspect 的类。

在切面类中，我们定义了前置通知逻辑。

EmployeeServiceAspect.java

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

在上面的类中