【Day13】事务管理、AOP

1 事务管理

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

事务操作：

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

1.1 案例：解散部门

        删除部门，同时删除部门下的员工

部门表：

员工表：

实现：

在 controller 层下，DeptController 类，调用 service 层

@RestController
@RequestMapping("/depts")
public class DeptController {
    @Autowired
    private DeptService deptService;

    /**
     * 根据 id 删除部门，并且删除部门下的员工
     * @param id
     * @return
     */
    @DeleteMapping("/{id}")
    public Result deleteById(@PathVariable Integer id){
        deptService.deleteById(id);
        return Result.success();
    }
}

DeptService 接口

public interface DeptService {
    /**
     * 删除部门
     * @param id
     */
    void deleteById(Integer id);
}

DeptServiceImpl 实现类，需要调用两个 Mapper

@Service
public class DeptServiceImpl implements DeptService {
    // 这里是 service 层，不能直接对数据库进行操作
    @Autowired
    private DeptMapper deptMapper;
    @Autowired
    private EmpMapper empMapper;

    /**
     * 根据部门 id 删除部门，但是要同时删除部门下的员工
     * @param id
     */
    @Override
    public void deleteById(Integer id) {
        // 删除部门
        deptMapper.deleteById(id);

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

EmpMapper 

@Mapper
public interface EmpMapper {
    /**
     * 删除部门，同时删除部门下的员工
     * @param id
     */
    @Delete("delete from emp where dept_id = #{id}")
    void deleteByDeptId(Integer id);
}

DeptMapper（不用动）

@Mapper
public interface DeptMapper {
    /**
     * 根据id删除部门
     * @param id
     */
    @Delete("delete from dept where id=#{id}")
    void deleteById(Integer id);
}

测试：

1.2 存在问题

        两个操作没有关联，中间有异常，就会出现删除了部门却没有删除员工的情况，造成数据不一致

        所以要用 事务，把他们视为一个事务，要么同时成功，要么同时失败

1.3 事务

        首先开启事务，然后执行事务，如果没有异常，就 提交事务；如果有异常就 回滚事务

Spring 框架的事务：

注解：@Transactional

位置：Service 层

作用：将当前方法交给 spring 进行事务管理，方法执行前，开启事务；成功执行完毕，提交事务；出现异常，回滚事务

一般在 Delete 方法这种 多次数据访问 的时候加上事务管理

@Transactional
@Override
public void deleteById(Integer id) {
    // 删除部门
    deptMapper.deleteById(id);

    int i = 1/0; // 异常

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

rolbackFor：

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

@Transactional(rollbackFor = Exception.class)

propagation：

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

2 AOP

        Spring 框架的第二大核心：AOP（Aspect Oriented Programming，面向切面编程），是一种编程范式，它允许开发者将横切关注点（如日志记录、事务管理、安全性等）与业务逻辑分离，从而提高代码的模块化和可维护性

第一大核心：IOC（Inversion of Control，控制反转）

实现：

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

案例：

统计各个业务层方法的运行时间

1、引入依赖

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

2、编写AOP程序，针对于特定方法根据业务需要进行编程

@Component // 当前类交给 IOC 容器管理
@Aspect // 当前类为 AOP 类
@Slf4j
public class TimeAspect {

    @Around("execution(* com.wyn.tlias.service.*.*(..))") // 切入点表达式
    public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable {
        long begin = System.currentTimeMillis();

        // 运行原始方法
        Object object = joinPoint.proceed();

        long end = System.currentTimeMillis();

        log.info(joinPoint.getSignature() + "用时 {}ms", end - begin);

        return object;
    }
}

注意切入点表达式中 com.wyn.tlias.service.*.*

第一个星号代表类

第二个星号代表方法

表示所有service层的类或方法都要执行 recordTime 代码

(..)

代表方法的形参也是任意的

测试

2.1 AOP 核心概念

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

2.2 AOP 执行流程

        在目标对象上生成一个代理对象，在代理对象的实际代码前、后增加 Advice 通知，增强功能，最后在controller层注入的时候，注入的是代理对象（代码写的还是目标对象，实际是代理对象）

2.3 通知类型

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

注：

1、@Around 环绕通知需要自己调用 ProceedingJoinPoint.proceed() 让原始方法执行，其他通知不需要考虑目标方法执行

2、@Around 环绕通知方法的返回值，必须指定为 Object，来接收原始方法的返回值

抽取重复的切入点表达式

使用注解 @Pointcut

@Pointcut("execution(* com.wyn.tlias.service.*.*(..))")
private void pt(){};

@Around("pt()") // 切入点表达式
public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable {
...
}

2.4 通知顺序

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

使用注解 @Order(数字) 加在切面类上来控制顺序

@Component // 当前类交给 IOC 容器管理
@Aspect // 当前类为 AOP 类
@Slf4j
@Order(1)
public class TimeAspect {
    @Pointcut("execution(* com.wyn.tlias.service.*.*(..))")
    private void pt(){};

    @Around("pt()") // 切入点表达式
    public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable {
...

}

2.5 切入点表达式

描述切入点的表达式

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

常见形式：

1、execution(...) 根据方法的签名匹配

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

2、@annotation(...) 根据注解匹配

@annotation(com.itheima.anno.log)

使用注解的切入点表达式

创建一个注解文件，加上两个源注解

标注目标对象

回到切面表达式，用注解来写，直接精确到 Mylog 注解就可以

@Component // 当前类交给 IOC 容器管理
@Aspect // 当前类为 AOP 类
@Slf4j
@Order(1)
public class TimeAspect {

//    @Pointcut("execution(* com.wyn.tlias.service.*.*(..))")
    @Pointcut("@annotation(com.wyn.tlias.aop.MyLog)")
    private void pt(){};

    @Around("pt()") // 切入点表达式
    public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable {

2.6 连接点

可以被 AOP 控制的方法

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

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

JoinPoint 的方法：