事物是区分文件存储系统与Nosql数据库重要特性之一,其存在的意义是为了保证即使在并发情况下也能正确的执行crud操作。怎样才算是正确的呢?这时提出了事物需要保证的四个特性即ACID:
在高并发的情况下,要完全保证其ACID特性是非常困难的,除非把所有的事物串行化执行,但带来的负面的影响将是性能大打折扣。很多时候我们有些业务对事物的要求是不一样的,所以数据库中设计了四种隔离级别,供用户基于业务进行选择。
隔离级别 |
脏读(Dirty Read) |
不可重复读(NonRepeatable Read) |
幻读(Phantom Read) |
未提交读(Read uncommitted) |
可能 |
可能 |
可能 |
已提交读(Read committed) |
不可能 |
可能 |
可能 |
可重复读(Repeatable read) |
不可能 |
不可能 |
可能 |
可串行化(SERIALIZABLE) |
不可能 |
不可能 |
不可能 |
脏读 :
一个事物读取到另一事物未提交的更新数据
不可重复读 :
在同一事物中,多次读取同一数据返回的结果有所不同, 换句话说, 后续读取可以读到另一事物已提交的更新数据. 相反, “可重复读”在同一事物中多次读取数据时, 能够保证所读数据一样, 也就是后续读取不能读到另一事物已提交的更新数据。
幻读 :
在同一事物中,多次读取同一表数据条数返回的结果有所不同,
查询表中一条数据如果不存在就插入一条,并发的时候却发现,里面居然有两条相同的数据。这就幻读的问题。
数据库默认隔离级别:
Oracle中默认级别是 Read committed
mysql 中默认级别 Repeatable read。另外要注意的是mysql 执行一条查询语句默认是一个独立的事物,所以看上去效果跟Read committed一样。
# 查看mysql 的默认隔离级别
SELECT @@tx_isolation
1、spring 事物相关API说明
spring 事物是在数据库事物的基础上进行封装扩展 其主要特性如下:
怎么样去使用Spring事物呢?spring 提供了三个接口供使用事物。分别是:
接口结构图:
API说明:
public class SpringTransactionExample {
private static String url = "jdbc:mysql://192.168.0.147:3306/test";
private static String user = "root";
private static String password = "123456";
public static Connection openConnection() throws ClassNotFoundException, SQLException {
Class.forName("com.mysql.jdbc.Driver");
Connection conn = DriverManager.getConnection("jdbc:mysql://192.168.0.147:3306/test", "root", "123456");
return conn;
}
public static void main(String[] args) {
final DataSource ds = new DriverManagerDataSource(url, user, password);
final TransactionTemplate template = new TransactionTemplate();
template.setTransactionManager(new DataSourceTransactionManager(ds));
template.execute(new TransactionCallback
2、声明示事物
我们前面是通过调用API来实现对事物的控制,这非常的繁琐,与直接操作JDBC事物并没有太多的改善,所以Spring提出了声明示事物,使我们对事物的操作变得非常简单,甚至不需要关心它。
配置spring.xml
编写服务类
@Transactional
public void addAccount(String name, int initMenoy) {
String accountid = new SimpleDateFormat("yyyyMMddhhmmss").format(new Date());
jdbcTemplate.update("insert INTO account (accountName,user,money) VALUES (?,?,?)", accountid, name, initMenoy);
// 人为报错
int i = 1 / 0;
}
3、事物传播机制
类别 |
事物传播类型 |
说明 |
支持当前事物 |
PROPAGATION_REQUIRED (必须的) |
如果当前没有事物,就新建一个事物,如果已经存在一个事物中,加入到这个事物中。这是最常见的选择。 |
PROPAGATION_SUPPORTS (支持) |
支持当前事物,如果当前没有事物,就以非事物方式执行。 |
|
PROPAGATION_MANDATORY (强制) |
使用当前的事物,如果当前没有事物,就抛出异常。 |
|
不支持当前事物 |
PROPAGATION_REQUIRES_NEW (隔离) |
新建事物,如果当前存在事物,把当前事物挂起。 |
PROPAGATION_NOT_SUPPORTED (不支持) |
以非事物方式执行操作,如果当前存在事物,就把当前事物挂起。 |
|
PROPAGATION_NEVER (强制非事物) |
以非事物方式执行,如果当前存在事物,则抛出异常。 |
|
套事物 |
PROPAGATION_NESTED (嵌套事物) |
如果当前存在事物,则在嵌套事物内执行。如果当前没有事物,则执行与PROPAGATION_REQUIRED类似的操作。 |
常用事物传播机制:
用例1:
创建用户时初始化一个帐户,表结构和服务类如下。
表结构 |
服务类 |
功能描述 |
user |
UserSerivce |
创建用户,并添加帐户 |
account |
AccountService |
添加帐户 |
UserSerivce.createUser(name) 实现代码
@Transactional
public void createUser(String name) {
// 新增用户基本信息
jdbcTemplate.update("INSERT INTO `user` (name) VALUES(?)", name);
//调用accountService添加帐户
accountService.addAccount(name, 10000);
}
AccountService.addAccount(name,initMoney) 实现代码(方法的最后有一个异常)
@Transactional(propagation = Propagation.REQUIRED)
public void addAccount(String name, int initMoney) {
String accountid = new SimpleDateFormat("yyyyMMddhhmmss").format(new Date());
jdbcTemplate.update("insert INTO account (accountName,user,money) VALUES (?,?,?)", accountid, name, initMenoy);
// 出现分母为零的异常
int i = 1 / 0;
}
实验预测一:
|
createUser |
addAccount(异常) |
预测结果 |
场景一 |
无事物 |
required |
user (成功) Account(不成功) 正确 |
场景二 |
required |
无事物 |
user (不成功) Account(不成功) 正确 |
场景三 |
required |
not_supported |
user (不成功) Account(成功)正确 |
场景四 |
required |
required_new |
user (不成功) Account(不成功)正确 |
场景五 |
required (异常移至createUser方法未尾)
|
required_new |
user (不成功) Account(成功)正确 |
场景六 |
required (异常移至createUser方法未尾) (addAccount 方法称至当前类)
|
required_new |
user (不成功) Account(不成功) |
讲事物原理之前我们先来做一个实验,当场景五的环境改变,把addAccount 方法移至UserService 类下,其它配置和代码不变:
@Override
@Transactional
public void createUser(String name) {
jdbcTemplate.update("INSERT INTO `user` (name) VALUES(?)", name);
addAccount(name, 10000);
// 人为报错
int i = 1 / 0;
}
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void addAccount(String name, int initMoney) {
String accountid = new SimpleDateFormat("yyyyMMddhhmmss").format(new Date());
jdbcTemplate.update("insert INTO account (accountName,user,money) VALUES (?,?,?)", accountid, name, initMoney);
}
经过演示我们发现得出的结果与场景五并不 一至,required_new 没有起到其对应的作用。原因在于spring 声明示事物使用动态代理实现,而当调用同一个类的方法时,是会不会走代理逻辑的,自然事物的配置也会失效。
通过一个动态代理的实现来模拟这种场景
UserSerivce proxyUserSerivce = (UserSerivce) Proxy.newProxyInstance(TestTransaction.class.getClassLoader(),
new Class[]{UserSerivce.class}, new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
try {
System.out.println("开启事物:"+method.getName());
return method.invoke(userSerivce, args);
} finally {
System.out.println("关闭事物:"+method.getName());
}
}
});
proxyUserSerivce.createUser("test");
当我们调用createUser 方法时 仅打印了 createUser 的事物开启、关闭,并没有打印addAccount 方法的事物开启、关闭,由此可见addAccount 的事物配置是失效的。
如果业务当中上真有这种场景该如何实现呢?在spring xml中配置 暴露proxy 对象,然后在代码中用AopContext.currentProxy() 就可以获当前代理对象
// 基于代理对象调用创建帐户,事物的配置又生效了
((UserSerivce) AopContext.currentProxy()).addAccount(name, 10000);