Spring的事务管理

1、对事务管理的理解

事务管理是企业级应用程序开发中必不可少的技术,  用来确保数据的完整性和一致性. 

事务就是一系列的动作, 它们被当做一个单独的工作单元. 这些动作要么全部完成, 要么全部不起作用
事务的四个关键属性(ACID)
原子性(atomicity): 事务是一个原子操作, 由一系列动作组成. 事务的原子性确保动作要么全部完成要么完全不起作用.
一致性(consistency): 一旦所有事务动作完成, 事务就被提交. 数据和资源就处于一种满足业务规则的一致性状态中.
隔离性(isolation): 可能有许多事务会同时处理相同的数据, 因此每个事物都应该与其他事务隔离开来, 防止数据损坏.

持久性(durability): 一旦事务完成, 无论发生什么系统错误, 它的结果都不应该受到影响. 通常情况下, 事务的结果被写到持久化存储器中.

2、为什么要使用事务管理机制

我们先来看看下面的一个例子。现在有一个“人买书”的问题，符合现实生活的行为是，买书时先判断书的库存，然后进行买书操作，再来判断买家当前的余额是否充足，如果充足，书本被卖出，买家余额减少对应的金额，书的库存减一。好，我们先看数据库的设计：

account(username,balance)

book(isbn,book_name,price)

book_stock(isbn,stock)

先使用注解的方式完成事务管理的讲解，后文再讲解XML文件的方式配置事务，先看xml文档

<context:component-scan base-package="edu.ctgu.spring"></context:component-scan>
	
<!-- 导入properties文件 -->
<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="driverClass" value="${jdbc.driver}"></property>
	<property name="jdbcUrl" value="${jdbc.url}"></property>
		
	<property name="initialPoolSize" value="${jdbc.initPoolSize}"></property>
	<property name="maxPoolSize" value="${jdbc.maxPoolSize}"></property>
</bean>
	
<!-- 配置Spring的JdbcTemplate -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
	<property name="dataSource" ref="dataSource"></property>
</bean>

本例使用Spring的JDBC工具来进行数据库操作，代码如下：

BookShopDaoImpl(实现了BookShopDao接口)

@Repository("bookShopDao")
public class BookShopDaoImpl implements BookShopDao {

	@Autowired
	private JdbcTemplate jdbcTemplate;
	
	@Override
	public int findPriceByIsbn(String isbn) {
		String sql = "SELECT price FROM book WHERE isbn = ?";
		// queryForObject方法的第二个参数指的是返回的对象的类型
		int price = jdbcTemplate.queryForObject(sql, Integer.class, isbn);
		return price;
	}

	@Override
	public void updateStock(String isbn) {
		// 更新操作前先判断藏书是否为零
		String sql2 = "SELECT stock FROM book_stock WHERE isbn = ?";
		int stock = jdbcTemplate.queryForObject(sql2,Integer.class,isbn);
		if(stock == 0){
			throw new BookStockException("库存不足!");
		}else{
		String sql = "UPDATE book_stock SET stock = stock - 1 WHERE isbn = ?";
		jdbcTemplate.update(sql, isbn);}
	}

	@Override
	public void updateBalance(String username, int price) {
		String sql2 = "SELECT balance FROM account WHERE username = ?";
		int balance = jdbcTemplate.queryForObject(sql2,Integer.class,username);
		if(balance < price){
			throw new UserAccountException("余额不足!");
		}else{
		String sql = "UPDATE account SET balance = balance - ? WHERE username = ?";
		jdbcTemplate.update(sql, price,username);}
	}

}

上面的代码完成了我们之前叙述中的操作过程，大家可能会发现上面的代码中顾客余额balance为0或者书本的库存stock为0，都会出现异常，此处异常代码不在展示，异常继承自RuntimeException类，实现了方法，没有其他的任何操作，现在先不管这个，后文会讲到为什么要使用异常。想要让这些操作成为一个流程，我们还需要一个业务逻辑类

BookServiceImpl(实现了BookService接口)

@Service("bookService")
public class BookServiceImpl implements BookService {
	
	@Autowired
	private BookShopDao bookShopDao;
	@Override
	public void purchase(String username, String isbn) {
		// 获取指定书的价格
		int price = bookShopDao.findPriceByIsbn(isbn);
		
		// 书的库存减一
		bookShopDao.updateStock(isbn);
		
		// 用户的账户余额减price
		bookShopDao.updateBalance(username, price);
	}
}

好了，现在工作基本完成了，我们来做一个测试。假设现在的账户余额balance是180元，书本的isbn为1001的价格price是100元，库存stock是10本。测试开始，第一轮的购书正常，然后对应的balance变为80元，stock变为9本；继续测试，本轮中余额不足，但是由于操作库存减少的代码执行在前，所以书本的库存减少，顾客却买不起书，显然逻辑出错了。读者大概会有想法了，我们目前急切的需要什么？我们需要一个操作，一个能够将出现问题的代码操作过的数据回滚到之前未操作的状态的操作，对，没错，事务管理登场了。

3、Spring的事物管理如何使用

     Spring支持编程式事物管理，也支持声明式事物管理。顾名思义，前者的意思是将事务管理代码嵌入到业务方法中来控制事务的提交和回滚. 在编程式管理事务时, 必须在每个事务操作中包含额外的事务管理代码，后者则指将事务管理代码从业务方法中分离出来, 以声明的方式来实现事务管理. 事务管理作为一种横切关注点, 可以通过 AOP 方法模块化. Spring 通过 Spring AOP 框架支持声明式事务管理。感受的出来，后者更加好用也更轻，这里仅介绍后者。

下面来看看配置声明式事务的步骤，第一步在xml文档中添加如下几行：

<!-- 配置处理JDBC数据源的事物管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
	<property name="dataSource" ref="dataSource"></property>
</bean>
	
<!-- 启用事务注解 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

然后修改业务逻辑类的代码，也很简单，在purchase(String username, String isbn)上加上事务注解@Transactional

好了，现在在测试，当进行到第二步的时候，出现了余额不足的异常，然后查看数据库表，发现书本的库存仍然是9本，没有减少。回到上面提出的问题，为什么要在余额不足的时候抛出异常呢？因为事务管理器只有在代码块发生的异常的时候才会进行数据的回滚。

4、事务的传播行为

现在新的需求来了，一个顾客一次性可能会买两本书，再次使用上面的例子，顾客现在有300元，书本1001价格是100元，书本1002价格是70元，两种书的库存都是10本，如果我们执行如下代码中的操作，就会出现新的问题。

CashierImpl(继承Cashier接口)

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

	@Autowired
	private BookService bookService;
	
	
	@Transactional
	@Override
	public void checkOut(String username, List<String> isbns) {
		for (String isbn : isbns) {
			bookService.purchase(username, isbn);
		}
	}

}

第一次买两本书，书本的库存都变为9本，顾客余额变为130，执行下一次的时候出现问题了，顾客的余额只能买第一本书，第二本书买不成，出现了异常。但是由于上面的操作也被事务管理器管理，所以当出现异常的时候，数据应该回滚到哪一个程度呢？数据库的数据告诉我们回滚到了上面的操作之前的样子。这就不符合逻辑了，我买不起两本，我可以买一本啊。别担心，Spring的Transactional注解有一个属性叫做propagation，有以下的属性值

我们在service的purchase方法的Transactional注解中添加属性propagation=Propagation.REQUIRES_NEW，这样当事务传递过来的时候，将调用purchase的方法的checkOut方法的事务挂起，转而在purchase方法的事务内运行。然后就可以正常的买第一本书，买第二本书出现异常也不会干扰第一次的成功交易。

5、事务的其他属性

事务的隔离级别

从理论上来说, 事务应该彼此完全隔离, 以避免并发事务所导致的问题. 然而, 那样会对性能产生极大的影响, 因为事务必须按顺序运行. 在实际开发中, 为了提升性能, 事务会以较低的隔离级别运行.使用isolation指定事务的隔离级别，最常用的是READ_COMMITTED，可以避免脏读。

回滚事务属性

默认情况下Spring的声明式事务对所有的运行时异常进行回滚，也可以通过对应的属性noRollbackFor(设置不回滚的异常)或者RollbackFor(设置必须回滚的异常)进行设置，通常情况下取默认值即可，用的比较少。

只读属性

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

超时属性

使用timeout属性指定强制回滚之前事务可以占用的时间，过了时间，则强制回滚。

6、使用XML配置的方式配置事务管理

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(* edu.ctgu.spring.tx.*.*(..))" 
		id="txPointCut"/>
	<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>	
</aop:config>