本文纲要
Spring事务概述Spring事务核心接口与实现- 案例一:无事务的转账——揭示范式需要
Spring事务三步接入
配置事务管理器
开启注解事务驱动
使用@Transactional- 案例一升级:事务保障的转账实现(完整项目源码)
Spring事务角色:事务管理员与事务协调员- 事务属性精讲
回滚异常控制(rollbackFor/noRollbackFor)
超时与只读属性
事务传播行为(Propagation) - 案例二:转账留痕——传播行为
REQUIRES_NEW实战(完整项目源码) - 传播行为六种枚举全解
- 总结
Spring事务概述
事务的核心作用:保证数据层操作的一致性,即若干操作要么全部成功,要么全部失败。
Spring事务的独特之处:可以将事务控制在业务层。原本事务通常只作用于DAO层的单个SQL操作,而Spring允许我们在Service层开启事务,将多个DAO操作纳入同一个事务管理,做到“同成功、同失败”。
Spring事务核心接口与实现
-
Spring通过一个标准接口来抽象事务管理:
PlatformTransactionManager(平台事务管理器)- 提供两个关键方法:
commit()和rollback()。
-
Spring提供了一个针对JDBC的实现:
DataSourceTransactionManager- 只要使用的数据库技术底层是JDBC,就可以用它作为事务管理器。
- MyBatis内部正是使用JDBC事务,因此在Spring整合MyBatis时,配置
DataSourceTransactionManager即可。
案例一:无事务的转账——揭示范式需要
1 ) 业务场景:Tom 向 Jerry 转账 100 元。
2 ) 实现逻辑:
DAO层:提供 outMoney(减钱)和 inMoney(加钱)两个方法。
Service层:转账方法 transfer 依次调用减钱和加钱。
数据库表tbl_account初始数据:
| name | money |
|---|---|
| Tom | 1000 |
| Jerry | 1000 |
如果转账过程中出现异常(例如减钱后、加钱前发生除零异常),结果将是:
- Tom的余额减少,Jerry的余额没有增加,钱“凭空消失”。
问题原因:两个DAO操作各自处于独立事务,互不影响。我们需要将整个业务方法纳入同一个事务。
Spring事务三步接入
只需三步即可为业务方法添加事务:
- 配置事务管理器(在Spring配置类中注册
DataSourceTransactionManager) - 开启注解式事务驱动(在配置类上加
@EnableTransactionManagement) - 在业务方法/接口上使用@Transactional(通常推荐加在接口上,降低耦合)
下面用完整项目代码展示。
案例一升级:事务保障的转账实现(完整项目源码)
1 ) 项目结构
spring_24_case_transfer/
├── pom.xml
├── src/
│ ├── main/
│ │ ├── java/com/wb/
│ │ │ ├── config/
│ │ │ │ ├── JdbcConfig.java
│ │ │ │ ├── MybatisConfig.java
│ │ │ │ └── SpringConfig.java
│ │ │ ├── dao/
│ │ │ │ └── AccountDao.java
│ │ │ ├── domain/
│ │ │ │ └── Account.java
│ │ │ └── service/
│ │ │ ├── AccountService.java
│ │ │ └── impl/
│ │ │ └── AccountServiceImpl.java
│ │ └── resources/
│ │ └── jdbc.properties
│ └── test/
│ └── java/com/wb/service/
│ └── AccountServiceTest.java
2 ) 依赖配置(pom.xml)
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.wb</groupId>
<artifactId>spring24case_transfer</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.16</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.6</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.0</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
</dependencies>
</project>
3 ) 数据源与事务管理器配置(JdbcConfig)
package com.wb.config;
import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import javax.sql.DataSource;
public class JdbcConfig {
@Value("${jdbc.driver}")
private String driver;
@Value("${jdbc.url}")
private String url;
@Value("${jdbc.username}")
private String userName;
@Value("${jdbc.password}")
private String password;
@Bean
public DataSource dataSource(){
DruidDataSource ds = new DruidDataSource();
ds.setDriverClassName(driver);
ds.setUrl(url);
ds.setUsername(userName);
ds.setPassword(password);
return ds;
}
// 配置事务管理器,mybatis使用的是jdbc事务
@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource){
DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
transactionManager.setDataSource(dataSource);
return transactionManager;
}
}
4 ) MyBatis配置(MybatisConfig)
package com.wb.config;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;
import javax.sql.DataSource;
public class MybatisConfig {
@Bean
public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
ssfb.setTypeAliasesPackage("com.wb.domain");
ssfb.setDataSource(dataSource);
return ssfb;
}
@Bean
public MapperScannerConfigurer mapperScannerConfigurer(){
MapperScannerConfigurer msc = new MapperScannerConfigurer();
msc.setBasePackage("com.wb.dao");
return msc;
}
}
5 ) Spring主配置类(开启事务驱动)
package com.wb.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.PropertySource;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@Configuration
@ComponentScan("com.wb")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class, MybatisConfig.class})
// 开启注解式事务驱动
@EnableTransactionManagement
public class SpringConfig {
}
6 ) 数据库属性文件
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
jdbc.username=root
jdbc.password=root
7 ) 实体类
package com.wb.domain;
import java.io.Serializable;
public class Account implements Serializable {
private Integer id;
private String name;
private Double money;
public Integer getId() { return id; }
public void setId(Integer id) { this.id = id; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public Double getMoney() { return money; }
public void setMoney(Double money) { this.money = money; }
@Override
public String toString() {
return "Account{" +
"id=" + id +
", name='" + name + '\'' +
", money=" + money +
'}';
}
}
8 ) DAO层
package com.wb.dao;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Update;
public interface AccountDao {
@Update("update tbl_account set money = money + #{money} where name = #{name}")
void inMoney(@Param("name") String name, @Param("money") Double money);
@Update("update tbl_account set money = money - #{money} where name = #{name}")
void outMoney(@Param("name") String name, @Param("money") Double money);
}
9 ) Service接口(加事务)
package com.wb.service;
import org.springframework.transaction.annotation.Transactional;
public interface AccountService {
/*
转账操作
@param out 转出方
@param in 转入方
@param money 金额
*/
// 配置当前接口方法具有事务
@Transactional
public void transfer(String out, String in, Double money);
}
10 ) Service实现类(包含模拟异常)
package com.wb.service.impl;
import com.wb.dao.AccountDao;
import com.wb.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
public void transfer(String out, String in, Double money) {
accountDao.outMoney(out, money);
// 模拟异常:除零错误
int i = 1 / 0;
accountDao.inMoney(in, money);
}
}
11 ) 测试类
package com.wb.service;
import com.wb.config.SpringConfig;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTest {
@Autowired
private AccountService accountService;
@Test
public void testTransfer() {
accountService.transfer("Tom", "Jerry", 100D);
}
}
效果:
若无@Transactional,异常后Tom减钱,Jerry未加钱,数据不一致。
启动事务后,异常导致整体回滚,数据库中Tom和Jerry金额均不变,保障一致性。
Spring事务角色:事务管理员与事务协调员
Spring如何将多个DAO操作纳入统一事务?引入两个角色:
- 事务管理员:发起事务的一方,通常是业务层加了
@Transactional的方法(如transfer)。 - 事务协调员:被管理员调用的方法,通常是DAO层方法(如
outMoney、inMoney)。它们原本各自有独立事务,但在Spring事务管理下,会“加入”管理员事务,合并为一个全局事务。
核心前提:事务管理器和SqlSessionFactory使用的必须是同一个DataSource,这样才能对同一连接进行事务控制。DataSourceTransactionManager正是通过共享数据源实现这一机制。
事务属性精讲
@Transactional提供了丰富的配置项,用于精细化控制事务行为。
1 ) 回滚异常控制(rollbackFor / noRollbackFor)
默认回滚规则:
Error及其子类RuntimeException及其子类(如NullPointerException、ArithmeticException)
非运行时异常(Checked Exception)默认不参与事务回滚,如IOException。
若希望这类异常也触发回滚,可使用rollbackFor属性。
示例:演示IOException不回滚与手动设置回滚。
public interface AccountService {
// 仅示范:设置当前事务对IOException也回滚
// @Transactional(rollbackFor = IOException.class)
@Transactional
public void transfer(String out, String in, Double money) throws IOException;
}
实现类中可抛出IOException:
if (true) throw new IOException();
不加rollbackFor时,即使抛出IOException,事务也不会回滚;加上后即可回滚。
对应还有noRollbackFor:设置某些异常不触发回滚。
2 ) 超时与只读
timeout:指定事务超时时间,默认-1表示永不超时。readOnly:是否只读事务,默认false(读写事务)。对于纯查询操作可设为true以优化性能。
示例:
@Transactional(timeout = 60, readOnly = false)
3 ) 事务传播行为(Propagation)
传播行为定义事务协调员对管理员事务的处理态度,即:当前方法被调用时,是加入已有事务、新建事务还是以非事务方式运行。
可通过propagation属性指定,枚举值包括:
@Transactional(propagation = Propagation.REQUIRED)
案例二:转账留痕——REQUIRES_NEW实战(完整项目源码)
需求升级:无论转账是否成功,都必须记录日志(留痕)。日志模块应拥有自己独立的事务,不随转账事务回滚。
1 ) 项目结构
spring_25_case_transfer_log/
├── pom.xml
├── src/
│ ├── main/
│ │ ├── java/com/wb/
│ │ │ ├── config/
│ │ │ │ ├── JdbcConfig.java
│ │ │ │ ├── MybatisConfig.java
│ │ │ │ └── SpringConfig.java
│ │ │ ├── dao/
│ │ │ │ ├── AccountDao.java
│ │ │ │ └── LogDao.java
│ │ │ ├── domain/
│ │ │ │ └── Account.java
│ │ │ └── service/
│ │ │ ├── AccountService.java
│ │ │ ├── LogService.java
│ │ │ └── impl/
│ │ │ ├── AccountServiceImpl.java
│ │ │ └── LogServiceImpl.java
│ │ └── resources/
│ │ └── jdbc.properties
│ └── test/
│ └── java/com/wb/service/
│ └── AccountServiceTest.java
代码与案例一类似,仅列出差异部分。
2 ) 新增LogDao
package com.wb.dao;
import org.apache.ibatis.annotations.Insert;
public interface LogDao {
@Insert("insert into tbl_log (info,createDate) values(#{info},now())")
void log(String info);
}
3 ) 新增LogService(设置传播行为为REQUIRES_NEW)
package com.wb.service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
public interface LogService {
// propagation设置为REQUIRES_NEW:当前操作需要新事务
@Transactional(propagation = Propagation.REQUIRES_NEW)
void log(String out, String in, Double money);
}
Propagation.REQUIRES_NEW含义:不管外部是否有事务,当前方法都会新建一个全新事务,外部事务挂起,且新旧事务互不影响。
4 ) LogServiceImpl实现
package com.wb.service.impl;
import com.wb.dao.LogDao;
import com.wb.service.LogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class LogServiceImpl implements LogService {
@Autowired
private LogDao logDao;
public void log(String out, String in, Double money) {
logDao.log("转账操作由" + out + "到" + in + ",金额:" + money);
}
}
5 ) 改造AccountServiceImpl(调用日志并保证一定记录)
package com.wb.service.impl;
import com.wb.dao.AccountDao;
import com.wb.service.AccountService;
import com.wb.service.LogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
@Autowired
private LogService logService;
public void transfer(String out, String in, Double money) {
try {
accountDao.outMoney(out, money);
int i = 1 / 0; // 模拟异常
accountDao.inMoney(in, money);
} finally {
logService.log(out, in, money); // 无论转账成败,日志都会记录
}
}
}
- 测试结果:
- 转账事务回滚,Tom和Jerry金额不变。
- 日志表仍新增一条记录。
通过设置传播行为REQUIRES_NEW,日志记录从主事务中剥离,形成独立事务,即使主事务回滚,日志也成功落库。
传播行为六种枚举全解
Propagation枚举共定义七种(常见分析六种):
| 传播行为 | 说明 |
|---|---|
REQUIRED(默认) | 如果当前存在事务则加入,否则新建一个。 |
REQUIRES_NEW | 总是新建事务,如果当前存在事务则挂起当前事务。 |
SUPPORTS | 支持当前事务,如果不存在则非事务运行。 |
NOT_SUPPORTED | 以非事务方式运行,如果存在事务则挂起。 |
MANDATORY | 必须运行在已有事务中,否则抛异常。 |
NEVER | 必须以非事务方式运行,如果存在事务则抛异常。 |
NESTED | 如果当前存在事务,则在嵌套事务内执行,否则类似REQUIRED。 |
总结
- Spring事务通过
PlatformTransactionManager接口统一抽象,DataSourceTransactionManager满足MyBatis场景。
接入只需三步:配置事务管理器、开启@EnableTransactionManagement、在业务层使用@Transactional。 - 事务角色:管理员(发起)与协调员(加入)基于同一数据源工作,将多个DAO操作归入统一事务。
- 属性配置:
rollbackFor/noRollbackFor精准控制回滚异常。- 传播行为决定事务边界与独立性,
REQUIRES_NEW可剥离子事务,实现日志等“必成功”场景。
合理运用传播行为能有效解决复杂业务中的事务一致性与独立性需求。
1531



被折叠的 条评论
为什么被折叠?



