事务管理&AOP

小七的张张

已于 2023-05-25 16:51:32 修改

阅读量860

点赞数 2

于 2023-05-25 16:42:36 首次发布

本文链接：https://blog.csdn.net/2301_78351063/article/details/130865851

版权

1.事务管理

1.1什么是事务

事务是一组操作的集合，是一个不可分割的工作单位，它会把所有操作当成一个整体，向数据库进行提交或者是撤销的操作请求，所以这组操作要么同时成功，要么同时失败。

1.2事务的操作

主要有三步
1.开启事务（一组操作开始前，开启事务）：start transaction / begin;
2.提交事务（这组操作全部成功后，提交事务）：commit;
3.回滚事务（但凡任何一个操作出现异常，就会进行回滚事务）: rollback;

1.2.1Transactional注解

@Transactional的作用：方法执行之前来开启事务，执行完毕提交事务，如果中间出现异常，则进行回滚操作。

@Transactional注解：我们一般会在业务层（Service）当中控制事务，因为在业务层当中，一个业务功能可能会包含多个数据访问(Mapper/dao)的操作，在业务层来控制事务，就会将多个数据访问的操作控制在一个事务范围内。

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

@Transactional注解中常见的两个属性
1.异常回滚的属性：rollbackFor
2.事务传播行为：propagation

rollbackFor:通过这个属性可以指定出现何种异常类型的回滚事务，因为在默认情况下，只有出现RuntimeException才会进行回滚事务，有了这个属性就可以指定任何异常类型来回滚事务。

propagation:这个属性是用来配置事务的传播行为的。
什么是事务传播行为？
就是当一个事务方法被另一个事务方法调用时，这个事务方法该如何进行事务控制。
eg:有两个事务方法，一个A，一个B，在这两个方法上都添加@Transactional，就代表这两个方法都具有事务，而在A中调用了B，那么B具有的事务该如何控制呢？接下来介绍常见的事务传播行为。

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

最常用的是前两个

REQUIRED（默认值）
REQUIRES_NEW

2.AOP基础

2.1什么是AOP？

AOP英文全称：Aspect Oriented Programming(面向切面编程、面向方面编程)面向切面编程其实就是面向特定方法编程。
又引入了一个新问题，什么是面向特定方法的编程？
比如有一个项目，项目中开发了很多的业务功能
在这里插入图片描述但是某些业务功能执行效率比较低，耗时长，就需要针对这些业务方法进行优化，第一步就是需要定位出执行耗时比较长的业务方法，然后再进行优化，那么有呢么多业务功能我们需要一个一个编写运行时长的代码吗，当然是不能，我们可以采用AOP面向方法编程，就可以在不改变这些原始方法的基础上，针对特定的方法进行功能的增强且采用AOP可以使耦合度降低。
比如：我们只想拿到部门管理的 list 方法的执行耗时，那就只有这一个方法是原始业务方法。而如果，我们是先想统计所有部门管理的业务方法执行耗时，那此时，所有的部门管理的业务方法都是原始业务方法。那面向这样的指定的一个或多个方法进行编程，我们就称之为面向切面编程。
求原始方法的执行耗时思路都是一样的
1.记录方法执行前的运行时间
2.运行原始方法
3.记录方法执行后的时间
4.该方法耗时 = 执行后-执行前
AOP的优势
1.减少重复代码
2.提高开发效率
3.维护方便

2.2 AOP快速入门

需求：统计各个业务层方法执行耗时。

实现步骤：

导入依赖：在pom.xml中导入AOP的依赖
编写AOP程序：针对于特定方法根据业务需要进行编程。
AOP的依赖

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


import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Slf4j
@Component //交给IOC容器管理
@Aspect//AOP类
public class TimeAspect {
    @Around("execution(* com.itheima.service.*.*(..))") //切入点表达式
    public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable {
        //1.记录开始的时间
        long begin = System.currentTimeMillis();

        //2.调用原始方法运行
        Object result = joinPoint.proceed();

        //3.记录结束时间
        long end = System.currentTimeMillis();

        log.info(joinPoint.getSignature() + "方法执行耗时: {}ms", end-begin);

        return result;

    }

}

在这里插入图片描述

2.3 AOP核心概念

1.连接点：JoinPoint，可以被AOP控制的方法
2.通知：Advice，指那些重复的逻辑，也就是抽取的共性功能（最终体现为一个方法）
3.切入点，PointCut,匹配连接点的条件，通知仅会在切入点方法执行时被应用
4.切面：Aspect，描述通知与切入点的对应关系（通知+切入点）
5.目标对象：Target，通知所应用的对象

3. AOP进阶

3.1通知类型

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

在使用通知时的注意事项：

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

3.2通知顺序

默认按照切面类的类名字母排序：

目标方法前的通知方法：字母排名靠前的先执行。
目标方法后的通知方法：字母排名靠前的后执行。

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

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

3.3 切入点表达式

作用：主要来决定项目中的哪些方法需要加入通知

3.3.1 execution

exexution主要根据方法的返回值、包名、类名、方法名、方法参数等信息来匹配，语法为：
execution(访问修饰符？返回值包名.类名.?方法名（方法参数）throws 异常？)
其中带？的表示可以省略的部分

访问修饰符：可省略（比如：public、protected）
包名.类名：可省略（不建议）
throws 异常：可省略（注意是方法上声明抛出的异常，不是实际抛出的异常）

可以使用通配符描述切入点
*：单个独立的任意符号，可以通配任意返回值、包名、类名、方法名、任意类型的一个参数，也可以通配包、类、方法名的一部分
… :多个连续的任意符号，可以通配任意层级的包或任意类型、任意个数的参数

切入点表达式的语法规则：
1.方法的访问修饰符可以省略
2.返回值可以使用*号代替（任意返回值类型）
3.包名可以使用 * 号代替，代表任意包（一层包使用一个 *）
4.使用…配置包名，标识此包以及包下的所有子包
5.类名可以使用 * 号代替，标识任意类
6方法名可以使用 * 号代替，表示任意方法
7.可以使用 * 配置参数，一个任意类型的参数
8.可以使用…配置参数，任意个任意类型的参数
注意事项：
1.可以使用且（&&）、或（||）、非（！）来组合比较复杂的切入点表达式。

2.所有业务方法名在命名时尽量规范，方便切入点表达式快速匹配。eg:查询类方法都是find开头，更新类方法都是update开头。

3.描述切入点方法通常基于接口描述，而不是直接描述实现类，增强其拓展性。

4.在满足业务需要的前提下，尽量缩小切入点的匹配范围。eg:包名匹配尽量不使用…，使用 * 匹配单个包。

3.3.2 annotation

基于注解的方式来匹配切入点方法。这种方式虽然多一步操作，我们需要自定义一个注解，但是相对来比较灵活。我们需要匹配哪个方法，就在方法上加上对应的注解就可以了

3.4 连接点

连接点可以简单理解为可以被AOP控制的方法
在spring中用JoinPoint抽象了连接点，用它可以获得方法执行时的相关信息，如目标类名、方法名、方法参数等
对于@Around通知，获取连接点信息只能使用ProceedingJoinPoint类型
对于其他四种通知，获取连接点信息只能使用JoinPoint，它是ProceedingJoinPoint的父类型

4.AOP案例

4.1需求：将案例中增、删、改相关接口的操作日志记录到数据库表中

就是当访问部门管理和员工管理当中的增、删、改相关功能接口时，需要详细的操作日志，并保存在数据表中，便于后期数据追踪

操作日志信息包含：
操作人、操作时间、执行方法的全类名、执行方法名、方法运行时参数、返回值、方法执行时长。
所记录的日志信息包括当前接口的操作人是谁操作的，什么时间点操作的，以及访问的是哪个类当中的哪个方法，在访问这个方法的时候传入进来的参数是什么，访问这个方法最终拿到的返回值是什么，以及整个接口方法的运行时长是多长时间。

4.2实现

-- 操作日志表
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
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 Log {
}

添加@Log

    //批量删除
    @Log
    @DeleteMapping("/emps/{ids}")
    public Result delete(@PathVariable List<Integer> ids){
        empService.deleteSe(ids);
        return Result.success();
    }

    //新增员工
    @Log
    @PostMapping("/emps")
    public Result insert(@RequestBody Emp emp){
        log.info("新增员工，emp{} ", emp);
        empService.insert(emp);
        return Result.success();

    }

    @GetMapping("/emps/{id}")
    @Log
    //修改员工(先根据id查询员工)
    public Result select(@PathVariable Integer id){
        Emp emp = empService.getById(id);
        return Result.success(emp);

    }
    @PutMapping("/emps")
    public Result update(@RequestBody Emp emp){
        empService.update(emp);
        return Result.success();

    }


//部门表
    //删除部门
    @Log
    @DeleteMapping("/{id}")
    public Result delete(@PathVariable Integer id) throws Exception {
        log.info("删除部门: {}",id);
        //调用service层
        deptService.deleteById(id);
        //响应
        return Result.success();
    }

    //新增部门
    @Log
    @PostMapping ()
    public Result insert(@RequestBody Dept dept){
        log.info("新增部门,{}",dept);
        deptService.insertById(dept);
        return Result.success();
    }


    //修改部门
    @Log
    @PutMapping()
    public Result update(@RequestBody Dept dept){
        deptService.list(dept);
        return Result.success();

    }

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

@Component
@Aspect //切面类
@Slf4j
//记录操作日志
public class LogAspect {

    @Autowired
    private HttpServletRequest httpServletRequest;

    @Autowired
    private OperateLogMapper operateLogMapper;

    @Around("@annotation(com.itheima.anno.Log)")
    public Object recordLog(ProceedingJoinPoint joinPoint) throws Throwable {
        //1.操作人ID --员工登录的id（拿到令牌 解析令牌从中拿到id）
        String jwt = httpServletRequest.getHeader("token");
        Claims claims = JwtUtils.parseJWT(jwt);
        Integer operateUser = (Integer) claims.get("id");
        log.info("操作人id: {}",operateUser);
        //2.操作时间
        LocalDateTime operateTime = LocalDateTime.now();
        log.info("操作时间： {}",operateTime);
        //3.操作类名
        String className = joinPoint.getTarget().getClass().getName();
        log.info("操作类名: {}",className);
        //4.操作方法名
        String methodName = joinPoint.getSignature().getName();
        log.info("操作方法名: {}",methodName);
        //5.操作方法参数
        Object[] args = joinPoint.getArgs();
        String methodParams = Arrays.toString(args);
        log.info("操作方法参数: {}", methodParams);

        //方法运行开始时间
        long begin = System.currentTimeMillis();

        //调用原始方法运行
        Object result = joinPoint.proceed();

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

        //6.操作方法返回值（返回JSON格式的字符串）
        String returnValue = JSONObject.toJSONString(result);
        log.info("操作方法的返回值: {}",returnValue);



        //操作耗时
        long costTime = end - begin;
        log.info("操作耗时: {}",costTime);

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

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

        return result;



    }

}

运行结果
在这里插入图片描述数据库展示

小七的张张

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
4
评论
事务管理&AOP

事务是一组操作的集合，是一个不可分割的工作单位，它会把所有操作当成一个整体，向数据库进行提交或者是撤销的操作请求，所以这组操作要么同时成功，要么同时失败。AOP英文全称：Aspect Oriented Programming(面向切面编程、面向方面编程)面向切面编程其实就是面向特定方法编程。又引入了一个新问题，什么是面向特定方法的编程？比如有一个项目，项目中开发了很多的业务功能。
复制链接

扫一扫