事务管理&AOP

1. 事务是什么？在MySQL中是怎么去开启，提交，回滚事务的。

定义:事务是一组操作的集合,要么全部成功,要么全部失败

MYSQL  开启事务  start transition/begin
MYSQL  提交     commit
MYSQL  回滚     rollback

2. 在Spring中怎么管理事务，用什么注解，在那个层次进行使用可以有效管理事务

注解: @Transactional

位置: 业务(Service)层的方法,类,接口上

将被@Transactional注解的方法交给spring进行事务管理,方法执行前,开启事务;成功执行完毕,提交事务;出现异常,回滚事务;

#开启事务管理日志
logging: 
    level: 
        org.springframework.jdbc.support.JdbcTransactionManager:debug

3. 事务管理时规则：如果方法能够正常执行完自动提交事务，如果出现异常自动回滚事物。事务默认识别的异常是运行时异常，如果想要识别到编译时异常从而实现回滚，该怎么操作？

方法一: 抛出异常 throws FileNotFoundException

将注解改为 @Transactional(rollbackFor = Exception.class)

方法二: 抓取异常

try{
    异常信息
}catch(FileNotFoundException e){
    throw new RuntimeException(e.getMessage());//将编译时异常转换为运行时异常并抛出
}

4. 事务的传播方式有哪些，含义是怎样？

定义:指的就是当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行事务控制。

(在被调用的事务方法的注解上定义一个属性值 例如:@Transactional(propagation=Propagation.REQUIRE))

    属性值	                     含义	                                        说明
   REQUIRE	         【默认值】需要事务，有则加入，无则创建新事务	                     -
 REQUIRES_NEW	    需要新事务，无论有无，总是创建新事务	                             -
   SUPPORTS	        支持事务，有则加入，无则在独立的连接中运行 SQL	           结合 Hibernate、JPA时有用，配在查询方法上
 NOT_SUPPORTED	    不支持事务，不加入，在独立的连接中运行 SQL	                          -
  MANDATORY	              必须有事务，否则抛异常	                                  -
    NEVER	              必须没事务，否则抛异常	                                  -
    NESTED	                   嵌套事务	                               仅对 DataSourceTransactionManager  有效

我们主需要掌握前两个 ： REQUIRED 以及 REQUIRES_NEW ，其他很少用到，无需掌握

5. AOP叫做什么，有什么作用？举一个5岁孩子就能理解的例子？

Aspect Oriented Programming（面向切面编程），它的核心思想是将重复的逻辑剥离出来，在不修改原始逻辑的基础上对原始功能进行增强。

就像是小孩子吃饭,不需要做饭,刷碗,让爸爸妈妈干这些活,小孩子只要吃就好了(此处可以将做饭刷碗剥离出来)

6. 如果要完成一个AOP的入门案例，需要有哪些步骤？

1.导入依赖

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

2.定义类抽取公共代码

@Slf4j
public class TimeAspect{
    public void recordTime(){
        long begin = System.currentTimeMillis();
        
        //调用原始操作
        
        long end =System.currentTimeMillis();
        
        log.info("执行耗时 : {} ms",(end - begin));
    }
}

3.标识当前类是一个AOP类,并被Spring容器管理

@Slf4j          //日志
@Aspect         //标识当前类是一个AOP类
@Component      //声明该类是spring的IOC容器中的bean对象
public class TimeAspect{

}

4.配置公共代码作用于那些目标方法

5.执行目标方法

@Slf4j          //日志
@Aspect         //标识当前类是一个AOP类
@Component      //声明该类是spring的IOC容器中的bean对象
public class TimeAspect{
    @Around("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))")
    public Object timeRecord(ProceedingJoinPoint joinPoint) throws Throwable{
        long begin = System.currentTimeMillis();
        
        //TODO 调用原始操作
        Object result = joinPoint.proceed(); 
        
        long end =System.currentTimeMillis();
        
        log.info("执行耗时 : {} ms",(end - begin));
        return result;
    }
}


@Around: 表示环绕通知,可以在目标方法执行前后执行一些公共代码
       * 表示通配符,代表任意
      .. 表示参数通配符,代表任意参数

7. AOP的概念理解：连接点，通知，切入点，切面 ？

连接点: JoinPoint ,可以被AOP控制的方法执行(包含方法信息)
通知: Advice ,重复逻辑代码
切入点: PointCut ,匹配连接点的条件
切面: Aspect ,通知+切点

8. 通知有哪些类型？

@Around : 此注解标注的通知方法在目标方法前,后都被执行
@Before : 此注解标注的通知方法在目标方法前被执行
@After : 此注解标注的通知方法在目标方法后被执行,无论是否有异常
@AfterReturning : 此注解标注的通知方法在目标方法后被执行,有异常不会执行
@AfterThrowing : 此注解标注的通知方法发生异常后执行   

注意事项:
    @Around: 需要自己调用ProceedingJoinPoint.proceed()来让目标方法执行,其他通知不需要考虑目标方法执行

9. 如果有不同切面的通知，增强相同的方法，执行顺序是怎样的？

1.默认按照切面类的名称字母排序:
    目标前的通知方法 : 字母排名靠前的先执行
    目标后的通知方法 : 字母排名靠前的后执行
2.用@Order(数字)加在切面类上来控制顺序:
    目标前的通知方法 : 数字小的先执行
    目标后的通知方法 : 数字小的后执行

10. 切点表达式有几种，具体怎么定义？

1.execution 主要根据方法的返回值,包名,类名,方法名,方法参数等信息来匹配,语法为
 execution(访问修饰符? 返回值 包名.类名?.方法名(方法参数) throws 异常?)
    * :可以通配任意返回值类型,包名,类名,方法名,或任意类型的一个参数
    ~ :可以通配任意层级的包,或任意类型,任意个数的参数
    其中带?的表示可以省略的部分
        访问修饰符: 可省略(没啥用,仅能匹配public,protected,包级,private不能增强)
        包名.类名: 可省略
        throws异常: 可省略(注意是方法上声明抛出的异常,不是实际抛出的异常)
        
2.@annotation
    切点表达式也支持匹配目标方法是否有注解,使用@annotation(com.itheima.anno.Log)
    
    @Before("@annotation(com.itheima.anno.Log)")
    public void before(){
        log.info("before ....")
    }

11. 如果有多个通知的切点表达式一样，怎么抽取？

@PointCut

通过@PointCut注解,可以抽取一个切入点表达式,然后再其他的地方我们可以通过类似于 方法调用 的形式来引用该切入点表达式

@PointCut("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))")
public void pt(){}

@Around("pt()")
public Object recordTime(ProceedingJoinPoint joinPoint) throws Throwable{
        long begin = System.currentTimeMillis();
        
        //TODO 调用原始操作
        Object result = joinPoint.proceed(); 
        
        long end =System.currentTimeMillis();
        
        log.info("执行耗时 : {} ms",(end - begin));
        return result;
}

12. 连接点是什么可以获取哪些信息？

连接点简单理解就是目标方法,在Spring中用JoinPoint抽象了连接点,用它可以获得方法执行的的相关信息,如方法名,方法参数类型,方法实际参数等等

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

@Around("execution(* com.itheima.service.impl.DeptServiceImpl.*(..))") throws Trowable{
    String className = joinPoint.getTarget().getClass.getName();
    Signature signature =joinPoint.getSignature();
    String methodName =signature.getName();
    Object[] args=joinPoint.getArgs();
    
    log.info("类名 :{} ,方法名 :{} , 参数 :{} ",className,methodName,args);
    long begin = System.currentTimeMillis();
        
    //TODO 调用原始操作
    Object result = joinPoint.proceed(); 
    
    long end =System.currentTimeMillis();
    
    log.info("执行耗时 : {} ms",(end - begin));
    return result;
}