【Spring Boot】Spring AOP 快速上手指南：开启面向切面编程新旅程
【Spring Boot】Spring AOP 快速上手指南：开启面向切面编程新旅程
1.1什么是AOP
AOP是Spring框架的第⼆⼤核⼼(第⼀⼤核⼼是IoC），说明AOP也是非常重要的；
AOP：Aspect Oriented Programming（⾯向切⾯编程） 面向切面编程：所谓的这里的切面就是表示一类特殊的问题，所以也叫面向特定方法编程；
这里特定的方法，在之前学习过的spring统一功能处理中，涉及到登录校验问题，而拦截器就是对这类问题的统一求解，AOP是一种求解问题的思想，那么拦截器就是一种思想的实现；
总结：
简单来说: AOP是⼀种思想, 是对某⼀类事情的集中处理
1.2什么是Spring AOP
AOP是⼀种思想, 它的实现⽅法有很多, 有Spring AOP，也有AspectJ、CGLIB等.Spring AOP是其中的⼀种实现⽅式；
在日常的代码编写中，有以下列子：
假如，我们要对这里面的接口实现改良，让执行时间减少，这里就定位到某些业务代码逻辑等改进，但是不是所有都是不好的，所以我们需要进行测试每个接口，业务执行的时间，那么就有如下的代码，来进行时间检测：
此时的方法固然是可以的，但是那么多接口都需要这样写吗？？答案是不可能的，此时这就是一类特定的问题，此时我们就可以使用AOP思想来进行解决~~~
AOP就可以做到在不改动这些原始⽅法的基础上, 针对特定的⽅法进⾏功能的增强. AOP的作⽤：在程序运⾏期间在不修改源代码的基础上对已有⽅法进⾏增强（⽆侵⼊性: 解耦）
📚️2.Spring AOP入门
2.1环境设置
首先创建一个springboot项目，设置Maven，然后引入如下的依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>这里还可以引入lombok来进行slf4j日志打印，但是在新版本中要将引入的lombok中一部分给注释掉，如下所示：
<plugins>
<!-- <plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<annotationProcessorPaths>
<path>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</path>
</annotationProcessorPaths>
</configuration>
</plugin>-->
<plugin>2.2代码编写
具体的代码如下所示：
@Slf4j
@Aspect
@Component
//交给spring进行管理
public class TimeAspect {
@Around("execution(* com.example.springaop.controller.*.*(..))")
public Object timeRecord(ProceedingJoinPoint joinPoint) throws Throwable {
//记录开始时间
long start = System.currentTimeMillis();
//执行目标方法
Object proceed = joinPoint.proceed();
//记录结束时间
long end = System.currentTimeMillis();
//日志打印耗时
log.info("耗时时间: "+ (end-start) + "ms");
return proceed;
}
}解释:
1. @Aspect: 标识这是⼀个切⾯类 2. @Around: 环绕通知, 在⽬标⽅法的前后都会被执⾏. 后⾯的表达式表⽰对哪些⽅法进⾏增强. 3. ProceedingJoinPoint.proceed() 让原始⽅法执⾏
那么上述代码大致分为如下：
总结优势：
• 代码⽆侵⼊: 不修改原始的业务⽅法, 就可以对原始的业务⽅法进⾏了功能的增强或者是功能的改变 • 减少了重复代码 • 提⾼开发效率 • 维护⽅便
📚️3.Spring AOP详细
3.1Spring AOP核心概念
1.切点
切点(Pointcut), 也称之为"切⼊点" Pointcut 的作⽤就是提供⼀组规则 (使⽤ AspectJ pointcut expression language 来描述), 告诉程序对哪些⽅法来进⾏功能增强
如下所示：
execution(* com.example.springaop.controller.*.*(..))这个就是切点表达式；
2.连接点
满⾜切点表达式规则的⽅法, 就是连接点. 也就是可以被AOP控制的⽅法，上述切点表达式中的类就是controller，说明这里面的所有方法都是AOP控制方法；
解释：直白来说就是我们需要操作的解决的一类问题接口，就是受到AOP管理的；
这个就是连接点；
3.通知
通知就是具体要做的⼯作, 指哪些重复的逻辑，也就是共性功能(最终体现为⼀个⽅法)⽐如上述程序中记录业务⽅法的耗时时间, 就是通知；
具体的部分就是如下：
在AOP⾯向切⾯编程当中, 我们把这部分重复的代码逻辑抽取出来单独定义, 这部分代码就是通知的内容.
4.切面
切⾯(Aspect) = 切点(Pointcut) + 通知(Advice) 通过切⾯就能够描述当前AOP程序需要针对于哪些⽅法, 在什么时候执⾏什么样的操作，切面包含了通知中要执行的逻辑，以及连接点的定义
3.2Spring AOP通知类型
Spring中AOP的通知类型有以下⼏种: • @Around: 环绕通知, 此注解标注的通知⽅法在⽬标⽅法前, 后都被执⾏ • @Before: 前置通知, 此注解标注的通知⽅法在⽬标⽅法前被执⾏ • @After: 后置通知, 此注解标注的通知⽅法在⽬标⽅法后被执⾏, ⽆论是否有异常都会执⾏ • @AfterReturning: 返回后通知, 此注解标注的通知⽅法在⽬标⽅法后被执⾏, 有异常不会执⾏ • @AfterThrowing: 异常后通知, 此注解标注的通知⽅法发⽣异常后执⾏
那么这里主要是通过代码来进行实验；
每个通知类型的代码如下所示：
@Slf4j
@Component
@Aspect
public class AspectDemo1 {
@Around("execution(* com.example.springaop.controller.*.*(..))")
public Object aroundTest(ProceedingJoinPoint point) throws Throwable {
//通知
log.info("Around 开始执行");
//执行目标函数
Object result = point.proceed();
//结束打印
log.info("Around 结束执行");
return result;
}
@Before("execution(* com.example.springaop.controller.*.*(..))")
public void beforeTest(){
log.info("before 开始执行");
}
@After("execution(* com.example.springaop.controller.*.*(..))")
public void afterTest(){
log.info("after 开始执行");
}
@AfterReturning("execution(* com.example.springaop.controller.*.*(..))")
public void afterReturnTest(){
log.info("afterReturn 开始执行");
}
@AfterThrowing("execution(* com.example.springaop.controller.*.*(..))")
public void afterThrowTest(){
log.info("afterThrow 开始执行");
}
}解释：
从上到下依次的通知类型，就是注解所表示，但是对于环绕通知中，要包含这里的连接点，即目标执行方法，以及返回类型是object；环绕通知需要调⽤ ProceedingJoinPoint.proceed() 来让原始⽅法执⾏, 其他通知不需要考虑⽬标⽅法执⾏；
此时运行如下的测试类：
@Slf4j
@RestController
@RequestMapping("/test")
public class AspectTest {
@RequestMapping("/t1")
public String test1(){
log.info("这是目标方法，开始执行");
return "t1";
}
@RequestMapping("/t2")
public String test2(){
log.info("这是目标方法，开始执行");
int a=10/0;
return "t2";
}
}那么此时我们先运行这里没有算数异常的代码，输出的情况如下所示：
解释：
程序正常运⾏的情况下, @AfterThrowing 标识的通知⽅法不会执⾏ 从上图也可以看出来, @Around 标识的通知⽅法包含两部分, ⼀个"前置逻辑", ⼀个"后置逻辑".其 中"前置逻辑" 会先于 @Before 标识的通知⽅法执⾏, "后置逻辑" 会晚于 @After 标识的通知⽅法执 ⾏
此时运行异常代码，结果如下所示：
解释：
@AfterReturning 标识的通知⽅法不会执⾏， @AfterThrowing 标识的通知⽅法执⾏了 • @Around 环绕通知中原始⽅法调⽤时有异常，通知中的环绕后的代码逻辑也不会在执⾏了(因为 原始⽅法调⽤出异常了
3.3@pointcut注解
上⾯代码存在⼀个问题, 就是存在⼤量重复的切点表达式 execution(* com.example.demo.controller.*.*(..)) , Spring提供了 @PointCut 注解, 把公共的切点 表达式提取出来, 需要⽤到时引⽤该切⼊点表达式即可
代码如下所示：
@Pointcut("execution(* com.example.springaop.controller.*.*(..))")
public void pt(){}
@Around("pt()")
public Object aroundTest(ProceedingJoinPoint point) throws Throwable {
//通知
log.info("Around 开始执行");
//执行目标函数
Object result = point.proceed();
//结束打印
log.info("Around 结束执行");
return result;
}解释：
此时就是通过@pointcut注解，对于切点表达式进行了提取，那么之后再次进行通知注解的切点表达式编写时，就可以直接使用提取的方法；
这里的方法若设置为私有类，那么只能在这一个类中进行使用，但是如果其他类要使用，这里必须变成public访问限定符；
代码如下所示：
@Slf4j
@Aspect
public class AspectDemo2 {
@Before("com.example.springaop.aspect.AspectDemo1.pt()")
public void beforeTest() {
log.info("AspectDemo2 before 开始执行...");
}其中@before注解中的切点编写就是，提取方法的全限定路径+类名+方法名；
3.4@order切面优先级
假如定义了多个切⾯类时, 并且这些切⾯类的多个切⼊点都匹配到了同⼀个⽬标⽅法.情况如下所示
首先定义三个切面类，里面的通知方法大致如下：
public class AspectDemo3 {
@Before("com.example.springaop.aspect.AspectDemo1.pt()")
public void doBefore(){
log.info("AspectDemo3 do before...");
}
@After("com.example.springaop.aspect.AspectDemo1.pt()")
public void doAfter(){
log.info("AspectDemo3 do after...");
}
}此时进行路由访问后，打印的日志如下所示：
解释：
存在多个切⾯类时, 默认按照切⾯类的类名字⺟排序 • @Before 通知：字⺟排名靠前的先执⾏ • @After 通知：字⺟排名靠前的后执⾏
那么此时我们可以通过@order注解实现顺序的逆转，代码如下所示：
@Component
@Aspect
@Order(3)
public class AspectDemo3 {
}解释：
我们设置 AspectDemo3order为3，AspectDemo4的order为2，AspectDemo5的order为1，输出的结果如下所示：
通过上述程序的运⾏结果, 得出结论: @Order 注解标识的切⾯类, 执⾏顺序如下: • @Before 通知：数字越⼩先执⾏ • @After 通知：数字越⼤先执⾏ @Order 控制切⾯的优先级, 先执⾏优先级较⾼的切⾯, 再执⾏优先级较低的切⾯, 最终执⾏⽬标⽅法
📚️4.总结
本期主要讲解了关于Spring AOP入门概念，以及快速入门，以及Spring AOP的代码的详细介绍：切点，连接点，通知，以及切面的概念，还有通知类型等其他注解的介绍~~~
🌅🌅🌅~~~~最后希望与诸君共勉，共同进步！！！
腾讯云开发者
