1、通常在java ee编程中，有两种事务管理的方式：全局事务和本地事务。
全局事务：可以同时管理多个transaction，但是通常都需要依赖于容器的事务管理
本地事务：直接使用jdbc的事务管理但是不能同时管理多个事务
2、但是在spring的事务管理中，它解决了全局事务和本地事务的缺点，它是的程序员可以在任何开发环境中都使用一致的编程模式，而且不依赖与任何的事务管理api。spring提供了声明式事务管理(推荐使用)和编程式事务管理。
spring的事务抽象中，依赖的最重要的一个类就是：org.springframework.transaction.PlatformTransactionManager接口
public interfact PlatformTransactionManager{ TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException; void commit(TransactionStatus status) throws TransactionException; void rollback(TransactionStatus status) throws TransactionException;p }
这是一个最基本的服务提供接口(SPI)。
getTransaction()方法依赖于一个TransactionDefinition类型的参数，返回一个TransactionStatus类型的对象，返回的TransactionStatus可以是一个新的transaction也有可能是一个已存的transaction。一个TransactionStatus总是和一个线程的执行相关联的。
TransactionDefinition接口指明了以下内容：
Isolation(隔离性):当前事务和其他事务是隔离开的
Propagation(传播)：通常在事务范围里面执行的代码都会在这个事务里执行，但是，当一个事务已经存在的时候，你可以选择指定在事务方法被执行的事件中的行为，例如：代码可以在已存的事务中持续执行，或者已存的事务可以被挂起，然后一个创建一个新的事务。
Timeout(持久性)：当前事务执行多久结束或者自动回滚
Read-only status(只读):但你的代码只是读操作，并没有对数据做修改的时候，就可以选择使用只读事务，只读事务操作在使用hibernate之类的情况下会是一个最佳的优化。
TransactionStatus接口提供了一种简单的方式去控制事务的执行和查询事务状态
public interface TransactionStatus extends SavepointManager { boolean isNewTransaction(); boolean hasSavepoint(); void setRollbackOnly(); boolean isRollbackOnly(); void flush(); boolean isCompleted(); }
不论使用声明式事务管理还是编程式事务管理，都需要正确的实现PlatformTransactionManager接口，通常都是通过依赖注入来实现。
下面是一种使用最基本的JDBC来实现本地PlatformTransactionManager的例子。
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close"> <property name="driverClassName" value="${jdbc.driverClassName}" /> <property name="url" value="${jdbc.url}" /> <property name="username" value="${jdbc.username}" /> <property name="password" value="${jdbc.password}" /> </bean>
相关联的PlatformTransactionManager类的定义需要注入一个dataSource
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"/> </bean>
当你使用Java EE容器中的JTA的时候，你可以使用容器的DataSource，下面是一个使用JTA和JNDI的例子：
<?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:jee="http://www.springframework.org/schema/jee" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd"> <jee:jndi-lookup id="dataSource" jndi-name="jdbc/jpetstore"/> <bean id="txManager" class="org.springframework.transaction.jta.JtaTransactionManager" /> <!-- other <bean/> definitions here --> </beans>
JtaTransactionManager不需要知道DataSource，或者其他特定的资源，因为它使用的是容器的全局事务管理结构。
你也可以更简单使用Hibernate的本地事务管理，但是你需要定义一个hibernate的LocalSessionFactoryBean，用来实例化Hibernate的Session实例。
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean"> <property name="dataSource" ref="dataSource"/> <property name="mappingResources"> <list> <value>org/springframework/samples/petclinic/hibernate/petclinic.hbm.xml</value> </list> </property> <property name="hibernateProperties"> <value> hibernate.dialect=${hibernate.dialect} </value> </property> </bean> <bean id="txManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory"/> </bean>
3、事务中的资源同步
①高级同步实现
首选的实现是使用spring的最高级模板。这个模板是基于持久综合APIs或者使用本地的ORM APIs和食物通知工厂类或者代理。通常使用JdbcTemplate来实现。
②低级同步实现
像DataSourceUtils(JDBC用)，EntityManagerFactoryUtils(JPA用)，SessionFactoryUtils(Hibernate用)PersistenceManagerFactoryUtils(JDO用)等等之类的既存的低级事务管理类。当你想程序代码直接处理本地持久APIs资源类型的时候，你可以使用这些类来保证获得合适的Spring Framework-Managed实例。
例如：在JDBC的时候，使用Spring的org.springframework.jdbc.datasource.DataSourceUtils类来代理传统的JDTC调用getConnection()方法来实现
Connection conn = DataSourceUtils.getConnection(dataSource);
当已经存在一个相关联的同步连接的时候，那么这个连接会被返回，否则的话则会返回一个新的连接。
③TransactionAwareDataSourceProxy
在很底层存在一个TransactionAwareDataSourceProxy类，这是一个DataSource的代理类，对DataSource类实行了一个包装并且加了一个对Spring管理的事务的认识。
通常我们都不需要使用这个类，除了既存的代码必须调用并且传递一个标准的DataSource接口实现。
4、声明式事务管理
下面是一个实现转账的具体实例：
表结构定义：
package com.fuwh.dao; //定义一个出入帐的接口类 public interface MoneyDao { public abstract void inMoney(int money,int id); public abstract void outMoney(int money,int id); }
1 package com.fuwh.dao.impl; 2 3 import org.springframework.jdbc.core.namedparam.MapSqlParameterSource; 4 import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate; 5 6 import com.fuwh.dao.MoneyDao; 7 8 //出入帐接口类的具体实现类 9 public class MoneyDaoImpl implements MoneyDao{ 10 11 private NamedParameterJdbcTemplate namedParameterJdbcTemplate; 12 13 public void setNamedParameterJdbcTemplate(NamedParameterJdbcTemplate namedParameterJdbcTemplate) { 14 this.namedParameterJdbcTemplate = namedParameterJdbcTemplate; 15 } 16 17 @Override 18 public void inMoney(int money,int id) { 19 // TODO Auto-generated method stub 20 String sql="update t_money set money=money+:money where id=:id"; 21 MapSqlParameterSource msps=new MapSqlParameterSource("money", money); 22 msps.addValue("id", id); 23 namedParameterJdbcTemplate.update(sql, msps); 24 } 25 26 @Override 27 public void outMoney(int money,int id) { 28 // TODO Auto-generated method stub 29 String sql="update t_money set money=money-:money where id=:id"; 30 MapSqlParameterSource msps=new MapSqlParameterSource("money",money); 31 msps.addValue("id", id); 32 namedParameterJdbcTemplate.update(sql, msps); 33 } 34 35 }
package com.fuwh.Service; //定义一个转账服务类 public interface MoneyService { public void transferMoney(int money,int inId,int outId); }
1 package com.fuwh.Service.impl; 2 3 import com.fuwh.dao.MoneyDao; 4 import com.fuwh.Service.MoneyService; 5 6 //转账服务类的具体实现 7 public class MoneyServiceImpl implements MoneyService { 8 9 private MoneyDao moneyDao; 10 11 public void setMoneyDao(MoneyDao moneyDao) { 12 this.moneyDao = moneyDao; 13 } 14 15 @Override 16 public void transferMoney(int money, int inId, int outId) { 17 // TODO Auto-generated method stub 18 moneyDao.outMoney(money, outId); 19 moneyDao.inMoney(money, inId); 20 } 21 22 }
package com.fuwh.test; import org.junit.Before; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import com.fuwh.Service.MoneyService; //Junit测试类 public class Test { private ApplicationContext ac; @Before public void setUp() throws Exception { ac=new ClassPathXmlApplicationContext("beans.xml"); } @org.junit.Test public void testTransfer() { MoneyService md=(MoneyService)ac.getBean("moneyService"); md.transferMoney(50, 1, 2); } }
1 <?xml version="1.0" encoding="UTF-8"?> 2 3 <beans xmlns="http://www.springframework.org/schema/beans" 4 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 5 xmlns:aop="http://www.springframework.org/schema/aop" 6 xmlns:context="http://www.springframework.org/schema/context" 7 xmlns:tx="http://www.springframework.org/schema/tx" 8 xsi:schemaLocation="http://www.springframework.org/schema/beans 9 http://www.springframework.org/schema/beans/spring-beans.xsd 10 http://www.springframework.org/schema/aop 11 http://www.springframework.org/schema/aop/spring-aop.xsd 12 http://www.springframework.org/schema/context 13 http://www.springframework.org/schema/context/spring-context.xsd 14 http://www.springframework.org/schema/tx 15 http://www.springframework.org/schema/tx/spring-tx.xsd"> 16 17 <!-- 配置DataSource 18 这里使用的是apache的dbcp连接池 19 需要引入apache的dbcp连接池jarbao 20 commons-dbcp2-2.1.1.jar 和 commons-pool2-2.4.2.jar 21 --> 22 <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close"> 23 <property name="driverClassName" value="${jdbc.driverClassName}"/> 24 <property name="url" value="${jdbc.url}"/> 25 <property name="username" value="${jdbc.username}"/> 26 <property name="password" value="${jdbc.password}"/> 27 </bean> 28 29 <context:property-placeholder location="jdbc.properties"/> 30 31 <bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate"> 32 <constructor-arg ref="dataSource"></constructor-arg> 33 </bean> 34 <bean id="moneyDao" class="com.fuwh.dao.impl.MoneyDaoImpl"> 35 <property name="namedParameterJdbcTemplate" ref="namedParameterJdbcTemplate"></property> 36 </bean> 37 <bean id="moneyService" class="com.fuwh.Service.impl.MoneyServiceImpl"> 38 <property name="moneyDao" ref="moneyDao"></property> 39 </bean> 40 41 <!-- 声明所有的方法都使用默认的事务定义 --> 42 <tx:advice id="txAdvice" transaction-manager="txManager"> 43 <tx:attributes> 44 <tx:method name="*"/> 45 </tx:attributes> 46 </tx:advice> 47 48 <aop:config> 49 <aop:pointcut id="txPoint" expression="execution(* com.fuwh.Service.*.*(..))" /> 50 <aop:advisor advice-ref="txAdvice" pointcut-ref="txPoint"/> 51 </aop:config> 52 53 <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 54 <property name="dataSource" ref="dataSource"></property> 55 </bean> 56 57 </beans>
#jdbc连接配置属性文件 jdbc.driverClassName=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/db_spring jdbc.username=root jdbc.password=mysqladmin
5、编程式事务管理
在spring中提供了两种方式来实现编程式事务管理
|-使用TransactionTemplate(推荐使用)
|-使用PlatformTransaxtionManager实现
具体实现实例：
1 package com.fuwh.Service.impl; 2 3 import com.fuwh.dao.MoneyDao; 4 5 import org.springframework.transaction.TransactionStatus; 6 import org.springframework.transaction.support.TransactionCallbackWithoutResult; 7 import org.springframework.transaction.support.TransactionTemplate; 8 9 import com.fuwh.Service.MoneyService; 10 11 //转账服务类的具体实现 12 public class MoneyServiceImpl implements MoneyService { 13 14 private TransactionTemplate transactionTemplate; 15 16 public void setTransactionTemplate(TransactionTemplate transactionTemplate) { 17 this.transactionTemplate = transactionTemplate; 18 } 19 20 private MoneyDao moneyDao; 21 22 public void setMoneyDao(MoneyDao moneyDao) { 23 this.moneyDao = moneyDao; 24 } 25 26 @Override 27 public void transferMoney(final int money, final int inId, final int outId) { 28 // TODO Auto-generated method stub 29 transactionTemplate.execute(new TransactionCallbackWithoutResult() { 30 31 @Override 32 protected void doInTransactionWithoutResult(TransactionStatus status) { 33 // TODO Auto-generated method stub 34 moneyDao.outMoney(money, outId); 35 moneyDao.inMoney(money, inId); 36 } 37 }); 38 } 39 40 }
<?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:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" 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/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> <!-- 配置DataSource 这里使用的是apache的dbcp连接池 需要引入apache的dbcp连接池jarbao commons-dbcp2-2.1.1.jar 和 commons-pool2-2.4.2.jar --> <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close"> <property name="driverClassName" value="${jdbc.driverClassName}"/> <property name="url" value="${jdbc.url}"/> <property name="username" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> </bean> <context:property-placeholder location="jdbc.properties"/> <bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate"> <constructor-arg ref="dataSource"></constructor-arg> </bean> <bean id="moneyDao" class="com.fuwh.dao.impl.MoneyDaoImpl"> <property name="namedParameterJdbcTemplate" ref="namedParameterJdbcTemplate"></property> </bean> <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate"> <property name="transactionManager" ref="txManager"></property> </bean> <bean id="moneyService" class="com.fuwh.Service.impl.MoneyServiceImpl"> <property name="moneyDao" ref="moneyDao"></property> <property name="transactionTemplate" ref="transactionTemplate"></property> </bean> <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource"></property> </bean> </beans>
6、<tx:advice>配置详解
默认的<tx:advice>是：
传播(propagation)：REQUIRED
隔离(Isolation)：DEFAULT
事务(Transaction)：read/write
持久性(timeout):默认的timeout是底层的事务系统
例如：
<tx:advice id="txAdvice" transaction-manager="txManager" > <tx:attributes> <tx:method name="*" /> </tx:attributes> </tx:advice>
在<tx:method>标签中，可以加入以下的配置来更改默认的设置
| 属性 | 必须? | 默认 | 描述 |
| name | 必须 | 匹配的方法，*:所有的方法,get*：以get开头的方法等等 | |
| propagation | 非必须 | REQUIRED | 食物传播行为 |
| isolation | 非必须 | DEFAULT | 事务隔离等级 |
| timeout | 非必须 | -1 | timeout的时间(秒单位) |
| read-only | 非必须 | false | 是否只读 |
| rollback-for | 非必须 | rollback的时候执行的方法 | |
| no-rollback-for | 非必须 | 没有触发rollback的时候执行的方法 |