SpringBoot 事务与AOP

news2024/11/26 11:57:22

目录

  • 事务
    • Spring事务管理 @Transactional
    • Spring事务进阶-rollbackFor与propagation属性
  • AOP(面向切面编程)
    • AOP入门案例实现-@Aspect & AOP核心概念
    • AOP进阶
      • 通知类型 @Around、@Before、@After和@PointCut抽取切入点表达式
      • 通知顺序 @Order
      • 切入点表达式 execution(……)与@annotation(……)
      • 连接点 JoinPoint与ProceedingJoinPoint
    • AOP案例
      • 实现

事务

在数据库阶段我们已学习过事务，其是一组操作的集合，它是一个不可分割的工作单位。

事务的操作主要有三步：

1. 开启事务（一组操作开始前，开启事务）：start transaction / begin ;
2. 提交事务（这组操作全部成功后，提交事务）：commit ;
3. 回滚事务（中间任何一个操作出现异常，回滚事务）：rollback ;

Spring事务管理 @Transactional

结合之前的SpringBootWeb案例——Tlias智能学习辅助系统，看一个场景，解散部门 （解散部门就是删除部门）步骤：1.根据ID删除部门数据 2.根据部门ID删除该部门下的员工

模拟删除过程中可能出现异常的代码：

@Slf4j
@Service
public class DeptServiceImpl implements DeptService {
    @Autowired
    private DeptMapper deptMapper;

    @Autowired
    private EmpMapper empMapper;


    //根据部门id，删除部门信息及部门下的所有员工
    @Override
    public void delete(Integer id){
        //根据部门id删除部门信息
        deptMapper.deleteById(id);
        
        //模拟：异常发生
        int i = 1/0;

        //删除部门下的所有员工信息
        empMapper.deleteByDeptId(id);   
    }
}

程序运行抛出了异常，部门依然删除了，但是部门下的员工却没有删除，造成了数据的不一致。此时，我们就需要在delete删除业务功能中添加事务。
在spring框架当中就已经把事务控制的代码都已经封装好了，只需要通过一个简单的注解@Transactional就搞定了。

@Transactional作用：在当前这个方法执行开始之前来开启事务，方法执行完毕之后提交事务。如果在这个方法执行的过程当中出现了异常，就会进行事务的回滚操作。


@Transactional注解：我们一般会在业务层当中来控制事务，并且一般不会在查询操作中使用@Transactional注解，因为其不会改变数据库内容。


@Transactional注解书写位置：
方法:当前方法交给spring进行事务管理
类：当前类中所有的方法都交由spring进行事务管理
接口:接口下所有的实现类当中所有的方法都交给spring 进行事务管理

delete上加上 @Transactional 来控制事务：

@Slf4j
@Service
public class DeptServiceImpl implements DeptService {
    @Autowired
    private DeptMapper deptMapper;

    @Autowired
    private EmpMapper empMapper;

    
    @Override
    @Transactional  //当前方法添加了事务管理
    public void delete(Integer id){
        //根据部门id删除部门信息
        deptMapper.deleteById(id);
        
        //模拟：异常发生
        int i = 1/0;

        //删除部门下的所有员工信息
        empMapper.deleteByDeptId(id);   
    }
}

运行程序，发现发生异常后数据库内的数据正常回滚。

在这里插入图片描述

可以在application.yml配置文件中开启事务管理日志，这样就可以在控制看到和事务相关的日志信息了

#spring事务管理日志
logging:
  level:
    org.springframework.jdbc.support.JdbcTransactionManager: debug


Spring事务进阶-rollbackFor与propagation属性

@Transactional注解当中的两个常见的属性：

1. 指定回滚异常类型的属性：rollbackFor
2. 配置事务传播行为属性：propagation

rollbackFor

做一个测试，我们修改业务功能代码，在模拟异常的位置上直接抛出Exception异常（编译时异常）

@Transactional
public void delete(Integer id) throws Exception {
        //根据部门id删除部门信息
        deptMapper.deleteById(id);
        
        //模拟：异常发生
        if(true){
            throw new Exception("出现异常了~~~");
        }

        //删除部门下的所有员工信息
        empMapper.deleteByDeptId(id);   
}

重新启动服务后测试：抛出异常之后事务会不会回滚。发生了Exception异常，但事务依然提交了：

在这里插入图片描述

结论：默认情况下，只有出现RuntimeException(运行时异常)才会回滚事务。
假如我们想让所有的异常都回滚，需要来配置@Transactional注解当中的rollbackFor属性，通过
rollbackFor这个属性可以指定出现何种异常类型回滚事务:

@Transactional(rollbackFor=Exception.class)
public void delete(Integer id){
    //根据部门id删除部门信息
    deptMapper.deleteById(id);
    
    //模拟：异常发生
    if(true){
        throw new Exception("出现异常了~~~");
    }

    //删除部门下的所有员工信息
    empMapper.deleteByDeptId(id);   
}

重新启动服务，测试删除部门的操作,异常,又进行了事务回滚。

在这里插入图片描述



propagation

例如：两个事务方法，一个A方法，一个B方法。在这两个方法上都添加了@Transactional注解，就代表这两个方法都具有事务，而在A方法当中又去调用了B方法。那么B方法在运行的时候，到底是加入到A方法的事务当中来，还是B方法在运行的时候新建一个事务？这个就涉及到了事务的传播行为。

可以通过propagation配置事务的传播行为的。

属性值含义
REQUIRED【默认值】需要事务，有则加入，无则创建新事务
REQUIRES_NEW需要新事务，无论有无，总是创建新事务
SUPPORTS支持事务，有则加入，无则在无事务状态中运行
NOT_SUPPORTED不支持事务，在无事务状态下运行,如果当前存在已有事务,则挂起当前事务
MANDATORY必须有事务，否则抛异常
NEVER必须没事务，否则抛异常
…

对于这些事务传播行为，我们只需要关注以下两个就可以了：

  1. REQUIRED（默认值）
  2. REQUIRES_NEW

比如在删除部门是需要操作记录日志，在删除部门的操作里调用了其他业务类中的方法——记录日志方法：

@Transactional(rollbackFor = Exception.class) 
public void delete(Integer id) throws Exception {
    try {
        //根据部门id删除部门信息
        deptMapper.deleteById(id);
        //模拟：异常
        if(true){
            throw new Exception("出现异常了~~~");
        }
        //删除部门下的所有员工信息
        empMapper.deleteByDeptId(id);
    }finally {
        //不论是否有异常，最终都要执行的代码：记录日志
        DeptLog deptLog = new DeptLog();
        deptLog.setCreateTime(LocalDateTime.now());
        deptLog.setDescription("执行了解散部门的操作，此时解散的是"+id+"号部门");
        //调用其他业务类中的方法
        deptLogService.insert(deptLog);
    }
}

deptLogService.insert()方法也有@Transactional注解：

@Service
public class DeptLogServiceImpl implements DeptLogService {

    @Autowired
    private DeptLogMapper deptLogMapper;

    @Transactional //事务传播行为：有事务就加入、没有事务就新建事务
    @Override
    public void insert(DeptLog deptLog) {
        deptLogMapper.insert(deptLog);
    }
}

此时重新启动SpringBoot服务，测试删除3号部门后会发生什么？
我们发现执行日志的操作也被回滚了，因为当执行insert操作时，insert设置的事务传播行是默认值REQUIRED，表示有事务就加入，没有则新建事务。
此时：delete和insert操作使用了同一个事务，同一个事务中的多个操作，要么同时成功，要么同时失败，所以当异常发生时进行事务回滚，就会回滚delete和insert操作

在这里插入图片描述



在DeptLogServiceImpl类中insert方法上，添加@Transactional(propagation=Propagation.REQUIRES_NEW):

@Service
public class DeptLogServiceImpl implements DeptLogService {

    @Autowired
    private DeptLogMapper deptLogMapper;

    @Transactional(propagation = Propagation.REQUIRES_NEW)//事务传播行为：不论是否有事务，都新建事务
    @Override
    public void insert(DeptLog deptLog) {
        deptLogMapper.insert(deptLog);
    }
}

此时，DeptServiceImpl中的delete方法运行时，会开启一个事务。 当调用deptLogService.insert(deptLog) 时，也会创建一个新的事务，那此时，当insert方法运行完毕之后，事务就已经提交了。 即使外部的事务出现异常，内部已经提交的事务，也不会回滚了，因为是两个独立的事务。

结论：

  • REQUIRED ：大部分情况下都是用该传播行为即可。

  • REQUIRES_NEW ：当我们不希望事务之间相互影响时，可以使用该传播行为。比如：下订单前需要记录日志，不论订单保存成功与否，都需要保证日志记录能够记录成功。





AOP(面向切面编程)

AOP是spring框架的第二大核心。AOP英文全称：Aspect Oriented Programming（面向切面编程、面向方面编程），其实说白了，面向切面编程就是面向特定方法编程。

下面进行一个快速入门案例展示。
当需要统计当前这个项目当中每一个业务方法的执行耗时，一种方案是在每一个业务方法运行之前，记录这个方法运行的开始时间。在这个方法运行完毕之后，再来记录这个方法运行的结束时间。但是此方案需要修改在每一个模块下的业务方法，非常繁琐。

在这里插入图片描述

AOP的作用：在程序运行期间在不修改源代码的基础上对已有方法进行增强（无侵入性: 解耦）

对于AOP，我们只需要定义一个模板方法，记录方法执行耗时这一部分公共的逻辑代码，在其中运行原始的业务方法。运行的原始业务方法可以是一个也可以是多个，我们可以指定运行哪些原始业务方法。那面向这样的指定的一个或多个方法进行编程，我们就称之为 面向切面编程。

在这里插入图片描述

这个流程和我们之前所学习的动态代理技术是非常类似的。所说的模板方法，其实就是代理对象中所定义的方法，那代理对象中的方法以及根据对应的业务需要， 完成了对应的业务功能。

AOP面向切面编程和OOP面向对象编程一样，它们都仅仅是一种编程思想，而动态代理技术是这种思想最主流的实现方式。而Spring的AOP是Spring框架的高级技术，旨在管理bean对象的过程中底层使用动态代理机制，对特定的方法进行编程(功能增强)。

AOP的优势：1. 减少重复代码 2. 提高开发效率 3. 维护方便



AOP入门案例实现-@Aspect & AOP核心概念

导入依赖：在pom.xml中导入AOP的依赖

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

AOP程序：TimeAspect

@Component //切面类也需要交给IOC容器管理!
@Aspect //当前类为切面类
@Slf4j
public class TimeAspect {

    @Around("execution(* com.itheima.service.*.*(..))") 
    public Object recordTime(ProceedingJoinPoint pjp) throws Throwable {
        //记录方法执行开始时间
        long begin = System.currentTimeMillis();

        //执行原始方法
        Object result = pjp.proceed();

        //记录方法执行结束时间
        long end = System.currentTimeMillis();

        //计算方法执行耗时
        log.info(pjp.getSignature()+"执行耗时: {}毫秒",end-begin);

        return result;
    }
}

切面所在的类，我们一般称为切面类,被@Aspect注解标识的类

此时查询3号部门信息：

在这里插入图片描述

AOP的功能远不止于此，常见的应用场景如下：

记录系统的操作日志
权限控制
事务管理：我们前面所讲解的Spring事务管理，底层其实也是通过AOP来实现的，只要添加@Transactional注解之后，AOP程序自动会在原始方法运行前先来开启事务，在原始方法运行完毕之后提交或回滚事务



下面我们再来学习AOP当中涉及到的一些核心概念。

  1. 连接点：JoinPoint，可以被AOP控制的方法（暗含方法执行时的相关信息）

在这里插入图片描述

  1. 通知：Advice，指哪些重复的逻辑，也就是共性功能（最终体现为一个方法）

在这里插入图片描述

  1. 切入点：PointCut，匹配连接点的条件，通知仅会在切入点方法执行时被应用

在这里插入图片描述

  1. 切面：Aspect，描述通知与切入点的对应关系（通知+切入点就形成了一个切面）

在这里插入图片描述

  1. 目标对象：Target，通知所应用的对象

在这里插入图片描述

结论：
Spring的AOP底层是基于动态代理技术来实现的，也就是说在程序运行的时候，会自动的基于动态代理技术为目标对象生成一个对应的代理对象。在代理对象当中就会对目标对象当中的原始方法进行功能的增强。

在这里插入图片描述





AOP进阶

对AOP当中的各个细节进行详细的学习。主要分为4个部分：

1. 通知类型
2. 通知顺序
3. 切入点表达式
4. 连接点

通知类型 @Around、@Before、@After和@PointCut抽取切入点表达式

在入门程序当中，我们已经使用了一种功能最为强大的通知类型，Around环绕通知，只要我们在通知方法上加上了@Around注解，就代表当前通知是一个环绕通知。

@Around("execution(* com.itheima.service.*.*(..))")

Spring中AOP的通知类型：

@Around：环绕通知，此注解标注的通知方法在目标方法前、后都被执行
@Before：前置通知，此注解标注的通知方法在目标方法前被执行
@After ：后置通知，此注解标注的通知方法在目标方法后被执行，无论是否有异常都会执行
@AfterReturning ： 返回后通知，此注解标注的通知方法在目标方法后被执行，有异常不会执
行
@AfterThrowing ： 异常后通知，此注解标注的通知方法发生异常后执行

注意@Before不要跟Junit中的@Before搞混。

下面通过代码演示，来加深对于不同通知类型的理解：

@Slf4j
@Component //切面类也需要交给IOC容器管理!
@Aspect
public class MyAspect1 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(JoinPoint joinPoint){
        log.info("before ...");

    }

    //环绕通知
    @Around("execution(* com.itheima.service.*.*(..))")
    public Object around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        log.info("around before ...");

        //调用目标对象的原始方法执行
        Object result = proceedingJoinPoint.proceed();
        
        //原始方法如果执行时有异常，环绕通知中的后置代码不会在执行了
        
        log.info("around after ...");
        return result;
    }

    //后置通知
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(JoinPoint joinPoint){
        log.info("after ...");
    }

    //返回后通知（程序在正常执行的情况下，会执行的后置通知）
    @AfterReturning("execution(* com.itheima.service.*.*(..))")
    public void afterReturning(JoinPoint joinPoint){
        log.info("afterReturning ...");
    }

    //异常通知（程序在出现异常的情况下，执行的后置通知）
    @AfterThrowing("execution(* com.itheima.service.*.*(..))")
    public void afterThrowing(JoinPoint joinPoint){
        log.info("afterThrowing ...");
    }
}

重新启动SpringBoot服务，查询部门测试：

在这里插入图片描述

往查询部门的DeptServiceImpl业务实现类中的代码中添加异常后测试：

在这里插入图片描述

程序发生异常的情况下：

  • @AfterReturning标识的通知方法不会执行，@AfterThrowing标识的通知方法执行了

  • @Around环绕通知中原始方法调用时有异常，通知中的环绕后的代码逻辑也不会在执行了 （因为原始方法调用已经出异常了）

在使用通知时的注意事项

@Around环绕通知需要自己调用 ProceedingJoinPoint.proceed() 来让原始方法执行，其他通知不需要考虑目标方法执行
@Around环绕通知方法的返回值，必须指定为Object，来接收原始方法的返回值，否则原始方法执行完毕，是获取不到返回值的。


PS：刚刚的每一个注解里面都指定了切入点表达式，而且这些切入点表达式都一模一样。假如此时切入点表达式需要变动，就需要将所有的切入点表达式一个一个的来改动，就变得非常繁琐了。
Spring提供了@PointCut注解，该注解的作用是将公共的切入点表达式抽取出来，需要用到时引用该切入点表达式即可。

@Slf4j
@Component //切面类也需要交给IOC容器管理!
@Aspect
public class MyAspect1 {

    //切入点方法（公共的切入点表达式）
    @Pointcut("execution(* com.itheima.service.*.*(..))")
    private void pt(){

    }

    //前置通知（引用切入点）
    @Before("pt()")
    public void before(JoinPoint joinPoint){
        log.info("before ...");

    }

    //环绕通知
    @Around("pt()")
    ....

当切入点方法使用private修饰时，仅能在当前切面类中引用该表达式， 当外部其他切面类中也要引用当前类中的切入点表达式，就需要把private改为public，而在引用的时候，具体的语法为：全类名.方法名()，具体形式如下：

@Slf4j
@Component //切面类也需要交给IOC容器管理!
@Aspect
public class MyAspect2 {
    //引用MyAspect1切面类中的切入点表达式
    @Before("com.itheima.aspect.MyAspect1.pt()")
    public void before(){
        log.info("MyAspect2 -> before ...");
    }
}




通知顺序 @Order

当定义了多个切面类，而多个切面类中多个切入点都匹配到了同一个目标方法。此时当目标方法在运行的时候，这多个切面类当中的这些通知方法都会运行。这多个通知方法到底哪个先运行，哪个后运行？下面我们通过程序来验证

定义三个切片类MyAspect2、MyAspect3、MyAspect4指向部门查询，分别写入@Before和@After：

@Slf4j
@Component //切面类也需要交给IOC容器管理!
@Aspect
public class MyAspect2 {
    //前置通知
    @Before("execution(* com.itheima.service.*.*(..))")
    public void before(){
        log.info("MyAspect2 -> before ...");
    }

    //后置通知
    @After("execution(* com.itheima.service.*.*(..))")
    public void after(){
        log.info("MyAspect2 -> after ...");
    }
}

重启服务测试（ 注释掉其他切面类(把@Aspect注释即可)，仅保留MyAspect2、MyAspect3、MyAspect4 ，这样就可以清晰看到执行的结果，而不被其他切面类干扰）：

在这里插入图片描述

通过以上程序运行可以看出在不同切面类中，默认按照切面类的类名字母排序：
目标方法前的通知方法：字母排名靠前的先执行
目标方法后的通知方法：字母排名靠前的后执行

如果我们想控制通知的执行顺序有两种方式：

  1. 修改切面类的类名（这种方式非常繁琐、而且不便管理）
  2. 使用Spring提供的@Order注解

@Order(2) //切面类的执行顺序（前置通知：数字越小先执行; 后置通知：数字越小越后执行）

我们给MyAspect2标注@Order(2)、MyAspect3标注@Order(3)、MyAspect4标注@Order(1)：

在这里插入图片描述





切入点表达式 execution(……)与@annotation(……)

切入点表达式：描述切入点方法的一种表达式
作用：主要用来决定项目中的哪些方法需要加入通知
常见形式：1. execution(……)：根据方法的签名来匹配；2. @annotation(……) ：根据注解匹配

在这里插入图片描述

在这里插入图片描述



1.execution切入点表达式

execution主要根据方法的返回值、包名、类名、方法名、方法参数等信息来匹配，语法为：

execution(访问修饰符?  返回值  包名.类名.?方法名(方法参数) throws 异常?)

其中带? 的表示可以省略的部分，访问修饰符：可省略（比如: public、protected），包名.类名： 可省略，throws 异常：可省略（注意是方法上声明抛出的异常，不是实际抛出的异常）。

可以使用通配符描述切入点

  • * ：单个独立的任意符号，可以通配任意返回值、包名、类名、方法名、任意类型的一个参数，也可以通配包、类、方法名的一部分

  • .. ：多个连续的任意符号，可以通配任意层级的包，或任意类型、任意个数的参数

切入点表达式的语法规则：

  1. 方法的访问修饰符可以省略
  2. 返回值可以使用*号代替（任意返回值类型）
  3. 包名可以使用*号代替，代表任意包（一层包使用一个*）
  4. 使用..配置包名，标识此包以及此包下的所有子包，包括子包的子包
  5. 类名可以使用*号代替，标识任意类
  6. 方法名可以使用*号代替，表示任意方法
  7. 方法名的一部分可以用*号代替，表示该部分匹配任意名称
  8. 可以使用 * 配置参数，一个任意类型的参数
  9. 可以使用.. 配置参数，任意个任意类型的参数
  10. 根据业务需要，可以使用 且（&&）、或（||）、非（!） 来组合比较复杂的切入点表达式。

execution切入点表达式示例

  • 省略方法的修饰符号

    execution(void com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))

  • 使用*代替返回值类型

    execution(* com.itheima.service.impl.DeptServiceImpl.delete(java.lang.Integer))

  • 使用*代替包名（一层包使用一个*）

    execution(* com.itheima.*.*.DeptServiceImpl.delete(java.lang.Integer))

  • 使用..省略包名

    execution(* com..DeptServiceImpl.delete(java.lang.Integer))

  • 使用*代替类名

    execution(* com..*.delete(java.lang.Integer))

  • 使用*代替方法名

    execution(* com..*.*(java.lang.Integer))

  • 使用 * 代替参数

  execution(* com.itheima.service.impl.DeptServiceImpl.delete(*))

  • 使用..省略参数

    execution(* com..*.*(..))

根据业务需要，可以使用 且（&&）、或（||）、非（!） 来组合比较复杂的切入点表达式：

  execution(* com.itheima.service.DeptService.list(..)) || execution(* com.itheima.service.DeptService.delete(..))



execution切入点表达式的书写建议：

  • 所有业务方法名在命名时尽量规范，方便切入点表达式快速匹配。如：查询类方法都是 find 开头，更新类方法都是update开头
    比如匹配DeptServiceImpl类中以find开头的方法：
execution(* com.itheima.service.impl.DeptServiceImpl.find*(..))
  • 描述切入点方法通常基于接口描述，而不是直接描述实现类，增强拓展性
execution(* com.itheima.service.DeptService.*(..))
  • 在满足业务需要的前提下，尽量缩小切入点的匹配范围。如：包名匹配尽量不使用 …，使用 *匹配单个包


2.@annotation切入点表达式

如果我们要匹配多个无规则的方法，比如：list()和 delete()这两个方法，这个时候我们基于execution这种切入点表达式来描述就不是很方便了，只能在execution表达式里写入||运算符匹配俩个方法。

execution(* com.itheima.service.DeptService.list(..)) || execution(* com.itheima.service.DeptService.delete(..))

此时使用@annotation切入点表达式则更加方便。

实现步骤：

  1. 编写自定义注解
  2. 在业务类要做为连接点的方法上添加自定义注解
  3. 切面类添加@annotation切入点表达式，在表达式里指定自定义注解的全类名

自定义注解：MyLog(名字自己随便取)

@Target(ElementType.METHOD)//元注解指定用于哪些位置
@Retention(RetentionPolicy.RUNTIME)//元注解指定注解保留周期
public @interface MyLog {
}

业务类添加自定义注解：

~~~java
@Slf4j
@Service
public class DeptServiceImpl implements DeptService {
    @Autowired
    private DeptMapper deptMapper;

    @Override
    @MyLog //自定义注解（表示：当前方法属于目标方法）
    public List<Dept> list() {
        List<Dept> deptList = deptMapper.list();
        //模拟异常
        //int num = 10/0;
        return deptList;
    }

    @Override
    @MyLog  //自定义注解（表示：当前方法属于目标方法）
    public void delete(Integer id) {
    ...

切面类

@Slf4j
@Component //切面类也需要交给IOC容器管理!
@Aspect
public class MyAspect6 {
    //针对list方法、delete方法进行前置通知和后置通知

    //前置通知
    @Before("@annotation(com.itheima.anno.MyLog)") // 需要指定自定义注解的全类名
    public void before(){
        log.info("MyAspect6 -> before ...");
    }

    //后置通知
    @After("@annotation(com.itheima.anno.MyLog)") // 需要指定自定义注解的全类名
    public void after(){
        log.info("MyAspect6 -> after ...");
    }
}

PS:@annotation切入点表达式也可以用@Pointcut抽取：

@Pointcut("@annotation(com.itheima.anno.MyLog)")
private void pt(){}

//前置通知
@Before("pt()")

总结：

execution切入点表达式是最为常用的一种方式，根据我们所指定的方法的描述信息来匹配切入点方法。

annotation 切入点表达式，基于注解的方式来匹配切入点方法，虽然需要自定义一个注解，但是相对来比较灵活。




连接点 JoinPoint与ProceedingJoinPoint

连接点可以简单理解为可以被AOP控制的方法。在Spring中用JoinPoint抽象了连接点，用它可以获得方法执行时的相关信息，如目标类名、方法名、方法参数等。

  • 对于@Around通知，获取连接点信息只能使用ProceedingJoinPoint类型
  • 对于其他四种通知，获取连接点信息只能使用JoinPoint，它是ProceedingJoinPoint的父类型

示例代码：

@Slf4j
@Component //切面类也需要交给IOC容器管理!
@Aspect
public class MyAspect7 {

    @Pointcut("@annotation(com.itheima.anno.MyLog)")
    private void pt(){}
   
    //前置通知
    @Before("pt()")
    public void before(JoinPoint joinPoint){
        log.info(joinPoint.getSignature().getName() + " MyAspect7 -> before ...");
    }
    
    //后置通知
    @Before("pt()")
    public void after(JoinPoint joinPoint){
        log.info(joinPoint.getSignature().getName() + " MyAspect7 -> after ...");
    }

    //环绕通知
    @Around("pt()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        //获取目标类名
        String name = pjp.getTarget().getClass().getName();
        log.info("目标类名：{}",name);

        //目标方法名
        String methodName = pjp.getSignature().getName();
        log.info("目标方法名：{}",methodName);

        //获取方法执行时需要的参数
        Object[] args = pjp.getArgs();
        log.info("目标方法参数：{}", Arrays.toString(args));

        //执行原始方法
        Object returnValue = pjp.proceed();

        return returnValue;
    }
}




AOP案例

通过一个案例来对AOP进行一个综合的应用。

需求：将SpringBootWeb案例——Tlias智能学习辅助系统中增、删、改相关接口的操作日志记录到数据库表中。
操作日志信息包含：操作人、操作时间、执行方法的全类名、执行方法名、方法运行时参数、返回值、方法执行时长。

实现分析：

因为项目当中增删改相关的方法有很多，针对每一个功能接口方法进行修改太繁琐，可以使用AOP解决(每一个增删改功能接口中要实现的记录操作日志的逻辑代码是相同)。

要匹配业务接口当中所有的增删改的方法，而增删改方法在命名上没有共同的前缀或后缀。此时如果使用execution切入点表达式也可以，但是会比较繁琐。所以使用annotation来描述表达式。

根据需要的操作日志信息，我们选择Around环绕通知。

实现

准备工作：

AOP起步依赖

<!--AOP起步依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

创建日志数据表

create table operate_log(
    id int unsigned primary key auto_increment comment 'ID',
    operate_user int unsigned comment '操作人',
    operate_time datetime comment '操作时间',
    class_name varchar(100) comment '操作的类名',
    method_name varchar(100) comment '操作的方法名',
    method_params varchar(1000) comment '方法参数',
    return_value varchar(2000) comment '返回值',
    cost_time bigint comment '方法执行耗时, 单位:ms'
) comment '操作日志表';

创建日志数据表对应的实体类

//操作日志实体类
@Data
@NoArgsConstructor
@AllArgsConstructor
public class OperateLog {
    private Integer id; //主键ID
    private Integer operateUser; //操作人ID
    private LocalDateTime operateTime; //操作时间
    private String className; //操作类名
    private String methodName; //操作方法名
    private String methodParams; //操作方法参数
    private String returnValue; //操作方法返回值
    private Long costTime; //操作耗时
}

Mapper接口

@Mapper
public interface OperateLogMapper {
    //插入日志数据
    @Insert("insert into operate_log (operate_user, operate_time, class_name, method_name, method_params, return_value, cost_time) " +
            "values (#{operateUser}, #{operateTime}, #{className}, #{methodName}, #{methodParams}, #{returnValue}, #{costTime});")
    public void insert(OperateLog log);
}



编码实现：

自定义注解@Log

package com.itheima.anno;//新建在anno包下 anno是annotation注解的简称

/**
 * 自定义Log注解
 */
@Target({ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {
}

修改业务实现类EmpServiceImpl和DeptServiceImpl，在增删改业务方法上添加@Log注解，注意是加在业务实现类的方法上。

定义切面类，完成记录操作日志的逻辑

@Slf4j
@Component //切面
@Aspect //切面类也需要交给IOC容器管理!
public class LogAspect {

    @Autowired
    private HttpServletRequest request; //从IOC容器中获取request对象

    @Autowired
    private OperateLogMapper operateLogMapper; //注入日志Mapper接口

    @Around("@annotation(com.itheima.anno.Log)")
    public Object recordLog(ProceedingJoinPoint joinPoint) throws Throwable {
        //操作人ID - 当前登录员工ID
        //获取请求头中的jwt令牌, 解析令牌
        String jwt = request.getHeader("token");
        Claims claims = JwtUtils.parseJWT(jwt);
        Integer operateUser = (Integer) claims.get("id");

        //操作时间
        LocalDateTime operateTime = LocalDateTime.now();

        //操作类名
        String className = joinPoint.getTarget().getClass().getName();

        //操作方法名
        String methodName = joinPoint.getSignature().getName();

        //操作方法参数
        Object[] args = joinPoint.getArgs();
        String methodParams = Arrays.toString(args);

        long begin = System.currentTimeMillis();
        //调用原始目标方法运行
        Object result = joinPoint.proceed();
        long end = System.currentTimeMillis();

        //方法返回值
        String returnValue = JSONObject.toJSONString(result);

        //操作耗时
        Long costTime = end - begin;


        //记录操作日志
        OperateLog operateLog = new OperateLog(null,operateUser,operateTime,className,methodName,methodParams,returnValue,costTime);
        operateLogMapper.insert(operateLog);

        log.info("AOP记录操作日志: {}" , operateLog);

        return result;
    }
}

代码实现细节： 从IOC容器中获取request对象，从请求头中获取到jwt令牌，再解析令牌，获取出当前用户的id。

重启SpringBoot服务，测试操作日志记录功能，添加一个新的部门：

在这里插入图片描述

数据库：

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1217014.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

redis运维(七)基础通用命令

redis运维(七)基础通用命令

一 基础通用命令 备注&#xff1a; 与具体数据类型无关Tab键 自动补全补充&#xff1a; redis 命令是不区分大小写 通用不到 10 个提升逼格的 redis 命令 后续&#xff1a; slowlog、rename-command、monitor、set ① help command 需求&#xff1a; 显示有关redis命令的…
阅读更多...
【Seata源码学习 】 篇二 TM与RM初始化过程

【Seata源码学习 】 篇二 TM与RM初始化过程

【Seata源码学习 】 篇二 TM与RM初始化过程 1.GlobalTransactionScanner 初始化 GlobalTransactionScanner 实现了InitializingBean 接口&#xff0c;在初始化后将执行自定义的初始化方法 io.seata.spring.annotation.GlobalTransactionScanner#afterPropertiesSet Override…
阅读更多...
手撕无头单链表

手撕无头单链表

&#x1f493; 博客主页&#xff1a;江池俊的博客⏩ 收录专栏&#xff1a;数据结构探索&#x1f449;专栏推荐&#xff1a;✅C语言初阶之路 ✅C语言进阶之路&#x1f4bb;代码仓库&#xff1a;江池俊的代码仓库&#x1f525;编译环境&#xff1a;Visual Studio 2022&#x1f38…
阅读更多...
腾讯云轻量服务器购买优惠，腾讯云轻量应用服务器优惠购买方法

腾讯云轻量服务器购买优惠，腾讯云轻量应用服务器优惠购买方法

你是否曾经为如何选择合适的服务器而苦恼&#xff1f;在互联网的海洋中&#xff0c;如何找到一个性价比高&#xff0c;性能稳定&#xff0c;价格合理的服务器供应商&#xff0c;确实是一个让人头疼的问题。今天&#xff0c;我要向你介绍的&#xff0c;是腾讯云轻量应用服务器的…
阅读更多...
【1567.乘积为正数的最长子数组长度】

【1567.乘积为正数的最长子数组长度】

目录 一、题目描述二、算法原理三、代码实现 一、题目描述 二、算法原理 三、代码实现 class Solution { public:int getMaxLen(vector<int>& nums) {int nnums.size();vector<int> f(n);vector<int> g(n);f[0]nums[0]>0?1:0;g[0]nums[0]<0?1:0…
阅读更多...
思考如何完成一个审批流

思考如何完成一个审批流

思考如何完成一个审批流 这篇文章&#xff0c;可能没有太多的干货&#xff0c;只是对于自己做过项目的一个反思与整理&#xff0c;同时&#xff0c;让这篇文章暴露在公共视野&#xff0c;虚心接受批评指导&#xff0c;向各位前辈同仁进行学习。 如果此文又不当之处&#xff0c;…
阅读更多...
数据分析 - 离散概率分布的运用

数据分析 - 离散概率分布的运用

期望公式 期望的方差 期望的标准差
阅读更多...
二十、泛型（9）

二十、泛型（9）

本章概要 对缺乏潜在类型机制的补偿 反射将一个方法应用于序列 Java 8 中的辅助潜在类型 使用 Suppliers 类的通用方法 总结&#xff1a;类型转换真的如此之糟吗&#xff1f; 对缺乏潜在类型机制的补偿 尽管 Java 不直接支持潜在类型机制&#xff0c;但是这并不意味着泛型代…
阅读更多...
windows虚拟内存自定义分配以及mysql错误：Row size too large (＞ 8126)

windows虚拟内存自定义分配以及mysql错误：Row size too large (＞ 8126)

文章目录 虚拟内存概要windows-server配置虚拟内存技术名词解释关于mysql错误Row size too large (> 8126)问题分析解决办法 虚拟内存概要 虚拟内存别称虚拟存储器&#xff08;Virtual Memory&#xff09;。电脑中所运行的程序均需经由内存执行&#xff0c;若执行的程序占用…
阅读更多...
【918.环形子数组的最大和】

【918.环形子数组的最大和】

目录 一、题目描述二、算法原理三、代码实现 一、题目描述 二、算法原理 三、代码实现 class Solution { public:int maxSubarraySumCircular(vector<int>& nums) {int sum0;for(auto x:nums) sumx;vector<int> f(nums.size());vector<int> g(nums.size…
阅读更多...
iOS项目集成RN（0）

iOS项目集成RN（0）

iOS原有项目集成RN 环境安装RN环境搭建Node & Watchman 安装 创建新应用iOS项目集成RN如果没有iOS项目&#xff0c;新建一个 swift&#xff0c; storyboard项目&#xff0c; 名字&#xff1a;RNTest新建一个 RNDemo目录&#xff0c;一个iOS子目录&#xff0c; 把iOS相关的拷…
阅读更多...
科研学习|研究方法——python T检验

科研学习|研究方法——python T检验

一、单样本T检验 目的&#xff1a;检验单样本的均值是否和已知总体的均值相等前提条件&#xff1a; &#xff08;1&#xff09;总体方差未知&#xff0c;否则就可以利用 Z ZZ 检验&#xff08;也叫 U UU 检验&#xff0c;就是正态检验&#xff09;&#xff1b; &#xff08;2&a…
阅读更多...
趣学python编程 (一、计算机基础知识科普)

趣学python编程 (一、计算机基础知识科普)

未来是高度科技化和智能化的时代。过去不识字的叫“文盲”&#xff0c;如今不懂点计算机知识&#xff0c;则可能是新时代的“文盲”。不论从事什么行业&#xff0c;了解下计算机和编程都是有益的。Python 连续多年占据最受欢迎的编程语言榜首&#xff0c;未来Python有机会成为像…
阅读更多...
（八）五种元启发算法（DBO、LO、SWO、COA、LSO、KOA、GRO）求解无人机路径规划MATLAB

（八）五种元启发算法（DBO、LO、SWO、COA、LSO、KOA、GRO）求解无人机路径规划MATLAB

​ 一、五种算法&#xff08;DBO、LO、SWO、COA、GRO&#xff09;简介 1、蜣螂优化算法DBO 蜣螂优化算法&#xff08;Dung beetle optimizer&#xff0c;DBO&#xff09;由Jiankai Xue和Bo Shen于2022年提出&#xff0c;该算法主要受蜣螂的滚球、跳舞、觅食、偷窃和繁殖行为…
阅读更多...
考虑区域多能源系统集群协同优化的联合需求侧响应模型(matlab代码)

考虑区域多能源系统集群协同优化的联合需求侧响应模型(matlab代码)

该程序复现《考虑区域多能源系统集群协同优化的联合需求侧响应模型》文献模型&#xff0c;程序的核心是对多个区域级多能源系统互联系统进行多目标优化&#xff0c;并且考虑联合需求侧响应&#xff0c;以多个区域多能源系统运行总成本最小、碳排放最小为目标&#xff0c;建立多…
阅读更多...
kickstarter数据采集

kickstarter数据采集

搜索界面字段如下&#xff1a; 详情界面字段如下&#xff1a; 评论页面采集&#xff1a; 需要的可以找我沟通
阅读更多...
超市管理系统

超市管理系统

闲着无聊写了个超市管理系统&#xff0c;包括商品管理、进销存、角色权限管理&#xff0c;很不错的项目分享给大家 1 商品管理 1.1 分类管理 分类信息主要包括名称、描述&#xff0c;可以进行停用、启用 1.2 商品信息 1.3 积分商品 1.4 销售统计 2 库存管理 2.1 仓库管理…
阅读更多...
idea中git 移除对某个文件的跟踪

idea中git 移除对某个文件的跟踪

应用场景如下 某个log 文件&#xff0c;被同事用git 提交到了服务器&#xff0c;本地拉去之后我们的跟踪也会受影响 取消跟踪的方法如下&#xff1a; 删除本地缓存 git rm --cached "logs/test.log" 提交无效的log git commit -m "ignore log" 再将lo…
阅读更多...
【AI视野·今日NLP 自然语言处理论文速览 第六十五期】Mon, 30 Oct 2023

【AI视野·今日NLP 自然语言处理论文速览 第六十五期】Mon, 30 Oct 2023

AI视野今日CS.NLP 自然语言处理论文速览 Mon, 30 Oct 2023 Totally 67 papers &#x1f449;上期速览✈更多精彩请移步主页 Daily Computation and Language Papers An Approach to Automatically generating Riddles aiding Concept Attainment Authors Niharika Sri Parasa,…
阅读更多...
Docker启动SRS流媒体服务器

Docker启动SRS流媒体服务器

一、安装Docker 1.1、下载windows桌面版Windows 1.2、配置镜像 镜像加速器镜像加速器地址Docker 中国官方镜像https://registry.docker-cn.comDaoCloud 镜像站http://f1361db2.m.daocloud.ioAzure 中国镜像https://dockerhub.azk8s.cn科大镜像站https://docker.mirrors.ustc…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023