事务&AOP
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();
}