Spring的AOP切面应用对【后台对接口增强】

简介：

咱们写一个办法时假如每个接口都需要写一段固定的代码时，咱们能够考虑运用切面（AOP）对办法进行增强，这些增强的办法称为连接点。好比我现在有个接口是用于提交数据或许对数据进行修正，这个时候假如发现数据有问题是不是应该进行排查，假如是直接打印日志的办法不是开发的同学就没办法判别为什么会发生过错数据，一般后台体系都有张表是用于记载用户操作数据的，这样咱们就能够通过提交的数据进行排查为什么会发生过错数据，还有一个就是对数据进行操作发生问题追究责任的看是那个后台用户进行操作的。假如是依照之前的办法就是在对应的接口写保存日志的代码，代码就会变得重复且无意义，当保存记载增加新字段时咱们又得到每一个接口上进行修正增加。

当运用切面以后咱们只需要定义一个切面类对一些办法进行统一处理。切面能够通过增加execution表达式进行对指定包下某个类某个办法进行增强。

切面表达式：

execution( [权限修饰符] [回来类型] [办法称号] ([参数列表]))

如：对com.itmei.service.CsService.update()办法进行增强 表达式如下：

execution(*  com.itmei.service.CsService.update(..))

如：对com.itmei.service.CsService下的一切办法进行增强 表达式如下：

execution(*  com.itmei.service.CsService.*(..))

如：对com.itmei.service包下的一切类办法进行增强 表达式如下：

execution(*  com.itmei.service.*.*(..))

切面告诉类型：

• 前置告诉——@Before() （在调用被增强的办法前会调用该办法）
• 后置告诉——@AfterReturning() （当办法运转完成后会调用该办法）
• 盘绕告诉——@Around
• 反常告诉——@AfterThrowing()
• 最终告诉——@After()（相当于finally）

后边代码中演示就比较好理解

️创立项目演示：

创立项目：

创立一个SpringBoot项目假如不知道然后创立能够点击检查 只需要看这个章节就能够创立好SpringBoot项目，我这儿就不过多进行介绍怎么创立项目。

增加依靠：

在pom.xml中增加依靠

   <!--增加SpringBoot的AOP依靠-->
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-aop</artifactId>
   </dependency>

增加对应的包和类：

需要增强的类

编写切面类：

创立切面类：

/**
 * @Author Itmei
 * @Date 2022/12/18 10:47
 * @Version 1.0
 * AOP类
 */
@SuppressWarnings("AlibabaCommentsMustBeJavadocFormat")
@Component
@Aspect //切面注解
@Order(10) // 若有多个切面类，能够用Order注解决议不同类中的切面的履行顺序值越小越先履行
public class CommonAop {
    //标识切入点的特征
    @Pointcut(value = "execution(*  com.itmei.springaopdemo.service.impl.CsServiceImpl.update(..))")
    public void pointCut(){}
    //前置告诉
    @Before(value = "pointCut()")
    public void before(JoinPoint joinPoint){
        System.out.println("前置告诉：处理查询该用户那些权限");
        System.out.println("  --办法的请求参数："+Arrays.toString(joinPoint.getArgs()));
    }
    /**
     * 后置告诉（@After）：当被增强的办法完毕后会调用该告诉
     * @param joinPoint
     */
    @After(value = "pointCut()")
    public void after(JoinPoint joinPoint){
        System.out.println("后置告诉：当被增强的办法完毕后会调用该告诉");
    }
    /**
     * 回来告诉（@AfterReturning）：当被增强的办法 成功履行之后调用告诉
     * @param joinPoint
     * @param jsonResult
     */
    @AfterReturning(value = "pointCut()",returning = "jsonResult")
    public void afterReturning(JoinPoint joinPoint,Object jsonResult){
        System.out.println("回来告诉：当被增强的办法 成功履行之后调用告诉");
    }
    /**
     * 反常告诉（afterThrowing） 当被增强的办法 出现反常之后调用告诉
     * @param joinPoint
     */
    @AfterThrowing(value = "pointCut()",throwing = "e")
    public void afterThrowing(JoinPoint joinPoint,Exception e){
        System.out.println("反常告诉：当被增强的办法 出现反常之后调用告诉");
        System.out.println("  --"+e.getMessage());
    }
    /**
     * 盘绕告诉 运用盘绕告诉后能够不运用Before和after告诉
     * proceedingJoinPoint.proceed();的作用是让方针办法履行，@Around = @Before + 办法履行 + @After
     */
    @Around(value = "pointCut()")
    public void around(ProceedingJoinPoint proceedingJoinPoint){
        //这儿写Before告诉的代码
        System.out.println("盘绕告诉：Before");
        try {
            proceedingJoinPoint.proceed();
        } catch (Throwable throwable) {
            System.out.println("盘绕告诉：报错信息"+throwable.getMessage());
        }
        //这儿写after告诉的代码
        System.out.println("盘绕告诉：after");
    }
}

测验作用：

@SpringBootTest
class SpringAopDemoApplicationTests {
    @Resource
    private CsService csService;
    @Test
    void contextLoads() {
        csService.update("123","itmei");
    }
}

运转成果：

由此能够得出： 无反常：@Around（proceed()之前的部分） → @Before → 办法履行 →@AfterReturning →@After →@Around（proceed()之后的部分

在需要增强的办法增加报错：

运转作用：

由此能够得出： 有反常：@Around（proceed(之前的部分)） → @Before→ 办法履行 → @AfterThrowing→ @After →@Around(反常捕获的代码) →@Around（proceed(之后的部分)）

完毕：

那么咱们就能够把，进入日志的代码写在前置告诉或许后置告诉里边