什么是 AOP ？

AOP：

• Aspect Oriented Programming（面向切面编程、面向方面编程），其实就是面向特定方法编程。

实现：

• 动态代理是面向切面编程最主流的实现。而SpringAOP是Spring框架的高级技术，旨在管理bean对象的过程中，主要通过底层的动态代理机制，对特定的方法进行编程。

AOP 核心概念

• 连接点: JoinPoint, 可以被AOP控制的方法（暗含方法执行时的相关信息）
• 通知: Advice, 指哪些重复的逻辑，也就是共性功能（最终体现为一个方法）
• 切入点: PointCut, 匹配连接点的条件，通知仅会在切入点方法执行时被应用
• 切面: Aspect, 描述通知与切入点的对应关系（通知+切入点）
• 目标对象: Target, 通知所应用的对象

场景说明

例如现有一个场景：定位执行耗时较长的业务方法，统计各个业务层方法的执行耗时

@Component
@Aspect // 切面类
@Slf4j
public class TimeAspect {
   
    @Around ("execution (* com.itheima.service.impl.DeptServiceImpl.list ())")  // 切面表达式
    public Object recordTime (ProceedingJoinPoint joinPoint) throws Throwable {
    
    long begin = System.currentTimeMillis ();
        // 调用原始操作
    Object result = joinPoint.proceed (); 
    long end = System.currentTimeMillis ();
    log.info("执行耗时 : {} ms", (end-begin));
    return result;
    }
}

// 目标对象
@Service
public class DeptServiceImpl implements DeptService {
   
    @Autowired
    private DeptMapper deptMapper;

    // region-begin 连接点 
    @Override
    public List<Dept> list() {
   
        List<Dept> deptList = deptMapper.list(); // 切入点
        return deptList;
    }

    @Override
    public void delete(Integer id) {
   
        deptMapper.delete(id);
    }

    @Override
    public void save(Dept dept) {
   
        dept.setCreateTime(LocalDateTime.now());
        dept.setUpdateTime(LocalDateTime.now());
        deptMapper.save(dept);
    }
    // region-end 连接点 
}

对于aop的五大核心概念，我们可以使用更加通俗易懂的类比来说明：

可以用 "学校检查卫生" 来类比：

• 连接点：学校里所有可能被检查的班级（每个班级都是一个潜在的检查点）
• 通知：检查卫生的具体操作流程（比如看地面是否干净、桌椅是否整齐，这是一套固定重复的动作）
• 切入点：筛选要检查的班级的条件（比如 "只查一年级的班级" 或 "只查偶数号的班级"）
• 切面：检查计划（把 "检查流程" 和 "筛选条件" 结合起来，比如 "用标准流程检查所有一年级班级"）
• 目标对象：最终被检查的那些班级（符合筛选条件，实际接受检查的对象）

简单来说就是：学校（AOP）要检查卫生（通知），所有的班级都可能被抽查到（连接点），但是只会查到一年级的（切入点），"用标准流程查一年级班级" 这个整体安排就是切面，而被查到的那些一年级班级就是目标对象。

特别注意：连接点

• 在Spring中用JoinPoint抽象了连接点，用它可以获得方法执行时的相关信息，如目标类名、方法名、方法参数等。

• • 对于 @Around 通知，获取连接点信息只能使用 ProceedingJoinPoint
  • 对于其他四种通知，获取连接点信息只能使用 JoinPoint，它是 ProceedingJoinPoint 的父类型

通知类型

通知类型

1. **@Around**：环绕通知，此注解标注的通知方法在目标方法前、后都被执行（常用）
2. @Before：前置通知，此注解标注的通知方法在目标方法前被执行
3. @After：后置通知，此注解标注的通知方法在目标方法后被执行，无论是否有异常都会执行
4. @AfterReturning：返回后通知，此注解标注的通知方法在目标方法后被执行，有异常不会执行
5. @AfterThrowing：异常后通知，此注解标注的通知方法发生异常后执行

注意事项

• @Around环绕通知需要自己调用 ProceedingJoinPoint.proceed() 来让原始方法执行，其他通知不需要考虑目标方法执行
• @Around环绕通知方法的返回值，必须指定为Object，来接收原始方法的返回值。

通知顺序

当有多个切面的切入点都匹配到了目标方法，目标方法运行时，多个通知方法都会被执行。

执行顺序

1. 不同切面类中，默认按照切面类的类名字母排序：

• • 目标方法前的通知方法：字母排名靠前的先执行
  • 目标方法后的通知方法：字母排名靠前的后执行

1. 用 @Order(数字) 加在切面类上来控制顺序

• • 目标方法前的通知方法：数字小的先执行
  • 目标方法后的通知方法：数字小的后执行

@PointCut

该注解的作用是将公共的切点表达式抽取出来，需要用到时引用该切点表达式即可。

@Pointcut("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))")
public void pt(){
   }

@Around("pt()")
public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable {
   
    // 方法体内容
}

切入点表达式

execution

execution 主要根据方法的返回值、包名、类名、方法名、方法参数等信息来匹配，语法为：

execution(访问修饰符? 返回值 包名.类名.?方法名(方法参数) throws 异常?)

• 可以使用通配符描述切入点

• • *：单个独立的任意符号，可以通配任意返回值、包名、类名、方法名、任意类型的一个参数，也可以通配包、类、方法名的一部分
    execution(* com.**.service.**.update*(*))
  • ..：多个连续的任意符号，可以通配任意层级的包，或任意类型、任意个数的参数
    execution(* com.itheima..DeptService.*(..))

切入点表达式-@annotation

• @annotation切入点表达式，用于匹配标识有特定注解的方法。
  @annotation(com.itheima.anno.Log)

@Before("@annotation(com.itheima.anno.Log)")
public void before(){
   
    log.info("before ....");
}

Spring 实战代码演示

依赖导入

引入aop依赖

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

日志响应拦截

主要作用：对controller上的

@Around("execution(* com.lantzuc.lanucbackend.controller.*.*(..))")
public Object doInterceptor(ProceedingJoinPoint joinPoint) throws Throwable {
   
    // 开始计时
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();

    // 获取请求路径
    RequestAttributes requestAttributes = RequestContextHolder.currentRequestAttributes();
    HttpServletRequest servletRequest = ((ServletRequestAttributes) requestAttributes).getRequest();

    // 生成唯一请求id
    String requestId = UUID.randomUUID().toString();
    String url = servletRequest.getRequestURI();

    // 获取请求参数
    Object[] args = joinPoint.getArgs();
    String reqParams = "[" + StringUtils.join(args, ", ") + "]";

    // 输出请求日志
    log.info("request start，id: {}, path: {}, ip: {}, params: {}", requestId, url,
             servletRequest.getRemoteHost(), reqParams);

    // 执行原方法
    Object result = joinPoint.proceed();

    // 输出原日志
    stopWatch.stop();
    long totalTimeMillis = stopWatch.getTotalTimeMillis();
    log.info("request end, id: {}, cost: {}ms", requestId, totalTimeMillis);

    return result;
}

结果显示

2025-10-15 17:13:48.649  INFO 23396 --- [nio-8080-exec-5] c.l.lanucbackend.aop.LogInterceptor      : request start，id: ad4061ee-d5ed-47f3-bf2e-e0567867fabc, path: /api/user/login, ip: 0:0:0:0:0:0:0:1, params: [UseLoginRequest(userAccount=Lantz, userPassword=12345678), org.apache.catalina.connector.RequestFacade@6ce7aed7]

2025-10-15 17:13:49.265  INFO 23396 --- [nio-8080-exec-5] c.l.lanucbackend.aop.LogInterceptor      : request end, id: ad4061ee-d5ed-47f3-bf2e-e0567867fabc, cost: 623ms

相比原来没有添加日志拦截的，我们可以更加清晰地看到对某一路径发送请求的状态，比如请求路径，请求参数，IP 地址等等信息，而且我们还可以获悉到某一请求的执行时间是多少，可以在后续有针对的目的优化

权限响应拦截

首先要创建一个注解：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface AuthCheck {
   
    /**
     * 必须有某一个角色（默认无）
     * @return
     */
    String mustRole() default "";
}

然后再编写权限校验拦截代码：

@Around("@annotation(authCheck)")
public Object doInterceptor(ProceedingJoinPoint joinPoint, AuthCheck authCheck) throws Throwable {
   

    String mustRole = authCheck.mustRole();
    RequestAttributes requestAttributes = RequestContextHolder.currentRequestAttributes();
    HttpServletRequest httpServletRequest = ((ServletRequestAttributes) requestAttributes).getRequest();
    // 当前登录用户
    User loginUer = userService.getLoginUer(httpServletRequest);
    UserRoleEnum mustRoleEnum = UserRoleEnum.getEnumByValue(mustRole);
    // 不需要权限，放行
    if (mustRoleEnum == null) {
   
        return joinPoint.proceed();
    }

    // 必须有该权限才放行
    UserRoleEnum userRoleEnum = UserRoleEnum.getEnumByValue(loginUer.getUserRole());
    if (userRoleEnum == null) {
   
        throw new BusinessException(ErrorCode.NO_AUTH);
    }
    // 如果被封号，直接拒绝
    if (UserRoleEnum.BAN.equals(userRoleEnum)) {
   
        throw new BusinessException(ErrorCode.NO_AUTH);
    }
    // 必需有管理员权限
    if (UserRoleEnum.ADMIN.equals(mustRoleEnum)) {
   
        // 用户没有管理员权限，拒绝
        if (!UserRoleEnum.ADMIN.equals(userRoleEnum)) {
   
            throw new BusinessException(ErrorCode.NO_AUTH);
        }
    }

    // 通过管理权限，放行
    return joinPoint.proceed();
}

在controller中使用：

@GetMapping("/search")
@AuthCheck(mustRole = ADMIN_ROLE) // 需要管理员权限
public List<User> searchUser(String userName, HttpServletRequest request){
   
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();
    if (StringUtils.isNotBlank(userName)) {
   
        queryWrapper.like("userName", userName);
    }
    List<User> userList = userService.list(queryWrapper);
    return userList.stream().map(user -> userService.getSafetyUser(user)).collect(Collectors.toList());
}

测试结果：

如果登录用户为管理员则正常通过，如果不是，则会报错：

Postman Body显示：

{
   
  "code": 40101,
  "data": null,
  "message": "无权限",
  "description": ""
}

记得如果使用了jwt鉴权，在Postman中测试的时候记得选择Bearer Token然后粘贴进去登录时候产生的Token