使用spring管理事务

使用spring管理事务有三种方式：编程式，声明式，注解。

Spring提供两种方式的编程式事务管理
使用TransactionTemplate

直接使用一个PlatformTransactionManager
实现

我们通常推荐使用第一种方式。

使用TransactionTemplate

TransactionTemplate
采用和其他Spring*模板 *，如JdbcTemplate
和 HibernateTemplate
，一样的方法。它使用回调方法，把应用 程序代码从处理取得和释放资源中解脱出来（不再有try/catch/finally）。如同 其他模板，TransactionTemplate
是线程安全的。

必须在事务上下文中执行的应用代码看起来像这样，注意使用 TransactionCallback
可以返回一个值：
Object result = tt.execute(new TransactionCallback() { public Object doInTransaction(TransactionStatus status){ updateOperation1(); return resultOfUpdateOperation2(); } });
如果没有返回值，使用TransactionCallbackWithoutResult
， 如下：
tt.execute(new TransactionCallbackWithoutResult() { protected void doInTransactionWithoutResult(TransactionStatus status) { updateOperation1(); updateOperation2(); } });
回调中的代码可以调用TransactionStatus
对象的 setRollbackOnly()
方法来回滚事务。

想要使用TransactionTemplate
的应用类必须能访问一 个PlatformTransactionManager
：通常通过一个JavaBean属 性或构造函数参数暴露出来。

使用PlatformTransactionManager

你也可以使用 org.springframework.transaction.PlatformTransactionManager
直接管理事务。简单地通过一个bean引用给你的bean传递一个你使用的 PlatformTransactionManager
实现。然后， 使用TransactionDefinition
和 TransactionStatus
对象就可以发起事务，回滚和提交。
DefaultTransactionDefinition def = new DefaultTransactionDefinition() ;def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED); TransactionStatus status = transactionManager.getTransactionDefinition(def); try { // execute your business logic here } catch (MyException ex) { transactionManager.rollback(status); throw ex; } transactionManager.commit(status);

使用注解实现事务

启用事务注解
<tx:annotation-driven transaction-manager="defaultTransactionManager"/>

在接口或类的声明处 ,写一个@Transactional.要是只在接口上写, 接口的实现类就会继承下来、接口的实现类的具体方法,可以覆盖类声明处的设置@Transactional //类级的注解、适用于类中所有的public的方法
当标于类前时, 标示类中所有方法都进行事物处理 , 例子:
@Transactional
public class TestServiceBean implements TestService {
}

事物传播行为介绍:
@Transactional(propagation=Propagation.REQUIRED) 如果有事务, 那么加入事务, 没有的话新建一个(默认情况下)

@Transactional(propagation=Propagation.NOT_SUPPORTED) 容器不为这个方法开启事务

@Transactional(propagation=Propagation.REQUIRES_NEW) 不管是否存在事务,都创建一个新的事务,原来的挂起,新的执行完毕,继续执行老的事务

@Transactional(propagation=Propagation.MANDATORY) 必须在一个已有的事务中执行,否则抛出异常

@Transactional(propagation=Propagation.NEVER) 必须在一个没有的事务中执行,否则抛出异常(与Propagation.MANDATORY相反)

@Transactional(propagation=Propagation.SUPPORTS) 如果其他bean调用这个方法,在其他bean中声明事务,那就用事务.如果其他bean没有声明事务,那就不用事务.

事物超时设置:
@Transactional(timeout=30) //默认是30秒

事务隔离级别:
@Transactional(isolation = Isolation.READ_UNCOMMITTED)
读取未提交数据(会出现脏读, 不可重复读) 基本不使用

@Transactional(isolation = Isolation.READ_COMMITTED)读取已提交数据(会出现不可重复读和幻读)

@Transactional(isolation = Isolation.REPEATABLE_READ)可重复读(会出现幻读)

@Transactional(isolation = Isolation.SERIALIZABLE)串行化

声明式事务管理

Spring也提供了声明式事务管理。这是通过Spring AOP实现的。
大多数Spring用户选择声明式事务管理。这是最少影响应用代码的选择， 因而这是和非侵入性的轻量级容器的观念是一致的。

Spring可以使声明式事务管理应用到普通Java对象。

Spring提供声明式回滚规则。

Spring允许你通过AOP定制事务行为。例如，如果需要，你可以在事务 回滚中插入定制的行为。你也可以增加任意的通知，就象事务通知一样。

回滚规则的概念是很重要的：它们使得我们可以指定哪些异常应该发起自 动回滚。我们在配置文件中，以声明的方式指定。因此，虽然我们仍 然可以编程调用TransactionStatus
对象的 setRollbackOnly()
方法来回滚当前事务，多数时候我们可以 指定规则，如MyApplicationException
应该导致回滚。 这有显著的优点，业务对象不需要依赖事务基础设施。例如，它们通常不需要引 入任何Spring API，事务或其他任何东西。

声明式事务基于AOP实现，因此我们需要引入aop空间，为简化事务配置，我们使用tx标签配置。

已使用hibernate为例，一个声明式事务的配置通常如下：

<?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-4.xsd             http://www.springframework.org/schema/context             http://www.springframework.org/schema/context/spring-context-4.xsd             http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.xsd             http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.xsd">  
  <context:component-scan base-package="spring4"/>  
  <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> 
    <property name="configLocation" value="classpath:hibernate.cfg.xml"/>  
    <property name="configurationClass" value="org.hibernate.cfg.AnnotationConfiguration"/> 
  </bean>  
  <!-- 定义事务管理器（声明式的事务） -->  
  <bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> 
    <property name="sessionFactory" ref="sessionFactory"/> 
  </bean>  
  <tx:advice id="txAdvice" transaction-manager="transactionManager"> 
    <tx:attributes> 
      <tx:method name="*" propagation="REQUIRED"/> 
    </tx:attributes> 
  </tx:advice>  
  <aop:config> 
    <aop:pointcut id="interceptorPointCuts" expression="execution(* spring4.*.*(..))"/>  
    <aop:advisor advice-ref="txAdvice" pointcut-ref="interceptorPointCuts"/> 
  </aop:config> 
</beans>

上面的aop拦截所有spring4包中的所有类的所有方法并自动管理这些方法的事务。
其中可以定义多个<tx:method name="*" propagation="REQUIRED" />
用于定义某些方法的事务属性。