什么是事务?
当你需要一次执行多条SQL语句时,可以使用事务。通俗一点说,如果这几条SQL语句全部执行成功,则才对数据库进行一次更新,如果有一条SQL语句执行失败,则这几条SQL语句全部不进行执行,这个时候需要用到事务。
数据库事务的四大特性ACID:
原子性(Atomicity)
要么都执行,要么都不执行一致性(Consistency)
事务前后的数据都是正确的隔离性(Isolation)
事物之间相互隔离,互不干扰(并发执行的事务彼此无法看到对方的中间状态)持久性(Durability)
事务一旦提交不可再回滚
- JavaEE体系进行分层开发,事务处理位于业务层,Spring提供了分层设计业务层的事务处理解决方案。
- Spring框架为我们提供了一组事务控制的接口。 PlatformTransactionManager和TransactionDefinition
事务控制的API
PlatformTransactionManager接口
作用:是一个事务管理器,负责开启、提交或回滚事务
实现类:DataSourceTransactionManager(sqlSession)
此接口是spring的事务管理器,它里面提供了我们常用的操作事务的方法
public interface PlatformTransactionManager {
//开启事务
TransactionStatus getTransaction(TransactionDefinition definition)
throws TransactionException;
//提交事务
void commit(TransactionStatus status) throws TransactionException;
//回滚事务
void rollback(TransactionStatus status) throws TransactionException;
}
Spring为不同的orm框架提供了不同的PlatformTransactionManager接口实现类:
-
DataSourceTransactionManager:使用Spring JDBC或iBatis 进行持久化数据时使用
-
HibernateTransactionManager:使用Hibernate版本进行持久化数据时使用
TransactionDefinition接口
作用:定义事务的属性
实现类:DefaultTransactionDefinition
TransactionDefinition接口包含与事务属性相关的方法 ,源代码如下
public interface TransactionDefinition {
int PROPAGATION_REQUIRED = 0;
int PROPAGATION_SUPPORTS = 1;
int PROPAGATION_MANDATORY = 2;
int PROPAGATION_REQUIRES_NEW = 3;
int PROPAGATION_NOT_SUPPORTED = 4;
int PROPAGATION_NEVER = 5;
int PROPAGATION_NESTED = 6;
int ISOLATION_DEFAULT = -1;
int ISOLATION_READ_UNCOMMITTED = 1;
int ISOLATION_READ_COMMITTED = 2;
int ISOLATION_REPEATABLE_READ = 4;
int ISOLATION_SERIALIZABLE = 8;
int TIMEOUT_DEFAULT = -1;
//传播行为
int getPropagationBehavior();
//隔离级别
int getIsolationLevel();
//事务超时
int getTimeout();
//是否只读
boolean isReadOnly();
}
TransactionDefinition 接口定义的事务规则包括:事务隔离级别、事务传播行为、事务超时、事务的只读、回滚规则属性,同时,Spring 还为我们提供了一个默认的实现类:DefaultTransactionDefinition,该类适用于大多数情况。如果该类不能满足需求,可以通过实现 TransactionDefinition 接口来实现自己的事务定义。
事务并发时的安全问题
问题 | 描述 | 隔离级别 |
---|---|---|
脏读 | 一个事务读取到另一个事务还未提交的数据 | read-commited |
不可重复读 | 一个事务内多次读取一行数据的内容,其结果不一致 | repeatable-read |
幻读 | 一个事务内多次读取一张表中的内容,其结果不一致 | serialized-read |
事务的隔离级别
隔离级别 | 说明 |
---|---|
ISOLATION_DEFAULT | 这是一个platfromtransactionmanager默认的隔离级别,使用数据库默认的事务隔离级别。 |
ISOLATION_READ_UNCOMMITTED | 这是事务最低的隔离级别,会产生脏读,不可重复读和幻像读。 |
ISOLATION_READ_COMMITTED | 这种事务隔离级别可以避免脏读出现,但是可能会出现不可重复读和幻像读。 Oracle数据库默认的隔离级别。 |
ISOLATION_REPEATABLE_READ | 这种事务隔离级别可以防止脏读、不可重复读,但是可能出现幻像读。MySQL数据库默认的隔离级别。 |
ISOLATION_SERIALIZABLE | 这是花费最高代价但是最可靠的事务隔离级别,事务被处理为顺序执行。除了防止脏读、不可重复读外,还避免了幻像读。 |
事务的隔离级别解决的事务并发时的安全问题
隔离级别 | 是否脏读 | 是否不可重复度 | 是否幻读 |
ISOLATION_DEFAULT | x | x | √ |
ISOLATION_READ_UNCOMMITTED | √ | √ | √ |
ISOLATION_READ_COMMITTED | x | √ | √ |
ISOLATION_REPEATABLE_READ | x | x | √ |
ISOLATION_SERIALIZABLE | x | x | x |
事务的传播行为
-
什么是事务传播行为?
事务传播行为(propagation behavior)指的就是当一个事务方法被另一个事务方法调用时,这个事务方法应该如何进行。 例如:methodA事务方法调用methodB事务方法时,methodB是继续在调用者methodA的事务中运行呢,还是为自己开启一个新事务运行,这就是由methodB的事务传播行为决定的。
Spring定义了七种传播行为:
事务传播行为类型 | 说明 |
---|---|
PROPAGATION_REQUIRED | 如果当前没有事务,就新建一个事务,如果已经存在一个事务中,加入到这个事务中。这是最常见的选择。 |
PROPAGATION_SUPPORTS | 支持当前事务,如果当前没有事务,就以非事务方式执行。 |
PROPAGATION_MANDATORY | 使用当前的事务,如果当前没有事务,就抛出异常。 |
PROPAGATION_REQUIRES_NEW | 新建事务,如果当前存在事务,把当前事务挂起。 |
PROPAGATION_NOT_SUPPORTED | 以非事务方式执行操作,如果当前存在事务,就把当前事务挂起。 |
PROPAGATION_NEVER | 以非事务方式执行,如果当前存在事务,则抛出异常。 |
PROPAGATION_NESTED | 如果当前存在事务,则在嵌套事务内执行。如果当前没有事务,则执行与REQUIRED类似的操作。 |
事务超时
timeout
事务超时时间: 当前事务所需操作的数据被其他事务占用,则等待。
-
100:自定义等待时间100(秒)。
-
-1:由数据库指定等待时间,默认值。(建议)
读写性
readonly
读写性
-
true:只读,可提高查询效率,适合查询
-
false:可读可写,适合增删改
回滚规则
rollbackOn
回滚规则,可省略或设置 rollbackOn="Exception"
-
如果事务中抛出 RuntimeException,则自动回滚
-
如果事务中抛出 CheckException,不会自动回滚
TransactionStatus
PlatformTransactionManager.getTransaction(…) 方法返回一个 TransactionStatus 对象,该对象代表一个新的或已经存在的事务,源代码如下:
public interface TransactionStatus{
boolean isNewTransaction();
void setRollbackOnly();
boolean isRollbackOnly();
}
转账案例
新建项目
配置pom.xml
<dependencies>
<!-- Spring常用依赖 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.1.8.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.1.8.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>5.1.8.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.1.8.RELEASE</version>
</dependency>
<!-- MySql -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<!--连接池-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.0</version>
</dependency>
<!--mybatis-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.3</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.3</version>
</dependency>
<!--日志-->
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.7.26</version>
</dependency>
<!--junit-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.1.8.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
</dependencies>
<build>
<resources>
<!-- 如果不添加此节点src/main/java目录下的所有配置文件都会被漏掉。 -->
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.xml</include>
</includes>
</resource>
<!-- 让MyBatis识别resiurces文件夹下的文件-->
<resource>
<directory>src/main/resources</directory>
</resource>
</resources>
</build>
配置db.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3305/spring?characterEncoding=UTF-8
jdbc.username=root
jdbc.password=
配置applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
">
<!-- Springioc注解扫描支持-->
<context:component-scan base-package="com.by.service"></context:component-scan>
<!-- 配置数据库-->
<!-- 加载数据源-->
<context:property-placeholder location="classpath:db.properties"/>
<!-- 配置数据源-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
<property name="driverClassName" value="${jdbc.driver}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
</bean>
<!-- 会话工厂-->
<bean id="sessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!--让mybatis扫描mapper接口,生成代理类并交给spring的ioc容器去管理-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<!--mapper所在的包-->
<property name="basePackage" value="com.by.mapper"></property>
<property name="sqlSessionFactoryBeanName" value="sessionFactory"></property>
</bean>
<!--DataSourceTransactionManager:是一个数据源事务管理器,负责开启,提交和回滚事务-->
<bean id="sourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- DefaultTransactionDefinition:定义事务属性-->
<bean id="transactionDefinition" class="org.springframework.transaction.support.DefaultTransactionDefinition">
<!--
隔离级别:默认值DEFAULT,等价于REPEATABLE_READ
传播行为:默认值REQUIRED,methodB()会加入到methodA()事务中
事务超时:默认值-1,永不超时
是否只读:默认值false,适用于增删改
回滚规则:可省略
-->
<!-- 以下配置均为默认属性,不用注入-->
<!--<!– 注入隔离级别–>-->
<!-- <property name="isolationLevel" value="REPEATABLE"></property>-->
<!--<!– 注入传播行为–>-->
<!-- <property name="propagationBehavior" value="REQUIRED"></property>-->
<!--<!– 注入事务超时–>-->
<!-- <property name="timeout" value=""></property>-->
<!--<!– 注入是否只读–>-->
<!-- <property name="readOnly" value="false"></property>-->
</bean>
</beans>
三层架构建包
service包下UserService类
public interface UserService {
void updateUser(String source, String target, Float money);
}
service包下UserServiceImpl实现类
@Service
public class UserServiceImpl implements UserService {
@Autowired
private UserMapper userMapper;
@Autowired
private PlatformTransactionManager transactionManager;
@Autowired
private TransactionDefinition transactionDefinition;
@Override
public void addUser(User user) {
userMapper.addUser(user);
}
@Override
public void updateUser(String source,String target,Float money){
TransactionStatus transactionStatus = transactionManager.getTransaction(transactionDefinition);
try {
//扣钱
userMapper.updateUserOfSub(source,money);
int a=6/0;
//加钱
userMapper.updateUserOfAdd(target,money);
//业务执行后,提交事务
transactionManager.commit(transactionStatus);
} catch (Exception e) {
e.printStackTrace();
//业务出错时,回滚事务
transactionManager.rollback(transactionStatus);
}
}
}
mapper包下UserMapper类
public interface UserMapper {
void updateUserOfSub(@Param("source") String source, @Param("money")Float money);
void updateUserOfAdd(@Param("target")String target, @Param("money")Float money);
}
mapper包下UserMapper.xml文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.by.mapper.UserMapper">
<!--转账-->
<update id="updateUserOfSub">
update t_user set money=money-#{money} where name=#{source}
</update>
<update id="updateUserOfAdd">
update t_user set money=money+#{money} where name=#{target}
</update>
</mapper>
pojo包下User类
public class User {
private Integer id;
private String name;
private Float money;
public User(String name, Float money) {
this.name = name;
this.money = money;
}
public User() {
}
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 Float getMoney() {
return money;
}
public void setMoney(Float money) {
this.money = money;
}
}
测试类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class ServiceTest {
@Autowired
private UserService userService;
@Test
public void testAdd(){
userService.addUser(new User("张wu丰",4000F));
userService.addUser(new User("宋远桥",2000F));
}
@Test
public void testUpdate(){
userService.updateUser("张三丰","宋远桥",1F);
}
}
测试结果