2017.4.18 慕课网-spring事务管理总结

1.课程目标

事务回顾
spring中的事务管理的api
spring中编程式事务管理
spring中声明式事务管理

2.事务回顾

2.1 事务的概念

事务是指逻辑上的一组操作，要么全成功，要么全失败。以银行转账为例，详细说明，略。

2.2 事务的特性

原子性：事务是一个不可分割的工作单位。事务中的操作要么一起成功，要么一起失败。

一致性：事务前后数据的完整性必须保持一致。

隔离性：多个用户并发访问数据库时，一个用户的事务不能被其他用户的事务干扰。可以通过设置隔离级别来实现。

持久性：一个事务一旦被提交，那么数据库中数据的改变是永久性的。即使数据库发生故障也不该对其有影响。

3.spring中事务管理的api

PlatformTransactionManager：包含了事务的提交、回滚等管理。
TransactionDefinition：包含了事务的隔离级别、传播、超时信息等。
TransactionStatus：包含了事务是否有保存点、是不是新事务等状态信息。

3.1 PlatformTransactionManager

是interface，有一些具体的实现类，比如datasourceTransactionManager。

spring为不同的持久化框架提供了不同的PlatformTransactionManager。以最常用的举例。

说明	事务
使用spring jdbc或ibatis、mybatis进行持久化数据时使用	org.springframework.jdbc.datasource.DataSourceTransactionManager
使用Hibernate进行持久化数据时使用	org.springframework.orm.hibernate3.HibernateTransactionManager

3.2 TransactionDefinition

(1) 隔离级别相关的常量，以ISOLATION开头。

不考虑隔离性会造成的问题：脏读、幻读、不可重复读。

脏读：一个事务读取了另一个事务改写但是还没提交的数据。如果这些数据被回滚，则读到的数据是无效的。

幻读：一个事务读取了几行数据后，另一个事务插入了一些记录。在后来的查询中，第一个事务就会发现一些原来不存在的记录。

不可重复读：在同一个事务中，多次读取同一个数据返回的结果不同。

事务的隔离级别：

隔离级别	含义
DEFAULT	使用后端数据库默认的隔离级别（spring中得选择项）
READ_UNCOMMITED	允许读取还没提交的已改变了的数据，可能导致脏读、幻读、不可重复读。
READ_COMMITED	允许在并发事务已经提交后读取，可防止脏读。但不可防止幻读和不可重复读。
REPEATABLE_READ	对相同字段的多次读取，结果是一致的，除非数据被事务本身改变。可防止脏读、不可重复读，但不可防止幻读。
SERIALIZABLE	完全服从ACID的隔离级别，可防止脏读、幻读、不可重复读。这在所有隔离级别中是最慢的，因为它是通过完全锁定在事务中涉及的数据表来完成的。是不可能出现并发访问的情况。

默认隔离级别举例：

mysql：REPEATABLE_READ

oracle：READ_COMMITED

(2) 传播行为相关的常量，以PROPAGATION开头。

事务的传播行为是什么？

用来解决业务层方法之间的相互调用问题。

web层-->业务层-->持久层

假设持久层有两个dao，dao1，dao2。业务层有两个service，service1和service2。

 1 Dao1{
 2 xxx(){}
 3 }
 4 
 5 Dao2{
 6 yyy(){}
 7 }
 8 
 9 Service1{
10     aaa(){
11         dao1.xxx();
12         dao2.yyy();
13     }
14 }
15  
16 Service2{
17     bbb();
18 }

View Code

事务是加在业务层的。若此时业务复杂，需要调用service1和service2的方法来共同完成业务功能。而此时service1和service2都有自己的事务管理，那么事务到底使用service1里的还是service2里的呢？此时就用到了业务的传播行为。

事务的传播行为	说明
PROPAGATION_REQUIRED	支持当前事务，如果不存在，就新建一个。
PROPAGATION_SUPPORTS	支持当前事务，如果不存在，就不使用事务。
PROPAGTION_MANDATORY	支持当前事务，如果不存在，就抛出异常。
PROPAGATION_REQUIRES_NEW	如果有事务存在，挂起当前事务，创建一个新的事务。
PROPAGATION_NOT_SUPPORTED	如果有事务存在，挂起当前事务。以非事务的方式进行。
PROPAGATION_NEVER	如果有事务存在，抛出异常。以非事务的方式进行。
PROPAGATION_NESTED	如果有事务存在，则嵌套事务执行。

重点记忆这三种：PROPAGATION_REQUIRED，PROPAGATION_REQUIRES_NEW，PROPAGATION_NESTED。

PROPAGATION_REQUIRED：保证service1的aaa()和service2的bbb()在同一个事务里。

PROPAGATION_REQUIRES_NEW：保证service1的aaa()和service2的bbb()不在同一个事务里。

PROPAGATION_NESTED：service1的aaa()执行完后可以设置一个保存点，如果service2的bbb()执行时出了问题，可以选择回滚到保存点，也可以选择回滚到最初点。是一种嵌套事务。

3.3 TransactionStatus

提供一组方法来获取、设置事务的一些状态信息。比如isCompleted()，isRollBackOnly()。

4.为后面事务管理建设场景--转账示例

4.1创建表

数据库名：spring_transaction

表名：account

4.2 创建项目

eclipse-->new web project-->输入project name为spring_transaction

项目结构：

 1 spring_transaction
 3     src
 5         cn.muke.spring.*
 7         log4j.properties
 9         applicationContext.xml
11         jdbc.properties
13     WebRoot
15         META-INF
17         WEB-INF
19             lib
21                ***.jar
23             web.xml

4.3 引入jar包

数据库驱动：mysql-connector-java-5.0.8-bin.jar

连接池：com.springsource.com.mchange.v2.c3p0.jar

spring：com.springsource.org.apache.commons.logging-1.1.1.jar

com.springsource.org.apache.log4j-1.2.15.jar

spring-beans-3.2.0.RELEASE.jar

spring-context-3.2.0.RELEASE.jar

spring-core-3.2.0.RELEASE.jar

spring-expression-3.2.0.RELEASE.jarr

spring-jdbc-3.2.0.RELEASE.jar（数据库）

spring-tx-3.2.0.RELEASE.jar（事务管理）

spring-test-3.2.0.RELEASE.jar（单元测试）

4.4 配置文件

(1) log4j.properties

(2) applicationContext.xml

<beans>

<context:property-placeholder location:"classpath:jdbc.properties"/>

<--配置c3p0连接池-->

</bean>

</bean>

</bean>

</bean>

</bean>

</beans>

(3) jdbc.properties

jdbc.driverClass=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql:///spring_transaction

jdbc.username=root

jdbc.password=123

4.5 代码

package cn.muke.spring.demo1;

(1) AccountService 和 AccountServiceImpl

public interface AccountService{

//转出账户，转入账户，转账金额

public void transfer(String out, String in, Double money);

}

public class AccountServiceImpl implements AccountService{

private AccountDao accountDao;

public void SetAccountDao()AccountDao accountDao{

this.accountDao = accountDao;

}

//转出账户，转入账户，转账金额

public void transfer(String out, String in, Double money){

accountDao.outMoney(out,money);

accountDao.outMoney(in,money);

}

(2) AccountDao 和 AccountDaoImpl

public interface AccountDao{

public void outMoney(String out, Double money);

public void InMoney(String in, Double money);

}

//jdbcDaoSupport提供了一个属性：jdbcTemplate，查看jdbcDaoSupport源代码可知，只要提供一个连接池，就能自动创建一个jdbcTemplate。

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao{

public void outMoney(String out, Double money){

String sql = "update account set money = money - ? where name = ? ";

this.getJdbcTemplate().update(sql,money,out);

}

public void InMoney(String in, Double money){

String sql = "update account set money = money + ? where name = ? ";

this.getJdbcTemplate().update(sql,money,in);

}

(3 ) 测试类SpringDemo

import org.junit.Test;

@RunWith(SpringJunit4ClassRunner.class)

@ContextConfiguration("classpath:applcationContext.xml")

public class SpringDemo{

//被测试的业务层类

@Resource("name=accountService")

private AccountService accountService;

@Test

public void demo1(){

accountService.transfer("aaa","bbb",200d);

}

选中方法demo1()，右键，选择run as junit4 test。

4.6 事务管理

前面的代码没有进行事务管理，如果在这里加一个会产生异常的代码。那么运行后，结果是：aaa从800变成了600，而bbb却仍然是1000，没有增加。

public class AccountServiceImpl implements AccountService{

//...

//转出账户，转入账户，转账金额

public void transfer(String out, String in, Double money){

accountDao.outMoney(out,money);

int i = 1/0 ; // 产生异常，后面的outMoney不会执行。

accountDao.outMoney(in,money);

}

5.编程式事务管理

（1）配置文件applicationContext.xml

</bean>

</bean>

</bean>

（2）代码

package cn.muke.spring.demo1;

public class AccountServiceImpl implements AccountService{

//...

private TransactionTemplate transactionTemplate;

public void SetTransactionTemplate(TransactionTemplate transactionTemplate){

this.transactionTemplate = transactionTemplate;

}

//这里要加上final，是因为在匿名内部类里使用了方法中的参数。所以方法中的参数要加上final，否则会报错。

public void transfer(final String out, final String in, final Double money){

transactionTemplate.execute(new TransactionCallbackWithoutResult(){// 匿名内部类

@Override

protected void doInTransactionWithoutResult( TransactionStatus transactionStatus ){

accountDao.outMoney(out,money);

int i = 1/0;

accountDao.outMoney(in,money);

}

});

}

（3）运行测试类

执行完，aaa还是800，没有变成600。因为事务回滚了。

5.声明式事务管理方式1--基于TransactionProxyFactoryBean

方式1实际中不适合使用，因为要为每一个类配置一个TransactionProxyFactoryBean，开发和维护都很麻烦。

（1）jar包

声明式事务管理是基于Spring的AOP思想，因此需要先引入AOP相关的jar包：

spring-aop-3.2.0.RELEASE.jar

com.springframework.org.aopalliance-1.0.0.jar

（2）配置文件applicationContext.xml

</bean>

</bean>

<props>

<!--

key表示方法名，支持*的写法，比如tran*，*。

中间的值：

* PROPAGATION : 事务的传播行为

* ISOLATION：事务的隔离级别

* readOnly：只读，数据库不可以进行插入、修改、删除等操作。

* -Exception：发生哪些异常时进行事务回滚，比如 -java.lang.ArithmeticException。

* +Exception：发生哪些异常时不进行事务回滚

-->

<prop key="transfer"> PROPAGATION_REQUIRED <prop>

</props>

</property>

</bean>

ps: ref 和 value 的区别：ref里写的是类，value里写的是值。

（3）代码

package cn.muke.spring.demo1;

import org.junit.Test;

@RunWith(SpringJunit4ClassRunner.class)

@ContextConfiguration("classpath:applcationContext.xml")

public class SpringDemo1{

//被测试的业务层代理类

@Resource("name=accountServiceProxy")

private AccountService accountService;

@Test

public void demo1(){

accountService.transfer("aaa","bbb",200d);

}

（4）运行测试类

执行完后，报异常。查看数据库信息，aaa还是800，没有变成600。因为事务回滚了。

5.声明式事务管理方式2--基于AspectJ的xml方式

这种配置方式，不需要配置AccountServiceImpl的代理类。因为实现了自动代理，类AccountServiceimpl在生成过程中，这个类本身就已经是代理对象了。

在实际的使用中，也是比较多的。

（1）jar包

aspectJ是一个开源的、第三方的aop框架。需要引入aspectJ的相关jar包：

spring-aspects-3.2.0.RELEASE.jar

com.springframesource.org.aspectj.weaver-1.6.8.RELEASE.jar

（2）配置文件applicationContext.xml

注意命名空间的引入。

<beans ...

xmlns:aop="http://www.springframework.org/schema/aop"

xmlns:aop="http://www.springframework.org/schema/tx"

xsi:schemaLocation="...

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"

...

/beans>

</bean>

</bean>

<tx:addvice id="txAdvice" transaction-manager="transactionManager">

<tx:attributes>

<!--

name表示方法名，支持*的写法，比如tran*，*。

属性key：

* propagation : 事务的传播行为。

* isolation：事务的隔离级别。

* read-only：false/true，只读，数据库不可以进行插入、修改、删除等操作。

* rollback-for：发生哪些异常时进行事务回滚。

* no-rollback-for：发生哪些异常时不进行事务回滚。

* time-out：过期信息。

-->

<tx:method name="transfer" propagation="REQUIRED"/>

</tx:attributes>

</tx:addvice>

<aop:config>

<aop:pointcut expression="execution(* cn.muke.spring.demo.AccountService+.*(..))" id="pointcut1>"/>

<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/>

</aop:config>

（3）代码

无任何修改。

（4）运行测试类

执行完后，报异常。查看数据库信息，aaa还是800，没有变成600。因为事务回滚了。

6.声明式事务管理方式3--基于注解方式

（1）jar包

？？？

（2）配置文件applicationContext.xml

同样注意命名空间的声明。

<beans ...

xmlns:aop="http://www.springframework.org/schema/aop"

xmlns:aop="http://www.springframework.org/schema/tx"

xsi:schemaLocation="...

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"

...

/beans>

</bean>

</bean>

<tx:annotation-driven transaction-mananger="transactionManager"/>

（3）代码

@Transactional

public class AccountServiceImpl implements AccountService{

//...

public void transfer( String out, String in, Double money){

accountDao.outMoney(out,money);

int i = 1/0;

accountDao.outMoney(in,money);

}

@Transactional注解也有属性配置：不写的时候按默认值配置。

* propagation : 事务的传播行为。

* isolation：事务的隔离级别。

* readOnly：false/true，只读，数据库不可以进行插入、修改、删除等操作。

* rollbackFor：发生哪些异常时进行事务回滚。

* noRollbackFor：发生哪些异常时不进行事务回滚。

* time-out：过期信息。

@Transactional(propagation=Propagation.REQUIRED, isolation=Isolation.DEFAULT, readOnly=false,...)

（4）运行测试类

执行完后，报异常。查看数据库信息，aaa还是800，没有变成600。因为事务回滚了。

7.总结

spring事务管理分为：编程式事务管理（很少使用）、声明式事务管理。

不论是声明式还是编程式，transactionManager都是必须配置的。

声明式事务管理：

基于TransactionFactoryProxyBean（很少使用，需要为每一个进行事务管理的类，配置一个增强生成代理。）

基于AspectJ的xml方式（常用，配置比xml复杂，但在配置文件中可以清晰看到增强的位置，并且类上不需要做任何修改。）

基于注解方式（常用，配置简单，但是需要修改业务层的类，为它们加上@Transactional注解。）