后端：Aop 面向切面编程

文章目录

- 1. Aop 初步学习面向切面编程，@EnableAspectJAutoProxy
- 2. AOP的核心概念
- 3. 前置通知（@Before）
- 4. 后置通知（@After）
- 5. 返回通知（@AfterReturning）
- 6. 异常通知（@AfterThrowing）
- 7. 通知的执行顺序
- 8. 切点表达式的抽取
- 9. 切点表达式的书写
- - 9.1 execution‌ 实现切点表达式
  - 9.2 within 实现切点表达式
  - 9.3 ‌‌@annotation 实现切点表达式

1. Aop 初步学习面向切面编程，@EnableAspectJAutoProxy

添加依赖，在新建的Spring Boot项目下的pom.xml文件添加aop对应的依赖，如下：

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

通过切面，在不改变原有代码的前提下，增强源代码的业务能力。下面是一段演示aop的代码。

package com.lize.demo.aop;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    public void add(){
        System.out.println("增加");
    }

    public void del(){
        System.out.println("删除");
    }

    public void query(){
        System.out.println("查询");
    }

    public void update(){
        System.out.println("修改");
    }
}

切面类，除了需要添加@Aspect注解表示这是一个切面类之外，还需要添加注解@Component表明这是一个Bean。通过注解@Around里边写上具体需要切入的方法，最终实现切面功能。

package com.lize.demo.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
// 标记为切面类
@Component
// 必须设置为切面的Bean
public class MyAspect {

    // 实现计时方法
    @Around("execution(* com.lize.demo.aop.UserService.*(..) )")
    // 切点表达式
    // * 表示方法的访问权限 可以为public等
    public void logTime(ProceedingJoinPoint point){

        long begin = System.currentTimeMillis();

        // 执行具体的方法
        try {
            point.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }

        long end = System.currentTimeMillis();

        System.out.println("用时为："+(end-begin));
    }
}

单元测试类

package com.lize.demo.aop;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@SpringBootTest(classes = AopDemo.class)
@ComponentScan
public class AopDemo {
    @Test
    public void test(@Autowired UserService us){
        us.add();
    }
}

运行结果如下：
在这里插入图片描述
只运行了add方法，原本只是输出“增加”，但是添加切面之后，除了输出“增加”这个字符串之外，还额外输出执行这个add方法的用时。在这个过程中，出现问题有，运行上述代码之后，切面没有起作用，也就是打印结果依旧为“增加”，但是我的项目是一个Spring Boot项目，Spring Boot项目会自动通过启动类帮我们加上@EnableAspectJAutoProxy，从而使切面起作用。解决方法可以是在这个单元测试类上加上这个注解@EnableAspectJAutoProxy，或者去掉@ComponentScan注解以及把@SpringBootTest(classes = AopDemo.class)这个注解修改为@SpringBootTest。出现这个问题的原因是因为我的单元测试所在的目录与Spring Boot项目启动类所在的目录不在同一个目录下，如果在同一个目录下，可以省略这个注解 @EnableAspectJAutoProxy，不过，建议加上。
在这里插入图片描述

2. AOP的核心概念

目标对象（target）：目标对象指将要被增强的对象。即包含主业务逻辑的类的对象，要增强的对象通常会有很多个。
切面（aspect）：指放存放增强代码的类。
通知（advice）：用来放增强的代码的那个方法，通知方式可以有环绕通知（@Around）【代码增强在目标方法的任意位置，更加通用】、前置通知（@Before）【目标方法之前执行】、后置通知（@After）【目标方法之后执行】、异常通知（@AfterThrowing）【目标方法出现了异常执行】、返回通知（@AfterReturning）【目标方法返回值执行】。
切点（pointcut）：增强代码要切入到哪些方法中，在代码中通常写的是切点表达式。
连接点（Join point）：通知和目标方法的一个桥梁，要获取目标方法的信息，就得通过JoinPoint。

关于连接点JoinPoint，在上面的代码中使用的是这个ProceedingJoinPoint，查看源码可知，ProceedingJoinPoint继承JoinPoint，并且还添加了如下方法的。
在这里插入图片描述

3. 前置通知（@Before）

现在我想要在执行上述代码中的add方法之前获取add这个方法名，此时可以考虑使用前置通知，在上述代码的基础之上，修改对应的注解即可，参考代码如下：

package com.lize.demo.aop.advice;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
// 标记为切面类
@Component
// 必须设置为切面的Bean
public class MyAspect {

    @Before("execution(* com.lize.demo.aop.advice.UserService.*(..) )")
    // 切点表达式
    public void before(JoinPoint joinPoint){

        String name = joinPoint.getSignature().getName();
        // 获取当前执行的方法名
        System.out.println("当前执行的方法是："+name);

    }
}

运行结果：
在这里插入图片描述

4. 后置通知（@After）

在目标方法执行之后再执行的代码，如下：

@After("execution(* com.lize.demo.aop.advice.UserService.*(..) )")
// 切点表达式
public void after(JoinPoint joinPoint){

    System.out.println("后置通知");
}

在这里插入图片描述

5. 返回通知（@AfterReturning）

在try\catch\finally这个防止异常代码结构中，如果在try中有返回值，依旧会执行finally里边的代码

获取目标方法的返回值：

@AfterReturning(value = "execution(* com.lize.demo.aop.advice.UserService.*(..) )",returning = "ans")
public void afterReturning(JoinPoint joinPoint,Object ans){
    System.out.println("返回通知。。目标方法的返回值为："+ans);
}

上述代码中为了获取返回值对象，在注解中使用returning进行接收，查看@AfterReturning的源码就可以知道了。
在这里插入图片描述
运行结果如下：

因为在add方面里边没有返回值，因此上述返回值为null。

6. 异常通知（@AfterThrowing）

当目标方法出现异常时执行的方法，参考代码如下：
在这里插入图片描述

@AfterThrowing(value = "execution(* com.lize.demo.aop.advice.UserService.*(..) )",throwing = "ans")
public void afterThrowing(JoinPoint joinPoint,Exception ans){

    System.out.println("异常通知。。目标方法的报错信息为："+ans);
}

通过throwing 获取异常信息，查看一下@AfterThrowing的源码就知道了。
在这里插入图片描述
运行结果如下：

7. 通知的执行顺序

正常情况下：先执行前置通知、再执行目标方法，然后执行返回通知、最后执行后置通知；
异常情况下：先执行前置通知、再执行目标方法、然后执行异常通知、最后执行后置通知。

在环绕通知中可以包含其他四种通知，因此环绕通知也是通用的。

8. 切点表达式的抽取

在这里插入图片描述
看一下上面的切点表达式，如果要进行修改，那么这些都需要进行修改，为此，可以利用切点表达式的抽取，把切点表达式抽取出来，这样只需要修改一处地方，在需要引入切点表达式的地方，引入方法即可，如下：

package com.lize.demo.aop.advice;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Aspect
// 标记为切面类
@Component
// 必须设置为切面的Bean
public class MyAspect {


    @Pointcut("execution(* com.lize.demo.aop.advice.UserService.*(..) )")
    public void pointCut(){}


    @Before("pointCut()")
    // 切点表达式
    public void before(JoinPoint joinPoint){

        String name = joinPoint.getSignature().getName();
        // 获取当前执行的方法名
        System.out.println("当前执行的方法是："+name);
    }

    @After("pointCut()")
    // 切点表达式
    public void after(JoinPoint joinPoint){

        System.out.println("后置通知");
    }

    @AfterReturning(value = "pointCut()",returning = "ans")
    public void afterReturning(JoinPoint joinPoint,Object ans){

        System.out.println("返回通知。。目标方法的返回值为："+ans);
    }

    @AfterThrowing(value = "pointCut()",throwing = "ans")
    public void afterThrowing(JoinPoint joinPoint,Exception ans){

        System.out.println("异常通知。。目标方法的报错信息为："+ans);
    }
}

9. 切点表达式的书写

9.1 execution‌ 实现切点表达式

execution‌ 能匹配到方法级别

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)

execution 表示切点标识符
modifiers-pattern 表示访问修饰符，即目标方法的访问权限，不写代表所有；
ret-type-pattern 表示目标方法的返回值类型，可以为void，*代表所有；
declaring-type-pattern 表示完整限定名，包含包名和类名；
- 包名
  - 可以写完整的，如com.xx.service
  - 也可以这样写，如com.xx.* 等价于 com.xx.dao、com.xx.service等，反正”*“只能代表一个层级吧！比如com.xx.service.inter是不能匹配到的
  - 如果想任意层级，可以这样写com.xx…，这样就可以匹配到com.xx.service.inter、com.xx.service.inter.until等
- 类名
  - ”*“代表所有类
  - com.xx…*可以匹配到com.xx.service.utils.inter.任意包.任意类
name-pattern 表示方法，"*"代表匹配所有
param-pattern 表示方法的参数，”…“表示任意参数，不写表示匹配无参数

9.2 within 实现切点表达式

within 只能匹配到类级别，表示类下面的所有方法都能匹配到。

@Before("within(com.lize.demo.aop.advice.UserService)")
// 切点表达式
public void before(JoinPoint joinPoint){

    String name = joinPoint.getSignature().getName();
    // 获取当前执行的方法名
    System.out.println("当前执行的方法是："+name);
}

9.3 ‌‌@annotation 实现切点表达式

@annotation 用于匹配特定注解的方法
这里定义了一个自定义的注解

package com.lize.demo.aop.advice;


import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;


@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface MyLog {
    String value();
}

在这里插入图片描述

@Before("@annotation(log)")
// 切点表达式
public void before(JoinPoint joinPoint,MyLog log){

    String name = joinPoint.getSignature().getName();
    // 获取当前执行的方法名
    System.out.println("当前执行的方法是："+name+"  "+log);
}