SpringBoot系列 - 声明式事务

发表于 | 分类于 | | 阅读次数:

所有数据访问技术都有事务机制，这些技术提供了API来开启事务、提交事务完成数据操作， 或者在发生错误的时候回滚数据。

Spring采用统一的机制来处理不同的数据访问技术的事务， Spring的事务提供一个PlatformTransactionManager的接口，不同的数据访问技术使用不同的接口实现。

Data Tech 实现
JDBC DataSourceTransactionManager
JPA JPATransactionManager
Hibernate HibernateTransactionManager
JDO JDOTransactionManager
分布式事务 JtaTransactionManager

而得益于SpringBoot的自动配置机制，为我们自动开启了声明式事务支持， 我们无需添加注解@EnableTransactionManagement

事务基础

Spring提供一个@EnableTransactionManagement注解在配置类上开启声明式事务支持， 自动扫描加了@Transactional注解的类和方法，加入事务支持。

这里重点讲下@Transactional注解的几个属性

propagation

事务的传播机制，主要有以下几种，默认是REQUIRED：

  1. REQUIRED - 方法A调用时候没有事务新建一个事务，在方法A中调用方法B，将使用相同的事务，如果方法B发生异常需要回滚，整个事务回滚。
  2. REQUIRES_NEW - 方法A调用方法B时，无论是否存在事务都开启一个新事务，这样B方法异常不会导致A的数据回滚。
  3. NESTED - 和REQUIRES_NEW类似，但是只支持JDBC，不支持JPA或Hibernate
  4. SUPPORTS - 方法调用时有事务就用事务，没事务就不用事务
  5. NOT_SUPPORTED - 强制方法不在事务中执行，若有事务，在方法调用到结束阶段先挂起事务。
  6. NEVER - 强制不能有事务，若有事务就抛出异常
  7. MANDATORY - 强制必须有事务，如果没有事务就抛出异常

isolation

事务的隔离级别，决定了事务的完整性，主要一下几种，默认是DEFAULT：

  1. READ_UNCOMMITTED - A事务修改记录但没提交，B事务可读取到修改后的值。可导致脏读、不可重复读、幻读。
  2. READ_COMMITTED - A事务修改并提交后，B事务才能读取到修改后的值，阻止了脏读，但可能导致不可重复读和幻读。
  3. REPEATABLE_READ - A事务读取了一条记录，B事务将不能修改这条记录，阻止脏读和不可重复读，但是可能出现幻读。
  4. SERIALIZABLE - 事务是顺序执行的，可避免所有缺陷，但是开销很大。
  5. DEFAULT - 使用当前数据库默认隔离级别，入Oracle、SQL Server是READ_COMMITTED，MySQL是REPEATABLE_READ

timeout

事务过期时间，默认是当前数据库默认事务过期时间。

readOnly

指定是否为只读事务，默认是false

如果你一次执行单条查询语句，则没有必要启用事务支持，数据库默认支持SQL执行期间的读一致性；

如果你一次执行多条查询语句，例如统计查询，报表查询，在这种场景下，多条查询SQL必须保证整体的读一致性， 否则，在前条SQL查询之后，后条SQL查询之前，数据被其他用户改变，则该次整体的统计查询将会出现读数据不一致的状态， 此时，应该启用只读事务支持。

只读事务与读写事务区别：

对于只读查询，可以指定事务类型为readonly，即只读事务。由于只读事务不存在数据的修改， 因此数据库将会为只读事务提供一些优化手段，例如Oracle对于只读事务，不启动回滚段，不记录回滚log。

rollbackFor

指定哪些异常可以导致事务回滚，默认是Throwable的子类

noRollbackFor

执行哪些异常不可用引起事务回滚，默认是Throwable的子类

实战篇

实际项目中，使用SpringBoot的默认配置就已经足够满足我们的需求了。 本篇将通过几个例子来演示如何使用@Transactional注解，在出现异常时候回滚或不回滚数据。

使用我最喜欢的DAO技术就是MyBatis进行数据访问，使用druid数据库连接池， 另外配合mybatis-plus，实现数据访问层。

引入依赖：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>${mysql-connector.version}</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>${druid.version}</version>
</dependency>
<!-- MyBatis plus增强和springboot的集成-->
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatis-plus</artifactId>
    <version>${mybatis-plus.version}</version>
</dependency>
<dependency>
    <groupId>com.baomidou</groupId>
    <artifactId>mybatisplus-spring-boot-starter</artifactId>
    <version>${mybatisplus-spring-boot-starter.version}</version>
</dependency>

配置数据库连接：

1
2
3
4
5
6
7
8
###################  spring配置  ###################
spring:
  profiles:
    active: dev
  datasource:
    url: jdbc:mysql://123.207.66.156:3306/test?useSSL=false&autoReconnect=true&tinyInt1isBit=false&useUnicode=true&characterEncoding=utf8
    username: mysql
    password: xxxxx

然后增加mybatis个性化配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
###################  mybatis-plus配置  ###################
mybatis-plus:
  mapper-locations: classpath*:com/xncoding/trans/dao/repository/mapping/*.xml
  typeAliasesPackage: >
    com.xncoding.trans.dao.entity
  global-config:
    id-type: 0  # 0:数据库ID自增   1:用户输入id  2:全局唯一id(IdWorker)  3:全局唯一ID(uuid)
    db-column-underline: false
    refresh-mapper: true
  configuration:
    map-underscore-to-camel-case: true
    cache-enabled: true #配置的缓存的全局开关
    lazyLoadingEnabled: true #延时加载的开关
    multipleResultSetsEnabled: true #开启的话，延时加载一个属性时会加载该对象全部属性，否则按需加载属性

增加实体类User：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
@TableName(value = "t_user")
public class User extends Model<User> {
    /**
     * 主键ID
     */
    @TableId(value="id", type= IdType.AUTO)
    private Integer id;

    private String username;

    private String password;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    protected Serializable pkVal() {
        return this.id;
    }
}

增加UserMapper类：

1
2
public interface UserMapper extends BaseMapper<User> {
}

增加Mybatis配置类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Configuration
@EnableTransactionManagement(order = 2)
@MapperScan(basePackages = {"com.xncoding.trans.dao.repository"})
public class MybatisPlusConfig {

    @Resource
    private DruidProperties druidProperties;

    /**
     * 单数据源连接池配置
     */
    @Bean
    public DruidDataSource singleDatasource() {
        DruidDataSource dataSource = new DruidDataSource();
        druidProperties.config(dataSource);
        return dataSource;
    }
}

定义Service，并注入UserMapper：

1
2
3
4
5
@Service
public class UserService {
    @Resource
    private UserMapper userMapper;
}

增加Controller，注入Service，定义几个url来做测试用：

1
2
3
4
5
@RestController
public class UserController {
    @Resource
    private UserService userService;
}

到此为止项目初始化完成，可以在Service中添加方法进行声明式事务测试了。

异常回滚

@Transactional注解可以放到类也可以放到方法上，如果放到类上面会对所有public方法添加注解， 不过你仍然可以在方法上面加这个注解，会覆盖类上面声明的事务注解。

先实验一个抛出异常会回滚的方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/**
 * 增删改要写 ReadOnly=false 为可写
 * @param user 用户
 */
@Transactional(readOnly = false)
public void updateUserError(User user) {
    userMapper.updateById(user);
    errMethod(); // 执行一个会抛出异常的方法
}

private void errMethod() {
    System.out.println("error");
    throw new RuntimeException("runtime");
}

然后在Controller里面添加一个url调用此方法：

1
2
3
4
5
6
7
8
9
10
@RequestMapping("/errorUpdate")
    public Object first() {
        User user = new User();
        user.setId(1);
        user.setUsername("admin");
        user.setPassword("admin");
        userService.updateUserError(user);
        return "first controller";
    }
}

数据库里面先插入一条数据：1|admin|123

启动应用后访问地址：http://localhost:8092/errorUpdate

控制台打印异常：

1
2
3
Caused by: java.lang.RuntimeException: runtime
	at com.xncoding.trans.service.UserService.errMethod(UserService.java:32) ~[classes/:na]
	at com.xncoding.trans.service.UserService.updateUserError(UserService.java:27) ~[classes/:na]

查看数据库中记录：1|admin|123，没有变动，说明回滚成功。

异常不会滚

你还可以指定特定异常不回滚，比如自定义一个MyException，抛出这个异常不回滚。

1
2
3
4
5
6
7
8
public class MyException extends RuntimeException {
    public MyException() {
        super();
    }
    public MyException(String runtime) {
        super(runtime);
    }
}

然后通过指定这个异常不回滚：

1
2
3
4
5
6
7
8
9
10
@Transactional(readOnly = false, noRollbackFor = {MyException.class})
public void updateUserError2(User user) {
    userMapper.updateById(user);
    errMethod2(); // 执行一个会抛出自定义异常的方法
}

private void errMethod2() {
    System.out.println("error");
    throw new MyException("runtime");
}

然后再定义一个url来验证：

1
2
3
4
5
6
7
8
9
@RequestMapping("/errorUpdate2")
public Object second() {
    User user = new User();
    user.setId(1);
    user.setUsername("admin");
    user.setPassword("admin");
    userService.updateUserError(user);
    return "second controller";
}

重启服务器，访问地址：http://localhost:8092/errorUpdate2

控制台仍然报异常：

1
2
3
Caused by: com.xncoding.trans.exception.MyException: runtime
	at com.xncoding.trans.service.UserService.errMethod2(UserService.java:43) ~[classes/:na]
	at com.xncoding.trans.service.UserService.updateUserError2(UserService.java:34) ~[classes/:na]

看看数据库中记录：1|admin|admin，更改成功，说明抛出这个MyException异常后并不会回滚。

GitHub源码

springboot-transaction