**摘要:**本文系统梳理了 Spring AOP 的核心知识体系,从 AOP 的编程思想与快速入门入手,讲解自定义注解、切面类定义和切入点配置的完整使用流程;随后深入 AOP 核心概念,说明连接点、切入点、通知以及底层动态代理机制;在进阶部分介绍通知类型、通知顺序、切入点表达式和连接点信息获取;最后通过操作日志记录案例,结合 ThreadLocal 与环绕通知,演示 AOP 在实际项目中的落地方式。
目录
一、AOP基础
1.AOP快速入门
AOP编程是什么?是用来解决什么问题的?
AOP编程,就是面对特定方法编程,其实它是一种编程思想,一种化繁为简的思想,是对一些通用的功能和重复性的逻辑,我们统一处理,这种思想就是AOP编程。举个例子,比如我们每个人上厕所都要带纸,是不是很麻烦,我们就可以在厕所里放一卷纸,大家就不用每个人都带纸了;再比如一个班级是不是每个人都要喝水,每个人都要买水喝,那我们可以直接在教室放个饮水机,大家就不用都去买水了,这就是AOP编程;
AOP编程有什么用呢?四个优势,目的就是为了优化
AOP编程怎么用呢?
一、引入依赖后,
二、自定义一个注解 ,我们自定义一个注解,是用来标识某个方法需要执行通知;
声明这个注解在哪用?比如在方法上用,@Target(ElementType.METHOD);什么时候生效?@Retention(RetentionPolicy.RUNTIME),是项目运行的时候生效;什么时候用这个注解?比如数据库执行新增修改操作时;
三、然后就可以一个定义AOP类 (用到@Aspect注解), 在这个AOP类里就可以对那些添加自定义注解的特定方法进行统一处理,执行通知(指定切入点的范围和标识的自定义注解、指定通知类型;我们指定切入点后,就可以将对应的方法拦截,执行通知后,再将值返回回去);
怎么定义一个AOP类
我们先声明三个注解,@Aspect、@Slf4j、@Conponent,作用分别是声明该类是一个切面类,使用日志技术、将该类交给IOC容器管理;然后我们就可以用@PointCut注解指定切入点的范围和标识在需要执行通知的方法上的自定义注解;最后再指定通知的类型,声明是在切入点方法之前还是之后执行通知,然后在通知类型下面编写通知方法,并将切入点方法作为一个JointPoint对象传入;最后再在切入点方法上标注自定义注解,并声明值;
这里是一个切面类例子
java
package com.sky.aspect;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import org.aspectj.lang.annotation.Aspect;
/**
自定义切面,实现自动填充公共字段逻辑
*/
@Aspect
@Slf4j
@Component
public class AutoFillAspect {
@Pointcut("execution(* com.sky.mapper..(..)) && @annotation(com.sky.annotation.AutoFill)")
public void autoFillPointCut() {}//定义一个切入点
@Before("autoFillPointCut()")//指定在切入点方法(需要执行通知的方法)执行之前执行
public void autoFill(JoinPoint joinPoint) {
log.info("开始执行填充公共字段");
}
}




2.AOP核心概念
记住三个即可,连接点就是能被AOP控制的方法;切入点就是需要执行通知的方法,用@PointCut注解来声明哪些类的哪些方法需要执行通知;通知就是哪些重复的逻辑,增强的功能;
记住:AOP的底层其实是动态代理技术 ,AOP会给我们生成一个代理对象,交给IOC容器管理,当我们调用方法时,调用的是增强功能后的代理对象,而不是原始的目标对象(方法);

二、AOP进阶
(1).通知类型
经常用到的是@Around环绕通知,需要用ProceedingJoinPoint pjp对象调用proceed()方法来引用我们的目标方法




(2).通知顺序
默认我们按照切面类的类名字母排序,也可以通过@Order()注解加在切面类来控制顺序

(3).切入点表达式
1.什么是切入点表达式?
就是用来描述项目中哪些方法需要添加通知的表达式
2.怎么用?有两种切入点表达式,建议使用execution(),如果描述目标方法的签名不太方便的话,就用@annotation()注解

有三个可以省略,但是包名类名强烈不建议删除,会大面积查找会降低性能,也不建议将连续任意符使用在包名类名。

使用步骤:先定义一个注解,再在切面类使用@annotation注解用于匹配使用自定义注解的方法需要通知,最后就是在对应的方法上添加定义的注解
怎么定义注解?知道两个注解@Target(ElementType.METHOD)//声明这个注解在哪里生效
@Retention(RetentionPolicy.RUNTIME)//声明这个注解什么时候生效

代码示例
java
@Slf4j
@Component
@Aspect
public class MyAspect5 {
//目标:将delete和list方法使用通知
//@Before("execution(public void com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer ))")
// @Before("execution( void delete(java.lang.Integer ))")//有三个可以省略,访问修饰符、包名类名、异常,但是包名类名强烈不建议省略
////@Before("execution(public void com.itheima.service.impl.DeptServiceImpl.delete()) ||
// execution(public void com.itheima.service.impl.DeptServiceImpl.list())")
@Before("@annotation(com.itheima.anno.LogOperation)")
public void before(){
log.info("begore....");
}
}
java
//定义注解
package com.itheima.anno;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Target(ElementType.METHOD)//声明这个注解在哪里生效
@Retention(RetentionPolicy.RUNTIME)//声明这个注解什么时候生效
public @interface LogOperation {
}
java
//在对应方法上加上注解
public class DeptServiceImpl implements DeptService {
@Autowired
private DeptMapper deptMapper;
@Override
@LogOperation
public List<Dept> list() {
List<Dept> deptList = deptMapper.list();
return deptList;
}
@Override
@LogOperation
public void delete(Integer id) {
deptMapper.delete(id);
}

(4).连接点
Spring中会将执行通知的方法的相关信息封装到JoinPoint连接点对象中,当我们需要获取方法的相关信息时,就可以调用连接点对象对应的方法即可。注意对于@Around环绕通知获取信息只能用ProceedingJoinPoint调用,其余四种用JoinPoint调用

java
public class MyAspect6 {
//前置通知
@Before("execution(* com.itheima.service.impl.*.*(..))")
public void before(JoinPoint joinPoint){
//1.先要获取目标对象
Object object = joinPoint.getTarget();
log.info("获取目标对象: {}",object);
//2.获取类名
String className = joinPoint.getTarget().getClass().getName();
log.info("获取类名:{}",className);
//3.获取方法
String methodName = joinPoint.getSignature().getName();
log.info("获取方法:{}",methodName);
//4.获取方法参数
Object[] args = joinPoint.getArgs();
log.info("获取方法参数:{}", Arrays.toString(args));
}
@Around("execution(* com.itheima.service.impl.*.*(..))")
public void around(ProceedingJoinPoint pjp){
//都是一样的
log.info("MyAspect3 -> after ...");
}
}
三、AOP案例





ThreadLocal是什么?是线程的局部变量,会为每一个线程单独提供一个存储空间,用来数据共享,可以使用三个方法,set,get,clear
我们可以在解析jwt令牌时获得登录员工的id,存储在它所在的线程变量中,在AOP中调用工具类获取id,最后再删除。
java
@Slf4j
@Aspect
@Component
public class OperateLogAspect {
@Autowired
private OperateLogMapper operateLogMapper;
@Autowired
private ObjectMapper objectMapper; // Spring Boot 默认提供的 JSON 序列化工具
/**
* 切入点:拦截标有 @Log 注解的方法
*/
@Around("@annotation(com.itheima.anno.Log)")
public Object recordLog(ProceedingJoinPoint joinPoint) throws Throwable {
// 1. 记录方法开始时间
long startTime = System.currentTimeMillis();
// 2. 获取操作人ID (从 UserContext 中获取当前登录用户ID)
Integer operateEmpId = null;
try {
operateEmpId = UserContext.getCurrentUserId();
} catch (Exception e) {
log.warn("获取当前操作人ID失败,可能未登录或Token过期");
}
// 3. 获取操作时间
LocalDateTime operateTime = LocalDateTime.now();
// 4. 获取目标类的全类名
String className = joinPoint.getSignature().getDeclaringTypeName();
// 5. 获取目标方法名
String methodName = joinPoint.getSignature().getName();
// 6. 获取方法运行时参数
Object[] args = joinPoint.getArgs();
String methodParams = serializeParams(args);
// 7. 执行目标方法并获取返回值
Object result = null;
try {
result = joinPoint.proceed(); // 执行原方法
} catch (Throwable throwable) {
// 如果目标方法抛出异常,记录异常信息作为返回值,并计算耗时
String errorValue = "执行异常: " + throwable.getMessage();
long costTime = System.currentTimeMillis() - startTime;
saveLog(operateEmpId, operateTime, className, methodName, methodParams, truncate(errorValue), costTime);
// 重新抛出异常,确保 Controller 的全局异常处理器能正常捕获
throw throwable;
}
// 8. 记录结束时间,计算耗时
long costTime = System.currentTimeMillis() - startTime;
// 9. 获取返回值
String returnValue = serializeObject(result);
// 10. 异步/同步保存日志
saveLog(operateEmpId, operateTime, className, methodName, methodParams, returnValue, costTime);
// 11. 返回原方法的返回值
return result;
}
/**
* 封装保存日志逻辑,使用 try-catch 包裹,防止日志保存失败导致主业务回滚或报错
*/
private void saveLog(Integer operateEmpId, LocalDateTime operateTime, String className,
String methodName, String methodParams, String returnValue, Long costTime) {
try {
OperateLog operateLog = new OperateLog();
operateLog.setOperateEmpId(operateEmpId);
operateLog.setOperateTime(operateTime);
operateLog.setClassName(className);
operateLog.setMethodName(methodName);
operateLog.setMethodParams(methodParams);
operateLog.setReturnValue(returnValue);
operateLog.setCostTime(costTime);
operateLogMapper.insert(operateLog);
} catch (Exception e) {
log.error("保存操作日志失败", e);
}
}
/**
* 序列化方法参数(过滤掉 Request/Response 等无法直接序列化的对象)
*/
private String serializeParams(Object[] args) {
if (args == null || args.length == 0) return "[]";
try {
Object[] logArgs = new Object[args.length];
for (int i = 0; i < args.length; i++) {
// 过滤掉 Servlet 相关的复杂对象,防止 Jackson 序列化报错
if (args[i] instanceof HttpServletRequest || args[i] instanceof HttpServletResponse) {
logArgs[i] = args[i].getClass().getSimpleName();
} else {
logArgs[i] = args[i];
}
}
return truncate(objectMapper.writeValueAsString(logArgs));
} catch (Exception e) {
log.error("方法参数序列化失败", e);
return "参数序列化失败";
}
}
/**
* 序列化普通对象
*/
private String serializeObject(Object obj) {
if (obj == null) return "";
try {
return truncate(objectMapper.writeValueAsString(obj));
} catch (Exception e) {
log.error("返回值序列化失败", e);
return "返回值序列化失败";
}
}
/**
* 字符串截断,防止超过数据库 varchar(2000) 的长度限制导致 SQL 异常
*/
private String truncate(String str) {
if (str != null && str.length() > 2000) {
return str.substring(0, 2000);
}
return str;
}
}
java
package com.itheima.utils;
/**
* 用户上下文工具类
* 使用 ThreadLocal 存储当前登录用户的信息
*/
//ThreadLocal是什么?是线程的局部变量,会为每一个线程单独提供一个存储空间,用来数据共享,可以使用三个方法,set,get,clear
//我们可以在解析jwt令牌时获得登录员工的id,存储在它所在的线程变量中,在AOP中调用工具类获取id,最后再删除。
public class UserContext {
private static final ThreadLocal<Integer> USER_ID_HOLDER = new ThreadLocal<>();
/**
* 设置当前用户ID
*
* @param userId 用户ID
*/
public static void setCurrentUserId(Integer userId) {
USER_ID_HOLDER.set(userId);
}
/**
* 获取当前用户ID
*
* @return 用户ID
*/
public static Integer getCurrentUserId() {
return USER_ID_HOLDER.get();
}
/**
* 清除当前用户ID(防止内存泄漏)
*/
public static void clear() {
USER_ID_HOLDER.remove();
}
}