Spring 面向切面编程(AOP)

一、aop介绍

(一)前言

一般的后端开发流程是纵向开发,就是controller(控制层)->service(业务层)->mapper(数据持久层),Spring采用动态代理技术可以在程序的运行过程中对每一层进行增强,也就是面向切面编程(Aspect Oriented Programming)。
Spring 面向切面编程(AOP)_第1张图片

(二)使用场景

(1)想要在每类业务处理的时候保存日志,包含业务处理的具体数据、具体时间、具体用户;
(2)如果业务方法是异步的,可以监控业务方法是否报错;
(3)可以实现数据库事务;

(三)相关术语

1、Joinpoint(连接点)

类里面可以被增强的方法即是连接点;

2、Pointcut(切入点)

对连接点进行拦截的定义即是切入点。
切入点的实现方式有两种:
(1)使用@Pointcut注解定义切入点;
(2)自定义注解作为连接点,对注解进行拦截;

3、Advice(通知)

拦截到切入点之后要做的事情
通知分为以下几类:
(1)前置通知(@Before):目标方法执行之前执行;
(2)后置通知(@After):目标方法执行之后执行,无论连接点是否出现异常,都会执行;
(3)异常通知(@AfterThrowing):连接点出现异常后才会执行;
(4)返回通知(@AfterReturning):连接点成功执行后,执行返回通知方法,如果连接点方法出现异常,该通知不执行;
(5)环绕通知(@Around):以上四种通知可以通过环绕通知实现;

4、Aspect(切面)

切入点和通知的结合

5、Target(目标对象)

要增强的类

二、代码实现

(一)准备工作

1、控制层(Controller)
package com.xiaobai.aroundtest.controller;

import com.xiaobai.aroundtest.entity.Article;
import com.xiaobai.aroundtest.service.IAroundTestService;
import lombok.AllArgsConstructor;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author wangtw
 * @date 2023/12/6 0:20
 * @description 切面测试控制器
 */
@AllArgsConstructor
@RestController
public class AroundTestController {

    private final IAroundTestService aroundTestService;

    @PostMapping("aroundTest")
    public void aroundTest(@RequestParam String name, @RequestBody Article article) {
        aroundTestService.aroundTest(name, article);
    }
}

2、业务层(Service)

(1)业务层接口

package com.xiaobai.aroundtest.service;

import com.xiaobai.aroundtest.annotation.AroundTest;
import com.xiaobai.aroundtest.entity.Article;

/**
 * @author wangtw
 * @date 2023/12/6 0:39
 * @description 环绕通知测试服务类
 */
public interface IAroundTestService {

    void aroundTest(String name, Article article);
}

(2)业务层实现类

package com.xiaobai.aroundtest.service.impl;

import com.xiaobai.aroundtest.annotation.AroundTest;
import com.xiaobai.aroundtest.entity.Article;
import com.xiaobai.aroundtest.service.IAroundTestService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

/**
 * @author wangtw
 * @date 2023/12/6 0:42
 * @description
 */
@Slf4j
@Service
public class AroundTestServiceImpl implements IAroundTestService {

    @AroundTest // 自定义注解
    @Override
    public void aroundTest(String name, Article article) {
        log.info("保存文章");
    }
}

(二)使用@Pointcut定义切入点

1、前言

@Pointcut 可以使用 annotation、within、execution 等方式将 方法(method)、类(class)、接口(interface)、包(package) 等作为切入点,
以下代码使用的是execution指定切入点。

2、execution语法
execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)

(1)修饰符匹配(modifier-pattern?)
(2)返回值匹配(ret-type-pattern)可以为*表示任何返回值,全路径的类名等
(3)类路径匹配(declaring-type-pattern?)
(4)方法名匹配(name-pattern)可以指定方法名 或者 代表所有, set 代表以set开头的所有方法
(5)参数匹配((param-pattern))可以指定具体的参数类型,多个参数间用“,”隔开,各个参数也可以用“”来表示匹配任意类型的参数,如(String)表示匹配一个String参数的方法;(,String) 表示匹配有两个参数的方法,第一个参数可以是任意类型,而第二个参数是String类型;可以用(…)表示零个或多个任意参数
(6)异常类型匹配(throws-pattern?)
其中后面跟着“?”的是可选项

3、定义切面

以下表达式指定的是com.xiaobai及其子包下service.impl的所有方法

execution(* com.xiaobai..*.service.impl..*.*(..))

切面类需要使用@Aspect指定,使用@Component注解将切面交由Spring容器管理,切面类代码如下:

package com.xiaobai.aroundtest.aspect;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

/**
 * @author wangtw
 * @date 2023/12/6 0:47
 * @description service切面
 */
@Aspect
@Component
@Slf4j
public class TransactionalAspect {

    @Pointcut("execution(* com.xiaobai..*.service.impl..*.*(..))")
    private void pointCut() {}

    /**
     * 开启事务(前置通知)
     */
    @Before("pointCut()")
    public  void beginTransaction(){
        try {
            log.info("开启事务");
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    /**
     * 提交事务(后置返回通知)
     */
    @AfterReturning("pointCut()")
    public  void commit(){
        try {
            log.info("提交事务");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    /**
     * 回滚事务(异常通知)
     */
    @AfterThrowing("pointCut()")
    public  void rollback(){
        try {
            log.info("回滚事务");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    /**
     * 释放连接(后置通知)
     */
    @After("pointCut()")
    public  void release(){
        try {
            log.info("释放连接");
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}


(三)通过拦截注解的方式实现切面

1、自定义注解

(1)使用@Target指定目标元素,这个注解是用于拦截方法,使用ElementType.METHOD
(2)使用@Retention指定注解的生命周期:
RetentionPolicy.RUNTIME 表示此注解被保存到class文件中,jvm加载class文件后,此注解仍存在;RetentionPolicy.SOURCE 表示此注解只会保留到源文件中,文件编译成class文件后,此注解就会消失;RetentionPolicy.CLASS 表示此注解会被保存到class文件中,但jvm加载class文件后,此注解会被遗弃;

package com.xiaobai.aroundtest.annotation;

import java.lang.annotation.*;

/**
 * @author wangtw
 * @date 2023/12/6 0:45
 * @description
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface AroundTest {

    /**
     * 实体类属性名
     * @return
     */
    String name() default "name";
}

2、定义切面

@Around 用于实现环绕通知,使用 @annotation(aroundTest) 指定需要拦截的注解,环绕通知需要携带 ProceedingJoinPoint 类型的参数。
可以使用 (MethodSignature) ProceedingJoinPoint.getSignature() 获取方法参数,具体代码如下:

// 获取参数名称
MethodSignature methodSignature = (MethodSignature) point.getSignature();
String[] parameterNames = methodSignature.getParameterNames();

使用 ProceedingJoinPoint.getArgs() 方法获取参数值

// 获取参数
Object[] args = point.getArgs();

切面代码如下:

package com.xiaobai.aroundtest.aspect;

import com.xiaobai.aroundtest.annotation.AroundTest;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Component;

import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * @author wangtw
 * @date 2023/12/6 0:47
 * @description
 */
@Aspect
@Component
@Slf4j
public class AroundTestAspect {

    @Around("@annotation(aroundTest)")
    public Object around(ProceedingJoinPoint point, AroundTest aroundTest) {
        // 获取参数名称
        MethodSignature methodSignature = (MethodSignature) point.getSignature();
        String[] parameterNames = methodSignature.getParameterNames();
        // 获取参数
        Object[] args = point.getArgs();
        for (int i = 0; i < parameterNames.length; i++) {
            if (parameterNames[i].equals(aroundTest.name())) {
                log.info("保存{}为{}的文章", parameterNames[i], args[i]);
            }
        }

        String info = "";
        for (Object arg : args) {
            if (arg instanceof String) {

            } else {
                // 获取文章信息
                PropertyDescriptor[] propertyDescriptors = BeanUtils.getPropertyDescriptors(arg.getClass());
                for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
                    if (!String.class.isAssignableFrom(propertyDescriptor.getPropertyType())) {
                        continue;
                    }
                    Method readMethod = propertyDescriptor.getReadMethod();
                    if (readMethod == null) {
                        continue;
                    }

                    Object propertyValue = null;
                    try {
                        propertyValue = readMethod.invoke(arg, null);
                    } catch (IllegalAccessException e) {
                        e.printStackTrace();
                    } catch (InvocationTargetException e) {
                        e.printStackTrace();
                    }

                    info = info.concat(propertyDescriptor.getName())
                            .concat(":")
                            .concat(propertyValue == null ? "" : propertyValue.toString())
                            .concat(",");
                }
            }
        }
        Object result = null;
        try {
            result = point.proceed(point.getArgs());
        } catch (Throwable e) {
            e.printStackTrace();
            log.error("方法异常,文章信息:{}", info);
        }
        log.info("修改成功, 文章信息:{}", info);
        return result;
    }
}

三、总结

1、Spring使用Cglib增强了service,注入到controller的service实际上是个代理对象
Spring 面向切面编程(AOP)_第2张图片

2、使用postman测试controller接口,输出结果如下:
Spring 面向切面编程(AOP)_第3张图片

保存name为java核心技术的文章
开启事务
保存文章
提交事务
释放连接
修改成功, 文章信息:description:囊括了Java平台标准版(JavaSE/J2SE)的全部基础知识,提供了大量完整且具有实际意义的应用实例,详细介绍了Java语言基础知识、面向对象程序设计、接口与内部类、事件监听器模型、swing图形用户界面程序设计、打包应用程序、异常处理、登录与调试、泛型程序设计、集合框架、多线程等内容,name:java核心技术,

参考

SpringBoot+Vue全栈开发实战 王松 清华大学出版社
@Retention注解详解 自由的棉花
Spring AOP中@Pointcut切入点表达式使用介绍 Roc Lau
【Spring AOP】@Aspect结合案例详解(一): @Pointcut使用@annotation + 五种通知Advice注解(已附源码) 天罡gg
AspectJ 切面注解中五种通知注解:@Before、@After、@AfterReturning、@AfterThrowing、@Around 苍鹰蛟龙
Spring——面向切面编程(AOP) 行者无疆_ty

你可能感兴趣的:(spring系列,spring)