Spring AOP

1.AOP概述

2.Spring AOP快速实现

3.Spring AOP核⼼概念

编辑 3.1切点(Pointcut)

3.2连接点(Join Point)

3.3通知(Advice)

3.4切⾯(Aspect)

4.通知类型

5.@PointCut

6.切⾯优先级 @Order

7.@annotation

1.AOP概述

（1）什么是AOP？

⾯向切⾯编程,切⾯就是指某⼀类特定问题, 所以AOP也可以理解为⾯向特定⽅法编程。

简单来说: AOP是⼀种思想, 是对某⼀类事情的集中处理。

（2）什么是Spring AOP?

用Spring框架实现了AOP这种思想。

它的实现⽅法有很多, 有Spring AOP，也有AspectJ、CGLIB等. Spring AOP是其中的⼀种实现⽅式。

（3）AOP作⽤的维度

AOP作⽤的维度非常细致，可以根据包、类、⽅法名、参数等进⾏拦截, 能够实现复杂的业务逻辑。

（4）AOP的作⽤

在程序运⾏期间在不修改源代码的基础上对已有⽅法进⾏增强（⽆侵⼊性: 解耦）。

（5）AOP⾯向切⾯编程的⼀些优势：

• 代码⽆侵⼊: 不修改原始的业务⽅法, 就可以对原始的业务⽅法进⾏了功能的增强或者是功能的改变

• 减少了重复代码

• 提⾼开发效率

• 维护⽅便

2.Spring AOP快速实现

1. 在pom.xml⽂件中添加配置

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

2.写一个切⾯类

记录Controller中每个⽅法的执⾏时间

代码:

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;@Component
@Aspect
@Slf4j
public class AspectDemo {@Around("execution(* com.wh.aop.controller.*.*(..))")public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable {//记录⽅法执⾏开始时间long start = System.currentTimeMillis();//执⾏原始⽅法Object result = joinPoint.proceed();//记录⽅法执⾏结束时间long end = System.currentTimeMillis();//记录⽅法执⾏耗时log.info(joinPoint.getSignature() + "执⾏耗时: {}ms", end - start);return result;}
}

说明：

1.@Aspect: 标识这是⼀个切⾯类

2.@Around: 环绕通知, 在⽬标⽅法的前后都会被执⾏. 后⾯的表达式表⽰对哪些⽅法进⾏增强

3.pjp.proceed()让原始⽅法执行

3.Spring AOP核⼼概念

3.1切点(Pointcut)

Pointcut 的作⽤就是提供⼀组规则 (使⽤ AspectJ pointcut expression language 来描述), 告诉程序对哪些⽅法来进⾏功能增强.

上⾯的表达式 execution(* com.wh.aop.controller.*.*(..))就是切点表达式.

execution表达式

execution() 是最常⽤的切点表达式, ⽤来匹配⽅法, 语法为:

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

* ：匹配任意字符，只匹配⼀个元素(返回类型, 包, 类名, ⽅法或者⽅法参数)

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

3.2连接点(Join Point)

满⾜切点表达式规则的⽅法, 就是连接点. 也就是可以被AOP控制的⽅法

以Spring AOP快速实现的代码为例，所有 com.example.demo.controller 路径下的⽅法, 都是连接点

TestController

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;@RestController
@Slf4j
public class TestController {@RequestMapping("/t1")public String t1() {log.info("t1执行~~~");return "t1";}@RequestMapping("/t2")public String t2(){log.info("执行t2方法...");int a = 10/0;return "t2";}
}

TestController2

import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;@RestController
@Slf4j
public class TestController2 {@RequestMapping("/t3")public String t3() {log.info("执行t3方法...");return "t3";}
}

3.3通知(Advice)

通知就是具体要做的⼯作, 指哪些重复的逻辑，也就是共性功能(最终体现为⼀个⽅法)

⽐如上述程序中记录业务⽅法的耗时时间, 就是通知

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

3.4切⾯(Aspect)

切⾯(Aspect) = 切点(Pointcut) + 通知(Advice)

1.通过切⾯就能够描述当前AOP程序需要针对于哪些⽅法, 在什么时候执⾏什么样的操作.

2.切⾯既包含了通知逻辑的定义, 也包括了连接点的定义. 切⾯所在的类, 我们⼀般称为切⾯类(被@Aspect注解标识的类）

4.通知类型

Spring中AOP的通知类型有以下⼏种：

1.@Around: 环绕通知, 此注解标注的通知⽅法在⽬标⽅法前, 后都被执⾏，如果有异常环绕后的行为不会执⾏

2.@Before: 前置通知, 此注解标注的通知⽅法在⽬标⽅法前被执⾏

3.@After: 后置通知, 此注解标注的通知⽅法在⽬标⽅法后被执⾏, ⽆论是否有异常都会执⾏

4. @AfterReturning: 返回后通知, 此注解标注的通知⽅法在⽬标⽅法后被执⾏, 有异常不会执⾏

5.@AfterThrowing: 异常后通知, 此注解标注的通知⽅法发⽣异常后执⾏

通过AspectText1对Spring中AOP的通知类型都进行个测试

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;@Slf4j
@Aspect
@Component
public class AspectText1 {@Before("execution(* com.wh.aop.controller.*.*(..))")public void doBefore() {log.info("AspectText do before....");}@After("execution(* com.wh.aop.controller.*.*(..))")public void doAfter() {log.info("AspectText do after....");}@Around("execution(* com.wh.aop.controller.*.*(..))")public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {log.info("AspectText do around before....");Object proceed = joinPoint.proceed();log.info("AspectText do around after....");return proceed;}@AfterReturning("execution(* com.wh.aop.controller.*.*(..))")public void doAfterReturning() {log.info("AspectDemo do AfterReturning....");}@AfterThrowing("execution(* com.wh.aop.controller.*.*(..))")public void doAfterThrowing() {log.info("AspectDemo do AfterThrowing....");}
}

运行TestController的t1方法的运行结果：

分析：

1.从上图也可以看出来, @Around 标识的通知⽅法包含两部分, ⼀个"前置逻辑", ⼀个"后置逻辑".其中"前置逻辑" 会先于 @Before 标识的通知⽅法执⾏, "后置逻辑" 会晚于 @After 标识的通知⽅法执行。

2.程序正常运⾏的情况下, @AfterThrowing 标识的通知⽅法不会执行

运行TestController的t2方法的运行结果：

小结：

1.@Around 环绕通知需要调⽤ ProceedingJoinPoint.proceed() 来让原始⽅法执⾏, 其他

通知不需要考虑⽬标⽅法执行

2. @Around 环绕通知⽅法的返回值, 必须指定为Object, 来接收原始⽅法的返回值, 否则原始⽅法执⾏完毕, 是获取不到返回值的.
3.⼀个切⾯类可以有多个切点.

5.@PointCut

Spring提供了 @PointCut 注解, 把公共的切点表达式提取出来, 需要⽤到时引⽤该切⼊点表达式即可

代码：

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;@Component
@Slf4j
@Aspect
public class AspectText2 {@Pointcut("execution(* com.wh.aop.controller.*.*(..))")public void pt() {}@Around("pt()")public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {log.info("AspectText do around before....");Object proceed = joinPoint.proceed();log.info("AspectText do around after....");return proceed;}}

当切点定义使⽤private修饰时, 仅能在当前切⾯类中使⽤, 当其他切⾯类也要使⽤当前切点定义时, 就需要把private改为public. 引⽤⽅式为: 全限定类名.⽅法名()

    @Before("com.wh.aop.aspect.AspectText2.pt()")public void doBefore() {log.info("AspectText do before....");}

6.切⾯优先级 @Order

当我们在⼀个项⽬中, 定义了多个切⾯类时, 并且这些切⾯类的多个切⼊点都匹配到了同⼀个⽬标⽅法. 当⽬标⽅法运⾏的时候, 这些切⾯类中的通知⽅法都会执⾏, 那么这⼏个通知⽅法的执⾏顺序是什么样的呢

存在多个切⾯类时, 默认按照切⾯类的类名字⺟排序：

• @Before 通知：字⺟排名靠前的先执行

• @After 通知：字⺟排名靠前的后执行

我们可以使用 @Order来自定义通知⽅法的执⾏顺序

@Order 注解标识的切⾯类, 执⾏顺序如下:

• @Before 通知：数字越⼩先执行

• @After 通知：数字越⼤先执行

代码：

AspectDemo1类

@Component
@Aspect
@Slf4j
@Order(1)
public class AspectDemo1 {@Before("execution(* com.wh.aop.controller.*.*(..))")public void doBefore() {log.info("AspectText do before1....");}
}

AspectDemo2类

@Component
@Aspect
@Slf4j
@Order(100)
public class AspectDemo2 {@Before("execution(* com.wh.aop.controller.*.*(..))")public void doBefore() {log.info("AspectText do before2....");}
}

AspectDemo3类

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;@Component
@Aspect
@Slf4j
@Order(75)
public class AspectDemo3 {@Before("execution(* com.wh.aop.controller.*.*(..))")public void doBefore() {log.info("AspectText do before3....");}
}

运行TestController的t1方法的运行结果：

7.@annotation

execution表达式更适⽤有规则的, 如果我们要匹配多个⽆规则的⽅法呢, ⽐如：TestController中的t1()和TestController 中的t3()这两个⽅法

我们可以借助⾃定义注解的⽅式以及另⼀种切点表达式 @annotation 来描述这⼀类的切点

1.⾃定义注解

创建⼀个注解类(和创建Class⽂件⼀样的流程, 选择Annotation就可以了)

代码：

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 MyAspect {
}

2.切⾯类

使⽤ @annotation 切点表达式定义切点, 只对 @MyAspect ⽣效

代码：

@Component
@Aspect
@Slf4j
public class AspectDemo {@Around("@annotation(com.wh.aop.config.MyAspect)")public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable {//记录⽅法执⾏开始时间long start = System.currentTimeMillis();//执⾏原始⽅法Object result = joinPoint.proceed();//记录⽅法执⾏结束时间long end = System.currentTimeMillis();//记录⽅法执⾏耗时log.info(joinPoint.getSignature() + "执⾏耗时: {}ms", end - start);return result;}
}

分别调用testController中的t1()和TestController中的t3()这两个⽅法

结果：