Spring管理事务
1、 Spring管理事务概述
1.1 概述
由于Spring对持久层的很多框架都有支持 , Hibernate 、 jdbc 、JdbcTemplate , MyBatis ,由于使用的框架不同,所以使用事务管理操作API 也不尽相同。 为了规范这些操作, Spring统一定义一个事务的规范 ,这其实是一个接口 。这个接口的名称 : PlatformTrasactionManager.并且它对已经做好的框架都有支持.
如果dao层使用的是JDBC, JdbcTemplate 或者mybatis,那么 可以使用DataSourceTransactionManager 来处理事务
如果dao层使用的是 Hibernate, 那么可以使用HibernateTransactionManager 来处理事务
1.2 相关的API
PlatformTransactionManager
平台事务管理器是一个接口,实现类就是Spring真正管理事务的对象。
常用的实现类:
DataSourceTransactionManager :JDBC开发的时候(JDBCTemplate,MyBatis),使用事务管理。
HibernateTransactionManager :Hibernate开发的时候,使用事务管理。
TransactionDefinition
事务定义信息中定义了事务的隔离级别,传播行为,超时信息,只读。
TransactionStatus:事务的状态信息
事务状态信息中定义事务是否是新事务,是否有保存点
2、编程式(通过代码)(硬编码)事务
- 创建DataSource对象
- 创建JDBCTemplate对象
- 创建事务管理器, 传入DataSource. DataSourceTransactionManager
- 创建事务模版
- 通过事务模版进行事务处理
- 在事务里面操作数据库
添加依赖
<dependencies>
<!--依赖-->
<!--1. spring的核心依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<!--2. spring-jdbc的依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<!--3. spring-test-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
<!--10. aop的依赖-->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.7</version>
</dependency>
<!--4. mysql-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.6</version>
</dependency>
<!--5. mybatis-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.3</version>
</dependency>
<!--6. mybatis-spring-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.0</version>
</dependency>
<!--7. Junit的依赖-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!--8. lombok的依赖-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.10</version>
</dependency>
<!--9. 日志的依赖-->
<!-- log start -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.12</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.6.6</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.6.6</version>
</dependency>
<!-- log end -->
</dependencies>
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.stereotype.Service;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallback;
import org.springframework.transaction.support.TransactionTemplate;
import javax.sql.DataSource;
/**
* 持久层不同的框架有不同的事务控制方案:
* 1. 原始的JDBC:
* 1.1 开启事务: connection.setAutoCommit(false);
* 1.2 提交事务: connection.commit();
* 1.3 回滚事务: connection.rollback();
*
* 2. DBUtils框架: 和原始的JDBC是一样的
* 3. mybatis框架: 底层也是使用的JDBC的事务
* 3.1 开启事务: sqlSessionFactory.openSession(); 开启事务
* 3.2 提交事务: sqlSession.commit();
* 3.3 回滚事务: sqlSession.rollback();
* 4. 只要某个持久层框架和spring整合了,那么事务相关的操作就都交给spring控制
* 4.1 编程式事务(了解)
* 4.2 声明式事务(重点掌握)
*/
@Service
public class AccountServiceImpl implements AccountService{
@Autowired
private AccountDao accountDao;
@Autowired
private DataSource dataSource;
@Override
public void transfer(String fromName, String toName, double money) {
//1. 创建事务管理者
DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
transactionManager.setDataSource(dataSource);
//2. 创建事务模板
TransactionTemplate transactionTemplate = new TransactionTemplate();
//3. 给事务模板配置事务管理者
transactionTemplate.setTransactionManager(transactionManager);
transactionTemplate.execute(new TransactionCallback<Object>() {
@Override
public Object doInTransaction(TransactionStatus status) {
//1. 转出账户扣款
accountDao.updateAccount(new Account(null,fromName,-money));
//出现异常
int num = 10/0;
//2. 转入账户收款
accountDao.updateAccount(new Account(null,toName,money));
return null;
}
});
}
}
我们项目开发 一般不会使用编程式(硬编码)方式. 一般使用声明式(配置)事务
- xml方式
- 注解方式
3、Spring声明式事务-xml配置方式
Spring的声明式事务的作用是: 无论spring集成什么dao框架,事务代码都不需要我们再编写了
声明式的事务管理的思想就是AOP的思想。面向切面的方式完成事务的管理。声明式事务有两种,xml配置方式和注解方式.
3.1 xml配置方式实现步骤
- 注册事务管理器, 配置数据源
- 配置事务建议(事务规则: 事务隔离级别, 遇到什么异常回滚,是否只读…)
- 配置AOP
- 配置切入点
- 配置切面
依赖:
<properties>
<!--mybatis-->
<mybatis.version>3.5.3</mybatis.version>
<!--mysql-->
<mysql.version>5.1.6</mysql.version>
<!--spring-->
<spring.version>5.0.2.RELEASE</spring.version>
<!--日志打印框架-->
<slf4j.version>1.6.6</slf4j.version>
<log4j.version>1.2.12</log4j.version>
</properties>
<dependencies>
<!--引入依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- log start -->
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>${log4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${slf4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>${slf4j.version}</version>
</dependency>
<!-- log end -->
<!--声明式事务必须有 SpringAOP相关的坐标 -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.8.7</version>
</dependency>
<!--
mybatis整合spring的依赖
-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.3.0</version>
</dependency>
<!--mybatis的依赖-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>${mybatis.version}</version>
</dependency>
<!--lombok-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.10</version>
</dependency>
<!--junit-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!--mysql依赖-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>${mysql.version}</version>
</dependency>
<!--引入spring整合Junit的依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dependency>
<!--
druid连接池
-->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.0.9</version>
</dependency>
</dependencies>
配置事务管理器
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
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
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<context:component-scan base-package="com.it"/>
<import resource="classpath:spring-mybatis.xml"></import>
<!--
spring的声明式事务:
1. 配置事务管理者 DatasourceTransactionManager
2. 进行事务配置:
2.1 声明事务规则(对应的就是代码中的事务模板)
-->
<!--对事务相关的对象进行IOC-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<!--配置事务规则-->
<tx:advice id="transferAdvice" transaction-manager="transactionManager">
<!--配置事务的属性-->
<tx:attributes>
<!--
哪个方法需要使用什么样的事务配置
rollback-for="java.lang.Exception" 什么时候回滚:遇到所有的Exception都会回滚
no-rollback-for="java.lang.NullPointerException" 什么时候不回滚:遇到NullPointerException不回滚
timeout="-1" 事务的超时时间,默认不超时
read-only="false" 是否是只读事务,默认不是只读事务,只读事务只会针对于查询方法,如果是增删改一定不能设置为只读
isolation="" 事务的隔离级别: 目的是为了防止不同事务之间相互影响
1. Read Uncommitted 读取到未提交的事务,在这种隔离级别下,可能发生脏读、不可重复读、幻读
2. Read Committed(Oracle的默认隔离级别) 读取到已提交的事务,在这种隔离级别下,不可能发生脏读,但是可能发生不可重复读和幻读
3. Repeatable Read(mysql的默认隔离级别) 可重复读,在这种隔离级别下不会发生脏读、不可重复读,但是有可能发生幻读
4. Serializable 串行化的,在这种隔离级别下不会发生脏读、不可重复读、幻读
propagation="" 事务的传播行为
- PROPAGATION_REQUIRED:默认值,也是最常用的场景.
如果当前没有事务,就新建一个事务,
如果已经存在一个事务中,加入到这个事务中。
- PROPAGATION_SUPPORTS:
如果当前没有事务,就以非事务方式执行。
如果已经存在一个事务中,加入到这个事务中。
- PROPAGATION_MANDATORY
如果当前没有有事务,就抛出异常;
如果已经存在一个事务中,加入到这个事务中。
保证不在同一个事务里:
- PROPAGATION_REQUIRES_NEW
如果当前有事务,把当前事务挂起,创建新的事务但独自执行
- PROPAGATION_NOT_SUPPORTED
如果当前存在事务,就把当前事务挂起。不创建事务
- PROPAGATION_NEVER
如果当前存在事务,抛出异常
-->
<tx:method name="transfer"
rollback-for="java.lang.Exception"/>
</tx:attributes>
</tx:advice>
<aop:config>
<!--声明切入点-->
<aop:pointcut id="pt1" expression="execution(* com.it.service.impl.AccountServiceImpl.transfer(..))"/>
<!--配置事务通知-->
<aop:advisor advice-ref="transferAdvice" pointcut-ref="pt1"></aop:advisor>
</aop:config>
</beans>
3.2事务的传播行为
3.2.1事务的传播行为的作用
我们一般都是将事务设置在Service层,那么当我们调用Service层的一个方法的时候, 它能够保证我们的这个方法中,执行的所有的对数据库的更新操作保持在一个事务中, 在事务层里面调用的这些方法要么全部成功,要么全部失败。
如果你的Service层的这个方法中,除了调用了Dao层的方法之外, 还调用了本类的其他的Service方法,那么在调用其他的Service方法的时候, 我必须保证两个service处在同一个事务中,确保事物的一致性。
事务的传播特性就是解决这个问题的。
3.2.2 事务的传播行为的取值
1)保证在同一个事务里面:
-
PROPAGATION_REQUIRED:默认值,也是最常用的场景.
如果当前没有事务,就新建一个事务,
如果已经存在一个事务中,加入到这个事务中。 -
PROPAGATION_SUPPORTS:
如果当前没有事务,就以非事务方式执行。
如果已经存在一个事务中,加入到这个事务中。
-
PROPAGATION_MANDATORY
如果当前没有有事务,就抛出异常;
如果已经存在一个事务中,加入到这个事务中。
2)保证不在同一个事物里:
-
PROPAGATION_REQUIRES_NEW
如果当前有事务,把当前事务挂起,创建新的事务但独自执行
-
PROPAGATION_NOT_SUPPORTED
如果当前存在事务,就把当前事务挂起。不创建事务
-
PROPAGATION_NEVER
如果当前存在事务,抛出异常
3)嵌套事务
PROPAGATION_NESTED – 如果当前存在事务,则在嵌套事务内执行。如果当前没有事务,则进行与PROPAGATION_REQUIRED类似的操作。
4、spring声明式事务-注解方式
4.1 步骤
-
注册事务管理器
-
开启事务注解支持
-
在业务类上面添加@Transactional
在applicationContext里面打开注解驱动
<?xml version="1.0" encoding="UTF-8"?>
<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
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<import resource="classpath:application-mybatis.xml"></import>
<!--配置申明式事务-->
<!--
注解方式配置声明式事务
1. 配置事务管理者
2. 加载事务注解驱动
3. 在代码中使用Transactional注解来标注,哪个方法需要使用事务
-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<tx:annotation-driven transaction-manager="transactionManager"/>
</beans>
application-mybatis.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
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">
<context:property-placeholder location="classpath:db.properties"></context:property-placeholder>
<!--整合mybatis-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="username" value="${jdbc.username}"></property>
<property name="password" value="${jdbc.password}"></property>
<property name="url" value="${jdbc.url}"></property>
<property name="driverClassName" value="${jdbc.driver}"></property>
</bean>
<bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<property name="typeAliasesPackage" value="com.it.pojo"></property>
</bean>
<bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.it.dao"></property>
</bean>
</beans>
在业务逻辑类上面使用注解
@Transactional : 如果在类上声明,那么标记着该类中的所有方法都使用事务管理。也可以作用于方法上, 那么这就表示只有具体的方法才会使用事务。
事务操作会进行锁表操作,影响性能
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.sql.DataSource;
@Service
public class AccountServiceImpl implements AccountService {
@Autowired
private AccountDao accountDao;
@Autowired
private DataSource dataSource;
/**
* 声明式事务的规则
* 1. rollbackFor 表示该事务遇到什么就回滚,默认是遇到所有的异常都回滚
* 2. noRollbackFor 表示该事务遇到什么不回滚
* 3. timeout 表示事务的超时时间,默认为-1
* 4. readOnly 表示该事务是只读事务,所以配置了readOnly的事务属性的方法中不能进行数据库的增删改操作
* 5. isolation 表示该事务的隔离级别:
* 1. READ_UNCOMMITTED 读取到未提交的事务
* 2. READ_COMMITTED 读取到已提交的事务
* 3. REPEATABLE_READ 可重复读
* 4. SERIALIZABLE 串行化
*
* 6. propagation 表示该事务的传播行为
*
*/
@Override
@Transactional
public void transfer(String fromName, String toName, Double money) {
//1. 调用dao的方法进行转出账户扣款
accountDao.updateAccount(fromName,-money);
int num = 10/0;
//2. 调用dao的方法进行转入账户收款
accountDao.updateAccount(toName,money);
}
}
5 相关注解
@Transactional
声明式事务的规则
- rollbackFor 表示该事务遇到什么就回滚,默认是遇到所有的异常都回滚
- noRollbackFor 表示该事务遇到什么不回滚
- timeout 表示事务的超时时间,默认为-1 (默认为基础事务系统的默认超时)
- readOnly 表示该事务是只读事务,所以配置了readOnly的事务属性的方法中不能进行数据库的增删改操作。可以设置隔离级别,避免脏读、幻读
- isolation 表示该事务的隔离级别:
1. READ_UNCOMMITTED 读取到未提交的事务
2. READ_COMMITTED 读取到已提交的事务
3. REPEATABLE_READ 可重复读
4. SERIALIZABLE 串行化 - propagation 表示该事务的传播行为