Spring框架学习笔记（10）——Spring中的事务管理

什么是事务

举例：A给B转500，两个动作，A的账户少500，B的账户多500

事务就是一系列的动作, 它们被当做一个单独的工作单元. 这些动作要么全部完成, 要么全部不起作用

一、注解添加事务管理方法：

1、配置文件添加事务管理器并启用

<!-- 1. 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>

<!-- 2. 启用事务注解 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

2、在需要事务管理的方法上添加@Transactional注解

@Transactional

买一本书的代码

@Service("bookShopService")
public class BookShopServiceImpl implements BookShopService {

@Autowired
private BookShopDao bookShopDao;

@Transactional
@Override
public void purchase(String username, String isbn) {

//1. 获取书的单价
int price = bookShopDao.findBookPriceByIsbn(isbn);

//2. 更新书的库存
bookShopDao.updateBookStock(isbn);

//3. 更新用户余额
bookShopDao.updateUserAccount(username, price);
}

}

二、事务的属性

1、事务的传播

举例：去饭店吃饭，有一桌朋友已经开了一桌，是新开一桌还是一起吃

事务的七种传播行为：

事务的默认传播行为是REQUIRED

在一的基础上添加一个买多本书的方法，并添加@Transactional注解，默认在抛出异常的情况下一本都不会成功，会回滚到最开始的时候。

买多本书的代码

@Service("cashier")
public class CashierImpl implements Cashier {

@Autowired
private BookShopService bookShopService;

@Transactional
@Override
public void checkout(String username, List<String> isbns) {
for(String isbn: isbns){
bookShopService.purchase(username, isbn);
}
}

}

@Transactional(propagation=Propagation.REQUIRES)为默认的事务传播行为，在一个事务调用其他事务的时候不会新开事务，只要有事务就会用，也就是为什么在买第二本书时余额不足会导致整个买多本书的事务回滚，因为买单本书时用的就是买多本书的事务。

@Transactional(propagation=Propagation.REQUIRES_NEW)在一个事务调用其他事务的时候，其他事务有自己的事务就会用自己的事务，这样买多本书的时候，用的都是买单本书的事务，当抛出异常的时候，回滚的是买单本书的事务，如果前面有买单本书成功不会被回滚。

（买多本书的事务去调用买单本书的事务，可以通过@Transactional的propagation属性修改事务的传播方式）

@Service("bookShopService")
public class BookShopServiceImpl implements BookShopService {

@Autowired
private BookShopDao bookShopDao;

//添加事务注解
//1.使用 propagation 指定事务的传播行为, 即当前的事务方法被另外一个事务方法调用时
//如何使用事务, 默认取值为 REQUIRED, 即使用调用方法的事务
//REQUIRES_NEW: 使用自己的事务, 调用的事务方法的事务被挂起.
@Transactional(propagation=Propagation.REQUIRES_NEW)
@Override
public void purchase(String username, String isbn) {
//1. 获取书的单价
int price = bookShopDao.findBookPriceByIsbn(isbn);

//2. 更新数的库存
bookShopDao.updateBookStock(isbn);

//3. 更新用户余额
bookShopDao.updateUserAccount(username, price);
}

}

举例：

REQUIRED一起吃

REQUIRED_NEW自己吃

图解：

REQUIRED的传播行为

 REQUIRED_NEW的传播行为

三、事务其他属性(隔离级别&回滚&只读&过期)

1、隔离级别

使用 isolation 指定事务的隔离级别, 最常用的取值为 READ_COMMITTED

 2、设置事务回滚属性

默认情况下 Spring 的声明式事务对所有的运行时异常进行回滚. 也可以通过对应的属性进行设置. 通常情况下去默认值即可.

3、设置事务超时属性

使用 readOnly 指定事务是否为只读. 表示这个事务只读取数据但不更新数据, 这样可以帮助数据库引擎优化事务. 若真的事一个只读取数据库值的方法, 应设置 readOnly=true

4、设置事务只读属性

使用 timeout 指定强制回滚之前事务可以占用的时间. 

//    @Transactional(propagation=Propagation.REQUIRES_NEW,
//            isolation=Isolation.READ_COMMITTED,
//            noRollbackFor={UserAccountException.class})
@Transactional(propagation=Propagation.REQUIRES_NEW,
isolation=Isolation.READ_COMMITTED,
readOnly=false,
timeout=3)
@Override
public void purchase(String username, String isbn) {

try {
Thread.sleep(5000);
} catch (InterruptedException e) {}

//1. 获取书的单价
int price = bookShopDao.findBookPriceByIsbn(isbn);

//2. 更新数的库存
bookShopDao.updateBookStock(isbn);

//3. 更新用户余额
bookShopDao.updateUserAccount(username, price);

 四、基于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"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

<context:component-scan base-package="com.spring"></context:component-scan>

<!-- 导入资源文件 -->
<context:property-placeholder location="classpath:db.properties"/>

<!-- 配置 C3P0 数据源 -->
<bean id="dataSource"
class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="user" value="${jdbc.user}"></property>
<property name="password" value="${jdbc.password}"></property>
<property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
<property name="driverClass" value="${jdbc.driverClass}"></property>

<property name="initialPoolSize" value="${jdbc.initPoolSize}"></property>
<property name="maxPoolSize" value="${jdbc.maxPoolSize}"></property>
</bean>

<!-- 配置 Spirng 的 JdbcTemplate -->
<bean id="jdbcTemplate"
class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>

<!-- 配置 bean -->
<bean id="bookShopDao" class="com.spring.tx.xml.BookShopDaoImpl">
<property name="jdbcTemplate" ref="jdbcTemplate"></property>
</bean>

<bean id="bookShopService" class="com.spring.tx.xml.service.impl.BookShopServiceImpl">
<property name="bookShopDao" ref="bookShopDao"></property>
</bean>

<bean id="cashier" class="com.spring.tx.xml.service.impl.CashierImpl">
<property name="bookShopService" ref="bookShopService"></property>
</bean>

<!-- 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="purchase" propagation="REQUIRES_NEW"/>
<tx:method name="get*" read-only="true"/>
<tx:method name="find*" read-only="true"/>
<tx:method name="*"/>
</tx:attributes>
</tx:advice>

<!-- 3. 配置事务切入点, 以及把事务切入点和事务属性关联起来 -->
<aop:config>
<aop:pointcut expression="execution(* com.spring.tx.xml.service.*.*(..))"
id="txPointCut"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
</aop:config>

</beans>