JAVA事务管理
一、事务管理
事务是一组操作的集合，它是一个不可分割的工作单位。事务会把所有的操作作为一个整体，一起向数据库提交或者是撤销操作请求。所以这组操作要么同时成功，要么同时失败。 事务的操作主要有三步： 1. 开启事务（一组操作开始前，开启事务）：start transaction / begin ; 2. 提交事务（这组操作全部成功后，提交事务）：commit ; 3. 回滚事务（中间任何一个操作出现异常，回滚事务）：rollback ;
1、Spring事务管理
案例:
需求：当部门解散了不仅需要把部门信息删除了，还需要把该部门下的员工数据也删除了。
步骤：
- 根据ID删除部门数据
- 根据部门ID删除该部门下的员工
DeptServiceImpl代码实现：
@Slf4j
@Service
public class DeptServiceImpl implements DeptService {
@Autowired
private DeptMapper deptMapper;
@Autowired
private EmpMapper empMapper;
//根据部门id，删除部门信息及部门下的所有员工
@Override
public void delete(Integer id){
//根据部门id删除部门信息
deptMapper.deleteById(id);
//模拟：异常发生
int i = 1/0;
//删除部门下的所有员工信息
empMapper.deleteByDeptId(id);
}
}
//异常出现后deptMapper的程序正常执行部门被删除，但部门下的员工未成功删除，造成了数据的不一致。
通过事务来实现，一个事务中的多个业务操作，要么全部成功，要么全部失败。
开发中所有的业务操作，一旦我们要进行控制事务，都是这样的套路
@Transactional注解书写位置:
- 方法
- 当前方法交给spring进行事务管理
- 类
- 当前类中所有的方法都交由spring进行事务管理
- 接口
- 接口下所有的实现类当中所有的方法都交给spring 进行事务管理
将上面的代码进行改造：
@Override
@Transactional //当前方法添加了事务管理
public void delete(Integer id){
..........
}
添加Spring事务管理后，由于服务端程序引发了异常，所以事务进行回滚。
可以在application.yml配置文件中开启事务管理日志，这样就可以在控制看到和事务相关的日志信息了
#spring事务管理日志 logging: level: org.springframework.jdbc.support.JdbcTransactionManager: debug
2、事务进阶
@Transactional注解当中的两个常见的属性：
1. 异常回滚的属性：rollbackFor
2. 事务传播行为：propagation
★★ 默认情况下，只有出现RuntimeException(运行时异常)才会回滚事务。
★★ 让所有的异常都回滚，需要来配置@Transactional注解当中的rollbackFor属性，通过rollbackFor这个属性可以指定出现何种异常类型回滚事务。
/*********************************************************************************/
@Slf4j
@Service
public class DeptServiceImpl implements DeptService {
@Autowired
private DeptMapper deptMapper;
@Autowired
private EmpMapper empMapper;
@Override
@Transactional(rollbackFor=Exception.class)
public void delete(Integer id){
//根据部门id删除部门信息
deptMapper.deleteById(id);
//模拟：异常发生
int num = id/0;
//删除部门下的所有员工信息
empMapper.deleteByDeptId(id);
}
}
@Transactional注解当中的第二个属性propagation，这个属性是用来配置事务的传播行为的。就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行事务控制。
| 属性值 | 含义 |
|---|---|
| REQUIRED | 【默认值】需要事务，有则加入，无则创建新事务 |
| REQUIRES_NEW | 需要新事务，无论有无，总是创建新事务 |
| SUPPORTS | 支持事务，有则加入，无则在无事务状态中运行 |
| NOT_SUPPORTED | 不支持事务，在无事务状态下运行,如果当前存在已有事务,则挂起当前事务 |
| MANDATORY | 必须有事务，否则抛异常 |
| NEVER | 必须没事务，否则抛异常 |
| … |
只需要关注以下两个就可以了：
-
REQUIRED ：大部分情况下都是用该传播行为即可。
-
REQUIRES_NEW ：当我们不希望事务之间相互影响时，可以使用该传播行为。比如：下订单前需要记录日志，不论订单保存成功与否，都需要保证日志记录能够记录成功。
二、AOP基础
AOP英文全称：Aspect Oriented Programming（面向切面编程、面向方面编程），其实说白了，面向切面编程就是面向特定方法编程。 AOP的作用： AOP面向方法编程，可以在不改动原始方法的基础上，针对特定的方法进行功能的增强。在程序运行期间在不修改源代码的基础上对已有方法进行增强（无侵入性: 解耦） AOP面向切面编程和OOP面向对象编程一样，它们都仅仅是一种编程思想，而动态代理技术是这种思想最主流的实现方式。而Spring的AOP是Spring框架的高级技术，旨在管理bean对象的过程中底层使用动态代理机制，对特定的方法进行编程(功能增强)。 > AOP的优势： > > 1. 减少重复代码 > 2. 提高开发效率 > 3. 维护方便
1、AOP快速入门
**需求：**统计各个业务层方法执行耗时。 **实现步骤：** 1. 导入依赖：在pom.xml中导入AOP的依赖 2. 编写AOP程序：针对于特定方法根据业务需要进行编程
**pom.xml org.springframework.boot spring-boot-starter-aop
AOP程序：TimeAspect
@Component
@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();
//计算方法执行耗时
log.info(pjp.getSignature()+"执行耗时: {}毫秒",end-begin);
return result;
}
}
AOP的功能常见的应用场景如下：
- 记录系统的操作日志
- 权限控制
- 事务管理：我们前面所讲解的Spring事务管理，底层其实也是通过AOP来实现的，只要添加@Transactional注解之后，AOP程序自动会在原始方法运行前先来开启事务，在原始方法运行完毕之后提交或回滚事务。
这些都是AOP应用的典型场景。
AOP面向切面编程的一些优势：
- 代码无侵入：没有修改原始的业务方法，就已经对原始的业务方法进行了功能的增强或者是功能的改变
- 减少了重复代码
- 提高开发效率
- 维护方便
2、AOP核心概念
1. 连接点：JoinPoint，可以被AOP控制的方法（暗含方法执行时的相关信息）,连接点指的是可以被aop控制的方法。
2. 通知：Advice，指哪些重复的逻辑，也就是共性功能（最终体现为一个方法）将重复的代码逻辑抽取出来单独定义。抽取出来的这一部分重复的逻辑，就是共性的功能。
3. 切入点：PointCut，匹配连接点的条件，通知仅会在切入点方法执行时被应用
4. 切面：Aspect，描述通知与切入点的对应关系（通知+切入点）
切面所在的类，我们一般称为切面类（被@Aspect注解标识的类）
Spring的AOP底层是基于动态代理技术来实现的，也就是说在程序运行的时候，会自动的基于动态代理技术为目标对象生成一个对应的代理对象。在代理对象当中就会对目标对象当中的原始方法进行功能的增强
3、AOP进阶
Spring中AOP的通知类型：
- @Around：环绕通知，此注解标注的通知方法在目标方法前、后都被执行
- @Before：前置通知，此注解标注的通知方法在目标方法前被执行
- @After ：后置通知，此注解标注的通知方法在目标方法后被执行，无论是否有异常都会执行
- @AfterReturning ： 返回后通知，此注解标注的通知方法在目标方法后被执行，有异常不会执行
- @AfterThrowing ： 异常后通知，此注解标注的通知方法发生异常后执行
/****************************************************************************************/
@Slf4j
@Component
@Aspect
public class MyAspect1 {
//前置通知
@Before("execution(* com.itheima.service.*.*(..))")
public void before(JoinPoint joinPoint){
log.info("before ...");
}
//环绕通知
@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;
}
//后置通知
@After("execution(* com.itheima.service.*.*(..))")
public void after(JoinPoint joinPoint){
log.info("after ...");
}
//返回后通知（程序在正常执行的情况下，会执行的后置通知）
@AfterReturning("execution(* com.itheima.service.*.*(..))")
public void afterReturning(JoinPoint joinPoint){
log.info("afterReturning ...");
}
//异常通知（程序在出现异常的情况下，执行的后置通知）
@AfterThrowing("execution(* com.itheima.service.*.*(..))")
public void afterThrowing(JoinPoint joinPoint){
log.info("afterThrowing ...");
}
}
程序发生异常的情况下：
- @AfterReturning标识的通知方法不会执行，@AfterThrowing标识的通知方法执行了
- @Around环绕通知中原始方法调用时有异常，通知中的环绕后的代码逻辑也不会在执行了 （因为原始方法调用已经出异常了）
在使用通知时的注意事项：
- @Around环绕通知需要自己调用ProceedingJoinPoint.proceed() 来让原始方法执行，其他通知不需要考虑目标方法执行
- @Around环绕通知方法的返回值，必须指定为Object，来接收原始方法的返回值，否则原始方法执行完毕，是获取不到返回值的。
通知执行的先后顺序：
不同切面类中，默认按照切面类的类名字母排序：
- 目标方法前的通知方法：字母排名靠前的先执行
- 目标方法后的通知方法：字母排名靠前的后执行
通知的执行顺序大家主要知道两点即可：
1. 不同的切面类当中，默认情况下通知的执行顺序是与切面类的类名字母排序是有关系的
2. 可以在切面类上面加上@Order注解，来控制不同的切面类通知的执行顺序`@Order(2)` 注解，切面类的执行顺序（前置通知：数字越小先执行; 后置通知：数字越小越后执行）
@Slf4j
@Component
@Aspect
@Order(2) //切面类的执行顺序（前置通知：数字越小先执行; 后置通知：数字越小越后执行）
public class MyAspect2 {
//前置通知
@Before("execution(* com.itheima.service.*.*(..))")
public void before(){
log.info("MyAspect2 -> before ...");
}
//后置通知
@After("execution(* com.itheima.service.*.*(..))")
public void after(){
log.info("MyAspect2 -> after ...");
}
}
★★★ 切入点表达式：
- 描述切入点方法的一种表达式
- 作用：主要用来决定项目中的哪些方法需要加入通知
- 常见形式：
1. execution(……)：根据方法的签名来匹配
2. @annotation(……) ：根据注解匹配
execution主要根据方法的返回值、包名、类名、方法名、方法参数等信息来匹配。
execution(访问修饰符? 返回值 包名.类名.?方法名(方法参数) throws 异常?)
其中带`?`的表示可以省略的部分
- 访问修饰符：可省略（比如: public、protected）
- 包名.类名： 可省略
- throws 异常：可省略（注意是方法上声明抛出的异常，不是实际抛出的异常）
可以使用通配符描述切入点
- `*` ：单个独立的任意符号，可以通配任意返回值、包名、类名、方法名、任意类型的一个参数，也可以通配包、类、方法名的一部分
- `..` ：多个连续的任意符号，可以通配任意层级的包，或任意类型、任意个数的参数
注意事项：
- 根据业务需要，可以使用 且（&&）、或（||）、非（!） 来组合比较复杂的切入点表达式，所有业务方法名在命名时尽量规范，方便切入点表达式快速匹配。
4、@annotation
案例：
实现步骤：
1. 编写自定义注解
2. 在业务类要做为连接点的方法上添加自定义注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface MyLog {
}
/********************************************************************/
@Target：元注解，用于表示该注解（上面的例子就是指MyLog）的作用范围，其作用决定于ElementType这个枚举的值，同时可以使用数组。其中枚举有非常多类型，比如包、属性、方法、类等等，这里不再一一解释，上面案例METHOD表示方法上
@Retention 元注解，用来表示注解的生命周期，其作用决定于RetentionPolicy这个枚举的值，有SOURCE、CLASS、RUNTIME三种
SOURCE：表示注解只保留在源文件，当java文件编译成class文件，就会消失，例如lombok的注解多是这种
CLASS：注解被保留到class文件，但jvm加载class文件时候被遗弃，这是默认的生命周期。
RUNTIME：注解不仅被保存到class文件中，jvm加载class文件之后，仍然存在。大多数的注解都是这种。
★★★ 业务类
@Slf4j
@Service
public class DeptServiceImpl implements DeptService {
@Autowired
private DeptMapper deptMapper;
@Override
@MyLog //自定义注解（表示：当前方法属于目标方法）
public List list() {
List deptList = deptMapper.list();
//模拟异常
//int num = 10/0;
return deptList;
}
@Override
@MyLog //自定义注解（表示：当前方法属于目标方法）
public void delete(Integer id) {
//1. 删除部门
deptMapper.delete(id);
}
@Override
public void save(Dept dept) {
dept.setCreateTime(LocalDateTime.now());
dept.setUpdateTime(LocalDateTime.now());
deptMapper.save(dept);
}
@Override
public Dept getById(Integer id) {
return deptMapper.getById(id);
}
@Override
public void update(Dept dept) {
dept.setUpdateTime(LocalDateTime.now());
deptMapper.update(dept);
}
}
★★★ 切面类：
@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 ...");
}
}
execution切入点表达式
- 根据我们所指定的方法的描述信息来匹配切入点方法，这种方式也是最为常用的一种方式
- 如果我们要匹配的切入点方法的方法名不规则，或者有一些比较特殊的需求，通过execution切入点表达式描述比较繁琐
annotation 切入点表达式
基于注解的方式来匹配切入点方法。这种方式虽然多一步操作，我们需要自定义一个注解，但是相对来比较灵活。
5、连接点
在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;
}
}
org.springframework.boot spring-boot-starter-aop