AOP本质：在不改变原有业务逻辑的情况下增强横切逻辑，横切逻辑代码往往是权限校验代码、日志代 码、事务控制代码、性能监控代码。

第1节 AOP 相关术语

1.1 业务主线

在讲解AOP术语之前，我们先来看一下下面这两张图，它们就是第三部分案例需求的扩展（针对这些扩展的需求，我们只进行分析，在此基础上去进一步回顾AOP，不进行实现）

上图描述的就是未采用AOP思想设计的程序，当我们红色框中圈定的方法时，会带来大量的重复劳动。程序中充斥着大量的重复代码，使我们程序的独立性很差。而下图中是采用了AOP思想设计的程序，它把红框部分的代码抽取出来的同时，运用动态代理技术，在运行期对需要使用的业务逻辑方法进行增强。

把重复部分的代码抽取出来的同时，运用动态代理技术，在运行期对需要使用的业务逻辑方法进行增强。

1.2 AOP 术语

连接点：方法开始时、结束时、正常运行完毕时、方法异常时等这些特殊的时机点，我们称之为连接点，项目中每个方法都有连接点，连接点是一种候选点。

切入点：指定AOP思想，想要影响的具体方法是哪些，描述感兴趣的方法（就对此方法进行切入）。

Advice增强：
第一个层次：指的是横切逻辑
第二个层次：方位点（在某一些连接点上加入横切逻辑，那么这些连接点就叫做方位点，描述的是具体的特殊时机）

Aspect切面：切面概念是对上述概念的一个综合
Aspect切面= 切入点+增强
= 切入点（要锁定的方法） + 方位点（开、结、正、异的那个时机点）+ 横切逻辑
众多的概念，目的就是为了锁定要在哪个地方插入什么横切逻辑代码

第2节 Spring中AOP的代理选择

Spring 实现AOP思想使用的是动态代理技术
默认情况下，Spring会根据被代理对象是否实现接口来选择使用JDK还是CGLIB。当被代理对象没有实现任何接口时，Spring会选择CGLIB。当被代理对象实现了接口，Spring会选择JDK官方的代理技术，不过我们可以通过配置的方式，让Spring强制使用CGLIB。

第3节 Spring中AOP的配置方式

在Spring的AOP配置中， 也和loC配置一样， 支持3类配置方式。
第一类：使用XML配置
第二类：使用XML+注解组合配置
第三类：使用纯注解配置

第4节Spring中AOP实现

需求：横切逻辑代码是打印日志， 希望把打印日志的逻辑织入到目标方法的特定位置(service层transfer方法)

4.1 Spring AOP的纯xml模式回顾 （XML模式）

Spring是模块化开发的框架， 使用aop就要引入aop的jar

<!--spring aop的jar包支持-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aop</artifactId>
  <version>5.1.12.RELEASE</version>
</dependency>
<!--第三方的aop框架aspectj的jar-->
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.8.13</version>
</dependency>

AOP 核心配置

注意：在spring的配置文件中加入aop的约束
切入点想锁定那个方法，其就是靠　　　全限定类名＋方法名＋参数类型　　
对那个方法进行切入，那个方法就作为切入点，
被切入的方法里面的逻辑为横切逻辑
那么什么时候执行切入这个方法的呢，就是时机点

<!--开始aop的配置-->
<!--使用config标签表明开始aop配置,在内部配置切面aspect -->
<!--aspect = 切入点（锁定方法） + 方位点（锁定方法中的特殊时机）+ 横切逻辑 -->
<aop:config>
    <!--配置切面，有id表示可以配置多个切入点-->
    <aop:aspect id="logAspect" ref="logUtils">

        <!--切入点配置，切入点锁定我们感兴趣的方法，使用aspectj语法表达式

　　　　　　　　　　　　其实也就是要对那个方法进行切入　—>

         <!--方位信息,pointcut-ref关联切入点-->
         <!--aop:before配置前置通知/增强 ，
            切入点（对那个方法进行织入代码）要与　执行横切代码　进行关联

　　　　　　　＝＞　如transfer方法（切入点）与　beforeMethod（横切代码）　进行关联 　　　　　　　　那么什么时候执行这个横切代码呢？　可在方法前/后/正/异 中的一个时机点发生 pointcut-ref=”pt1”把切入点pt1关联进来—>

         <!--aop:after，配置最终通知，无论如何都执行-->
         <!--aop:after-returnning，正常执行通知。returning是一个形参
            当successMethod方法执行完后，将返回值通过形参回传-->
        <aop:after-returning method="successMethod" returning="retValue"/>

         <!--aop:after-throwing，异常通知-->
        <aop:after-throwing method="exceptionMethod" pointcut-ref="pt1"/>

        <!--aop:around，环绕通知
          可以控制原有业务逻辑是否执行，就行反射中的事件触发-->
        <aop:around method="arroundMethod" pointcut-ref="pt1"/>

    </aop:aspect>
</aop:config>-->

<a name="hWkmL"></a>
### 相关的Java代码块
```java
public class LogUtils {

      /**
     * 业务逻辑开始之前执行
     */
       public void beforeMethod(JoinPoint joinPoint) {
        // 通过JoinPoint这个可以获取参数   
        Object[] args = joinPoint.getArgs();
        for (int i = 0; i < args.length; i++) {
            Object arg = args[i];
            System.out.println(arg);
        }
        System.out.println("业务逻辑开始执行之前执行.......");
    }


    /**
     * 业务逻辑结束时执行（无论异常与否）
     */
      public void afterMethod() {
        System.out.println("业务逻辑结束时执行，无论异常与否都执行.......");
    }


    /**
     * 异常时时执行
     */
      public void exceptionMethod() {
        System.out.println("异常时执行.......");
    }


    /**
     * 业务逻辑正常时执行
     */
     public void successMethod(Object retVal) {
        System.out.println("业务逻辑正常时执行.......");
    }


    /**
     * 环绕通知
     *
     */
    public Object arroundMethod(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知中的beforemethod....");

        Object result = null;
        try{
            // 这句代码是可以控制原有业务逻辑是否执行，就相当于method.invoke,
            //如果不写则原有业务逻辑就不会去执行的
            // result = proceedingJoinPoint.proceed(proceedingJoinPoint.getArgs());
        }catch(Exception e) {
            System.out.println("环绕通知中的exceptionmethod....");
        }finally {
            // 无论如何都会去执行的
            System.out.println("环绕通知中的after method....");
        }

        return result;
    }

}

这句代码是可以控制原有业务逻辑是否执行，就相当于method.invoke,
proceedingJoinPoint.proceed(proceedingJoinPoint.getArgs());
一般而言： 环绕通知不和其他通知一起使用

关于切入点表达式

上述配置实现了对TransferServicelmpl的updateAccountByCardNo方法进行增强， 在其执行之前，输出了记录日志的语句。这里面，我们接触了一个比较陌生的名称：切入点表达式，它是做什么的呢?我们往下看。
expression=”execution( com.lagou.edu.service.impl.TransferServiceImpl.(..))”
返回类型可以用 代替 方法可用 代替 参数可用 .. 来代替
*表示可以是所有类型的， .. 表示可变的参数
使用最多的还是具体到某一层。

概念及作用

切入点表达式， 也称之为Aspectj切入点表达式， 指的是遵循特定语法结构的字符串， 其作用是用于对符合语法格式的连接点进行增强。它是AspectJ表达式的一部分。

关于Aspectj

Aspectj是一个基于Java语言的AOP框架， Spring框架从2.0版本之后集成了Aspectj框架中切入点表达式的部分， 开始支持AspectJ切入点表达式。

切入点表达式使用示例

全限定方法名   访问修饰符   返回值   包名.包名.包名.类名.方法名(参数列表)

全匹配方式：
public void com.lagou.service.impl.TransferServiceImpl.updateAccountByCardNo(com.lagou.pojo.Account)

访问修饰符可以省略
void com.lagou.service.impl.TransferServiceImpl.updateAccountByCardNo(com.lagou.pojo.Account)
 返回值可以使用*，表示任意返回值 

*  com.lagou.service.impl.TransferServiceImpl.updateAccountByCardNo(com.lagou.pojo.Account)

包名可以使用.表示任意包，但是有几级包，必须写几个

* ....TransferServiceImpl.updateAccountByCardNo(com.lagou.pojo.Account)

包名可以使用..表示当前包及其子包
* ..TransferServiceImpl.updateAccountByCardNo(com.lagou.pojo.Account)

 类名和方法名，都可以使用.表示任意类，任意方法
 * ...(com.lagou.pojo.Account)
 参数列表，可以使用具体类型
 基本类型直接写类型名称 ： int
 引用类型必须写全限定类名：java.lang.String
 参数列表可以使用*，表示任意参数类型，但是必须有参数

 * *..*.*(*)
 参数列表可以使用..，表示有无参数均可。有参数可以是任意类型
 * *..*.*(..)
 全通配方式：
 * *..*.*(..)

改变代理方式的配置

Spring创建代理对象时会根据被代理对象的实际情况来选择。被代理对象实现了接口，则采用基于接口的动态代理。当被代理对象没有实现任何接口， Spring会自动切换到基于子类的动态代理方式。
但无论被代理的对象是否实现接口， 只要不是final修饰的类都可以采用cglib提供的方式创建代理对象。所以Spring也考虑到了这个情况， 提供了配置的方式实现强制使用基于子类的动态代理(即cglib的方式) ， 配置的方式有两种

• 使用aop:confifig标签配置

  <aop:config proxy-target-class="true">
  

• 使用aop:aspectj-autoproxy标签配置

  <!--此标签是基于XML和注解组合配置AOP时的必备标签，表示Spring开启注解配置AOP的支持-->
  <aop:aspectj-autoproxy proxy-target-class="true">
  </aop:aspectj-autoproxy>
  

五种通知类型

前置通知——配置方式：aop:before标签

 <!--作用：用于配置前置通知。
     出现位置：它只能出现在aop：aspect标签内部
     属性：  method：用于指定前置通知的方法名称
             pointcut：用于指定切入点表达式
             pointcut-ref：用于指定切入点表达式的引用-->
 <aop:before method="printLog" pointcut-ref="pointcut1">
 </aop:before>

执行时机：前置通知永远都会在切入点方法(业务核心方法)执行之前执行。
细节：前置通知可以获取切入点方法的参数，并对其进行增强。

异常执行时通知——配置方式

 <!--作用：用于配置异常通知。
     出现位置： 它只能出现在aop：aspect标签内部
     属性：method：用于指定异常通知的方法名称
           pointcut-ref：用于指定切入点表达式的引用
           pointcut：用于指定切入点表达式
 -->

 <aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1">
 </aop:after-throwing>

执行时机：异常通知的执行时机是在切入点方法(业务核心方法)执行产生异常之后，异常通知执行。如果切入点方法执行没有产生异常，则异常通知不会执行。
细节：异常通知不仅可以获取切入点方法执行的参数，也可以获取切入点方法执行产生的异常信息。

最终通知——配置方式

 <!--作用：用于指定最终通知。
     出现位置：它只能出现在aop：aspect标签内部
     属性：method：用于指定最终通知的方法名称
           pointcut：用于指定切入点表达式
           pointcut-ref：用于指定切入点表达式的引用
 -->
 <aop：aftermethod=”afterPrintLog”pointcut-ref=”pt1”>
 </aop：after>

执行时机：最终通知的执行时机是在切入点方法(业务核心方法)执行完成之后，切入点方法返回之前执行。
换句话说，无论切入点方法执行是否产生异常，它都会在返回之前执行。

细节：最终通知执行时，可以获取到通知方法的参数。同时它可以做一些清理操作。

环绕通知——配置方式

 <!--作用：用于配置环绕通知。
     出现位置：它只能出现在aop：aspect标签的内部
     属性：  method：用于指定环绕通知的方法名称
             pointcut-ref：用于指定切入点表达式的引用
             pointcut：用于指定切入点表达式
 -->
 <aop：aroundmethod=”aroundPrintLog”pointcut-ref=”pt1”>
 </aop：around>

特别说明
环绕通知，它是有别于前面四种通知类型外的特殊通知。前面四种通知(前置，后置，异常和最终)它们都是指定何时增强的通知类型。而环绕通知， 它是Spring框架为我们提供的一种可以通过编码的方式， 控制增强代码何时执行的通知类型。它里面借助的ProceedingJoinPoint接口及其实现类，实现手动触发切入点方法的调用。

4.2 XML+注解模式

XML 中开启 Spring 对注解 AOP 的支持

<!--开启spring对注解aop的支持,开启aop注解驱动
 proxy-target-class:true强制使用cglib  ,如果默认就得由框架自己选择了-->
<aop:aspectj-autoproxy/>

用注解替换xml

<bean id="logUtils" class="com.lagou.edu.utils.LogUtils"></bean>
切换为注解，需要在上面添加@Component

<aop:aspect id="logAspect" ref="logUtils">
如何表面切面的注解呢？  ref="logUtils"是指向横切逻辑，需要在logUtils类上面添加@Aspect，
  现在已经在他的头顶了，不用再其他关联

<aop:pointcut id="pt1" expression="execution(* com.lagou.edu.service.impl.TransferServiceImpl.*(..))"/>
  切入点如何改为注解呢？  需要在类里面添加一个空实现方法public void pt1()，承载上面的注解

<aop:before method="beforeMethod" pointcut-ref="pt1"/>
  前置通知改注解，需要添加  @Before("pt1()")并且关联切入点方法pt1()

横切逻辑和切入点(方法) 进行关联后 ，那么执行方位点 就会 执行横切逻辑代码 。那么要在什么时候执行呢，就得看是哪个时机点了。是在前、后、正、异，还是自己控制？

注解替换xml后例子：

@Component
@Aspect
public class LogUtils {


    @Pointcut("execution(* com.lagou.edu.service.impl.TransferServiceImpl.*(..))")
    public void pt1(){

    }


    /**
     * 业务逻辑开始之前执行
     */
    @Before("pt1()") //横切逻辑beforeMethod 和切入点 pt1 进行关联,Before表示在切入点之前执行横切
    public void beforeMethod(JoinPoint joinPoint) {
        Object[] args = joinPoint.getArgs();
        for (int i = 0; i < args.length; i++) {
            Object arg = args[i];
            System.out.println(arg);
        }
        System.out.println("业务逻辑开始执行之前执行.......");
    }


    /**
     * 业务逻辑结束时执行（无论异常与否）
     */
    @After("pt1()")
    public void afterMethod() {
        System.out.println("业务逻辑结束时执行，无论异常与否都执行.......");
    }


    /**
     * 异常时时执行
     */
    @AfterThrowing("pt1()")
    public void exceptionMethod() {
        System.out.println("异常时执行.......");
    }


    /**
     * 业务逻辑正常时执行
     */
    @AfterReturning(value = "pt1()",returning = "retVal")
    public void successMethod(Object retVal) {
        System.out.println("业务逻辑正常时执行.......");
    }


    /**
     * 环绕通知
     *
     */
    /*@Around("pt1()")*/
    public Object arroundMethod(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知中的beforemethod....");

        Object result = null;
        try{
            // 控制原有业务逻辑是否执行
            // result = proceedingJoinPoint.proceed(proceedingJoinPoint.getArgs());
        }catch(Exception e) {
            System.out.println("环绕通知中的exceptionmethod....");
        }finally {
            System.out.println("环绕通知中的after method....");
        }

        return result;
    }

}

4.3 注解模式

如果是存注解模式，则就没有xml，就会有一个类是Java的配置类入口，
在使用注解驱动开发aop时，我们要明确的就是，是注解替换掉配置文件中的下面这行配置：

<!--开启spring对注解aop的支持-->
<aop:aspectj-autoproxy/>

在配置类中使用如下注解进行替换上述配置

 @Configuration
 @ComponentScan("com.lagou")
 @EnableAspectJAutoProxy //开启spring对注解AOP的支持
 public class SpringConfiguration {
 }

第5节 Spring 声明式事务的支持

编程式事务：在业务代码中添加事务控制代码，这样的事务控制机制就叫做编程式事务（业务代码和控制代码混合在一起）
声明式事务：通过xml或者注解配置的方式达到事务控制的目的， 叫做声明式事务（业务代码和控制代码分离了）

5.1事务回顾

5.1.1事务的概念

事务指逻辑上的一组操作，组成这组操作的各个单元，要么全部成功，要么全部不成功（作为一个整体）。从而确保了数据的准确与安全。
例如：A——B转帐， 对应于如下两条sql语句：

/*转出账户减钱*/
update account set money=money-100 where name=‘a’; /**转入账户加钱*/
update account set money=money+100 where name=‘b’;

这两条语句的执行，要么全部成功，要么全部不成功

5.1.2 事务的四大特性

原子性（Atomicity） 原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。
从操作的⻆度来描述，事务中的各个操作要么都成功要么都失败。

一致性（Consistency） 事务必须使数据库从一个一致性状态变换到另外一个一致性状态。
例如转账前A有1000，B有1000。转账后A+B也得是2000。
一致性是从数据的⻆度来说的，（1000，1000） （900，1100），不应该出现（900，1000）

隔离性（Isolation） 事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，
每个事务不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离。（避免脏读）
比如：事务1给员工涨工资2000，但是事务1尚未被提交，员工发起事务2查询工资，发现工资涨了2000块钱，读到了事务1尚未提交的数据（脏读）

持久性（Durability）
持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响。

5.1.3 事务的隔离级别

不考虑隔离级别，会出现以下情况：（以下情况全是错误的），也即为隔离级别在于解决事务并发问题
并发状态下可能存在以下问题（如何解决和避免呢，就需要隔离级别）
脏读：一个线程中的事务读到了另外一个线程中未提交的数据。（隔离级别:是读未提交的）

不可重复读：一个线程中的事务读到了另外一个线程中已经提交的update的数据（前后内容不一样）
（隔离级别:是不可重复读的）
场景：
员工A发起事务1，查询工资，工资为1w，此时事务1尚未关闭
财务人员发起了事务2，给员工A张了2000块钱，并且提交了事务
员工A通过事务1再次发起查询请求，发现工资为1.2w，原来读出来1w读不到了，叫做不可重复读

虚读（幻读）：一个线程中的事务读到了另外一个线程中已经提交的insert或者delete的数据（前后条数不一样） 通过间隙表解决，但是不能完全解决
场景：
事务1查询所有工资为1w的员工的总数，查询出来了10个人，此时事务尚未关闭事务2财务人员发起，新来员工，工资1w，向表中插入了2条数据，并且提交了事务事务1再次查询工资为1w的员工个数，发现有12个人.

数据库共定义了四种隔离级别：
Serializable（串行化）：可避免脏读、不可重复读、虚读情况的发生。（串行化） 最高
Repeatable read（可重复读）：可避免脏读、不可重复读情况的发生。(幻读有可能发生) 第二
该机制下会对要update的行进行加锁（通过redo undo来解决）
Read committed（读已提交）：可避免脏读情况发生。不可重复读和幻读一定会发生。 第三
Read uncommitted（读未提交）：最低级别，以上情况均无法保证。(读未提交) 最低

注意：级别依次升高，效率依次降低。（越上面隔离级别越高，效率越低）

MySQL的默认隔离级别是：REPEATABLE READ （可重复度）
查询当前使用的隔离级别： select @@tx_isolation;
设置MySQL事务的隔离级别： set session transaction isolation level xxx; （设置的是当前mysql连接会话的，并不是永久改变的）

5.1.4 事务的传播行为

事务往往在service层进行控制，如果出现service层方法A调用了另外一个service层方法B，A和B方法本身都已经被添加了事务控制，那么A调用B的时候，就需要进行事务的一些协商，这就叫做事务的传播行为。

A调用B，我们站在B的⻆度来观察来定义事务的传播行为(站在被调用方的角度来看)

面试中会问的。？？？？

5.2 Spring中事务的API

如何实现声明式事物，（就是业务代码不用和事物代码 编辑 在一起）

PlatformTransactionManager
这是一个Spring中的一个顶级的接口，接口中定义了一些事物的基本的行为，事物的规范
为什么定义规范呢，因为不同的数据库规则不一样。所以Spring只能一定接口了。
mybatis: sqlSession.commit();
hibernate: session.commit();

public interface PlatformTransactionManager {
    /**
    *获取事务状态信息
    */

    TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws TransactionException;
    /**
    *提交事务
    */
    void commit(TransactionStatus status) throws TransactionException;

    /**
    *回滚事务
    */
    void rollback(TransactionStatus status) throws TransactionException;
}

作用
此接口是Spring的事务管理器核心接口。Spring本身并不支持事务实现，只是负责提供标准，应用底层支持什么样的事务，需要提供具体实现类。此处也是策略模式的具体应用。在Spring框架中，也为我们内置了一些具体策略，例如：DataSourceTransactionManager , HibernateTransactionManager 等等。（ 和 HibernateTransactionManager 事务管理器在 spring-orm-5.1.12.RELEASE.jar 中）

SpringJdbcTemplate（数据库操作工具 Spring自有的）、
Mybatis（mybatis-spring.jar）————> DataSourceTransactionManager（实现类）
Hibernate框架 ——————> HibernateTransactionManager（实现类）

DataSourceTransactionManager 归根结底是横切逻辑代码，声明式事务要做的就是使用Aop（动态代理）来将事务控制逻辑织入到业务代码。

对于原生的jdbc，Spring框架DataSourceTransactionManager没有提供一个具体的实现支持，原生的jdbc是自己到连接池拿一个连接，自己去操作，相当于一个游离态的连接，对于SpringJdbcTemplate是Spring框架自有的，这个是可以实现。

涉及到数据库操作都需要添加如下依赖

 <!--引入spring声明式事务相关-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.1.12.RELEASE</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-tx</artifactId>
      <version>5.1.12.RELEASE</version>
    </dependency>

因为声明式事物底层是使用aop来实现的，所以添加下面的引用

<!--spring aop的jar包支持-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>5.1.12.RELEASE</version>
    </dependency>

    <!--第三方的aop框架aspectj的jar-->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.13</version>
    </dependency>

5.3没有配置声明式事物的时候如下

在xml中的配置如下信息（applicationContext.xml）

 <!--开启注解扫描，base-package指定扫描的包路径-->
<context:component-scan base-package="com.lagou.edu"/>

<!--引入外部资源文件-->
<context:property-placeholder location="classpath:jdbc.properties"/>

<!--第三方jar中的bean定义在xml中-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${jdbc.driver}"/>
    <property name="url" value="${jdbc.url}"/>
    <property name="username" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
 </bean>

<!--通过JdbcTemplate类对jdbc进行操作-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <constructor-arg name="dataSource" ref="dataSource"/>
</bean>

Dao层的接口

public interface AccountDao {

    Account queryAccountByCardNo(String cardNo) throws Exception;

    int updateAccountByCardNo(Account account) throws Exception;
}

对Dao层的实现

借助JdbcTemplate这个类，对jdbc进行操作。

@Repository("accountDao")
public class JdbcTemplateDaoImpl implements AccountDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public Account queryAccountByCardNo(String cardNo) throws Exception {
        String sql = "select * from account where cardNo=?";
        return jdbcTemplate.queryForObject(sql, new RowMapper<Account>() {
            @Override
            public Account mapRow(ResultSet resultSet, int i) throws SQLException {
                Account account = new Account();
                account.setName(resultSet.getString("name"));
                account.setCardNo(resultSet.getString("cardNo"));
                account.setMoney(resultSet.getInt("money"));
                return account;
            }
        }, cardNo);
    }

    @Override
    public int updateAccountByCardNo(Account account) throws Exception {
        String sql = "update account set money=? where cardNo=?";
        return jdbcTemplate.update(sql,account.getMoney(),account.getCardNo());
    }
}

上面的情况是没有添加事物的，（没有实现事物的隔离，容易脏读各种情况，为了实现事物的隔离，所以要配置声明式事物，具体操作如下）

5.4 Spring 声明式事务配置

基于纯xml的模式

1、引入相关的jar包

 <!--引入Spring IoC容器功能-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.1.12.RELEASE</version>
    </dependency>

  <!--spring aop的jar包支持-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aop</artifactId>
      <version>5.1.12.RELEASE</version>
    </dependency>

    <!--第三方的aop框架aspectj的jar-->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.13</version>
    </dependency>

    <!--引入spring声明式事务相关-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>5.1.12.RELEASE</version>
    </dependency>

2、xml中配置相关的约束

tx是专门针对事物的标签，aop是针对切面的标签

<beans ...
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="
         http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/tx
        https://www.springframework.org/schema/tx/spring-tx.xsd

3、xml中配置声明式事物

接着上面的 （applicationContext.xml）配置
spring声明式事务配置，声明式事务无非就是配置一个aop，只不过有些标签不一样罢了

注意定义增强的时候：定义事物的行为的时候，需要事物REQUIRED，有没有事物都行SUPPORTS

<!--spring声明式事务配置，声明式事务无非就是配置一个aop，只不过有些标签不一样罢了-->

<!--1、横切逻辑-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  <!--传入一个数据源：因为要控制事物，所以需要将数据源给到他-->      
  <constructor-arg name="dataSource" ref="dataSource"></constructor-arg>
</bean>

 <!--3、定义增强，通过tx标签，将上面 1 的横切逻辑关联进来-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
  <!--定制事务细节，传播行为、隔离级别等-->
  <tx:attributes>
    <!-- tx:method 说明这些拦截是拦截方法的，反过来想：如果拦截某个方法需要对其做哪些事物属性配置呢？-->
    <!--一般性配置，对所有方法的使用率高的配置（如:增删改查）
       不仅仅是只读，增删改成要求有事物REQUIRED，使用数据库默认的隔离级别DEFAULT（不日志也是默认的） -->
    <tx:method name="*" read-only="false" propagation="REQUIRED" isolation="DEFAULT" timeout="-1"/>

    <!--针对查询的覆盖性配置：也就是如果遇到查询的时候，会覆盖上面的方法
        对于查询，是只读的 true  ，有没有事物都可以 SUPPORTS -->
    <tx:method name="query*" read-only="true" propagation="SUPPORTS"/>
  </tx:attributes>
</tx:advice>


<!--2、配置aop-->
<aop:config>
  <!--之前是用aop:asepct,现在用aop:advisor
   通过 advice-ref 来指向增强 = 横切逻辑（txAdvice）+方位(也就是切入点：pointcut)  
     将上面 3 的增强关联到这里
   切入点是：TransferServiceImpl类下的所有方法   
    -->
<aop:advisor advice-ref="txAdvice" pointcut="execution(* com.lagou.edu.service.impl.TransferServiceImpl.*(..))"/>
</aop:config>

4、其他层是否需要改动

dao层和dao的实现类层都不需要改动

基于XML+注解的模式

1、xml配置如下

transactionManager是第三方的Bean ，可以先留着，其他自个手写的可以用注解来替换
把2、3的xml都注掉，同时需要改用声明式事务的注解驱动。就能通过注解来了

    <!--spring声明式事务配置，声明式事务无非就是配置一个aop，只不过有些标签不一样罢了-->
    <!--横切逻辑-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
      <!--传入一个数据源：因为要控制事物，所以需要将数据源给到他-->      
        <constructor-arg name="dataSource" ref="dataSource"></constructor-arg>
    </bean>


   <!-- <tx:advice id="txAdvice" transaction-manager="transactionManager">
        &lt;!&ndash;定制事务细节，传播行为、隔离级别等&ndash;&gt;
        <tx:attributes>
            &lt;!&ndash;一般性配置&ndash;&gt;
            <tx:method name="*" read-only="false" propagation="REQUIRED" isolation="DEFAULT" timeout="-1"/>
            &lt;!&ndash;针对查询的覆盖性配置&ndash;&gt;
            <tx:method name="query*" read-only="true" propagation="SUPPORTS"/>
        </tx:attributes>
    </tx:advice>


    <aop:config>
        &lt;!&ndash;advice-ref指向增强=横切逻辑+方位&ndash;&gt;
        <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.lagou.edu.service.impl.TransferServiceImpl.*(..))"/>
    </aop:config>-->

    <!--声明式事务的注解驱动-->
    <tx:annotation-driven transaction-manager="transactionManager"/>

2、在接口/实现类/方法上添加@Transactional注解

如果在接口上，则对所有的类都实现了事物
如果在实现类上，则对所有的方法都实现了事物
如果在方法上，则只是对该方法实现事物
（优先级是： 方法>类>接口）
只要添加完@Transactional注解就完事了，不需要其他的操作了

@Service("transferService")
@Transactional
public class TransferServiceImpl implements TransferService {

    @Autowired
    @Qualifier("accountDao")
    private AccountDao accountDao;

    @Override
    public void transfer(String fromCardNo, String toCardNo, int money) throws Exception {

            Account from = accountDao.queryAccountByCardNo(fromCardNo);
            Account to = accountDao.queryAccountByCardNo(toCardNo);

            from.setMoney(from.getMoney()-money);
            to.setMoney(to.getMoney()+money);

            accountDao.updateAccountByCardNo(to);
            int c = 1/0;
            accountDao.updateAccountByCardNo(from);
    }
}

基于纯注解的模式

1、Spring基于注解驱动开发的事务控制配置， 只需把xml配置部分改为注解实现。
只是需要一个注解替换掉xml配置文件中的

<tx:annotation-driven transactionmanager="transactionManager"/>

在Spring的配置类上添加@EnableTransactionManagement注解即可

 @Enable TransactionManagement//开启spring注解事务的支持
 public classSpring Configuration{
 }