一文搞懂什么是事务

事务概念

咱们要理解下事务概念：什么是事务呢？事务是并发控制的单位，是用户定义的一个操做序列。有四个特性(ACID)：html

原子性(Atomicity)：事务是数据库的逻辑工做单位，事务中包括的诸操做要么全作，要么全不作。java
一致性(Consistency)：事务执行的结果必须是使数据库从一个一致性状态变到另外一个一致性状态。一致性与原子性是密切相关的。mysql
隔离性(Isolation)：一个事务的执行不能被其余事务干扰。sql
持续性/永久性(Durability)：一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。数据库

以上是书面解释，简单来讲就是把你的操做统一化，要么全部操做都成功，要么就都不成功，若是执行中有某一项操做失败，其以前全部的操做都回滚到未执行这一系列操做以前的状态。编程

脏读、不可重复读、幻读

先理解这三种因为并发访问致使的数据读取问题，再理解事务隔离级别就简单多了。数组

脏读

A事务读取B事务还没有提交的数据，此时若是B事务发生错误并执行回滚操做，那么A事务读取到的数据就是脏数据。就好像本来的数据比较干净、纯粹，此时因为B事务更改了它，这个数据变得再也不纯粹。这个时候A事务当即读取了这个脏数据，但事务B良心发现，又用回滚把数据恢复成原来干净、纯粹的样子，而事务A却什么都不知道，最终结果就是事务A读取了这次的脏数据，称为脏读。微信

这种状况常发生于转帐与取款操做中并发

不可重复读（先后屡次读取，数据内容不一致）

事务A在执行读取操做，由整个事务A比较大，先后读取同一条数据须要经历很长的时间。而在事务A第一次读取数据，好比此时读取了小明的年龄为20岁，事务B执行更改操做，将小明的年龄更改成30岁，此时事务A第二次读取到小明的年龄时，发现其年龄是30岁，和以前的数据不同了，也就是数据不重复了，系统不能够读取到重复的数据，成为不可重复读。app

幻读（先后屡次读取，数据总量不一致）

事务A在执行读取操做，须要两次统计数据的总量，前一次查询数据总量后，此时事务B执行了新增数据的操做并提交后，这个时候事务A读取的数据总量和以前统计的不同，就像产生了幻觉同样，无缘无故的多了几条数据，成为幻读。

小总结:不可重复读和幻读到底有什么区别?

(1) 不可重复读是读取了其余事务更改的数据，针对update操做

解决：使用行级锁，锁定该行，事务A屡次读取操做完成后才释放该锁，这个时候才容许其余事务更改刚才的数据。

(2) 幻读是读取了其余事务新增的数据，针对insert和delete操做

解决：使用表级锁，锁定整张表，事务A屡次读取数据总量以后才释放该锁，这个时候才容许其余事务新增数据。

这时候再理解事务隔离级别就简单多了呢。

数据库事务的隔离级别

SQL 标准定义的四种隔离级别被 ANSI（美国国家标准学会）和 ISO/IEC（国际标准）采用，每种级别对事务的处理能力会有不一样程度的影响。事务是一系列的动做，它们综合在一块儿才是一个完整的工做单元，这些动做必须所有完成，若是有一个失败的话，那么事务就会回滚到最开始的状态，仿佛什么都没发生过同样。

数据库事务的隔离级别有4个，由低到高依次为Read uncommitted 、Read committed 、Repeatable read 、Serializable ，这四个级别能够逐个解决脏读、不可重复读、幻读这几类问题。

DEFAULT

默认值，表示使用底层数据库的默认隔离级别。大部分数据库为READ_COMMITTED(MySql默认REPEATABLE_READ)

READ UNCOMMITTED（读未提交）

该隔离级别表示一个事务能够读取另外一个事务修改但尚未提交的数据。该级别不能防止脏读和不可重复读，所以不多使用该隔离级别。

READ_COMMITTED (读提交)

该隔离级别表示一个事务只能读取另外一个事务已经提交的数据。该级别能够防止脏读，这也是大多数状况下的推荐值。

REPEATABLE_READ (可重复读)

该隔离级别表示一个事务在整个过程当中能够屡次重复执行某个查询，而且每次返回的记录都相同。即便在屡次查询之间有新增的数据知足该查询，这些新增的记录也会被忽略。该级别能够防止脏读和不可重复读。

SERIALIZABLE (串行化)

全部的事务依次逐个执行，这样事务之间就彻底不可能产生干扰，也就是说，该级别能够防止脏读、不可重复读以及幻读。可是这将严重影响程序的性能。一般状况下也不会用到该级别。在该隔离级别下事务都是串行顺序执行的，MySQL 数据库的 InnoDB 引擎会给读操做隐式加一把读共享锁，从而避免了脏读、不可重读复读和幻读问题。

MVCC（多版本并发控制）

mysql中，默认的事务隔离级别是可重复读（repeatable-read），为了解决不可重复读，innodb采用了MVCC（多版本并发控制）来解决这一问题。 MVCC是利用在每条数据后面加了隐藏的两列（建立版本号和删除版本号），每一个事务在开始的时候都会有一个递增的版本号,用来和查询到的每行记录的版本号进行比较。 MYSQL MVCC

Spring事务传播行为

先来介绍下Spring事务传播行为的使用方法:

@Transactional(propagation=Propagation.REQUIRED)
public void test() {
        //todo something
}

注解@Transactional 经过使用 propagation 属性设置，例如：@Transactional(propagation = Propagation.REQUIRED)

它的propagation属性取值有如下几种:

public enum Propagation {

    REQUIRED(TransactionDefinition.PROPAGATION_REQUIRED),

    SUPPORTS(TransactionDefinition.PROPAGATION_SUPPORTS),

    MANDATORY(TransactionDefinition.PROPAGATION_MANDATORY),

    REQUIRES_NEW(TransactionDefinition.PROPAGATION_REQUIRES_NEW),

    NOT_SUPPORTED(TransactionDefinition.PROPAGATION_NOT_SUPPORTED),

    NEVER(TransactionDefinition.PROPAGATION_NEVER),

    NESTED(TransactionDefinition.PROPAGATION_NESTED);

}

事务传播行为:

REQUIRED ：若是当前存在事务，则加入该事务；若是当前没有事务，则建立一个新的事务。
SUPPORTS ：若是当前存在事务，则加入该事务；若是当前没有事务，则以非事务的方式继续运行。
MANDATORY ：若是当前存在事务，则加入该事务；若是当前没有事务，则抛出异常。
REQUIRES_NEW ：建立一个新的事务，若是当前存在事务，则把当前事务挂起。
NOT_SUPPORTED ：以非事务方式运行，若是当前存在事务，则把当前事务挂起。
NEVER ：以非事务方式运行，若是当前存在事务，则抛出异常。
NESTED ：若是当前存在事务，则建立一个事务做为当前事务的嵌套事务来运行；若是当前没有事务，则该取值等价于 REQUIRED

Spring 事务的两种实现

Spring 支持“编程式事务”管理和“声明式事务”管理两种方式：

1编程式事务：编程式事务使用 TransactionTemplate 或者直接使用底层的 PlatformTransactionManager 实现事务。对于编程式事务 Spring 比较推荐使用 TransactionTemplate 来对事务进行管理。

2声明式事务：声明式事务是创建在 AOP 之上的。其本质是对方法先后进行拦截，而后在目标方法开始以前建立或者加入一个事务，在执行完目标方法以后根据执行状况“提交”或者“回滚”事务。

两种事务管理间的区别

编程式事务容许用户在代码中精肯定义事务的边界。
声明式事务有助于用户将操做与事务规则进行解耦，它是基于 AOP 交由 Spring 容器实现，是开发人员只重点关注业务逻辑实现。
编程式事务侵入到了业务代码里面，可是提供了更加纤细的事务管理。而声明式事务基于 AOP，因此既能起到事务做用，又能够不影响业务代码的具体实现。通常而言比较推荐使用声明式事务，尤为是使用 @Transactional 注解，它能很好地帮助开发者实现事务的同时，也减小代码开发量，且使代码看起来更加清爽整洁。

Spring 编程式事务

通常来讲编程式事务有两种方法能够实现： 模板事务的方式（TransactionTemplate）和 平台事务管理器方式（PlatformTransactionManager）

模板事务的方式（TransactionTemplate）：主要是使用 TransactionTemplate 类实现事务，这也是 Spring 官方比较推荐的一种编程式使用方式；

例:

① 获取模板对象 TransactionTemplate；
② 选择事务结果类型；
③ 业务数据操做处理；
④ 业务执行完成事务提交或者发生异常进行回滚；

其中 TransactionTemplate 的 execute 能接受两种类型参数执行事务，分别为：

TransactionCallback<Object>()： 执行事务且能够返回一个值。
 TransactionCallbackWithoutResult()： 执行事务没有返回值。

下面是使用 TransactionTemplate 的实例：

@Service
public class TransactionExample {
  /** 一、获取 TransactionTemplate 对象 **/
  @Autowired
  private TransactionTemplate transactionTemplate;
  
  public void addUser() {
      // 二、使用 TransactionCallback 或者 TransactionCallbackWithoutResult 执行事务
      transactionTemplate.execute(new TransactionCallbackWithoutResult() {
          @Override
          public void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
              try {
                  // 三、执行业务代码（这里进行模拟，执行多个数据库操做方法）
                  userMapper.delete(1);
                  userMapper.delete(2);
              } catch (Exception e) {
                  // 四、发生异常，进行回滚
                  transactionStatus.setRollbackOnly();
              }
          }
      });
  }
  
}

平台事务管理器方式（PlatformTransactionManager）：这里使用最基本的事务管理局对事务进行管理，借助 Spring 事务的 PlatformTransactionManager 及 TransactionDefinition 和 TransactionStatus 三个核心类对事务进行操做。

使用事务管理器方式实现事务步骤：

① 获取事务管理器 PlatformTransactionManager；
② 获取事务属性定义对象 TransactionDefinition；
③ 获取事务状态对象 TransactionStatus；
④ 业务数据操做处理；
⑤ 进行事务提交 commit 操做或者发生异常进行事务回滚 rollback 操做；

@Service
public class TransactionExample {
    
    /** 一、获取 PlatformTransactionManager 对象 **/
    @Autowired
    private PlatformTransactionManager platformTransactionManager;

    public void addUser() {
        // 二、获取默认事务定义
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        // 设置事务传播行为
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
        // 三、根据事务定义对象设置的属性，获取事务状态
        TransactionStatus status = platformTransactionManager.getTransaction(def);
        try {
            // 四、执行业务代码（这里进行模拟，执行多个数据库操做方法）
            userMapper.delete(1);
            userMapper.delete(2);
            // 五、事务进行提交
            platformTransactionManager.commit(status);
        } catch(Exception e){
            // 五、事务进行回滚
            platformTransactionManager.rollback(status);
        }
    }
    
}

Spring 声明式事务

声明式事务（declarative transaction management）顾名思义就是使用声明的方式来处理事务。该方式是基于 Spring AOP 实现的，将具体业务逻辑和事务处理解耦，其本质是在执行方法先后进行拦截，在方法开始以前建立或者加入一个事务，在执行完目标方法以后根据执行状况提交或者回滚事务。

经常使用的声明式事务使用方法

经常使用的声明式事务使用方法有

1 XML
2 @Transactional 注解

两种方法，因为近几年 SpringBoot 的流行，提供很方便的自动化配置，导致 XML 方式已经逐渐淘汰，比较推荐使用注解的方式

@Transactional 的做用范围

注解 @Transactional 不只仅能够添加在方法上面，还能够添加到类级别上，当注解放在类级别时，表示全部该类的公共方法都配置相同的事务属性信息。若是类级别配置了 @transactional，方法级别也配置了 @transactional，应用程序会以方法级别的事务属性信息来管理事务，换言之，方法级别的事务属性信息会覆盖类级别的相关配置。

@Transactional 注解中可配置参数

value：事务管理器，此配置项是设置 Spring 容器中的 Bean 名称，这个 Bean 须要实现接口 PlatformTransactionManager。
transactionManager：事务管理器，该参数和 value 配置保持一致，是同一个东西。
isolation：事务隔离级别，默认为 Isolation.DEFAULT 级别
propagation：事务传播行为，默认为 Propagation.REQUIRED
timeout：事务超时时间，单位为秒，默认值为-1，当事务超时时会抛出异常，进行回滚操做。
readOnly：是否开启只读事务，是否开启只读事务，默认 false
rollbackForClassName：回滚事务的异常类名定义，同 rollbackFor，只是用类名定义。
noRollbackForClassName：指定发生哪些异常名不回滚事务，参数为类数组，同 noRollbackFor，只是使用类的名称定义。
rollbackFor：回滚事务异常类定义，当方法中出异常，且异常类和该参数指定的类相同时，进行回滚操做，不然提交事务。
noRollbackFor：指定发生哪些异常不回滚事务，当方法中出异常，且异常类和该参数指定的类相同时，不回滚而是将继续提交事务。

示例

@Transactional(propagation=Propagation.REQUIRED)
public void test() {
        //todo something
}

注意: 通常而言，不推荐将 @Transaction 配置到类上，由于这样极可能使后来的维护人员必须强制使用事务。

使用事务时须要注意的点

一、遇到异常检测不回滚，缘由：默认RuntimeException级别才回滚，若是是Eexception级别的异常须要手动添加

@Transactional(rollbackFor=Exception.class)

二、捕捉异常后事物不生效,缘由：捕捉处理了异常致使框架没法感知异常，天然就没法回滚了。建议:若非实际业务要求，则在业务层统一抛出异常，而后在控制层统一处理

@Transactional(rollbackFor=Exception.class)
public void test() {
    try {
         //业务代码
    } catch (Exception e) {
        // TODO: handle exception
    }
　　　//主动捕捉异常致使框架没法捕获，从而致使事物失效
}

总结

本章主要讲了事务基本概念ACID是什么 ,脏读、不可重复读、幻读等等术语的介绍及例子数据库事务的隔离级别(4种), Spring事务传播行为(7种),事务的实现实例和使用事务时须要注意的地方经过这篇文章,小伙伴们应该已经对事务有了更深的了解吧 ,最后欢迎关注个人公众号:JAVA宝典或者加个人微信咱们一块儿探讨和学习.

关注公众号:java宝典