Spring AOP 详解

25-03-07 15:22

2623

6599

blog.csdn.net

id="article_content" class="article_content clearfix"> id="content_views" class="markdown_views prism-atom-one-dark">

class="toc">

文章目录

一、AOP 概述
二、Spring AOP 快速入门
- 2.1 引入 AOP 依赖：
- 2.2 编写 AOP 程序：
三、Spring AOP 详解
四、代理模式

Spring 框架有两大核心 IoC，AOP。在前面我们已经学习过了 IoC 的相关知识，今天就让我们开始 AOP 的学习。

一、AOP 概述

Aspect Oriented Programming（面向切面编程）。

切面就是指某一类特定问题，所以 AOP 也可以理解为面向特定方法编程。

**AOP 是一种思想，是对某一类事情的集中处理。**Spring AOP 是其中的一种实现方式。

AOP 的作用：在程序运行期间，在不修改源代码的基础上，对已有方法进行增强（无侵入性：解耦）。

二、Spring AOP 快速入门

我们先通过下面的程序体验下 AOP 的开发，并掌握 Spring 中 AOP 的开发步骤。

2.1 引入 AOP 依赖：

在 pom.xml 文件中添加配置：

<dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-aopartifactId>
dependency>
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

2.2 编写 AOP 程序：

@Aspect
@Slf4j
@Component
public class TestAspect {
    @Around("execution(* com.example.demo.controller.*.*(..))")
    public Object demo(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("方法执行前执行");
        Object result = joinPoint.proceed();
        log.info("方法执行后执行");
        return result;
    }
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

controller 类：

@RequestMapping("/test")
@RestController
@Slf4j
public class TestController {

    @RequestMapping("/t1")
    public void test1(){
        log.info("我是 test1");
    }
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

调用 controller 中的 test1 方法。

结果如下：

对程序进行简单的讲解：

@Aspect：标识这是一个切面类。
@Around：环绕通知，在目标方法的前后都会被执行。后面的表达式表示对哪些方法进行增强。
ProceedingJoinPoint.proceed（）让原始方法执行。

整个代码划分为三部分。

通过上面的程序，我们也可以感受到 AOP 面向切面编程的一些优势：

代码无侵入：不修改原始的业务方法，就可以对原始的业务方法进行了功能的增强或者是功能的改变。
减少了重复代码。
提高开发效率。
维护方便。

三、Spring AOP 详解

3.1 Spring AOP 核心概念：

3.1.1 切点（Pointcut）：

切点（Pointcut），也称之为"切入点"。

Pointcut 的作用就是提供一组规则（使用 AspectJ pointcut expression language 来描述），告诉程序对哪些方法来进行功能增强。

上面的表达式 execution(* com.example.demo.controller..(…)) 就是切点表达式。

3.1.2 连接点（Join Point）：

满足切点表达式规则的方法，就是连接点。也就是可以被 AOP 控制的方法。

切点和连接点的关系：

连接点是满足切点表达式的元素。切点可以看做是保存了众多连接点的一个集合。

3.1.3 通知（Advice）：

通知就是具体要做的工作，指哪些重复的逻辑，也就是共性功能（最终体现为一个方法）。

在 AOP 面向切面编程当中，我们把这部分重复的代码逻辑抽取出来单独定义，这部分代码就是通知的内容。

3.1.4 切面（Aspect）：

切面（Aspect）= 切点（Pointcut）+ 通知（Advice）。

通过切面就能够描述当前 AOP 程序需要针对于哪些方法，在什么时候执行什么样的操作。

切面既包含了通知逻辑的定义，也包括了连接点的定义。

切面所在的类，我们一般称为切面类（被 @Aspect 注解标识的类）。

3.2 通知类型：

上面我们讲了什么是通知，接下来学习通知的类型。@Around 就是其中一种通知类型，表示环绕通知。Spring 中 AOP 的通知类型有以下几种：

@Around：环绕通知，此注解标注的通知方法在目标方法前后都被执行。
@Before：前置通知，此注解标注的通知方法在目标方法前被执行。
@After：后置通知，此注解标注的通知方法在目标方法后被执行，无论是否有异常都会执行。
@AfterReturning：返回后通知，此注解标注的通知方法在目标方法返回后被执行，有异常不会执行。
@AfterThrowing：异常后通知，此注解标注的通知方法发生异常后执行。

没有异常的运行顺序：

程序正常运行的情况下，@AfterThrowing 标识的通知方法不会执行。

出现异常的运行顺序：

@AfterReturning 标识的通知方法不会执行，@AfterThrowing 标识的通知方法执行了。

@Around 环绕通知中原始方法调用时有异常，通知中的环绕后的代码逻辑也不会再执行了（因为原始方法调用出异常了）。

注意：

@Around 环绕通知需要调用 ProceedingJoinPoint.proceed() 来让原始方法执行，其他通知不需要考虑目标方法执行。
@Around 环绕通知方法的返回值，必须指定为 Object，来接收原始方法的返回值，否则原始方法执行完毕，是获取不到返回值的。
一个切面类可以有多个切点。

3.3 @PointCut：

Spring 提供了 @PointCut 注解，把公共的切点表达式提取出来，需要用到时引用该切入点表达式即可，便于后续代码的维护。

@Aspect
@Slf4j
@Component
public class TestAspect {
    @Pointcut("execution(* com.example.demo.controller.*.*(..))")
    public void pt(){}
    @Around("pt()")
    public Object demo(ProceedingJoinPoint joinPoint) throws Throwable {
        log.info("方法执行前执行");
        Object result = joinPoint.proceed();
        log.info("方法执行后执行");
        return result;
    }
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

当切点定义使用 private 修饰时，仅能在当前切面类中使用，当其他切面类也要使用当前切点定义时，就需要把 private 改为 public。引用方式为：全限定类名.方法名()。

@Slf4j
@Component
@Aspect
public class TestAspect2 {
    @Before("com.example.demo.aspect.TestAspect.pt()")
    public void doBefore() {
        log.info("执⾏ TestAspect2 -> Before ⽅法");
    }
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">

3.4 切面优先级 @Order：

当我们在一个项目中，定义了多个切面类时，并且这些切面类的多个切入点都匹配到了同一个目标方法。当目标方法运行的时候，这些切面类中的通知方法都会执行，那么这几个通知方法的执行顺序是什么样的呢？

我们通过程序来进行验证。

@Slf4j
@Component
@Aspect
public class TestAspect2 {
    @Pointcut("execution(* com.example.demo.controller.*.*(..))")
    private void pt(){}
    //前置通知
    @Before("pt()")
    public void doBefore() {
        log.info("执行 TestAspect2 -> Before 方法");
    }
    //后置通知
    @After("pt()")
    public void doAfter() {
        log.info("执行 TestAspect2 -> After 方法");
    }
}

@Aspect
@Component
@Slf4j
public class TestAspect3 {
    @Pointcut("execution(* com.example.demo.controller.*.*(..))")
    private void pt(){}
    //前置通知
    @Before("pt()")
    public void doBefore() {
        log.info("执行 TestAspect3 -> Before 方法");
    }
    //后置通知
    @After("pt()")
    public void doAfter() {
        log.info("执行 TestAspect3 -> After 方法");
    }
}

@Aspect
@Component
@Slf4j
public class TestAspect4 {
    @Pointcut("execution(* com.example.demo.controller.*.*(..))")
    private void pt(){}
    //前置通知
    @Before("pt()")
    public void doBefore() {
        log.info("执行 TestAspect4 -> Before 方法");
    }
    //后置通知
    @After("pt()")
    public void doAfter() {
        log.info("执行 TestAspect4 -> After 方法");
    }
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}"> class="hide-preCode-box">1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

运行上面程序：

通过上述程序的运行结果，可以看出：

存在多个切面类时，默认按照切面类的类名字母排序：

@Before 通知：字母排名靠前的先执行。
@After 通知：字母排名靠前的后执行。

但这种方式不方便管理，我们的类名更多还是具备一定含义的。

Spring 给我们提供了一个新的注解，来控制这些切面通知的执行顺序：@Order。

@Slf4j
@Component
@Aspect
@Order(10)
public class TestAspect2 {
    //代码省略
}

@Aspect
@Component
@Slf4j
@Order(5)
public class TestAspect3 {
    //代码省略
}

@Aspect
@Component
@Slf4j
@Order(1)
public class TestAspect4 {
    //代码省略
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}"> class="hide-preCode-box">1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

运行程序：

通过上述程序的运行结果，得出结论：

@Order 注解标识的切面类，执行顺序如下：

@Before 通知：数字越小先执行。
@After 通知：数字越大先执行。

@Order 的执行顺序可以抽象成下面这张图：

3.5 切点表达式：

上面的代码中，我们一直在使用切点表达式来描述切点。下面我们来介绍一下切点表达式的语法。

切点表达式常见有两种表达方式：

execution：根据方法的签名来匹配。
@annotation：根据注解匹配。

3.5.1 execution 表达式：

execution() 是最常用的切点表达式，用来匹配方法，语法为：

execution (<访问修饰符> <返回类型> <包名.类名.方法(方法参数)> <异常>)
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">1

其中：访问修饰符和异常可以省略。

切点表达式支持通配符表达：

* ：匹配任意字符，只匹配一个元素（返回类型，包，类名，方法或者方法参数）。

包名使用 * 表示任意包（一层包使用一个 * )。
类名使用 * 表示任意类。
返回值使用 * 表示任意返回值类型。
方法名使用 * 表示任意方法（参数可能有限制）。
参数使用 * 表示一个任意类型的参数。

..：匹配多个连续的任意符号，可以通配任意层级的包，或任意类型，任意个数的参数。

使用..配置包名，标识此包以及此包下的所有子包。
可以使用..配置参数，任意个任意类型的参数。

3.5.2 @annotation：

execution 表达式更适用有规则的，如果我们要匹配多个无规则的方法呢，比如：TestController 中的 t1() 和 UserController 中的 u1() 这两个方法。这个时候我们使用 execution 这种切点表达式来描述就不是很方便了。我们可以借助自定义注解的方式以及另一种切点表达式 @annotation 来描述这一类的切点。

实现步骤：

编写自定义注解。
使用 @annotation 表达式来描述切点。
在方法上添加自定义注解。

创建一个注解类（和创建 Class 文件一样的流程，选择 Annotation 就可以了）

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAspect {
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">1
2
3
4

使用 @annotation 表达式来描述切点。

@Component
@Slf4j
@Aspect
public class MyAspectDemo {
    @Before("@annotation(com.example.demo.aspect.MyAspect)")
    public void doBefore(){
        log.info("我是 MyAspectDemo");
    }
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">1
2
3
4
5
6
7
8
9

在方法上添加自定义注解。

@RequestMapping("/test")
@RestController
@Slf4j
public class TestController {
    @MyAspect
    @RequestMapping("/t1")
    public void test1(){
        log.info("我是 test1");
    }
}
 class="hljs-button signin active" data-title="登录复制" data-report-click="{"spm":"1001.2101.3001.4334"}">1
2
3
4
5
6
7
8
9
10

运行程序，访问 test1 方法。

3.6 Spring AOP 的实现方式（常见面试题）：

基于注解 @Aspect。
基于自定义注解（@annotation）。
基于 Spring API（通过 xml 配置的方式，自从 SpringBoot 广泛使用之后，这种方法几乎看不到了）。
基于代理来实现（更加久远的一种实现方式，写法笨重，不建议使用）。

四、代理模式

Spring AOP 是基于动态代理来实现 AOP 的。

代理模式，也叫委托模式。

定义：

为其他对象提供一种代理，以控制对这个对象的访问。它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。

代理模式可以在不修改被代理对象的基础上，通过扩展代理类，进行一些功能的附加与增强。

根据代理的创建时期，代理模式分为静态代理和动态代理。

静态代理：由程序员创建代理类或特定工具自动生成源代码再对其编译，在程序运行前代理类的 .class 文件就已经存在了。
动态代理：在程序运行时，运用反射机制动态创建而成。

结语：
其实写博客不仅仅是为了教大家，同时这也有利于我巩固知识点，和做一个学习的总结，由于作者水平有限，对文章有任何问题还请指出，非常感谢。如果大家有所收获的话，还请不要吝啬你们的点赞收藏和关注，这可以激励我写出更加优秀的文章。

data-report-view="{"mod":"1585297308_001","spm":"1001.2101.3001.6548","dest":"https://blog.csdn.net/2301_80035594/article/details/143078123","extend1":"pc","ab":"new"}">>

注：本文转载自blog.csdn.net的gobeyye的文章"https://blog.csdn.net/2301_80035594/article/details/143078123"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。

复制链接

发表评论

/ 登录

评论记录：

未查询到任何数据！