spring中 事务管理 和 AOP 学习笔记

1. 事务

1.1 事务的概念

事务 是一组操作的集合，它是一个不可分割的工作单位，这些操作 要么同时成功，要么同时失败。

1.2 Spring事务管理

• 注解：@Transactional
• 位置：业务（service）层的方法上、类上、接口上
• 作用：将当前方法交给spring进行事务管理，方法执行前，开启事务；成功执行完毕，提交事务；出现异常，回滚事务

 @Transactional
    @Override
    public void delete(Integer id) throws Exception {
        try {
            deptMapper.deleteById(id); //根据ID删除部门数据

            int i = 1/0;
            //if(true){throw new Exception("出错啦...");}

            empMapper.deleteByDeptId(id); //根据部门ID删除该部门下的员工
        } finally {
            DeptLog deptLog = new DeptLog();
            deptLog.setCreateTime(LocalDateTime.now());
            deptLog.setDescription("执行了解散部门的操作,此次解散的是"+id+"号部门");
            deptLogService.insert(deptLog);
        }
    }

1.3 事务属性-回滚

•  rollbackFor
• 默认情况下，只有出现 RuntimeException 才回滚异常。rollbackFor属性用于控制出现何种异常类型，回滚事务。

    @Transactional(rollbackFor = Exception.class) //spring事务管理
    @Override
    public void delete(Integer id) throws Exception {
            deptMapper.deleteById(id); //根据ID删除部门数据
  
            if(true){throw new Exception("出错啦...");}

            empMapper.deleteByDeptId(id); //根据部门ID删除该部门下的员工
        
    }

•  propagation
• 事务传播行为：指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行事务控制。

传播行为：

 

@Trabsactional
public void a(){
    //...
    userService.b();
    //...
}


@Trabsactional(propagation = Propagation.REQQUIRED)
public void b(){   
    //...
}

2. AOP

2.1 AOP概述

AOP：Aspect Oriented Programming（面向切面编程、面向方面编程），其实就是面向特定方法编程。

实现：动态代理是面向切面编程最主流的实现。而SpringAOP是Spring框架的高级技术，旨在管理bean对象的过程中，主要通过底层的动态代理机制，对特定的方法进行编程。

2.2 关于AOP编程的基础实现

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

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

• 编写AOP程序：针对特定方法根据业务须要进行编程

@Slf4j
@Component
@Aspect//标注切面类
public class TimeAspect {
    
    @Around("execution(* com..*.*(..))")//切入点表达式
    public Object recordTime(ProceedingJoinPoint proceedingJoinPoint)throws Throwable{
        long begin = System.currentTimeMillis();
        Object object = proceedingJoinPoint.proceed();//调用原始方法运行
        long end = System.currentTimeMillis();
        log.info(proceedingJoinPoint.getSignature()+"执行耗时：{}ms",end-begin);
        return object;
    }
}

 2.3 AOP核心概念

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

 

 2.4  AOP通知类型

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

注意事项：

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

@PoinCut：

该注解的作用是将公共的切点表达式提取出来，需要用到时应用切点表达式即可

 @Pointcut("execution(* com.itheima.service.DeptService.*(..))")
    private void pt(){}

 @Around("pt()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {

2.5 通知顺序

 当有多个切面的切入点都匹配到了目标方法，目标方法运行时，多个通知方法都会被执行。

1.  不同切面类中，默认按照切面类的类名字母排序：
   • 目标方法前的通知方法：字母排名靠前的先执行
   • 目标方法后的通知方法：字母排名靠前的后执行
2. 用 @Order（数字）加在切面类上来控制顺序
   • 目标方法前的通知方法：数字小的先执行
   • 目标方法后的通知方法：数字大的先执行

2.6 切入点表达式

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

 

2.6.1切入点表达式-execution

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

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

其中带 ? 的表示可以省略的部分

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

 

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

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

2.6.2 切入点表达式-@annotation

@annotation 切入点表达式，用于匹配标识有特定注解的方法。

@annotation(com.itheima.anno.Log)//在切入方法前加入这个注解即可
---------------------------------------------------------------------
@Before("@annotation(com.itheima.anno.Log)")
public void before(){
    //...
}
---------------------------------------------------------------------
//关于注解的定义写法
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface MyLog {
}

2.7 连接点

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

@Before("execution(* com.itheima.service.DeptService.*(..))")
public void before(JoinPoint joinPoint) {
    String className = joinPoint.getTarget().getClass().getName(); //获取目标类名
    Signature signature = joinPoint.getSignature(); //获取目标方法签名
    String methodName = joinPoint.getSignature().getName(); //获取目标方法名
    Object[] args = joinPoint.getArgs(); //获取目标方法运行参数 
}

2.8 AOP案例

关于调用某个方法时进行日志记录

@Slf4j
@Component
@Aspect //切面类
public class LogAspect {

    @Autowired
    private HttpServletRequest request;

    @Autowired
    private OperateLogMapper operateLogMapper;

    @Around("@annotation(com..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 operateLog = new OperateLog(null,operateUser,operateTime,className,methodName,methodParams,returnValue,costTime);
        operateLogMapper.insert(operateLog);

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

        return result;
    }

}