Spring的事务管理（11）

• 事务：是逻辑上一组操作，要么全都成功，要么全都失败.
• ** 事务特性**（四大特性）：
  • ACID：
  • 原子性：事务不可分割
  • 一致性：事务执行的前后，数据完整性保持一致.
  • 隔离性：一个事务执行的时候，不应该受到其他事务的打扰
  • 持久性：一旦结束，数据就永久的保存到数据库.

---

• 如果不考虑隔离性：
  • 脏读：一个事务读到另一个事务未提交数据
  • 不可重复读：一个事务读到另一个事务已经提交数据（update）导致一个事务多次查询 结果不一致
  • 虚读：一个事务读到另一个事务已经提交数据（insert）导致一个事务多次查询结果不一致

---

• 事务的隔离级别：
  • 未提交读（Read uncommitted）：以上情况都有可能发生。
  • 已提交读（Read committed）：避免脏读，但不可重复读，虚读是有可能发生。
  • 可重复读（Repeatable read）：避免脏读，不可重复读，但是虚读有可能发生。
  • 串行的：避免以上所有情况.

---

Spring中事务管理

分层开发：事务处在Service层.

---

Spring提供事务管理API（三个接口）

• PlatformTransactionManager：平台事务管理器.（以下方法）

• commit(TransactionStatus status)

• getTransaction(TransactionDefinition definition)

• rollback(TransactionStatus status)

• TransactionDefinition：事务定义信息（隔离、传播、超时、只读）（以下常量）

• ISOLation_XXX：事务隔离级别.

• PROPAGATION_XXX：事务的传播行为.(不是JDBC中有的，为了解决实际开发问题.)

• 过期时间：

• TransactionStatus：事务运行状态

• 是否有保存点

• 是否一个新的事务

• 事务是否已经提交

他们之间关系：PlatformTransactionManager通过TransactionDefinition设置事务相关信息管理事务，管理事务过程中，产生一些事务状态：状态由TransactionStatus记录.

---

API详解：

• PlatformTransactionManager：接口. Spring为不同的持久化框架提供了不同PlatformTransactionManager接口实现

事务	说明
org.springframework.jdbc.datasource.DataSourceTransactionManager	使用Spring JDBC或iBatis 进行持久化数据时使用
org.springframework.orm.hibernate3.HibernateTransactionManager	使用Hibernate3.0版本进行持久化数据时使用
org.springframework.orm.jpa.JpaTransactionManager	使用JPA进行持久化时使用
org.springframework.jdo.JdoTransactionManager	当持久化机制是Jdo时使用
org.springframework.transaction.jta.JtaTransactionManager	使用一个JTA实现来管理事务，在一个事务跨越多个资源时必须使用

TransactionDefinition：

• ISOLATION_DEFAULT：默认级别. Mysql repeatable_read oracle read_commited ISOLATION_READ_UNCOMMITTED ISOLATION_READ_COMMITTED ISOLATION_REPEATABLE_READ ISOLATION_SERIALIZABLE

• 事务的传播行为：(不是JDBC事务管理，用来解决实际开发的问题.)传播行为：解决业务层之间的调用的事务的关系.

• PROPAGATION_REQUIRED ：支持当前事务，如果不存在 就新建一个 A,B 如果A有事务，B使用A的事务，如果A没有事务，B就开启一个新的事务.(A,B是在一个事务中。)

• PROPAGATION_SUPPORTS ：支持当前事务，如果不存在，就不使用事务

• A,B 如果A有事务，B使用A的事务，如果A没有事务，B就不使用事务.

• PROPAGATION_MANDATORY ：支持当前事务，如果不存在，抛出异常

• A,B 如果A有事务，B使用A的事务，如果A没有事务，抛出异常.

• PROPAGATION_REQUIRES_NEW 如果有事务存在，挂起当前事务，创建一个新的事务

• A,B 如果A有事务，B将A的事务挂起，重新创建一个新的事务.(A,B不在一个事务中.事务互不影响.)

• PROPAGATION_NOT_SUPPORTED 以非事务方式运行，如果有事务存在，挂起当前事务

• A,B 非事务的方式运行，A有事务，就会挂起当前的事务.

• PROPAGATION_NEVER 以非事务方式运行，如果有事务存在，抛出异常

• PROPAGATION_NESTED 如果当前事务存在，则嵌套事务执行 基于SavePoint技术.

• A,B A有事务，A执行之后，将A事务执行之后的内容保存到SavePoint.B事务有异常的话，用户需要自己设置事务提交还是回滚.

• 常用：(重点)

• PROPAGATION_REQUIRED

• PROPAGATION_REQUIRES_NEW

• PROPAGATION_NESTED

---

Spring的事务管理：

Spring的事务管理分成两类：

• 编程式事务管理：
  • 手动编写代码完成事务管理.
• 声明式事务管理：
  • 不需要手动编写代码,配置.

---

事务操作的环境搭建

CREATE TABLE `account` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(20) NOT NULL,
  `money` double DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8;
INSERT INTO `account` VALUES ('1', 'aaa', '1000');
INSERT INTO `account` VALUES ('2', 'bbb', '1000');
INSERT INTO `account` VALUES ('3', 'ccc', '1000');

创建一个web项目:	
* 导入相应jar包
* 引入配置文件:
* applicationContext.xml、log4j.properties、jdbc.properties

创建类:
* AccountService
---------------AccountService--------------------
package cn.spring3.demo1;
public interface AccountService {
	/*
	 * 转账的方法
	 * @param from:从哪转出
	 * @param to:转入
	 * @param money:转账金额
	 */
	public void transfer(String from ,String to,Double moeny);

}


* AccountDao
--------------AccountDao-------------------
package cn.spring3.demo2;
public interface AccountDao {
	/*
	 * 转账的方法
	 * @param from:从哪转出
	 * @param money:转账金额
	 */
	public void out(String from ,Double money);
	/*
	 * 转账的方法
	 * @param to:转入
	 * @param money:转账金额
	 */
	public void in(String to ,Double money);
}



在Spring中注册:
	<!-- 业务层 -->
	<bean id="accountService" class="cn.spring3.demo1.AccountServiceImpl">
		<!-- 在业务层注入Dao -->
		<property name="accountDao" ref="accountDao"/>
	</bean>
	
	<!-- 持久层类 -->
	<bean id="accountDao" class="cn.spring3.demo1.AccountDaoImpl">
		<!-- 注入连接池的对象,通过连接池对象创建模板. JdbcDaoSupport-->
		<property name="dataSource" ref="dataSource"></property>
	</bean>

编写dao实现层
--------------------------------AccountDaoImpl----------------------------------
package cn.spring3.demo1;

import org.springframework.jdbc.core.support.JdbcDaoSupport;

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {

	/* 因为继承JdbcDaoSupport，所以直接调用父类方法
	 * 转账的方法
	 * 
	 * @param to:转入
	 * 
	 * @param money:转账金额
	 */
	public void in(String to, Double money) {
		String sql = "update account set money = money + ? where name = ?";
		getJdbcTemplate().update(sql, money, to);
	}

	/*
	 * 转账的方法
	 * 
	 * @param from:从哪转出
	 * 
	 * @param money:转账金额
	 */
	public void out(String from, Double money) {
		String sql = "update account set money = money - ? where name = ?";
		getJdbcTemplate().update(sql, money, from);

	}

}


在service里注册dao，编写AccountServiceImpl类
package cn.spring3.demo1;


import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;

public class AccountServiceImpl implements AccountService {
	private AccountDao accountDao;

	public void setAccountDao(AccountDao accountDao) {
		this.accountDao = accountDao;
	}


	/*
	 * 转账的方法
	 * @param from:从哪转出
	 * @param to:转入
	 * @param money:转账金额
	 */
	public void transfer(final String from, final String to, final Double money) {
		template.execute(new TransactionCallbackWithoutResult() {
		accountDao.out(from, money);
		//int o= 1/0;
		accountDao.in(to, money);
	}

}

编写一个测试类:
package cn.spring3.demo1;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class SpringTest {
	@Autowired
	@Qualifier("accountService")
	private AccountService accountService;

	@Test
	public void demo1() {
		//完成转账
		accountService.transfer("aaa", "bbb", 100.00);
	}

}


测试结果：
如果没有事务的话，【//int o= 1/0;】会有sql执行失败，导致结果不对。这是目前整合的初始环境

---

Spring的事务管理

手动编码的方式完成事务管理:

需要事务管理器:真正管理事务对象.

• Spring提供了事务管理的模板(工具类.)

第一步:注册事务管理器:

<!-- 配置事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
		<!-- 需要注入连接池，通过连接池获得连接 -->
		<property name="dataSource" ref="dataSource"/>
	</bean>

第二步:注册事务模板类:

<!-- 事务管理模板 -->
	<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
		<property name="transactionManager" ref="transactionManager"></property>
	</bean>

第三步:在业务层注入模板类:(模板类管理事务***)

<!-- 业务层 -->
	<bean id="accountService" class="cn.spring3.demo1.AccountServiceImpl">
		<!-- 在业务层注入Dao -->
		<property name="accountDao" ref="accountDao"/>
		<!-- 在业务层注入管理的模板 -->***
		<property name="template" ref="transactionTemplate"></property>***
	</bean>

第四步:在业务层代码上使用模板(***为增):

***template.execute(new TransactionCallbackWithoutResult() {
		***@Override
		***	protected void doInTransactionWithoutResult(TransactionStatus status) {
				accountDao.out(from, money);
				int o= 1/0;
				accountDao.in(to, money);
		***	}
	***	});

手动编码方式缺点:

• 代码量增加,代码有侵入性.

---

完整配置文件，红框为新增。

---

声明式事务管理:(有两种方式：第一种方式【原始方式】)

基于TransactionProxyFactoryBean.

导入:aop相应jar包. 第一步:注册平台事务管理器:

<!-- 配置事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
		<!-- 需要注入连接池，通过连接池获得连接 -->
		<property name="dataSource" ref="dataSource"/>
	</bean>

第二步:创建业务层代理对象(***为):

<!-- 配置生成代理对象 -->
	<bean id="accountServiceProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
		<!-- 目标对象 对上面的accountService生成代理-->
		<property name="target" ref="accountService"></property>
		***<!-- 注入事务管理器 -->
		***<property name="transactionManager" ref="transactionManager"></property>
		***<property name="transactionAttributes">
			***<props>
			***	<!-- key方法名 -->
				***<prop key="*">PROPAGATION_REQUIRED</prop>
				<!--prop格式：PROPAGATION,ISOLATION,readOnly,-Exception,+Exception-->
			***</props>
	***</property>
	</bean>

第三步:编写测试类(***** 千万注意:注入代理对象):

@Autowired
@Qualifier("accountServiceProxy")*****
private AccountService accountService;

prop格式：PROPAGATION,ISOLATION,readOnly,-Exception,+Exception * 顺序:传播行为、隔离级别、事务是否只读、发生哪些异常可以回滚事务（所有的异常都回滚）、发生了哪些异常不回滚.

举例1：

<prop key="*">PROPAGATION_REQUIRED,readOnly</prop>
测试结果：只读。

举例2：

<prop key="*">PROPAGATION_REQUIRED,+java.lang.ArithmeticException</prop>
测试结果：
发生这个异常依旧提交成功。

***** 缺点:就是需要为每一个管理事务的类生成代理.需要为每个类都需要进行配置.

---

声明式事务管理:(自动代理.基于切面 ******重点)

第一步:导入相应jar包.

• aspectj 【spring-aspects-3.2.0.RELEASE.jar】 【com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar】

第二步:引入相应约束:

* aop、tx约束.
<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: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/context
	http://www.springframework.org/schema/context/spring-context.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">

第三步:注册事务管理器;

<!-- 配置事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
		<!-- 需要注入连接池，通过连接池获得连接 -->
		<property name="dataSource" ref="dataSource"/>
	</bean>

第四步:定义增强(事务管理)

<!-- 定义一个增强 -->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<!-- 增强属性配置 -->
		<tx:attributes>
			<!--
			 isolation:DEFAULT 事务的隔离级别
			 propagation:REQUIRED 事务的传播行为
			 read-only:false 是否是只读的
			 timeout:-1 超时时间
			 no-rollback-for 发生哪些不回滚
			 rollback-for 发生哪些回滚
			 -->
			<tx:method name="transfer"/>
		</tx:attributes>
	</tx:advice>

第五步:定义aop的配置(切点和通知的组合)

<!-- 使用aop配置定义切面切点 -->
	<aop:config>
		<!-- 定义切点：哪些方法应用增强 -->
		<aop:pointcut expression="execution(* cn.spring3.demo3.AccountService+.*(..))" id="myPointCut"/>
		<!-- 定义切面 -->
		<aop:advisor advice-ref="txAdvice" pointcut-ref="myPointCut"/>
	</aop:config>

第六步:编写测试类:

* 注入accountService对象,不需要注入代理对象(生成这个类的时候,已经是代理对象.)

基于注解的事务管理:

第一步:事务管理器:

<!-- 配置事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
		<!-- 需要注入连接池，通过连接池获得连接 -->
		<property name="dataSource" ref="dataSource"/>
	</bean>

第二步:注解事务:

<!-- 开启注解的事物管理 -->
	<tx:annotation-driven transaction-manager="transactionManager"/>

第三步:在Service上使用注解

//注解中的事物属性设置
@Transactional(isolation = Isolation.DEFAULT, propagation = Propagation.REQUIRED)
public class AccountServiceImpl implements AccountService 

例子中的accountService代码如下：