Spring AOP

马尔代夫哈哈哈2026-02-20 9:56

1.什么是Spring AOP?

AOP =>面向切片编程思想,是一种对一类问题集中处理的思想,比如拦截器,统一返回结果管理,统一异常处理,登录校验......如果使用OOP(面向结果编程)会让相同的代码重复多次出现,业务方法中混杂着非核心的逻辑。

Spring AOP就是为了解决这些问题存在,是AOP思想的其中一种实现方式

2.SpringAOP优点与上手

优点:

  • 不影响原有代码,解耦
  • 便于维护功能
  • 提高开发效率
  • 减少重复代码

快速上手SpringAOP

编写一个使用SpringAOP计算所有方法的运行时长的例子

1.在pom.xml文件引入依赖

复制代码 
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

注意:SpringBoot使用版本号为4.x.x, AOP依赖需要添加版本号

2.编写AOP程序

复制代码 
package com.example.springbookdemo.aspect;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Slf4j
@Aspect
@Component
public class TimeRecordAspect {


 @Around("execution(* com.example.springbookdemo.controller.*.*(..))")//该注解()中是要执行方法的路径

    //参数部分的ProceedingJoinPoint joinPoint即要执行的方法
    //不确定执行方法的返回类型,因此在这里设返回类型为Object
    public Object timeRecord(ProceedingJoinPoint joinPoint) throws Throwable {

        long start=System.currentTimeMillis();//记录方法执行前时间

        //执行方法
        Object proceed = joinPoint.proceed();//proceed()方法返回类型固定为Object

        long end=System.currentTimeMillis();//记录方法执行完的时间

        log.info(joinPoint.getSignature()+"方法耗时:"+(end-start)+"ms");//getSignature()用于获取执行方法名

        return proceed;
    }
}

注解解释:

  • Aspect=>标识切面类
  • Component=>将该类交给Spring容器管理,使其能自动扫描并注入
  • Around=>指明对哪些方法生效
  • Slf4j=>自动生成日志对象,可调用log.info()等方法打印日志

Spring AOP 的核心术语

理解这些术语是掌握 AOP 的关键：

  1. Aspect（切面）：

    • 是什么 ：横切关注点的模块化。它是一个类，里面包含了需要被织入到业务代码中的各种通知（Advice）。包含了切点,通知,连接点

  2. Join Point（连接点）：

    • 是什么 ：程序执行过程中可以插入切面的点。在 Spring AOP 中，连接点总是代表执行的方法。

  3. Pointcut（切点）：

    • 是什么 ：一个表达式，用于定义在哪些连接点上应用通知。它告诉 AOP："在哪里 " 执行切面代码。例如，你可以定义一个切点，匹配所有 com.example.service包下以 delete开头的方法。

  4. Advice（通知）：

    • 是什么 ：切面在特定连接点上执行的动作。指具体要做的⼯作, 指哪些重复的逻辑,它回答了 "什么时候 " 和 "做什么" 的问题。

    • 类型：

      • @Before ：在目标方法执行之前执行。

      • @After ：在目标方法执行之后执行（无论是否成功完成）。

      • @AfterReturning ：在目标方法成功执行并返回结果后执行。

      • @AfterThrowing ：在目标方法抛出异常后执行。

      • @Around ：最强大的通知，它包围了连接点。可以在方法调用前后执行自定义行为，并决定是否继续执行方法、返回值或抛出异常。

用上面的例子来区分

3.通知类型注解

写两个方法,用于测试

复制代码 
package com.example.springaopdemo.controller;


@Slf4j
@RestController
@RequestMapping("/test")
public class TestController {
    @RequestMapping("/t1")
    public String t1(){
        log.info("执行t1");
        return "t1";
    }

    @RequestMapping("/t2")
    public boolean t2(){
        log.info("执行t2");

        return true;
    }
}

编写AOP

复制代码 
package com.example.springaopdemo.aspect;

@Aspect
@Component
@Slf4j
public class TestAspect {
    
    //抽取切点
    @Pointcut("execution(* com.example.springaopdemo.controller.*.*(..))")
    public void pt(){}
    //前置通知
    @Before("pt()")
    public void doBefore() {
        log.info("执行doBefore方法");
    }
    //后置通知
    @After("pt()")
    public void doAfter() {
        log.info("执行 After 方法");
    }

    //返回后通知
    @AfterReturning("pt()")
    public void doAfterReturning() {
        log.info("执行 AfterReturning 方法");
    }

    //抛出异常后通知
    @AfterThrowing("pt()")
    public void doAfterThrowing() {
        log.info("执行 doAfterThrowing 方法");
    }

    //添加环绕通知
    @Around("pt()")
    public Object doAround(ProceedingJoinPoint joinPoint)  {
        log.info("Around 方法开始执行");
        Object result = null;
        try {
            result = joinPoint.proceed();
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
        log.info("Around 方法结束执行");
        return result;
    }
}

结果展示:

访问t1=>即接口正常访问

访问t2=>即接口发生异常且不捕获

访问t2=>即接口发生异常且捕获不throw

4.@PointCut+@Order

@PointCut

在上面中存在大量的同样的切点表达式,使用该注解能够定义可重用的切点表达式，避免在多个通知中重复编写相同的表达式。

通过@PointCut注解定义一个公共切点方法，该方法本身没有实现，仅作为切点表达式的载体：

java 复制代码 
@PointCut("execution(* com.example.service.*.*(..))")
public void serviceLayer() {}

重用切点表达式

定义好的切点可以在其他通知中通过方法名引用，避免重复编写表达式：

java 复制代码 
@Before("serviceLayer()")
public void beforeService() {
    // 前置通知逻辑
}

@After("serviceLayer()")
public void afterService() {
    // 后置通知逻辑
}

@Order用于设置优先级,控制多个切面的执行顺序,@Order(),()中的数字越小,优先级越高

复制代码 
@Component
@Aspect
@Slf4j
public class TestAspect2 {
    @Before("com.example.springaopdemo.aspect.TestAspect.pt()")
    public void doBefore() {
        log.info("执行doBefore2方法");
    }
}
复制代码 
@Component
@Aspect
@Slf4j
public class TestAspect3 {
    @Before("com.example.springaopdemo.aspect.TestAspect.pt()")
    public void doBefore() {
        log.info("执行doBefore3方法");
    }
}
复制代码 
@Aspect
@Component
@Slf4j
public class TestAspect {

    //抽取切点
    @Pointcut("execution(* com.example.springaopdemo.controller.*.*(..))")
    public void pt(){}
    //前置通知
    @Before("pt()")
    public void doBefore() {
        log.info("执行doBefore方法");
    }
}

执行结果:也就是切面默认执行顺序(按照类名排序)

通过添加@Order注解可以人为控制切面执行顺序

@Order(3)

public class TestAspect(){}

@Order(2)

public class TestAspect2(){}

@Order(1)

public class TestAspect3(){}

添加之后执行结果:

5.切点表达式

有两种

第一种execution(<访问修饰符><返回类型><包名.类名.方法名(方法参数)><异常>)

其中访问修饰符和异常可以省略," * "匹配任意字符," .. "匹配多个连续符号

第二种@annotation=>自定义注解

相比较第一种有一定规律来说,想要执行的方法没有规律可以使用这种

复制代码 
//自定义注解
@Retention(RetentionPolicy.RUNTIME)//设置生命周期
@Target({ElementType.METHOD})//设置注解使用位置
public @interface TimeRecord {
}

//注解通过切面实现

复制代码 
@Aspect
@Component
@Slf4j
public class TimeRecordAspect {
    @Around("@annotation(com.example.springaopdemo.aspect.TimeRecord)")
    public  Object timeRecord(ProceedingJoinPoint joinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long end = System.currentTimeMillis();
        log.info(joinPoint.getSignature() + "耗时" + (end - start) + "ms");
        return result;
    }
}

注解完成自定义之后,只要在对应方法添加该注解即可实现计算方法运行时间的功能

6.代理模式

它为另一个对象提供一个替身或占位符，以控制对这个对象的访问。其核心目的是：在不修改原始对象（目标对象）代码的前提下，通过代理对象来增强或控制对目标对象的访问。

一个标准的代理模式通常包含三个角色：

  • 抽象主题 (Subject)： 定义了目标对象和代理对象的公共接口。这样在任何使用目标对象的地方都可以透明地使用代理对象。

  • 真实主题 (Real Subject)： 即"目标对象"，是业务逻辑的真正执行者。

  • 代理 (Proxy)： 持有对真实主题的引用，客户端直接与代理交互。代理可以在调用真实主题的前后，添加额外的处理逻辑。

分为静态代理和动态代理,区别在于代理对象的class文件生成的时机

静态代理:程序运行之前就创建好了代理对象

动态代理:程序运行时动态生成代理对象

其中动态代理有两种

  • jdk动态代理=>要求目标类必须实现至少一个接口。代理对象会实现与目标类相同的接口。
  • cGlib字节码增强=>当目标类没有实现接口 时，Spring会使用CGLIB。它通过生成目标类的子类 来创建代理，因此不能代理 final类或方法。

7.Spring AOP原理

Spring AOP是通过动态代理将横切关注点(如日志,事务)模块化,并织入到目标方法的编程范式

它的实现同时使用了jdk和CGlib

工作流程

  1. Spring容器启动时,会自动扫描被@Aspect注解的类
  2. 通过扫描切点表达式,找到所有匹配的Bean（即目标对象）
  3. 通过ProxyFactory创建目标对象对应的代理对象(jdk/cglib)并将通知封装成拦截器链
  4. 在调用代理对象方法时,拦截器链被触发,按顺序执行通知逻辑,最终调用目标方法

此外ProxyFactory有个很重要的属性proxyTargetClass,

SpringBoot默认为true,Spring默认为false

可以通过在application.properties中进行配置:spring.aop.proxy-target-class=true/false

相关推荐
only-qi1 小时前
Java 包装器模式：告别“类爆炸“
java·开发语言
Yweir1 小时前
Java 接口测试框架 Restassured
java·开发语言
wangbing11251 小时前
开发指南141-类和字节数组转换
java·服务器·前端
～央千澈～1 小时前
抖音弹幕游戏开发之第15集：添加配置文件·优雅草云桧·卓伊凡
java·前端·python
肖。35487870941 小时前
html中onclick误区，后续变量会更改怎么办？
android·java·javascript·css·html
暴力袋鼠哥1 小时前
SpringBoot+Vue实战：多模态疾病初筛与护理建议系统（含泳道图+时序图+完整后端代码）
vue.js·spring boot·后端
码云数智-园园1 小时前
Java Swing 界面美化与 JPanel 优化完全指南：从复古到现代的视觉革命
java·开发语言
舟舟亢亢1 小时前
Java并发编程（下）
java·开发语言
我是大猴子1 小时前
常见八股caffine
java·开发语言·mybatis
热门推荐
01从零搭建一个 PHP 登录注册系统（含完整源码）02GitHub 镜像站点03AI Agent 平台横评：ZeroClaw vs OpenClaw vs Nanobot04使用 1panel面板 部署 php网站05openClaw安装飞书插件｜核心踩坑：spawn EINVAL 错误终极解决指南06MIUI显示/隐藏5G开关的方法，信号弱时开启手机Wifi通话方法07配置 OpenClaw 使用 Ollama 本地模型08Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services09全面体验 Grok API 中转站（2025 · Grok 4 系列最新版）10让你的代码更整洁：10 个必知的 Kotlin 扩展函数