Spring--Spring的事务管理

事务:是逻辑上一组操作，要么全都成功，要么全都失败.

事务特性:

ACID:

原子性:事务不可分割

一致性:事务执行的前后，数据完整性保持一致.

隔离性:一个事务执行的时候，不应该受到其他事务的打扰

持久性:一旦结束，数据就永久的保存到数据库.

 

如果不考虑隔离性:

脏读:一个事务读到另一个事务未提交数据

不可重复读:一个事务读到另一个事务已经提交数据（update）导致一个事务多次查询结果不一致

虚读:一个事务读到另一个事务已经提交数据（insert）导致一个事务多次查询结果不一致

 

事务的隔离级别:

未提交读:以上情况都有可能发生。

已提交读:避免脏读，但不可重复读，虚读是有可能发生。

可重复读:避免脏读，不可重复读，但是虚读有可能发生。

串行的:避免以上所有情况.

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_readoracle 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,BA有事务，A执行之后，将A事务执行之后的内容保存到SavePoint.B事务有异常的话，用户需要自己设置事务提交还是回滚.

 

* 常用:(重点)

PROPAGATION_REQUIRED

PROPAGATION_REQUIRES_NEW

PROPAGATION_NESTED

用转账的案例说明Spring的事务管理：

package com.demo1;

public interface accountDao {
	//转入
	public void in(String to,double money);
	//转出
	public void out(String from,double money);
}

public class accountDaoImpls extends JdbcDaoSupport implements accountDao{
	//继承JdbcDaoSupport，其中setDatasource这个方法，在有jdbc模板情况下，传入datasource,在没有jdbc模板情况下，攒尖一个模板，传入datasource.所以直接注入连接池给DAO
	public void in(String to, double money) {
		// TODO Auto-generated method stub
		String sql="update account set money = ? where name=?";
		this.getJdbcTemplate().update(sql,money,to);
	}

	public void out(String from, double money) {
		// TODO Auto-generated method stub
		String sql="update account set money = ? where name=?";
		this.getJdbcTemplate().update(sql,money,from);
	}

}

public interface accountService {
	public void transffer(String from,String to,double money);
}

public class accountServiceImpls implements accountService{
	private accountDao accountdao;

	public void setAccountdao(accountDao accountdao) {
		this.accountdao = accountdao;
	}


	public void transffer(String from, String to, double money) {
		// TODO Auto-generated method stub
		accountdao.in(to, money);
		accountdao.out(from, money);
	}

}

配置文件：

<?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: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">
	
	<!-- 引入外部属性文件 -->
	<context:property-placeholder location="classpath:jdbc.properties"/>
	
	<!-- 配置c3p0连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driver}"/>
		<property name="jdbcUrl" value="${jdbc.url}"/>
		<property name="user" value="${jdbc.user}"/>
		<property name="password" value="${jdbc.password}"/>
	</bean>
	
	<!-- 业务为层 -->
	<bean id="accountService" class="com.demo1.accountServiceImpls">
		<!-- 业务层注入DAO 持久层 -->
		<property name="accountdao" ref="accountdao"></property>
	</bean>
	<!-- 持久层 -->
	<bean id="accountdao" class="com.demo1.accountDaoImpls">
		<!-- 注入连接池对象，通过连接池对象创建模板 -->
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
</beans>

Spring的事务管理分成两类:

* 编程式事务管理:

* 手动编写代码完成事务管理.

* 声明式事务管理:

* 不需要手动编写代码,配置.

编程式事务管理（手动编码完成事务管理）：

1. 注册事务管理器

 <!-- 注册平台事务管理器 -->
	<bean id="transactionmanage" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 注入连接池 -->
		<property name="dataSource" ref="dataSource"/>
	</bean>

2. 注册事务模板类

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






3. 业务层注入模板类，用模板类去管理事务


	<bean id="accountService" class="cn.itcast.spring3.demo1.AccountServiceImpl">
		<!-- 在业务层注入Dao -->
		<property name="accountDao" ref="accountDao"/>
		<!-- 在业务层注入事务的管理模板 -->
		<property name="transactionTemplate" ref="transactiontemplate"/>
	</bean>
4. 在业务层代码中 使用模板


	public void transfer(final String from, final String to, final Double money) {
		transactionTemplate.execute(new TransactionCallbackWithoutResult() {
			@Override
			protected void doInTransactionWithoutResult(TransactionStatus status) {
				accountDao.out(from, money);
				//int d = 1 / 0;
				accountDao.in(to, money);
			}
		});
	}

手动编码实现事务管理IDE缺点：代码量增多， 业务层中 有模板类的代码侵入。

声明式事务管理（不需要手动编码进行配置）：
基于TransactionProxyFactoryBean.
要先导入AOP的jar包


1. 注册平台事务管理器



 <!-- 注册平台事务管理器 -->
	<bean id="transactionmanage" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 注入连接池 -->
		<property name="dataSource" ref="dataSource"/>
	</bean>
2. 创建业务层代理对象

<!-- 配置生成代理对象 -->
	<bean id="accountServiceProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
		<!-- 目标对象 -->
		<property name="target" ref="accountService"/>
		<!-- 注入事务管理器 -->
		<property name="transactionManager" ref="transactionmanage"/>
		<!-- 事务的属性设置 -->
		<property name="transactionAttributes">
			<props>
				<prop key="transfer">PROPAGATION_REQUIRED</prop>
			</props>
		</property>
	</bean>
易错点：容易将property的name属性写成其他bean的id, 它是property的固定写法。

3.编写测试类
* 在测试类中注入代理对象

@Autowired
@Qualifier("accountServiceProxy")
private AccountService accountService;
prop格式：PROPAGATION,ISOLATION,readOnly,-Exception,+Exception
* 
顺序:传播行为、隔离级别、事务是否只读、发生哪些异常可以回滚事务（所有的异常都回滚）、发生了哪些异常不回滚.
 
***** 
缺点:就是需要为每一个管理事务的类生成代理.需要为每个类都需要进行配置.
使用自动代理，基于切面的声明式事务管理 ***（重点掌握）
引入aspectJ ja包
引入aop, tx的约束。
1. 注册事务管理器



 <!-- 注册平台事务管理器 -->
	<bean id="transactionmanage" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 注入连接池 -->
		<property name="dataSource" ref="dataSource"/>
	</bean>

2. 定义增强 （事务管理）


<tx:advice id="txAdvice" transaction-manager="transactionManager">
<!-- 增强(事务)的属性的配置-->
<tx:attributes>
<!-- 
isolation:DEFAULT:事务的隔离级别.
propagation:事务的传播行为.
read-only:false.不是只读
timeout:-1
no-rollback-for:发生哪些异常不回滚
rollback-for:发生哪些异常回滚事务
 -->
<tx:method name="transfer"/>
</tx:attributes>
</tx:advice>
3. 进行aop的配置

<!-- aop配置定义切面和切点的信息 -->
<aop:config>
		<!-- 定义切点:哪些类的哪些方法应用增强 -->
		<aop:pointcut expression="execution(* cn.itcast.spring3.demo3.AccountService+.*(..))" id="mypointcut"/>
		<!-- 定义切面: -->
		<aop:advisor advice-ref="txAdvice" pointcut-ref="mypointcut"/>
</aop:config>
4. 编写测试类， 注入service对象，  这是后不要注入代理对象，（生成这个类的时候 已经是代理对象了）




基于注解的事务管理

第一步:事务管理器:
<!-- 事务管理器-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>
 
第二步:注解事务:
<!-- 开启注解的事务管理-->
<tx:annotation-driven transaction-manager="transactionManager"/>
 
第三步:在Service上使用注解
@Transactional
* 注解中有属性值:
* isolation
* propagation
* readOnly
...