1. Spring的事务管理机制
Spring事务管理高层抽象主要包括3个接口，Spring的事务主要是由他们共同完成的：
PlatformTransactionManager：事务管理器—主要用于平台相关事务的管理
TransactionDefinition： 事务定义信息(隔离、传播、超时、只读)—通过配置如何进行事务管理。
TransactionStatus：事务具体运行状态—事务管理过程中，每个时间点事务的状态信息。
1.1. PlatformTransactionManager事务管理器
该接口提供三个方法：
lcommit：提交事务
lrollback：回滚事务
lgetTransaction：获取事务状态
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实现来管理事务，在一个事务跨越多个资源时必须使用
|
lDataSourceTransactionManager针对JdbcTemplate、MyBatis 事务控制 ，使用Connection（连接）进行事务控制：
开启事务ection.setAutoCommit(false);
提交事务ection.commit();
回滚事务ection.rollback();
lHibernateTransactionManager针对Hibernate框架进行事务管理， 使用Session的Transaction相关操作进行事务控制：
开启事务
提交事务
回滚事务
事务管理器的选择？ 用户根据选择和使用的持久层技术，来选择对应的事务管理器。 |
1.2. TransactionDefinition事务定义信息
用来定义事务相关的属性的，给事务管理器用。
该接口主要提供的方法：
lgetIsolationLevel：获取隔离级别
lgetPropagationBehavior：获取传播行为
lgetTimeout：获取超时时间（事务的有效期）
lisReadOnly 是否只读(保存、更新、删除—对数据进行操作-变成可读写的，查询-设置这个属性为true，只能读不能写)，事务管理器能够根据这个返回值进行优化。
这些事务的定义信息，都可以在配置文件中配置和定制。
1.2.1. 事务的隔离级别IsolationLevel
隔离级别 | 含义 |
DEFAULT | 使用后端数据库默认的隔离级别(spring中的默认选择项) |
READ_UNCOMMITED | 允许你读取还未提交的改变了的数据。可能导致脏、幻、不可重复读 |
READ_COMMITTED | 允许在并发事务已经提交后读取。可防止脏读，但幻读和 不可重复读仍可发生 |
REPEATABLE_READ | 对相同字段的多次读取是一致的，除非数据被事务本身改变。可防止脏、不可重复读，但幻读仍可能发生。 |
SERIALIZABLE | 完全服从ACID的隔离级别，确保不发生脏、幻、不可重复读。这在所有的隔离级别中是最慢的，它是典型的通过完全锁定在事务中涉及的数据表来完成的。 |
隔离级别 | 含义 |
DEFAULT | 使用后端数据库默认的隔离级别(spring中的默认选择项) |
READ_UNCOMMITED | 允许你读取还未提交的改变了的数据。可能导致脏、幻、不可重复读 |
READ_COMMITTED | 允许在并发事务已经提交后读取。可防止脏读，但幻读和 不可重复读仍可发生 |
REPEATABLE_READ | 对相同字段的多次读取是一致的，除非数据被事务本身改变。可防止脏、不可重复读，但幻读仍可能发生。 |
SERIALIZABLE | 完全服从ACID的隔离级别，确保不发生脏、幻、不可重复读。这在所有的隔离级别中是最慢的，它是典型的通过完全锁定在事务中涉及的数据表来完成的。 |
脏读:一个事务读取了另一个事务改写但还未提交的数据,如果这些数据被回滚，则读到的数据是无效的。
不可重复读：在同一事务中，多次读取同一数据返回的结果有所不同。换句话说就是，后续读取可以读到另一事务已提交的更新数据。
相反，“可重复读”在同一事务中多次读取数据时，能够保证所读数据一样，也就是，后续读取不能读到另一事务已提交的更新数据。
幻读：一个事务读取了几行记录后，另一个事务插入一些记录，幻读就发生了。再后来的查询中，第一个事务就会发现有些原来没有的记录。
事务四大特性 ACID ---隔离性引发问题 ---- 解决事务的隔离问题 隔离级别
Mysql 默认隔离级别 REPEATABLE_READ
Oracle 默认隔离级别 READ_COMMITTED
1.2.2. 事务的传播行为PropagationBehavior
什么是事务的传播行为？ 有什么作用？
事务传播行为用于解决两个被事务管理的方法互相调用问题
业务层两个方法面临的事务问题：
* 有些时候需要处于同一个事务（删除用户删除完成之后，需要同时删除用户对应的订单，需要事务回滚，例如商场工作人员删除订单业务），
* 有些时候不能在同一个事务（取款是一个事务操作，打印凭条是一个事务操作，例如ATM取款业务） ！
事务的传播行为的7种类型：
事务传播行为类型 | 说明 |
PROPAGATION_REQUIRED | 支持当前事务，如果不存在 就新建一个 |
PROPAGATION_SUPPORTS | 支持当前事务，如果不存在，就不使用事务 |
PROPAGATION_MANDATORY | 支持当前事务，如果不存在，抛出异常 |
PROPAGATION_REQUIRES_NEW | 如果有事务存在，挂起当前事务，创建一个新的事务 |
PROPAGATION_NOT_SUPPORTED | 以非事务方式运行，如果有事务存在，挂起当前事务 |
PROPAGATION_NEVER | 以非事务方式运行，如果有事务存在，抛出异常 |
PROPAGATION_NESTED | 如果当前事务存在，则嵌套事务执行只对DataSourceTransactionManager 起效 |
主要分为三大类：
l PROPAGATION_REQUIRED(默认值)、PROPAGATION_SUPPORTS、PROPAGATION_MANDATORY 支持当前事务， A调用B，如果A事务存在，B和A处于同一个事务 。 事务默认传播行为 REQUIRED。最常用的。
l PROPAGATION_REQUIRES_NEW、PROPAGATION_NOT_SUPPORTED、PROPAGATION_NEVER 不会支持原来的事务 ，A调用B， 如果A事务存在， B肯定不会和A处于同一个事务。 常用的事务传播行为：PROPAGATION_REQUIRES_NEW
l PROPAGATION_NESTED 嵌套事务 ，只对DataSourceTransactionManager有效 ，底层使用JDBC的SavePoint机制，允许在同一个事务设置保存点，回滚保存点 |
【面试题】REQUIRED、REQUIRES_NEW、NESTED 区分
REQUIRED：只有一个事务(默认，推荐)
REQUIRES_NEW：存在两个事务，如果事务存在，挂起事务，重新又开启了一个新的事务
NESTED：嵌套事务，事务可以设置保存点，回滚到保存点 ，选择提交或者回滚
1.3. TransactionStatus 事务状态
事务运行过程中，每个时间点事务状态信息 ！
，给hibernate使用，底层发出sql的
：判断是否有保留点
：判断事务是否结束
：判断当前事务是否是新开的一个事务。
：判断事务是否只能回滚
：设置事务是否回滚
事务的结束：必须通过commit 确认事务提交，rollback作用标记为回滚。
数据库操作中，如果只是回滚，后面不操作，数据库在关闭连接的时候，自动发出了commit。
try {
操作
} catch (){
rollback
} finally {
commit
}
【三个事务超级接口对象之间的关系】
1） 首先用户管理事务，需要先配置TransactionManager（事务管理器）进行事务管理；
2）然后根据TransactionDefinition（事务定义信息、事务的管理方案），通过TransactionManager（事务管理器）进行事务管理；
3）最后事务运行过程中，每个时刻都可以通过获取TransactionStatus（事务状态）来了解事务的运行状态。
1.4. Spring事务管理两种方式
Spring 支持两种方式事务管理
一：编程式的事务管理
通过TransactionTemplate手动管理事务
在实际应用中很少使用，原因是要修改原来的代码，加入事务管理代码 （侵入性 ）
二：声明式事务管理（XML配置文件方式或注解方式）
Spring的声明式事务是通过AOP实现的（环绕通知）
开发中经常使用（代码侵入性最小）--推荐使用！
注：后面会演示声明式事务管理的两种方式：xml配置文件方式和注解方式，不演示编程式方式
2. 声明式事务管理案例-转账（xml、注解）
2.1. 编写转账案例，引出事务管理问题
需求：账号转账，Tom账号取出1000元，存放到Jack账号上
第一步：创建工程（略）
第二步：配置文件
spring的配置文件：applicationContext.xml
<!-- 引入外部文件 -->
<context:property-placeholder location="classpath:db.properties" />
<!-- 配置数据源 -->
<!-- c3p0连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<!-- 设置连接字符串 -->
<property name="driverClass" value="${jdbcClass}" />
<property name="jdbcUrl" value="${jdbcUrl}" />
<property name="user" value="${user}" />
<property name="password" value="${password}" />
</bean>
<!-- 配置dao，注入jdbctemplate 对象-->
<bean id="AccounDaoImpl" class="cn.itcast.spring.dao.AccounDaoImpl">
<!-- 方案二：BookDao类继承JdbcDaoSupport，直接注入数据源，就拥有了jdbctempate对象 -->
<property name="dataSource" ref="dataSource"/>
</bean>
第三步：创建IAccountDao接口
public interface IAccountDao {
//转入
public void in(String name,Double money);
//转出
public void out(String name,Double money);
}
创建AccounDaoImpl实现类，实现了IAccountDao接口
//账户操作持久层
//技术方案：jdbctempate
public class AccountDaoImpl extends JdbcDaoSupport implements IAccountDao {
//转入
public void in(String name,Double money){
String sql="update t_account set money = money+ ? where name = ?";
super.getJdbcTemplate().update(sql, money,name);
}
//转出
public void out(String name,Double money){
String sql="update t_account set money = money- ? where name = ?";
super.getJdbcTemplate().update(sql, money,name);
}
}
第四步：建立service层，创建IAccountService接口，编写转账的业务代码：
public interface IAccountService {
//转账业务
void transfer(String outName,String inName,Double money);
}
创建AccountServiceImpl实现类，实现了IAccountService接口，编写转账的业务操作
//掌握操作的业务层
public class AccountServiceImpl implements IAccountService{
//注入dao（xml方式）
private IAccountDao accountDao;
public void setAccountDao(IAccountDao accountDao) {
this.accountDao = accountDao;
}
//转账操作的业务逻辑
public void transfer(String outName,String inName,Double money){
//调用dao层
//先取出
accountDao.out(outName, money);
//再转入
accountDao.in(inName, money);
}
}
继续配置applicationContext.xml文件：
<!-- 配置dao-->
<bean id="accountDao" class="cn.dao.AccountDaoImpl">
<!--注入数据源 -->
<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 配置service -->
<bean id="accountService" class="cn.itcast.service.AccountServiceImpl">
<!-- 注入dao -->
<property name="accountDao" ref="accountDao"></property>
</bean>
第五步：使用SpringTest进行测试
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:applicationContext.xml"})
public class SpringTest {
//注入测试的service
@Autowired
private IAccountService accountService;
//需求：账号转账，Tom账号取出1000元，存放到Jack账号上
@Test
public void testTransfer(){
accountService.transfer("Tom", "Jack", 1000d);
System.out.println("转账成功！");
}
}
但是发现问题：
事务管理问题：在Service层没有事务的情况下，如果出现异常，则会转账不成功，数据异常。
扩展：如果不配置事务，那么每一个数据库的操作都是单独的一个事务。
2.2. 方式一：XML配置方式
【操作思路】：
1、 确定目标：需要对AccountService 的 transfer方法，配置切入点
2、 需要Advice （环绕通知），方法前开启事务，方法后提交关闭事务
3、
配置Advice通知：
Spring为简化事务的配置，提供了<tx:advice>来配置事务管理，也可以理解为该标签是spring为你实现好了的事务的通知增强方案。
第一步：导入jar包：
其中：
com.springsource.org.aopalliance-1.0.0.jar：aop切面编程
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar：注解开发切面
spring-aop-3.2.0.RELEASE.jar：aop切面编程
spring-aspects-3.2.0.RELEASE.jar：注解开发切面
spring-tx-3.2.0.RELEASE.jar：事务处理
第二步：配置spring文件applicationContext.xml
<!-- 引入外部属性配置文件-->
<context:property-placeholder location="classpath:db.properties"/>
<!-- 配置数据源 -->
<!-- c3p0连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="${jdbc.className}" />
<property name="jdbcUrl" value="${jdbc.url}" />
<property name="user" value="${jdbc.user}" />
<property name="password" value="${jdbc.password}" />
</bean>
<!-- 配置dao -->
<bean id="accountDao" class="cn.itcast.spring.dao.AccountDaoImpl">
<!-- 注入数据源，才拥有jdbctemplate -->
<property name="dataSource" ref="dataSource"/>
</bean>
<!-- 配置service -->
<bean id="accountService" class="cn.itcast.spring.service.AccountServiceImpl">
<!-- 注入dao -->
<property name="accountDao" ref="accountDao"/>
</bean>
<!-- 第一步：定义具体的平台事务管理器（DataSource事务管理器） -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 注入数据源 -->
<property name="dataSource" ref="dataSource"/>
</bean>
<!-- 第二步：定义通知，通知中要处理的就是事务 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
//注意：如果第一步的事务管理器id设为transactionManager,transaction-manager属性可以省略，默认
<!-- 配置事务的属性定义 -->
<tx:attributes>
<!-- 配置具体的方法的事务属性
name：事务添加在哪个方法上，需要自己定义
Isolation：事务的隔离级别，默认是按数据库的隔离级别来
Propagation：事务的传播行为，默认是同一个事务
timeout="-1": 事务的超时时间，默认值使用数据库的超时时间。
read-only="false": 事务是否只读，默认可读写。
rollback-for: 遇到哪些异常就回滚，其他的都不回滚
no-rollback-for：遇到哪些异常不回滚，其他的都回滚。和上面互斥的
-->
//method定义的方法都会添加事务管理
<tx:method name="transfer" isolation="DEFAULT" propagation="REQUIRED" timeout="-1" read-only="false"/>
<!-- 支持通配符：切面中 方法名字符合下面规则的方法都会添加事务管理 -->
<tx:method name="save*"/>
<tx:method name="update*"/>
<tx:method name="delete*"/>
<tx:method name="find*" read-only="true"/>
</tx:attributes>
</tx:advice>
<!-- 第三步：配置切入点，让通知关联切入点，即事务控制业务层的方法 -->
<aop:config>
<!-- 切入点 -->
<aop:pointcut expression="bean(*Service)" id="txPointcut"/>
<!-- 切面 -->
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>
</aop:config>
使用SpringTest.java测试：
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:applicationContext.xml"})
public class SpringTest {
//注入测试的service
@Autowired
private IAccountService accountService;
//需求：账号转账，Tom账号取出1000元，存放到Jack账号上
@Test
public void testTransfer(){
accountService.transfer("Tom", "Jack", 1000d);
System.out.println("转账成功！");
}
}
数据正常!
【声明式事务处理的原理图】
【注意】
如果不配置，则走默认的事务（默认事务是每个数据库操作都是一个事务，相当于没事务），所以我们开发时需要配置事务。
【补充了解】：
rollback-for属性：
注意事项：声明式事务处理对运行时异常有效，任何 RuntimeException 将触发事务回滚，但是任何 checked Exception 将不触发事务回滚
测试：applicationContext.xml:
遇到该异常事务不会回滚:
2.3. 方式二：注解方式
步骤：
1．在需要管理事务的方法或者类上面 添加@Transactional 注解
2．配置注解驱动事务管理（事务管理注解生效的作用）（需要配置对特定持久层框架使用的事务管理器）
第一步：确定目标（bean的方法）：创建IAccountDao和AccountDaoImpl类
（1）IAccountDao接口
public interface IAccountDao {
//（存入）转入
public void in(String name,Double money);
//（取出）转出
public void out(String name,Double money);
}
（2）AccountDaoImpl
//账户操作持久层
//技术方案：jdbctempate
/**
* @Repository("accountDao")
* 相当于容易中定义<bean id="accountDao" class="cn.itcast.spring.anntx.dao.AccountDaoImpl"/>
*/
@Repository("accountDao")
public class AccountDaoImpl extends JdbcDaoSupport implements IAccountDao {
/*
演示:注入数据源的错误方式：
//注入数据源
/*@Autowired
private DataSource dataSource;
//注入失败，@Autowired的原理是为属性生成setter方法通过setter方法注入，但是JdbcDaoSupport 类有setter方法方法且为最终方法，不可重写
注意：xml配置与注解注入数据源的区别：xml配置是在配置文件中注入数据源到dao，不生成setter方法，注解注入的@Autowired会底层生成setter方法，
*/
//注入数据源的正确方式：自定义方法，在方法内调用父类方法注入数据源
@Autowired //当初始化dao的时候，会调用该方法，通过set方法的形参注入数据源
public void setSuperDataSource(DataSource dataSource){ //方法名自定义
//调用父类的setDataSource方法，注入数据源
super.setDataSource(dataSource);
}
//（存入）转入
public void in(String name,Double money){
String sql="update t_account set money = money+ ? where name = ?";
super.getJdbcTemplate().update(sql, money,name);
}
//（取出）转出
public void out(String name,Double money){
String sql="update t_account set money = money- ? where name = ?";
super.getJdbcTemplate().update(sql, money,name);
}
}
创建IAccountService和AccountServiceImpl类
（1）IAccountService接口
public interface IAccountService {
void transfer(String outName,String inName,Double money);
}
（2）AccountServiceImpl
//掌握操作的业务层
/**
* @Service("accountService")
* 相当于spring容器中定义：<bean id="accountService" class="cn.itcast.spring.anntx.service.AccountServiceImpl">
*/
@Service("accountService")
@Transactional //在类上添加事务管理，自动对类中所有的公有的方法添加事务
public class AccountServiceImpl implements IAccountService{
//注入dao
@Autowired
private IAccountDao accountDao;
//转账操作的业务逻辑
@Transactional //在方法上添加事务管理，事务管理只在此方法上
public void transfer(String outName,String inName,Double money){
//调用dao层
//先取出
accountDao.out(outName, money);
//异常
int d = 1/0;
//再转入
accountDao.in(inName, money);
}
@Transactional(readOnly=true) //在方法和类上同时定义了事务的属性，且属性值不同，局部会覆盖全局
public void findAccount(){
System.out.println("查询帐号的信息了");
}
}
第二步：创建applicationContext-tx.xml在applicationContext-tx.xml中配置：
<!-- 引入外部属性文件 -->
<context:property-placeholder location="classpath:db.properties" />
<!-- 配置数据源 -->
<!-- c3p0连接池 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="${jdbc.className}" />
<property name="jdbcUrl" value="${jdbc.url}" />
<property name="user" value="${jdbc.user}" />
<property name="password" value="${jdbc.password}" />
</bean>
<!-- 配置bean注解扫描 -->
<context:component-scan base-package="cn.itcast.spring.anntx"/>
<!-- 事务管理 -->
<!-- 配置事务管理器（DataSource事务管理器） -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!-- 注入数据源 -->
<property name="dataSource" ref="dataSource"/>
</bean>
<!-- 配置事务注解驱动 ：识别事务的注解@tr
transaction-manager:具体的平台事务管理器
-->
<!-- 默认的平台事务管理器的名字叫：transactionManager，如果与自定义的事务管理器id相同，transaction-manager="transactionManager"可以省略 -->
<tx:annotation-driven transaction-manager="transactionManager"/>
【注意】：方法与类添加事务管理：
（1）在需要管理事务的方法或者类上面 添加@Transactional 注解
（2）配置事务的定义属性信息，在注解中直接配置：
[扩展]
如果 @Transactional 标注在 Class 上面， 那么将会对这个 Class 里面所有的 public 方法都包装事务方法。等同于该类的每个公有方法都放上了@Transactional。
如果某方法需要单独的事务定义，则需要在方法上加@Transactional来覆盖类上的标注声明。
//掌握操作的业务层
/**
* @Service("accountService")
* 相当于spring容器中定义：<bean id="accountService" class="cn.itcast.spring.anntx.service.AccountServiceImpl">
*/
@Service("accountService")
@Transactional() //会对该类中，所有的共有的方法，自动加上事务--全局的设置，默认是可写
public class AccountServiceImpl implements IAccountService{
//注入dao
@Autowired
private IAccountDao accountDao;
//转账操作的业务逻辑
@Transactional(readOnly=false)//在方法上添加事务
public void transfer(String outName,String inName,Double money){
//调用dao层
//先取出
accountDao.out(outName, money);
int d = 1/0;
//再转入
accountDao.in(inName, money);
}
@Transactional(readOnly=true) //使用局部覆盖全局的
public void findAccount(){
System.out.println("查询帐号的信息了");
}
}
2.4. 小结-xml和注解的选择
XML配置方式和注解配置方式 进行事务管理 哪种用的多？
XML方式，集中式维护，统一放置到applicationContext.xml文件中，缺点在于配置文件中的内容太多。
使用@Transactional注解进行事务管理，配置太分散，使用XML进行事务管理，属性集中配置，便于管理和维护
注意：以后的service的方法名字的命名，必须是上面规则，否则，不能被spring事务管理。！！！！
即以save开头的方法，update开头的方法，delete开头的方法，表示增删改的操作，故事务为可写
以find开头的方法，表示查询，故事务为只读
（1）xml方式小结
（2）注解方式小结
