Spring学习笔记（五）： Spring 事务管理

本章节讲述企业应用中最为重要的内容之一，就是数据库的事务管理。

全部章节传送门：
Spring学习笔记（一）：Spring IoC 容器
Spring学习笔记（二）：Spring Bean 装配
Spring学习笔记（三）： Spring 面向切面
Spring学习笔记（四）： Spring 数据库编程
Spring学习笔记（五）： Spring 事务管理

事务及其特性

事务（Transaction），一般是指要做的或所做的事情。在计算机术语中是指访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。在企业级应用程序开发中，事务管理是必不可少的技术，用来确保数据的完整性和一致性。

事务的四个特性（ACID）：

• 原子性（Atomicity）：事务是一个原子操作，由一系列动作组成。事务的原子性确保动作要么全部完成，要么完全不起作用。

• 一致性（Consistency）：一旦事务完成（不管成功还是失败），系统必须确保它所建模的业务处于一致的状态，而不会是部分完成部分失败。在现实中的数据不应该被破坏。

• 隔离性（Isolation）：可能有许多事务会同时处理相同的数据，因此每个事务都应该与其他事务隔离开来，防止数据损坏。

• 持久性（Durability）：一旦事务完成，无论发生什么系统错误，它的结果都不应该受到影响，这样就能从任何系统崩溃中恢复过来。通常情况下，事务的结果被写到持久化存储器中。

Spring 数据库事务管理器的设计

在 Spring 中数据库事务是通过 PlatformTransactionMananger 进行管理的， Spring事务管理涉及的接口的联系如下：

spring-transaction.jpg

其中最重要的部分是事务管理器，而事务管理器的实现和平台相关，本文使用 MyBatis 框架中使用比较多的 DataSourceTransactionManager，其它也大同小异。

声明式事务

Spring 事务分为编程式事务和声明式事务，编程式事务需要开发者自己的代码实现，当业务量很大时会很痛苦，目前已经很少使用，本文主要介绍声明式事务。

声明式事务是一种约定型的事务，当你的业务方法不发生异常时，Spring 就会让事务管理器提交事务，而发生异常时则让事务管理器回滚事务。

Transactional 的配置项

Transactional 的配置项如下表。

配置项	含义	备注
value	定义事务管理器	一个Bean，需要实现 PlatformTransactionManager接口
propagation	传播行为	传播行为是方法之间调用的问题，默认值是Propagation.REQUIRED
isolation	隔离级别	默认值取数据库的隔离级别
readOnly	读写或只读事务	默认读写,即false
timeout	超时时间	单位为秒，超时会引发异常
rollbackFor	导致事务回滚的异常类数组	只有当方法产生的异常包含在其中时，才回滚事务
rollbackForClassName	导致事务回滚的异常类名字数组	同rollBackFor，只是使用类名称定义
noRollbackFor	不会导致事务回滚的异常类数组	当方法产生的异常包含在其中时，会继续提交事务
noRollbackForClassName	不会导致事务回滚的异常类名字数组	同上，只是使用类名称

其中便较难理解的是 isolation 和 propagation，下面会详细介绍。

另外，声明式事务可以通过 XML 或者注解进行配置，比较常用的是注解配置，需要在配置文件中开启,然后使用 @Transactional 注解。

隔离级别

隔离级别定义一个事务可能受其他并发事务活动影响的程度。

在一个典型的应用程序中，多个事务同时运行，经常会为了完成他们的工作而操作同一个数据。并发虽然是必需的，但是会导致以下问题：

• 脏读（Dirty read）-- 脏读发生在一个事务读取了被另一个事务改写但尚未提交的数据时。如果这些改变在稍后被回滚了，那么第一个事务读取的数据就会是无效的。
• 不可重复读（Nonrepeatable read）-- 不可重复读发生在一个事务执行相同的查询两次或两次以上，但每次查询结果都不相同时。这通常是由于另一个并发事务在两次查询之间更新了数据。
• 幻影读（Phantom reads）-- 幻影读和不可重复读相似。当一个事务（T1）读取几行记录后，另一个并发事务（T2）插入了一些记录时，幻影读就发生了。在后来的查询中，第一个事务（T1）就会发现一些原来没有的额外记录。

在理想状态下，事务之间将完全隔离，从而可以防止这些问题发生。然而，完全隔离会影响性能，因为隔离经常牵扯到锁定在数据库中的记录（而且有时是锁定完整的数据表）。侵占性的锁定会阻碍并发，要求事务相互等待来完成工作。

考虑到完全隔离会影响性能，而且并不是所有应用程序都要求完全隔离，所以有时可以在事务隔离方面灵活处理。因此，就会有好几个隔离级别。

隔离级别	含义
ISOLATION_DEFAULT	使用数据库默认的隔离级别。
ISOLATION_READ_UNCOMMITTED	允许读取尚未提交的更改。可能导致脏读、幻影读或不可重复读
ISOLATION_READ_COMMITTED	允许从已经提交的并发事务读取。可防止脏读，但幻影读和不可重复读仍可能会发生。
ISOLATION_REPEATABLE_READ	对相同字段的多次读取的结果是一致的，除非数据被当前事务本身改变。可防止脏读和不可重复读，但幻影读仍可能发生
ISOLATION_SERIALIZABLE	完全服从ACID的隔离级别，确保不发生脏读、不可重复读和幻影读。这在所有隔离级别中也是最慢的，因为它通常是通过完全锁定当前事务所涉及的数据表来完成的。

在实际工作中，注解 @Transactional 经常使用默认值ISOLATION_DEFAULT，因为不同数据库的隔离级别可能不同，比如 MYSQL 可以支持4个隔离级别，而 Oracle 只能支持 ISOLATION_READ_COMMITTED 和 ISOLATION_SERIALIZABLE，默认为前者。

传播行为

传播行为是指方法之间的调用事务策略问题，一共包含7种。

传播行为	含义
PROPAGATION_REQUIRED	支持当前事务，如果当前没有事务，就新建一个事务。这是Spring的默认传播行为。
PROPAGATION_SUPPORTS	支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY	支持当前事务，如果当前没有事务，就抛出异常
PROPAGATION_REQUIRES_NEW	新建事务，如果当前存在事务，把当前事务挂起，执行当前新建事务完成以后，上下文事务恢复再执行。
PROPAGATION_NOT_SUPPORTED	以非事务方式执行操作，如果当前存在事务，就把当前事务挂起，执行当前逻辑，结束后恢复上下文的事务。
PROPAGATION_NEVER	以非事务方式执行，如果当前存在事务，则抛出异常。
PROPAGATION_NESTED	表示如果当前正有一个事务在进行中，则该方法应当运行在一个嵌套式事务中。被嵌套的事务可以独立于封装事务进行提交或回滚。如果封装事务不存在，行为就像PROPAGATION_REQUIRED一样

在 Spring+MyBatis中使用事务

创建 Maven 项目，添加依赖。

    4.0.0

    com.wyk
    springtransactiondemo
    1.0-SNAPSHOT


    
        4.3.2.RELEASE
        3.4.0
    

    
        
        
            org.springframework
            spring-core
            ${spring.version}
        

        
            org.springframework
            spring-jdbc
            ${spring.version}
        

        
            org.springframework
            spring-aop
            ${spring.version}
        

        
            org.springframework
            spring-context-support
            ${spring.version}
        
        
            org.springframework
            spring-tx
            ${spring.version}
        

        
        
            org.mybatis
            mybatis
            ${mybatis.version}
        

        
        
            org.mybatis
            mybatis-spring
            1.3.0
        

        
            mysql
            mysql-connector-java
            5.1.25
        
        
            commons-dbcp
            commons-dbcp
            1.4
        
        
            log4j
            log4j
            1.2.17
        

    

    
    
        
            
                src/main/java
                
                    **/*.xml
                
                true
            
        
    

添加 Spring 配置文件。

添加 MyBatis 配置文件。

添加 log4j 配置文件。

log4j.rootLogger=DEBUG,stdout
log4j.logger.org.springframework=DEBUG
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n

创建 Role 实体类。

package com.wyk.springmybatisdemo.domain;

public class Role {
    private Long id;
    private String roleName;
    private String note;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getRoleName() {
        return roleName;
    }

    public void setRoleName(String roleName) {
        this.roleName = roleName;
    }

    public String getNote() {
        return note;
    }

    public void setNote(String note) {
        this.note = note;
    }
}

创建映射接口。

package com.wyk.springtransactiondemo.dao;

import com.wyk.springtransactiondemo.domain.Role;
import org.springframework.stereotype.Repository;

@Repository
public interface RoleMapper {
    public int insertRole(Role role);
}

添加映射文件。

    
        insert into t_role (role_name, note) values(#{roleName}, #{note})
    

添加一个主程序进行测试。

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("spring-cfg.xml");
        RoleListService roleListService = ctx.getBean(RoleListService.class);
        List roleList = new ArrayList();
        for(int i = 1; i <= 2; i++) {
            Role role = new Role();
            role.setRoleName("role_name_" + i);
            role.setNote("note_" + i);
            roleList.add(role);
        }
        int count = roleListService.insertRoleList(roleList);
        System.out.println(count);
    }
}

在其中插入了2个角色，由于 insertRoleList 会调用 insertRole，而 insertRole 标注了 REQUIRES_NEW ,所以每次调用会产生新的事务，在控制台会打印如下日志。从日志中会观察到每次调用 insertRole 会产生新的事务。

2019-03-23 12:05:12,916 [main] DEBUG [org.springframework.jdbc.datasource.DataSourceTransactionManager] - Suspending current transaction, creating new transaction with name [com.wyk.springtransactiondemo.service.impl.RoleServiceImpl.insertRole]
2019-03-23 12:05:12,919 [main] DEBUG [org.springframework.jdbc.datasource.DataSourceTransactionManager] - Acquired Connection [jdbc:mysql://localhost:3306/springstudy?characterEncoding=UTF8, UserName=root@localhost, MySQL Connector Java] for JDBC transaction
2019-03-23 12:05:12,920 [main] DEBUG [org.springframework.jdbc.datasource.DataSourceUtils] - Changing isolation level of JDBC Connection [jdbc:mysql://localhost:3306/springstudy?characterEncoding=UTF8, UserName=root@localhost, MySQL Connector Java] to 2
2019-03-23 12:05:12,923 [main] DEBUG [org.springframework.jdbc.datasource.DataSourceTransactionManager] - Switching JDBC Connection [jdbc:mysql://localhost:3306/springstudy?characterEncoding=UTF8, UserName=root@localhost, MySQL Connector Java] to manual commit
2019-03-23 12:05:12,933 [main] DEBUG [org.mybatis.spring.SqlSessionUtils] - Creating a new SqlSession

将 insertRole 的传播行为改为 NESTED，再次进行测试，可以看到如下日志。

2019-03-23 12:10:56,371 [main] DEBUG [org.springframework.jdbc.datasource.DataSourceTransactionManager] - Releasing transaction savepoint

说明数据库启用了保存点技术，由于不是所有数据库都支持保存点技术，所以在把传播行为设置为NESTED的时候，如果数据库不予支持，那么它会和 REQUIRES_NEW 一样创建新事务运行代码，以达到内部方法发生异常时并不回滚当前事务的目的。

@Transactional 的自调用失效问题

有的时候配置了注解 @Transactional，但是它会失效，这里需要注意一些细节。

注解 @Transactional 的底层实现时 Spring AOP 技术，而 Spring AOP 技术使用的是动态代理，这就意味着对于静态（static）方法和非 public 方法，注解 @Transactional 是失效的。还有一个更为隐秘，且及其容易犯错误的——自调用。

所谓自调用，就是一个类的方法调用自身另外一个方法的过程。

改写前面的 RoleServiceImpl 类。

@Service
public class RoleServiceImpl implements RoleService {
    @Autowired
    private RoleMapper roleMapper;

    @Transactional(propagation = Propagation.REQUIRES_NEW, isolation = Isolation.READ_COMMITTED)
    public int insertRole(Role role) {
        return roleMapper.insertRole(role);
    }

    @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED)
    public int insertRoleList(List roleList) {
        int count = 0;
        for(Role role : roleList) {
            try {
                //调用自身
                insertRole(role);
                count++;
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }
    }
}

当通过这个实现类去实现 RoleService 的时候，insertRole 方法并不会产生新的事务，也就是说 insertRole 上面的 @Transactional 注解失效了。

出现这个问题的根本原因是 AOP 的实现原理，自己调用自己的过程并不存在代理对象的调用，这样就不会产生 AOP 去为我们设置 @Transactional 配置的参数，就出现了自调用失效的问题。

为了解决自调用问题，一方面可以使用2个服务类，如前文所示；另一方面，可以直接从容器中获取 RoleService 的代理对象，如下所示。但这样会有一个弊端：就是从容器中获取代理对象有入侵之嫌。

@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED)
public int insertRoleList(List roleList) {
    int count = 0;
    //从容器中获取代理对象
    RoleService service = ctx.getBean(RoleService.class);
    for(Role role : roleList) {
        try {
            service.insertRole(role);
            count++;
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

典型错误用法的剖析

数据事务时企业应用中最关注的核心内容，这里介绍一些容易犯错的地方。

错误使用 Service

在 Spring MVC 中，经常使用 Controller 来调用 Service，假如我们想在一个 Controller 中插入两个角色，而且需要在同一个事务中处理，使用下面的代码。

@Controller
public class RoleController {
    @Autowired
    private RoleSerivce roleService;

    @Autowired
    private RoleListService roleListService;

    public void errorUseServices() {
        Role role1 = new Role();
        role1.setRoleName("role_name_1");
        role1.setNote("role_note_1");
        roleService.insertRole(role1);
        Role role2 = new Role();
        role2.setRoleName("role_name_2");
        role2.setNote("role_note_2");
        roleService.insertRole(role2);
    }
}

这里存在的问题是两个 insertRole 方法不在一个事务里，如果第一个插入成功了，第二个插入失败了，这样会使数据库数据不完全同时成功或者失败，可能产生严重的数据不一致问题。

过长时间占用事务

在企业生产中，数据库事务资源是最宝贵的资源之一，使用数据库事务之后要及时释放。对于一些不需要在数据库中完成的工作，尽量放到事务之外，尤其是一些使用文件、对外连接等消耗时间的操作。

@Transactional(propagation = Propagation.REQUIRES_NEW, isolation = Isolation.READ_COMMITTED)
    public int insertRole(Role role) {
        int result = roleMapper.insertRole(role);
        //与数据库无关的操作
        doSomeThingForFile();
        return result;
    }

其中的 doSomeThingForFile() 方法是与数据库操作无关的方法，却占用了数据库事务资源。如果占用时间较长，在高并发下很容易发生系统宕机。

对于这些方法，建议放到 Controller 中操作，而不是 Service 中。

错误捕获异常

模拟一段购买商品的代码，其中 ProductService 是产品服务类， TransactionService 是记录交易信息，需求显然是产品减少库存和保存交易在同一个事务里。

@Autowired
private ProductService productService;

@Autowired
private TransactionService transactionService;

@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED)
public int doTransaction(TransactionBean trans) {
    int result = 0;
    try {
        //减少库存
        int result = productService.docreaseStock(trans.getProductId);
        //如果减少库存成功则保存记录
        if(result > 0) {
            transactionService.save(trans);
        }
    } catch (Exception ex) {
        log.info(ex);
    }
    return result;
}

这里的问题是由于开发者不了解 Spring 的事务约定，在方法里加入了自己的try...catch...语句，这样在发生异常的时候， Spring在数据库事务约定的流程中无法得到异常信息，就会提交事务，导致出现问题。

可以对代码进行如下修改。抛出一个运行异常，这样 Spring的事务流程可以捕获到这个异常，进行事务回滚。

@Autowired
private ProductService productService;

@Autowired
private TransactionService transactionService;

@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED)
public int doTransaction(TransactionBean trans) {
    int result = 0;
    try {
        //减少库存
        int result = productService.docreaseStock(trans.getProductId);
        //如果减少库存成功则保存记录
        if(result > 0) {
            transactionService.save(trans);
        }
    } catch (Exception ex) {
        log.info(ex);
        //自行抛出异常，让Spring获取异常
        throw new RuntimeException(ex);
    }
    return result;
}