【javaWeb &第十一篇】（Spring ）事务管理&AOP

事务管理

事务：

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

Spring事务管理

案例：删除部门数据表，删除部门，同时删除该部门下的员工
如果在删除的同时，删除了部门没有删除员工就会出现问题，这个时候需要引入事务
在spring中不需要手动来写事务的问题，只需要通过注解 @Transactional
注解的位置：业务层的方法上，类上，接口上
作用：将当前方法交给spring进行事务管理，方法执行前，开启事务；成功执行完毕，提交事务，出现异常，回滚事务

在业务层的方法上，该业务层中多个数据操作方法控制在一个事务当中

在类上进行注解，表示该类中所有的方法都交给spring事务管理

在接口上注解，表示该接口所有实现类的方法都交由spring事务管理

成功注解之后还要在配置文件中配置spring事务管理日志的开关

logging.level.org.springframework.jdbc.support.JdbcTransactionManager=debug

事务属性rollbackFor

注意：在默认情况下，只有出现RuntimeException才会出现回滚异常，rollbackFor属性用于控制出现何种异常类型，回滚事务，如果要指定执行那种异常的时候回滚事务，需要在注解 @Transactional后设置属性rollbackFor的值

@Transactional(rollbackFor= Exception.class) 

事务属性propagation

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

案例：解散部门时，记录操作日志
需求：解散部门时，无论是成功还是失败，都要记录操作日志

@Transactional
@Override
public void delete(Integer id){
   try{
   deptMapper.deleteByid(id);//删除部门
   int i=1/0;
   empMapper.deleteByid(id);
   }
   finally{
   DeptLog Log= new DeptLog();
   Log.setCreateTime(LocalDateTime.now());
   Log.setDescription("执行了解散部门操作，此次解散的是"+id+"号部门");
   deptLogService.insert(log);// 记录操作日志
   }
}

REQUIRED:大部分情况下都是用该传播行为即可
REQUIRED_NEW：当我们不希望事物之间相互影响时，可以使用该行为传播行为

AOP

AOP：面向切面编程，面向方面编程，其实就是面向特定方法编程

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

快速入门

统计各个业务层方法的耗时：
导入AOP起步依赖：在pom.xml中导入AOP的依赖

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

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

@Component
@Aspect  //该注解表示当前类是AOP类
@Slf4j
public class TimeAop {
    @Around("execution(* com.example.service.*.*(..))") //切入点表达式
    public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable {
        //1.记录开始时间
        long begin=System.currentTimeMillis();
        //2.调用原始方法
        Object proceed = joinPoint.proceed();
        //3.记录结束时间，计算方法执行耗时
        long end=System.currentTimeMillis();
        log.info("方法执行的时间:{}ms",end-begin);
        return proceed;
    }
}

通过注解 @Component将该类交予IOC容器管理
通过注解 @Aspect 标定该类是一个AOP类
通过注解 @Around 标定执行的目标方法

AOP的使用场景：记录操作日志，权限控制，事务管理等等
AOP的优点：代码无侵入，减少重复代码，提高开发效率，维护方便

AOP概念

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

AOP的执行流程

springAOP的底层是基于动态代理的，执行时系统会为目标对象创建一个代理对象，在代理对象中对目标对象进行增强，这个时候在注入这个对象的时候，注入的其实是这个对象的代理对象

AOP进阶

通知类型

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

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

当切入点表达式中出现大量重复的表达式的时候：
我们可以通过注解 ==@Pointcut ==来标定重复的切入点表达式

@Point("execution(* com.exemple.service.impl.*(..))")
private void pt(){}

注意：private： 仅能在当前切面类中引用该表达式
public:在其他外部的切面类中也可以引用该表达式
注解下的方法不需要给出方法体，在需要此切入点表达式的时候直接调用就ok
例如：

@Around("pt()")

通知顺序

当有多个切面的切入点都匹配到了目标方法，目标方法运行时，多个通知方法都会被执行
不同的切面类中，默认按照切面类的类名字母排序：

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

除此之外还能通过 @order(数字) 加在切面类上来控制顺序

1. 目标方法前的通知方法：数字小的先执行
2. 目标方法后的通知方法：数字小的后执行

切入点表达式

作用：主要用来决定项目中的哪些方法需要加入通知
常见形式：
execution(…)：根据方法的签名来匹配
@annotation（…）:根据注解匹配

切入点表达式-execution

execution主要根据方法的返回值，包名，类名，方法名，方法参数等信息来匹配
语法：execution(访问修饰符？ 返回值 包名.类名.？方法名（方法参数） throws 异常?)
其中带？的部分可以省略：
访问修饰符：可省略（比如：public,protected）
包名.类名： 可省略
throws 异常：可省略（注意是方法上抛出的异常，不是实际抛出的异常）
可以使用通配符描述切入点：
*：单个独立的任意符号，可以通配任意返回值，包名，类名，方法名，任意类型的一个参数，也可以通配包，类，方法名的一部分
..：多个连续的任意符号，可以通配任意层级的包，或任意类型，任意个数的参数

注意：根据业务需要，可以使用且（&&），或(||),非（！）来组合比较复杂的切入点表达式

切入点表达式-@annotation

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

@Retention(RetentionPolicy.RUNTIME)  //这个注解用来描述该自定义注解什么时候生效
@Target(ElementType.METHOD) //该注解标识该注解的使用范围，这里标识在方法中
public @interface MyLog {
}

在@Point（“@annotation(自定义注解的全类名注解)”）
在使用该通知的切入点上添加上该自定义的注解即可

连接点

在Spring中用JoinPoint抽象了连接点，用它可以获得方法执行时的相关信息，如目标类名，方法名，方法参数等
对于 @Around通知，获取连接点信息只能使用 ProceedingJoinPoint
对于其他四种通知，获取连接点信息只能使用 JoinPoint，它是ProceedingJoinPoint的父类型

@Component
@Aspect
@Slf4j
public class SendAop {
    @Around("execution(* com.example.service.*.*(..))")
    public Object shishi(ProceedingJoinPoint joinPoint) throws Throwable {
        //1.获取目标对象的类名
        String name = joinPoint.getTarget().getClass().getName();
        log.info("目标对象的类名:{}",name);
        //2.获取目标对象的方法名
        String name1 = joinPoint.getSignature().getName();
        log.info("获得目标方法的方法名:{}",name1);
        //3.获取目标方法运行时传入的参数
        Object[] args = joinPoint.getArgs();
        log.info("目标方法运行时传入的参数：{}", Arrays.toString(args));
        //4.放行，目标方法执行
        Object proceed = joinPoint.proceed();
        //5.获取 目标方法运行时的返回值
        log.info("目标方法运行的返回值:{}",proceed);
        return proceed;
    }
}