14. Spring AOP 的组成和实现

最新推荐文章于 2024-03-11 03:07:28 发布

小鱼的学习笔记

最新推荐文章于 2024-03-11 03:07:28 发布

阅读量646

点赞数

分类专栏： java ee 文章标签： spring java 后端

本文链接：https://blog.csdn.net/qq_58969626/article/details/132004052

版权

java ee 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

本文介绍了SpringAOP的基本概念，包括切面、连接点、切点和通知，并通过示例详细阐述了如何在实际项目中实现AOP，如统计方法执行时间。此外，还探讨了切点表达式的使用，以及不同类型的通知（前置、后置、返回后、异常后、环绕）在代码中的应用。

摘要由CSDN通过智能技术生成

5. 练习：使用 AOP 统计 UserController 每个方法的执行时间

1. Spring AOP 简介

AOP 是一种思想，Spring AOP 是这种思想的具体实现。

OOP：面向对象编程

AOP：面向切面编程

AOP 面向切面编程，就是对某一类事情的集中处理。

比如，我们需要在 CSDN 上进行编辑博客、发布博客、删除博客等操作，这些功能都是需要进行权限校验的，判断是否登录。

开发三阶段

对于公共方法的处理：

（初级阶段）每个方法都去实现
（中级阶段）把同一类功能抽取成公共方法
（高级阶段）采用 AOP 的方式，对代码无侵入实现

除了统⼀的用户登录判断之外，AOP 还可以实现：

统⼀日志记录
统一方法执行时间统计
统一的返回格式设置
统一的异常处理
事务的开启和提交等

统一方法执行时间统计

项目监控：监控项目请求流量、监控接口的响应时间甚至每个方法的响应时间

统一的返回格式设置

httpstatus: HTTP状态码

code: 业务状态码（后端响应成功不代表业务办理成功）

msg: 业务处理失败返回的信息

data:

也就是说使用 AOP 可以扩充多个对象的某个能力，所以 AOP 可以说是 OOP（Object Oriented Programming，面向对象编程）的补充和完善。

2. AOP 的组成

2.1 切面（Aspect）

切面（Aspect）由切点（Pointcut）和通知（Advice）组成，它既包含了横切逻辑的定义，也包括了连接点的定义。

切面是包含了：通知、切点和切面的类，相当于 AOP 实现的某个功能的集合。

2.2 连接点（Join Point）

应⽤执行过程中能够插入切面的⼀个点，这个点可以是方法调用时、抛出异常时，甚至修改字段时。切面代码可以利用这些点插入到应用的正常流程之中，并添加新的行为。

连接点相当于需要被增强的某个 AOP 功能的所有方法。

2.3 切点（Pointcut）

Pointcut 是匹配 Join Point 的谓词。 Pointcut 的作用就是提供⼀组规则（使用 AspectJ pointcut expression language 来描述）来匹配 Join Point，给满足规则的 Join Point 添加 Advice。

切点相当于保存了众多连接点的一个集合（如果把切点看成一个表，而连接点就是表中⼀条⼀条的数据）。

2.4 通知（Advice）

切面也是有目标的 ——它必须完成的工作。在 AOP 术语中，切面的工作被称之为通知。

Spring 切面类中，可以在方法上使用以下注解，会设置方法为通知方法，在满足条件后会通知本方法进行调用：

前置通知使用 @Before：通知方法会在目标方法调用之前执行。
后置通知使用 @After：通知方法会在目标方法返回或者抛出异常后调用。
返回之后通知使用 @AfterReturning：通知方法会在目标方法返回后调用。
抛异常后通知使用 @AfterThrowing：通知方法会在目标方法抛出异常后调用。
环绕通知使用户 @Around：通知包裹了被通知的方法，在被通知的方法通知之前和调用之后执行自定义的行为。

切点相当于要增强的方法。

AOP 整个组成部分的概念如下图所示，以多个页面都要访问用户登录权限为例：

既然说 AOP 是对一类事情的集中处理，那么我们就需要明确两点：

一类事情：处理对象的一个范围
集中处理：处理的内容是什么

我们通过生活中的一个例子来看一下：

比如，我们乘坐高铁需要安检

那么，我们需要处理的内容就是安检；处理的范围就是需要乘坐高铁的人。

此处乘坐高铁需要安检这件事情就是切面，处理的内容安检就是通知，处理的范围乘坐高铁的人就是切点，具体有哪些人就是连接点。

切点是一个规则，事情的处理，最终作用在方法上。

3. Spring AOP的实现

3.1 新建项目

3.2 添加 AOP 框架支持

在 pom.xml 中添加如下配置：

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

3.3 定义切面、切点和通知

我们先定义 UserController 类：

@RequestMapping("/user")
@RestController
public class UserController {
    // 获取用户信息
    @RequestMapping("/getInfo")
    public String getInfo(){
        return "get info...";
    }
    // 注册
    @RequestMapping("/reg")
    public String reg(){
        return "reg...";
    }
    // Login
    @RequestMapping("/login")
    public String login(){
        return "login...";
    }
}

运行后，成功访问：

接下来，我们在 UserController 类中定义切面和切点：

@Slf4j
@RequestMapping("/user")
@RestController
public class UserController {
    // 获取用户信息
    @RequestMapping("/getInfo")
    public String getInfo(){
        log.info("get info...");
        return "get info...";
    }
    // 注册
    @RequestMapping("/reg")
    public String reg(){
        log.info("reg...");
        return "reg...";
    }
    // Login
    @RequestMapping("/login")
    public String login(){
        log.info("login...");
        return "login...";
    }
}

在 LoginAspect 类中使用 @Before 注解（通知方法会在目标方法调用之前执行）：

@Slf4j
@Component
@Aspect
public class LoginAspect {
    @Pointcut("execution(* com.example.demo.controller.UserController.* (..))")
    public void pointcut(){}

    @Before("pointcut()")
    public void doBefore(){
        log.info("do berore...");
    }
}

我们接着新建一个 TestController 类：

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

可以看到运行的结果中，并没有在控制台打印 @Before 中的内容：

那么为什么没有执行呢？

我们再来看一下其他注解，@After（通知方法会在目标方法返回或者抛出异常后调用）：

@Slf4j
@Component
@Aspect
public class LoginAspect {
    @Pointcut("execution(* com.example.demo.controller.UserController.* (..))")
    public void pointcut(){}

    @Before("pointcut()")
    public void doBefore(){
        log.info("do berore...");
    }
    @After("pointcut()")
    public void doAfter(){
        log.info("do after...");
    }
}

运行结果如下：

@AfterReturning（通知方法会在目标方法返回后调用）：

@Slf4j
@Component
@Aspect
public class LoginAspect {
    @Pointcut("execution(* com.example.demo.controller.UserController.* (..))")
    public void pointcut(){}

    @Before("pointcut()")
    public void doBefore(){
        log.info("do berore...");
    }
    @After("pointcut()")
    public void doAfter(){
        log.info("do after...");
    }
    @AfterReturning("pointcut()")
    public void doAfterReturning(){
        log.info("do after returning...");
    }
}

运行以上代码后：

可以看到：@AfterReturning 在 @After 之前被调用。

@AfterThrowing（通知方法会在目标方法抛出异常后调用）：

我们首先在 UserController 类中加入异常：

@Slf4j
@RequestMapping("/user")
@RestController
public class UserController {
    // 获取用户信息
    @RequestMapping("/getInfo")
    public String getInfo(){
        log.info("get info...");
        return "get info...";
    }
    // 注册
    @RequestMapping("/reg")
    public String reg(){
        log.info("reg...");
        int a = 10/0;
        return "reg...";
    }
    // Login
    @RequestMapping("/login")
    public String login(){
        log.info("login...");
        return "login...";
    }
}

添加 @AfterThrowing 注解：

@Slf4j
@Component
@Aspect
public class LoginAspect {
    @Pointcut("execution(* com.example.demo.controller.UserController.* (..))")
    public void pointcut(){}

    @Before("pointcut()")
    public void doBefore(){
        log.info("do berore...");
    }
    @After("pointcut()")
    public void doAfter(){
        log.info("do after...");
    }
    @AfterReturning("pointcut()")
    public void doAfterReturning(){
        log.info("do after returning...");
    }
    @AfterThrowing("pointcut()")
    public void doAfterThrowing(){
        log.info("do after throwing...");
    }
}

运行后可以看到：

当正常返回时，执行 @AfterReturning 注解，当出现异常时，不会执行 @AfterReturning 注解；

当出现异常时，才会执行 @AfterThrowing 注解，当正常返回时，不会执行 @AfterThrowing 注解。

@Around（通知包裹了被通知的方法，在被通知的方法通知之前和调用之后执行自定义的行为）：

添加 @Around 注解：

@Slf4j
@Component
@Aspect
public class LoginAspect {
    @Pointcut("execution(* com.example.demo.controller.UserController.* (..))")
    public void pointcut(){}

    @Before("pointcut()")
    public void doBefore(){
        log.info("do berore...");
    }
    @After("pointcut()")
    public void doAfter(){
        log.info("do after...");
    }
    @AfterReturning("pointcut()")
    public void doAfterReturning(){
        log.info("do after returning...");
    }
    @AfterThrowing("pointcut()")
    public void doAfterThrowing(){
        log.info("do after throwing...");
    }
    @Around("pointcut()")
    public void doAround(ProceedingJoinPoint joinPoint){
        log.info("环绕通知执行之前...");
        try {
            joinPoint.proceed(); // 调用目标方法
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
        log.info("环绕通知执行之后...");
    }
}

运行后界面显示如下：

可以看到此时界面中不再有返回值，因此修改代码如下：

@Around("pointcut()")
public Object doAround(ProceedingJoinPoint joinPoint){
    Object oj = null;
    log.info("环绕通知执行之前...");
    try {
        oj = joinPoint.proceed(); // 调用目标方法
    } catch (Throwable e) {
        throw new RuntimeException(e);
    }
    log.info("环绕通知执行之后...");
    return oj;
}

此时可以看到成功返回并打印了值：

我们再来看一下这段代码：

4. 切点表达式说明

AspectJ 支持三种通配符

* ：匹配任意字符，只匹配一个元素（包，类，或方法，方法参数）
.. ：匹配任意字符，可以匹配多个元素，在表示类时，必须和 * 联合使用。
+ ：表示按照类型匹配指定类的所有类，必须跟在类名后面，如 com.cad.Car+ ,表示继承该类的所有子类包括本身

切点表达式由切点函数组成，其中 execution() 是最常用的切点函数，用来匹配方法，语法为：

execution(<修饰符><返回类型><包.类.方法（参数）><异常>)

5. 练习：使用 AOP 统计 UserController 每个方法的执行时间

@Slf4j
@Component
@Aspect
public class LoginAspect {
    @Pointcut("execution(* com.example.demo.controller.UserController.* (..))")
    public void pointcut(){}

    @Before("pointcut()")
    public void doBefore(){
        log.info("do berore...");
    }
    @After("pointcut()")
    public void doAfter(){
        log.info("do after...");
    }
    @AfterReturning("pointcut()")
    public void doAfterReturning(){
        log.info("do after returning...");
    }
    @AfterThrowing("pointcut()")
    public void doAfterThrowing(){
        log.info("do after throwing...");
    }
    @Around("pointcut()")
    public Object doAround(ProceedingJoinPoint joinPoint){
        Object oj = null;
        log.info("环绕通知执行之前...");
        try {
            oj = joinPoint.proceed(); // 调用目标方法
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
        log.info("环绕通知执行之后...");
        return oj;
    }

    /**
     *
     * @param joinPoint 使用 AOP 统计 UserController 每个方法的执行时间
     * @return
     */
    @Around("pointcut()")
    public Object doAroundCount(ProceedingJoinPoint joinPoint){
        Object oj = null;
        long start = System.currentTimeMillis();
        try {
            oj = joinPoint.proceed(); // 调用目标方法
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }
        log.info(joinPoint.getSignature().toString()+"耗时："+(System.currentTimeMillis()-start));
        return oj;
    }
}

可以看到不同的方法直接在 url 中进行更改重新运行界面即可获得：