事务&AOP

有模有样(^～^)

于 2023-11-11 21:12:26 发布

阅读量93

点赞数

文章标签： servlet mybatis

本文链接：https://blog.csdn.net/m0_57682986/article/details/134347433

版权

1事务：

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

1.1实现：@Transactional注解

@Transactional作用：就是在当前这个方法执行开始之前来开启事务，方法执行完毕之后提交
事务。如果在这个方法执行的过程当中出现了异常，就会进行事务的回滚操作。
@Transactional注解：我们一般会在业务层当中来控制事务，因为在业务层当中，一个业务功
能可能会包含多个数据访问的操作。在业务层来控制事务，我们就可以将多个数据访问操作控制在
一个事务范围内。
DeptServieImpe类中实现删除部门，并且部门的员工也一块删除：

  @Transactional
    @Override
    public void delectById(Integer id) {
        deptMapper.delectById(id);
        empMapper.delectByEmpId(id);
    }

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

异常回滚的属性：rollbackFor
事务传播行为：propagation

1.2.1配置所有的异常都能够回滚（默认运行时异常才能回滚）:

@Transactional(rollbackFor = Exception.class)

1.2.2事务的传播行为:

就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行事务控制。

在@Transactional注解的后面指定一个属性propagation，通过
propagation 属性来指定传播行为。接下来我们就来介绍一下常见的事务传播行为。

在这里插入图片描述

@Transactional(propagation = Propagation.REQUIRES_NEW)//事务传播
行为：不论是否有事务，都新建事务

2AOP

AOP英文全称：Aspect Oriented Programming（面向切面编程、面向方面编程），其实说白
了，面向切面编程就是面向特定方法编程。

2.1实现步骤：

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

2.1.1导入相关的包：

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

2.1.2创建相关的类：

@Component//成为bean对象
@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();

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

2.2.1Spring中AOP的通知类型：

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

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

例如：

@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;
 }

2.3抽取：

Spring提供了@PointCut注解，该注解的作用是将公共的切入点表达式抽取出来，需要用到时引用该
切入点表达式即可。
例如：

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

下面再写切入点点表达式的时候可以直接调用方法抽取。（可以在其他类中引用，方法设为public即可）

2.4通知的顺序（多个切面类中的执行顺序）

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

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

2.4.2 控制通知的执行顺序：

使用@Order注解，控制通知的执行顺序：

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

2.4 切入点表达式

2.4.1 execution(……)：根据方法的签名来匹配：

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

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

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

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

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

切入点表达式的语法规则：
1. 方法的访问修饰符可以省略
2. 返回值可以使用 * 号代替（任意返回值类型）
3. 包名可以使用 * 号代替，代表任意包（一层包使用一个 * ）
4. 使用 .. 配置包名，标识此包以及此包下的所有子包
5. 类名可以使用 * 号代替，标识任意类
6. 方法名可以使用 * 号代替，表示任意方法
7. 可以使用 * 配置参数，一个任意类型的参数
8. 可以使用 .. 配置参数，任意个任意类型的参数

2.5 @annotation切入点表达式：

2.5.1自定义注解：

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

2.5.2切面类：

@Slf4j
@Component
@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 ...");
 }
}

2.6@连接点：

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

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

举例：

@Slf4j
@Component
@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;
 }
}

2.7 需求举例：

需求：将案例中增、删、改相关接口的操作日志记录到数据库表中
就是当访问部门管理和员工管理当中的增、删、改相关功能接口时，需要详细的操作日志，并保存
在数据表中，便于后期数据追踪。
操作日志信息包含：
操作人、操作时间、执行方法的全类名、执行方法名、方法运行时参数、返回值、方法执行时长.

实现步骤：

准备工作
1. 引入AOP的起步依赖
2. 导入资料中准备好的数据库表结构，并引入对应的实体类
编码实现
1. 自定义注解@Log
2. 定义切面类，完成记录操作日志的逻辑

2.7.1引入AOP的起步依赖

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

2.7.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);
}

2.7.3

自定义注解@LogAnno

@Target({ElementType.METHOD})
@Documented
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {
}

切面类的实现：

package com.heima.Aop;


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.heima.mapper.OperateLogMapper;
import com.heima.poji.OperateLog;
import com.heima.utils.JwtUtil;
import io.jsonwebtoken.Claims;
import jakarta.servlet.http.HttpServletRequest;
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.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.lang.annotation.Retention;
import java.lang.reflect.Array;
import java.net.http.HttpRequest;
import java.time.LocalDateTime;
import java.util.Arrays;


@Slf4j
@Aspect
@Component
public class LogAspect {

    @Autowired
    private HttpServletRequest httpServletRequest;

     @Autowired
     private OperateLogMapper operateLogMapper;
     @Around("@annotation(com.heima.anno.LogAnno)")
    public Object RecordLog(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
         //调用目标方法
         String jwt = httpServletRequest.getHeader("token");
         Claims claims = JwtUtil.parseJWT(jwt);
         Integer operateId = (Integer) claims.get("id");
         String className = proceedingJoinPoint.getTarget().getClass().getName();
         String methodName = proceedingJoinPoint.getSignature().getName();
         long start = System.currentTimeMillis();
         Object[] arys = proceedingJoinPoint.getArgs();
         String arys1 = Arrays.toString(arys);
         LocalDateTime localDateTime1 = LocalDateTime.now();

         Object result = proceedingJoinPoint.proceed();
         long end = System.currentTimeMillis();
         long time = end - start;

         String jsonResult = JSONObject.toJSONString(result);
         OperateLog operateLog = new OperateLog(null,operateId,localDateTime1,className,
                 methodName,arys1,jsonResult,time);
         operateLogMapper.insert(operateLog);
         return result;
     }
}

2.7.4在相应的控制类的方法中加入实体类：

加入需要记录部门修改的日志信息即可加入相应的注解。

  @LogAnno
    //部门修改
    @PutMapping
    public Result update(@RequestBody Dept dept){
        log.info("输出部门信息{}",dept);
        deptService.update(dept);
        return Result.success();
    }