【JavaEE】Spring AOP详解

07-17 1608阅读

一.AOP的定义.

Aspect Oriented Programming（面向切面编程）概括的来说AOP是一种思想, 是对某一类事情的集中处理
- 什么是面向切面编程呢? 切面就是指某一类特定问题, 所以AOP也可以理解为面向特定方法编程.
- 什么是面向特定方法编程呢? 比如上个博客文章所写的"登录校验", 就是一类特定问题. 登录校验拦截器, 就是对"登录校验"这类问题的统一处理. 所以, 拦截器也是AOP的一种应用. AOP是一种思想, 拦截器是AOP思想的一种实现.Spring框架实现了这种思想, 提供了拦截器技术的相关接口.同样的, 统一数据返回格式和统一异常处理, 也是AOP思想的一种实现.
- AOP是一种思想, 它的实现方法有很多, 有Spring AOP，也有AspectJ、CGLIB等. Spring AOP是其中的一种实现方式.
- AOP的作用：在程序运行期间在不修改源代码的基础上对已有方法进行增强（无侵入性: 解耦）
- 举个使用AOP的例子:
  - 现在我们手上有一个项目, 项目中开发了很多的业务功能, 但是现在项目的运行效率较低(项目运行的时间过长) 现在需要对项目的时长进行评估, 找出哪一个模块消耗的时间长, 传统的方法就是对每个模块的每个方法进行计时,算出这个模块需要的总时间. 这种方法是可以解决问题的, 但一个项目中会包含很多业务模块, 每个业务模块又有很多接口, ⼀个接口又包含很多方法, 如果我们要在每个业务方法中都记录方法的耗时, 对于程序员而言, 会增加很多的工作量. AOP就可以做到在不改动这些原始方法的基础上, 针对特定的方法进行功能的增强
    二.AOP的快速入门.
    - AOP的pom.xml依赖:
```
		
            org.springframework.boot
            spring-boot-starter-aop
        
```
      编写一个AOP的实现,用来计算Controller中每个方法的运行时间
```
@Component
@Aspect
@Slf4j
public class AspectDemo1 {
@Around("execution(* com.tuanzi.aop.controller.*.*(..))")
    public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
        //规范情况下,要有返回值,否则可能会造成controller中没有返回结果
        log.info("执行了around before方法");
        Object result = null;
        try {
            result = joinPoint.proceed();
        } catch (Throwable e) {
            log.error("执行 doAround的目标函数, 内部出现异常");
            throw new RuntimeException(e);
        }
        log.info("执行了around after方法");
        return result;
    }
}
```
      运行结果:
      
      先对程序进行简单解释:
      1. @Aspect: 用来标识这是一个切面类.
      2. @Around: 环绕通知, 在目标方法执行前后都会执行, 后面的表达式表示对哪些方法进行增强.
      3. joinPoint.proceed(): 表示让目标方法(Controller中的方法)执行
      整个代码可以分为三部分:
      - 我们通过AOP入门程序完成了业务接口执行耗时的统计.通过上面的程序, 我们也可以感受到AOP面向切面编程的一些优势：
        代码无侵入: 不修改原始的业务方法, 就可以对原始的业务方法进行了功能的增强或者是功能的改变
        减少了重复代码
        提高开发效率
        维护方便
        三.AOP详解.
        
        3.1.1切点(Pointcut)
        
        Pointcut 的作用就是提供一组规则 (使用 AspectJ pointcut expression language 来描述), 告诉程序对
        哪些方法来进行功能增强.
        execution(* com.example.demo.controller..(…)) 就是切点表达式.
        
        3.1.2连接点(Join Point)
        
        满足切点表达式规则的方法就是连接点. 也就是可以被AOP控制的方法.
        比如TestController中的test1和test2方发.
        3.1.3通知(advice)
        
        通知就是具体要做的工作, 指哪些重复的逻辑, 也就是共性功能(最终体现为一个方法). 比如上述程序中记录业务方法的消耗时间,就是通知.
        3.1.4切面(Aspect)
        
        切面(Aspect) = 切点(Pointcut) + 通知(Advice)
        通过切面就能够描述当前AOP程序需要针对于哪些方法, 在什么时候执行什么样的操作. 切面既包含了通知逻辑的定义, 也包括了连接点的定义.
        切面所在的类, 我们一般称为切面类(被@Aspect注解标识)
        举个例子来彻底理解上面的这几个概念.
        现在有一则通知, 22级软件工程的全体同学 , 在上午的10点在教学楼前开会
        针对上面的一句话:
        
        切点就是: 22级的全体同学.
        连接点就是: 张三,李四, 王五…
        通知就是: 在上午10点在教学楼前开会.
        切面就是: 22级的全体同学,在上午10点在教学楼前开会.
        3.2 通知类型
        
        Spring的通知类型有一下几种:
        @Around: 环绕通知, 此注解标注的通知方法在目标方法前, 后都被执行.
        @Before: 前置通知, 此注解标注的通知方法在目标方法前被执行.
        @After: 后置通知,此注解标注的通知方法在目标方法后被执行, 无论是否异常都会执行.
        @AfterReturning: 返回后通知,此注解标注的通知方法在目标方法后被执行, 有异常不会执行.
        @AfterThrowing: 异常后通知, 此注解标注的通知方法发生异常后执行.
        @Component @Aspect @Slf4j public class AspectDemo1 { @Pointcut("execution(* com.tuanzi.aop.controller.*.*(..))") public void pointCut() { } @Before("pointCut()") public void doBefore(JoinPoint joinPoint) { log.info("执行了before方法"); } @After("execution(* com.tuanzi.aop.controller.*.*(..))") public void doAfter(JoinPoint joinPoint) { log.info("执行了after方法"); } @Around("execution(* com.tuanzi.aop.controller.*.*(..))") public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable { //规范情况下,要有返回值,否则可能会造成controller中没有返回结果 log.info("执行了around before方法"); Object result = null; try { result = joinPoint.proceed(); } catch (Throwable e) { log.error("执行 doAround的目标函数, 内部出现异常"); throw new RuntimeException(e); } log.info("执行了around after方法"); return result; } @AfterReturning("execution(* com.tuanzi.aop.controller.*.*(..))") public void doAfterReturning(JoinPoint joinPoint) { log.info("执行了afterReturning方法"); } @AfterThrowing("execution(* com.tuanzi.aop.controller.*.*(..))") public void doAfterThrowing(JoinPoint joinPoint) { log.info("执行了afterThroeing方法"); } }
        
        正常情况:
        异常情况:
        3.3.@PointCut
        
        上面代码存在一个问题, 就是存在大量重复的切点表达式 execution(* com.example.demo.controller..(…)) ,Spring提供了 @PointCut 注解, 把公共的切点表达式提取出来, 需要用到时引用该切入点表达式即可.
        
        修改后的代码:
        @Pointcut("execution(* com.tuanzi.aop.controller.*.*(..))") public void pointCut() { } @Before("pointCut()") public void doBefore(JoinPoint joinPoint) { log.info("执行了before方法"); }
        
        注意事项:
        当切点定义使用private修饰时, 仅能在当前切面类中使用, 当其他切面类也要使用当前切点定义时, 就需
        要把private改为public. 引用方式为: 全限定类名.方法名()
        
        @Slf4j @Aspect @Component public class AspectDemo2 { //前置通知 @Before("com.example.demo.aspect.AspectDemo.pt()") public void doBefore() { log.info("执⾏ AspectDemo2 -> Before ⽅法"); } }
        
        3.4 切面的优先级(@Order)
        
        当一个项目中有多个切面类, 并且这些切面类的多个切点都匹配到同一个目标方法中,当目标方法运行的时候,所有切面类的通知方法都会执行,那这些切面执行的先后顺序该如何定义?
        不加任何措施的执行结果:
        通过上述程序的运行结果, 可以看出:
        存在多个切面类时, 默认按照切面类的类名字母排序：
        @Before 通知：字母排名靠前的先执行
        @After 通知：字母排名靠前的后执行
        但这种方式不方便管理, 我们的类名更多还是具备一定含义的. Spring 给我们提供了一个新的注解, 来控制这些切⾯通知的执行顺序: @Order
        
        @Order的使用方法:
        @Aspect @Component @Order(2) public class AspectDemo2 { //...代码省略 } @Aspect @Component @Order(1) public class AspectDemo3 { //...代码省略 } @Aspect @Component @Order(3) public class AspectDemo4 { //...代码省略 }
        
        加上@Order的执行结果:
        
        通过上述程序的运行结果, 得出@Order 注解标识的切面类, 执行顺序如下:
        
        @Before 通知：数字越小先执行
        @After 通知：数字越大先执行
        @Order 控制切面的优先级, 先执行优先级较高的切面, 再执行优先级较低的切面, 最终执行目标方法
        
        
        3.5切点表达式
        
        切点表达式常见有两种表达方式:
        
        execution(RR)：根据方法的签名来匹配
        @annotation(RR) ：根据注解匹配
        3.5.1 execution表达式
        
        execution() 是最常用的切点表达式, 用来匹配方法, 语法为:
        
        execution( )
        
        切点表达式⽀持通配符表达:
        
        * ：匹配任意字符，只匹配一个元素(返回类型, 包, 类名, 方法或者方法参数)
        a. 包名使用 * 表示任意包(一层包使用⼀个*)
        b. 类名使⽤ * 表示任意类
        c. 返回值使⽤ * 表示任意返回值类型
        d. ⽅法名使⽤ * 表示任意方法
        e. 参数使⽤ * 表示一个任意类型的参数
        … ：匹配多个连续的任意符号, 可以通配任意层级的包, 或任意类型, 任意个数的参数
        a. 使用 … 配置包名，标识此包以及此包下的所有子包
        b. 可以使用 … 配置参数，任意个任意类型的参数
        切点表达式示例:
        
        TestController 下的 public修饰, 返回类型为String 方法名为t1, 无参方法
        
        execution(public String com.example.demo.controller.TestController.t1())
        
        省略访问修饰符
        
        execution(String com.example.demo.controller.TestController.t1())
        
        匹配所有返回类型
        
        execution(* com.example.demo.controller.TestController.t1())
        
        匹配TestController 下的所有无参方法
        
        execution(* com.example.demo.controller.TestController.*())
        
        匹配TestController 下的所有方法
        
        execution(* com.example.demo.controller.TestController.*(…))
        
        匹配controller包下所有的类的所有方法
        
        execution(* com.example.demo.controller..(…))
        
        匹配所有包下面的TestController
        
        execution(* com…TestController.*(…))
        
        匹配com.example.demo包下, 子孙包下的所有类的所有方法
        
        execution(* com.example.demo…*(…))
        
        3.5.2@annotation
        
        execution表达式更适用有规则的, 如果我们要匹配多个无规则的方法呢, 比如：TestController中的t1()
        和UserController中的u1()这两个方法.
        
        这个时候我们使用execution这种切点表达式来描述就不是很方便了. 我们可以借助自定义注解的方式以及另一种切点表达式 @annotation 来描述这一类的切点.
        
        实现步骤：
        
        编写自定义注解
        使用 @annotation 表达式来描述切点
        在连接点的方法上添加自定义注解
        
        自定义注解@MyAspect:
        创建一个注解类(和创建Class文件一样的流程, 选择Annotation就可以了)
        
        @Target(ElementType.METHOD) //说明这个注解只能作用在方法上 @Retention(RetentionPolicy.RUNTIME) public @interface MyAspect { }
        
        代码简单说明:
        
        @Target 标识了 Annotation 所修饰的对象范围, 即该注解可以用在什么地方.
        常用取值:
        ElementType.TYPE: 用于描述类、接口(包括注解类型) 或enum声明
        ElementType.METHOD: 描述方法
        ElementType.PARAMETER: 描述参数
        ElementType.TYPE_USE: 可以标注任意类型
        @Retention 指Annotation被保留的时间长短, 标明注解的生命周期. @Retention 的取值有三种:
        
        RetentionPolicy.SOURCE：表示注解仅存在于源代码中, 编译成字节码后会被丢弃. 这意味着在运行时无法获取到该注解的信息, 只能在编译时使用. 比如 @SuppressWarnings , 以及lombok提供的注解 @Data , @Slf4j
        
        RetentionPolicy.CLASS：编译时注解. 表示注解存在于源代码和字节码中, 但在运行时会被丢弃. 这意味着在编译时和字节码中可以通过反射获取到该注解的信息, 但在实际运行时无法获取. 通常用于一些框架和工具的注解.
        
        RetentionPolicy.RUNTIME：运行时注解. 表示注解存在于源代码, 字节码和运行时中. 这意味着在编译时, 字节码中和实际运行时都可以通过反射获取到该注解的信息. 通常用于一些需要在运行时处理的注解, 如Spring的 @Controller @ResponseBody.
        切面类如何书写:
        @Aspect @Component @Slf4j public class MyAspectDemo { /** * 切面之间互不影响, * 如果一个方法既实现了RequestMapping接口,又使用了MyAspect注解,则两个切面的功能都会实现 */ //作用的范围是标识了这个注解的全部方法 @Around("@annotation(com.tuanzi.aop.config.MyAspect)") public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable { log.info("MyAspectDemo doAround before"); Object proceed = joinPoint.proceed(); log.info("MyAspectDemo doAround after"); return proceed; } //对所有实现requestMapping接口的方法生效 @Around("@annotation(org.springframework.web.bind.annotation.RequestMapping)") public Object doAround2(ProceedingJoinPoint joinPoint) throws Throwable { log.info("RequestMapping doAround before"); Object proceed = joinPoint.proceed(); log.info("RequestMapping doAround after"); return proceed; } }
        
        如何使用自定义注解
        @MyAspect @RequestMapping("/t1") public String t1() { return "t1"; } @MyAspect @RequestMapping("/u1") public String u1(){ return "u1"; }
        
        四.总结.
        
        Spring AOP的实现方式
        
        基于注解 @Aspect (参考上述课件内容)
        基于自定义注解 (参考自定义注解 @annotation 部分的内容)
        基于Spring API (通过xml配置的方式, 自从SpringBoot 广泛使用之后, 这种方法几乎看不到了)
        想了解的可以参考链接 https://cloud.tencent.com/developer/article/2032268
        基于代理来实现(更加久远的一种实现方式, 写法笨重, 不建议使用)