目录
事务概述
什么是事务
举个栗子,小明给小华转账,操作流程大致分为二步:1.小明执行转账,余额减少;2.小华收款,账户余额增加。
其中转账就是一个事务,而这个事务由二个操作组成。总的来说,事务是一系列操作组成的工作单元,该工作单元内的操作是不可分割的,即所有操作执行必须成功完成,否则在每个操作所做的更改将会被撤销。
事务的特性(ACID)
- 原子性(Atomicity):事务必须是原子工作单元,由一系列操作组成。事务的原子性确保操作要么全都执行,要么全都不执行。
- 一致性(Consistency)::事务执行前和执行后必须使所有的数据都保持一致状态.例如:转账事务执行前后,两账户余额的总和不变.。
- 隔离性(Isolation):可能有多个事务会同时处理相同的数据,因此每个事务都应该与其他事务隔离。
- 持久性(Durability):事务完成之后,它对数据库数据的改变是永久性的,该修改即使出现致命的系统故障也将一直保持。
事务的隔离级别
事务的隔离级别是为了解决并发问题,分为四种,隔离级别由低到高分别为:
- read uncommited:读未提交,是最低的事务隔离级别,它允许其它事务可以看到这个事务未提交的数据。
- read commited:读已提交(Oracle 数据库默认隔离级别),保证一个事务不会读到其它事务已修改但未提交的数据。
- repeatable read:可重复读(Mysql 数据库默认的隔离级别),保证同一事务先后执行的多次查询将返回同一结果,不受其它事务影响。
- serializable:序列化,是花费最高代价但最可靠的事务隔离级别。不允许事务并发执行,强制事务串行执行。
事务隔离级别 | 脏读 | 不可重复读 | 幻读 |
---|---|---|---|
读未提交(read-uncommitted) | ✓ | ✓ | ✓ |
读已提交(read-committed) | ✕ | ✓ | ✓ |
隔离性(Isolation) | ✕ | ✕ | ✓ |
持久性(Durability) | ✕ | ✕ | ✕ |
- 脏读: 一个事务读到其它事务还未提交(可能被回滚)的脏数据。
- 不可重复读: 一个事务多次读取同一数据期间(多次查询同一张表),其他事务修改了该数据,导致第一个事务前后两次查询结果不一致。
- 幻读: 一个事务执行期间其它事务提交添加数据,导致第一个事务前后两次查询结果到的数据条数不同。
Spring 事务管理 API
事务管理,就是按照给定的事务规则来执行提交或者回滚操作。Spring 框架中,最重要的事务管理的 API 有三个:TransactionDefinition、PlatformTransactionManager 和 TransactionStatus。
PlatformTransactionManager 事务管理器
PlatformTransactionManager 是 Spring 事务管理的核心接口。主要功能是事务管理器,该接口的源代码如下:
public interface PlatformTransactionManager {
//获取事务状态
TransactionStatus getTransaction(TransactionDefinition var1) throws TransactionException;
//事务提交
void commit(TransactionStatus var1) throws TransactionException;
//事务回滚
void rollback(TransactionStatus var1) throws TransactionException;
}
PlatformTransactionManager 接口有许多不同的实现类,应用程序面向与平台无关的接口编程,而对不同平台的底层支持由此接口的实现类完成,故而应用程序无须与具体的事务 API 耦合。在实际开发中我们常使用的实现类有:
org.springframework.jdbc.datasource.DataSourceTransactionManager
:使用 SpringJDBC 或 iBatis 进行持久化数据时使用;org.springframework.orm.hibernate5.HibernateTransactionManager
:使用 Hibernate 版本进行持久化数据时使用;
TransactionStatus 事务状态
在上面 PlatformTransactionManager 接口中,有如下方法:
TransactionStatus getTransaction(TransactionDefinition var1) throws TransactionException;
这个方法返回的是 TransactionStatus对象,然后程序根据返回的对象来获取事务状态,然后进行相应的操作,该接口的源代码如下:
public interface TransactionStatus extends SavepointManager, Flushable {
//查询是否是新事务
boolean isNewTransaction();
//查询是否存在存储点
boolean hasSavepoint();
//设置事务回滚
void setRollbackOnly();
//查询事务是否回滚
boolean isRollbackOnly();
//刷新事务
void flush();
//查询事务是否完成
boolean isCompleted();
}
TransactionDefinition 基本事务属性的定义
TransactionDefinition 接口用于定义事务信息, 它包含了一些事务的相关属性,Spring 还为我们提供了一个默认的实现类:DefaultTransactionDefinition,该类适用于大多数情况。TransactionDefinition接口包含与事务属性相关的方法,如下:
public interface TransactionDefinition {
//获取事务传播行为
int getPropagationBehavior();
//获取事务隔离级别
int getIsolationLevel();
//获取事务超时时间
int getTimeout();
//获取事务是否只读
boolean isReadOnly();
//获取事务对象名称
String getName();
}
事务传播行为: 事务的传播行为是指,如果在开始当前事务之前,一个事务上下文已经存在,此时有>若干选项可以指定一个事务性方法的执行行为,常用的是 REQUIRED
和 SUPPORTS
:
REQUIRED
:Spring 默认事务传播行为.若当前存在事务,则加入该事务;若当前没有事务,则创建一个新的事务,增删改查操作均可用。SUPPORTS
:若当前存在事务,则加入该事务;若当前没有事务,则以非事务的方式继续运行,查询操作可用。MANDATORY
:若当前存在事务,则加入该事务;如果当前没有事务,则抛出异常。REQUERS_NEW
:创建一个新的事务,若当前存在事务,则把当前事务挂起。NOT_SUPPORTED
:以非事务方式运行,如果当前存在事务,则把当前事务挂起。NEVER
:以非事务方式运行,如果当前存在事务,则抛出异常。NESTED
:若当前存在事务,则创建一个事务作为当前事务的嵌套事务来运行;若当前没有事务,则执行 REQUIRED 类似的操作。
事务隔离级别: 事务的隔离级别是指若干个并发的事务之间的隔离程度,事务的隔离级别由弱到强,依次有如下五种:
ISOLATION_DEFAULT
:Spring 事务管理的的默认级别,使用数据库默认的事务隔离级别。ISOLATION_READ_UNCOMMITTED
:读未提交.ISOLATION_READ_COMMITTED
:读已提交.ISOLATION_REPEATABLE_READ
:可重复读.ISOLATION_SERIALIZABLE
:序列化
事务超时: 事务超时是指一个事务所允许执行的最长时间,如果超过该时间限制但事务还没有完成,则自动回滚事务。Spring 默认设置事务的超时时间为-1,表示永不超时,也可自行设置,在 TransactionDefinition 中以 int 的值来表示超时时间,其单位是秒。
事务是否只读:事务的只读属性是指,对事务性资源进行只读操作或者是读写操作。
使用 XML 配置实现事务
模拟实现一个转账业务,
依赖
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.0.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>4.0.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>4.0.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.7.4</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>4.0.3.RELEASE</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13</version>
<scope>test</scope>
</dependency>
</dependencies>
实体类 Account
public class Account implements Serializable {
private Integer id;
private String name;
private float money;
...
//此处省略 getter setter toStirng
}
持久层接口和实现类
public interface AccountDao {
/**
* 根据名称查询账户
* @param name
* @return
*/
Account queryAccountByName(String name);
/**
* 更新账户
* @param account
*/
void updateAccount(Account account);
}
public class AccountDaoImpl implements AccountDao {
private JdbcTemplate jdbcTemplate;
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
@Override
public Account queryAccountByName(String name) {
List<Account> accounts = jdbcTemplate.query("select * from account where name = ?", new BeanPropertyRowMapper<Account>(Account.class), name);
if (accounts.isEmpty()) {
return null;
}
if (accounts.size() > 1) {
throw new RuntimeException("查询结果不唯一");
}
return accounts.get(0);
}
@Override
public void updateAccount(Account account) {
jdbcTemplate.update("update account set name = ?, money = ? where id = ?", account.getName(), account.getMoney(), account.getId());
}
}
业务层接口和实现类
public interface AccountService {
/**
* 根据名称查询账户
* @param name
* @return
*/
Account queryAccountByName(String name);
/**
* 更新账户
* @param account
*/
void updateAccount(Account account);
/**
* 转账
* @param sourceName 转出账户
* @param targetName 转入账户
* @param money 交易金额
*/
void transfer(String sourceName, String targetName, float money);
}
public class AccountServiceImpl implements AccountService {
private AccountDao accountDao;
public void setAccountDao(AccountDao accountDao) {
this.accountDao = accountDao;
}
@Override
public Account queryAccountByName(String name) {
return accountDao.queryAccountByName(name);
}
@Override
public void updateAccount(Account account) {
accountDao.updateAccount(account);
}
@Override
public void transfer(String sourceName, String targetName, float money) {
//1.根据名称查询转出账户
Account source = accountDao.queryAccountByName(sourceName);
//2.根据名称查询转入账户
Account target = accountDao.queryAccountByName(targetName);
//3.转出账户金额减少
source.setMoney(source.getMoney() - money);
//4.转入账户金额增加
target.setMoney(target.getMoney() + money);
//5.更新转出账户
accountDao.updateAccount(source);
int i = 1/0;
//6.更新转入账户
accountDao.updateAccount(target);
}
}
在 applicationContext.xml 中配置 Spring 容器需要管理的对象
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/tx
https://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="accountService" class="com.hn.service.impl.AccountServiceImpl">
<property name="accountDao" ref="accountDao"></property>
</bean>
<bean id="accountDao" class="com.hn.dao.impl.AccountDaoImpl">
<property name="jdbcTemplate" ref="jdbcTemplate"></property>
</bean>
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql://localhost:3306/spring"></property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>
Spring 配置事务控制本质上是基于 AOP 的,因此下面我们在 applicationContext.xml 中配置事务管理器对象并和 AOP 配置建立联系.
<!-- Spring 事务控制 -->
<!-- 1.配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 2.配置事务通知 引用事务管理器-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<!-- 配置事务的属性 -->
<tx:attributes>
<tx:method name="*" propagation="REQUIRED" read-only="false"/>
<tx:method name="query*" propagation="SUPPORTS" read-only="true"/>
</tx:attributes>
</tx:advice>
<!-- 3.配置 AOP -->
<aop:config>
<!-- 配置切入点表达式 -->
<aop:pointcut id="pcService" expression="execution(* com.hn.service.impl.*.*(..))"/>
<!-- 4.切入点表达式和事务通知建立关系 -->
<aop:advisor advice-ref="txAdvice" pointcut-ref="pcService"></aop:advisor>
</aop:config>
</beans>
<tx:advice>
标签:配置事务通知
- id:事务通知的唯一标识
- transaction-manager: 该通知对应的事务管理器
<tx:attributes>
标签下的<tx:method>
标签,为切面上的方法配置事务属性,<tx:method>
标签常用的属性如下:
name
: 拦截到的方法,可以使用通配符*。propagation
: 事务的传播行为,默认为REQUIRED.增删改方法应该用REQUIRED,查询方法可以使用SUPPORTS。read-only
: 事务是否为只读事务,默认为false.增删改方法应该用false,查询方法可以使用true。
配置完成后执行单元测试
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class AccountServiceTest {
@Autowired
private AccountService accountService;
@Test
public void testTransfer(){
accountService.transfer("张学友","李冰冰",200);
}
}
由于在业务层转账方法中添加了 int i = 1/0 ;
进行模拟事务操作异常,在配置了事务管理后,事务将会回滚,符合了事务的特性。