目录
🚩Spring AOP概述
🚩Spring AOP快速⼊⻔
🎓引入AOP依赖
🎓编写AOP程序
🚩Spring AOP 详解
🎓Spring AOP核⼼概念
🎓通知类型
🎓@PointCut
🎓切⾯优先级 @Order
🎓切点表达式
📝execution表达式
📝@annotation
🎈⾃定义注解 @MyAspect
🎈切⾯类
🎈添加⾃定义注解
🚩Spring AOP的实现⽅式(常⻅⾯试题)
🚩Spring AOP概述
Spring框架的第一大核心是IOC(控制反转),接下来我们学习第二大核心——AOP.
什么是AOP?
Aspect Oriented Programming（⾯向切⾯编程)和面向对象编程不是互斥的关系，也不是面向对象编程的升级，是面向对象编程的补充。什么是⾯向切⾯编程呢? 切⾯就是指某⼀类特定问题, 所以AOP也可以理解为⾯向特定⽅法编程. 什么是⾯向特定⽅法编程呢? ⽐如上个章节学习的"登录校验", 就是⼀类特定问题. 登录校验拦截器, 就 是对"登录校验"这类问题的统⼀处理. 所以, 拦截器也是AOP的⼀种应⽤.AOP是⼀种思想, 拦截器是AOP 思想的⼀种实现. Spring框架实现了这种思想, 提供了拦截器技术的相关接⼝. 同样的, 统⼀数据返回格式和统⼀异常处理, 也是AOP思想的⼀种实现.简单来说: AOP是⼀种思想, 是对某⼀类事情的集中处理（用户登录校验，结果统一返回，异常统一处理）
拦截器作⽤的维度是URL(⼀次请求和响应), @ControllerAdvice 应⽤场景主要是全局异常处理 (配合⾃定义异常效果更佳), 数据绑定, 数据预处理.
AOP作⽤的维度更加细致(可以根据包、类、⽅法 名、参数等进⾏拦截), 能够实现更加复杂的业务逻辑.
一个项目需要开发很多的业务功能，有一些业务的执行效率是很低的，需要对接口进行优化。第一步就需要定位出执行耗时比较长的业务方法，然后针对该业务方法进行优化。如何定位呢？我们就需要统计当前项目中每一个业务方法的执行耗时，我们需要在每个业务方法运行前和运行后，记录下方法的开始时间和结束时间，两者之差就是这个方法的耗时。但是一个项目中有很多的方法和类，我们需要记录每个方法的执行时长，需要在每个方法中记录，这种执行效率是比较低的，耗时比较长，
这种⽅法是可以解决问题的, 但⼀个项⽬中会包含很多业务模块, 每个业务模块⼜有很多接⼝, ⼀个接⼝ ⼜包含很多⽅法, 如果我们要在每个业务⽅法中都记录⽅法的耗时, 对于程序员⽽⾔, 会增加很多的⼯作量。
AOP就可以做到在不改动这些原始⽅法的基础上, 针对特定的⽅法进⾏功能的增强.AOP的作⽤：在程序运⾏期间在不修改源代码的基础上对已有⽅法进⾏增强（⽆侵⼊性: 解耦）
🚩Spring AOP快速⼊⻔
需求: 统计图书系统各个接⼝⽅法的执⾏时间
🎓引入AOP依赖
在pom.xml⽂件中添加配置
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-aop</artifactId>
</dependency>🎓编写AOP程序
记录Controller中每个⽅法的执⾏时间
@Slf4j
@Component
@Aspect
public class TimeRecordAspect {/*** 记录时间*/@Around("execution(* com.example.cl.controller.*.*(..))")//对哪些方法生效//@Around表示侵入程序的时机，表示环绕,目标函数执行前后都会执行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;}//AOP这种写法作用的维度是 方法//拦截器 作用的维度是 url 接口
}
在进行用户登录，我们看到该方法耗时时间：234ms.
对程序进⾏简单的讲解:
- @Aspect: 标识这是⼀个切⾯类
- @Around: 环绕通知, 在⽬标⽅法的前后都会被执⾏. 后⾯的表达式表⽰对哪些⽅法进⾏增强.
- ProceedingJoinPoint.proceed() 让原始⽅法执⾏
我们通过AOP⼊⻔程序完成了业务接⼝执⾏耗时的统计.通过上⾯的程序, 我们也可以感受到 AOP⾯向切⾯编程的⼀些优势 ：
- • 代码⽆侵⼊: 不修改原始的业务⽅法, 就可以对原始的业务⽅法进⾏了功能的增强或者是功能的改变
- • 减少了重复代码
- • 提⾼开发效率
- • 维护⽅便
🚩Spring AOP 详解
🎓Spring AOP核⼼概念
🎈切点(Pointcut)切点(Pointcut), 也称之为"切⼊点"Pointcut 的作⽤就是提供⼀组规则 (使⽤ AspectJ pointcut expression language 来描述), 告诉程序对 哪些⽅法来进⾏功能增强.@Around("execution(* com.example.cl.controller.*.*(..))") 这就是切点表达式🎈连接点(Join Point)满⾜切点表达式规则的⽅法, 就是连接点. 也就是可以被AOP控制的⽅法以⼊⻔程序举例, 所有 com.example.demo.controller 路径下的⽅法, 都是连接点UserController/BookController 中的⽅法都是连接点📝切点表达式和连接点的关系：连接点是满足切点表达式的元素，切点可以看作是保存了众多连接点的一个集合连接点——路径下里面的所有的方法切点表达式——路径🎈通知(Advice)通知就是具体要做的⼯作, 指哪些重复的逻辑，也就是共性功能(最终体现为⼀个⽅法)⽐如上述程序中记录业务⽅法的耗时时间, 就是通知
在AOP⾯向切⾯编程当中, 我们把这部分重复的代码逻辑抽取出来单独定义, 这部分代码就是通知的内容.🎈切⾯(Aspect)切⾯(Aspect) = 切点(Pointcut) + 通知(Advice)通过切⾯就能够描述当前AOP程序需要针对于哪些⽅法, 在什么时候执⾏什么样的操作切⾯既包含了通知逻辑的定义, 也包括了连接点的定义
切⾯所在的类, 我们⼀般称为切⾯类(被@Aspect注解标识的类)
🎓通知类型
上⾯我们讲了什么是通知, 接下来学习通知的类型.
@Around 就是其中⼀种通知类型, 表⽰环绕通知.
Spring中AOP的通知类型有以下⼏种:
- @Around: 环绕通知, 此注解标注的通知⽅法在⽬标⽅法前, 后都被执⾏
- @Before: 前置通知, 此注解标注的通知⽅法在⽬标⽅法前被执⾏
- @After: 后置通知, 此注解标注的通知⽅法在⽬标⽅法后被执⾏, ⽆论是否有异常都会执⾏
- @AfterReturning: 返回后通知, 此注解标注的通知⽅法在⽬标⽅法后被执⾏, 有异常不会执⾏
- @AfterThrowing: 异常后通知, 此注解标注的通知⽅法发⽣异常后执⾏
@Aspect
@Slf4j
public class AspectDemo {/*** 前置通知*/@Before("execution(* com.cl.springaop.controller.*.*(..))")public void doBefore(){log.info("AspectDemo do before......");}//是否发生异常，都会执行（再执行方法前）优先级小于around/*** 后置通知*/@After("execution(* com.cl.springaop.controller.*.*(..))")public void doAfter(){log.info("AspectDemo do after......");}//是否发生异常，都会执行（再执行方法后） 优先级小于around/***添加环绕通知*///around必须有返回值，需要将目标返回值返回，否则会没有返回值@Around("execution(* com.cl.springaop.controller.*.*(..))")public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {log.info("AspectDemo do around before......");Object result=null;result=joinPoint.proceed();log.info("AspectDemo do around after.......");return result;}//发生异常就不会返回结果/*** 返回后通知*/@AfterReturning("execution(* com.cl.springaop.controller.*.*(..))")public void doAfterReturning(){log.info("AspectDemo do AfterReturning......");}//没有异常执行/*** 抛出异常后通知*/@AfterThrowing("execution(* com.cl.springaop.controller.*.*(..))")public void doAfterThrowing(){log.info("AspectDemo do AfterThrowing......");}//有异常执行
}
写一些测试程序：
@RestController
@Slf4j
@RequestMapping("/test")
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";}
}1. 正常运⾏的情况
程序正常运⾏的情况下, @AfterThrowing 标识的通知⽅法不会执⾏从上图也可以看出来,@Around 标识的通知⽅法包含两部分, ⼀个"前置逻辑", ⼀个"后置逻辑". 其中"前置逻辑" 会先于 @Before 标识的通知⽅法执⾏, "后置逻辑" 会晚于 @After 标识的通知⽅法执⾏
2.异常时的情况
程序发⽣异常的情况下：
- • @AfterReturning 标识的通知⽅法不会执⾏， @AfterThrowing 标识的通知⽅法执⾏了
- • @Around 环绕通知中原始⽅法调⽤时有异常，通知中的环绕后的代码逻辑也不会在执⾏了(因为原始⽅法调⽤出异常了)
注意事项:
- • @Around 环绕通知需要调⽤ ProceedingJoinPoint.proceed() 来让原始⽅法执⾏, 其他 通知不需要考虑⽬标⽅法执⾏.
- • @Around 环绕通知⽅法的返回值, 必须指定为Object, 来接收原始⽅法的返回值, 否则原始⽅法执⾏完毕, 是获取不到返回值的.
- • ⼀个切⾯类可以有多个切点.
🎓@PointCut
上⾯代码存在⼀个问题, 就是存在⼤量重复的
切点表达式 execution(* com.example.demo.controller.*.*(..))
Spring提供了 @PointCut 注解, 把公共的切点表达式提取出来, 需要⽤到时引⽤该切⼊点表达式即可.
@Pointcut("execution(* com.cl.springaop.controller.*.*(..))")public void pt(){}; @Pointcut("execution(* com.cl.springaop.controller.*.*(..))")public void pt(){};/*** 前置通知*/@Before("pt()")public void doBefore(){log.info("AspectDemo do before......");}//是否发生异常，都会执行（再执行方法前）优先级小于around/*** 后置通知*/@After("pt()")public void doAfter(){log.info("AspectDemo do after......");}//是否发生异常，都会执行（再执行方法后） 优先级小于around
当切点定义使⽤private修饰时, 仅能在当前切⾯类中使⽤,当其他切⾯类也要使⽤当前切点定义时, 就需要把 private改为public.引⽤⽅式为: 全限定类名.⽅法名()
@Component @Aspect @Slf4j public class AspectDemo2 {@Before("com.cl.springaop.aspect.AspectDemo.pt()")public void doBefore(){log.info(" AspectDemo2 do before......");} }
🎓切⾯优先级 @Order
当我们在⼀个项⽬中, 定义了多个切⾯类时, 并且这些切⾯类的多个切⼊点都匹配到了同⼀个⽬标⽅法.当⽬标⽅法运⾏的时候, 这些切⾯类中的通知⽅法都会执⾏, 那么这⼏个通知⽅法的执⾏顺序是什么样的呢?
定义多个切⾯类:
为防⽌⼲扰, 我们把AspectDemo这个切⾯先去掉(把 @Component 注解去掉就可以 )
存在多个切⾯类时, 默认按照切⾯类的类名字⺟排序：
- • @Before 通知：字⺟排名靠前的先执⾏
- • @After 通知：字⺟排名靠前的后执⾏
但这种⽅式不⽅便管理, 我们的类名更多还是具备⼀定含义的.Spring 给我们提供了⼀个新的注解, 来控制这些切⾯通知的执⾏顺序: @Order
按照4，3，2的顺序在先执行。
@Order 注解标识的切⾯类, 执⾏顺序如下:
- • @Before 通知：数字越⼩先执⾏
- • @After 通知：数字越⼤先执⾏
@Order 控制切⾯的优先级, 先执⾏优先级较⾼的切⾯, 再执⾏优先级较低的切⾯, 最终执⾏⽬标⽅法.
🎓切点表达式
上⾯的代码中, 我们⼀直在使⽤切点表达式来描述切点. 下⾯我们来介绍⼀下切点表达式的语法.切点表达式常⻅有两种表达⽅式
- 1. execution(RR)：根据⽅法的签名来匹配
- 2. @annotation(RR) ：根据注解匹配
📝execution表达式
execution() 是最常⽤的切点表达式, ⽤来匹配⽅法, 语法为:
execution(< 访问修饰符 > < 返回类型 > < 包名 . 类名 . ⽅法 ( ⽅法参数 )> < 异常 >)
其中: 访问修饰符和异常可以省略
📝@annotation
execution表达式更适⽤有规则的,
如果我们要匹配多个⽆规则的⽅法呢, ⽐如：TestController中的t1() 和UserController中的u1()这两个⽅法. 这个时候我们使⽤execution这种切点表达式来描述就不是很⽅便了.
我们可以借助⾃定义注解的⽅式以及另⼀种切点表达式 @annotation 来描述这⼀类的切点，来指定方法
实现步骤：
- 1. 编写⾃定义注解
- 2. 使⽤ @annotation 表达式来描述切点
- 3. 在连接点的⽅法上添加⾃定义注解
UserController
@Component
@RestController
@Slf4j
@RequestMapping("/user")
public class UserController {@RequestMapping("/u1")public String u1(){log.info("执行u1方法");return "u1";}//由于没有引入注解，所以没有@RequestMapping("/u2")public String u2(){log.info("执行u2方法");return "u2";}
}TestController
@RestController
@Slf4j
@RequestMapping("/test")
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";}
}🎈⾃定义注解 @MyAspect
创建⼀个注解类(和创建Class⽂件⼀样的流程, 选择Annotation就可以了)
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface MyAspect {
}🎈切⾯类
使⽤ @annotation 切点表达式定义切点, 只对 @MyAspect ⽣效
@Aspect
@Component
@Slf4j
public class MyAspectDemo {@Around("@annotation(com.cl.springaop.config.MyAspect)")public Object doAround(ProceedingJoinPoint joinPoint) {log.info("MyAspectDemo do around before.....");Object result= null;try {result = joinPoint.proceed();} catch (Throwable e) {log.error("发生异常，e："+e);}log.info("MyAspectDemo do around after.....");return result;}
} @Around("@annotation(org.springframework.web.bind.annotation.RequestMapping)")public Object doAround2(ProceedingJoinPoint joinPoint) {log.info("RequestMapping do around before.....");Object result= null;try {result = joinPoint.proceed();} catch (Throwable e) {log.error("发生异常，e："+e);}log.info("RequestMapping do around after.....");return result;}🎈添加⾃定义注解
在TestController中的t1()和UserController中的u1()这两个⽅法上添加⾃定义注解 @MyAspect , 其
他⽅法不添加
对testController中的t1测试
对testController中的t2测试
没有打印结果。
🚩Spring AOP的实现⽅式(常⻅⾯试题)
- 1. 基于注解 @Aspect
- 2. 基于⾃定义注解 (参考⾃定义注解 @annotation 部分的内容)
- 3. 基于Spring API (通过xml配置的⽅式, ⾃从SpringBoot ⼴泛使⽤之后, 这种⽅法⼏乎看不到了)
- 4. 基于代理来实现(更加久远的⼀种实现⽅式, 写法笨重, 不建议使⽤)
背挺直一点，向前靠一点。
