开始之前
关于本教程
本教程将深入讲解Spring 简单而强大的事务管理功能，包括编程式事务和声明式事务。通过对本教程的学习，您将能够理解Spring 事务管理的本质，并灵活运用之。
先决条件
本教程假定您已经掌握了Java 基础知识，并对Spring 有一定了解。您还需要具备基本的事务管理的知识，比如：事务的定义，隔离级别的概念，等等。
本文将直接使用这些概念而不做详细解释。另外，您最好掌握数据库的基础知识，虽然这不是必须。
系统需求
要试验这份教程中的工具和示例，硬件配置需求为：至少带有512MB 内存（推荐1GB）的系统。需要安装以下软件：
?Sun JDK 或更新版本或IBM Developer Kit for the Java 5 platform 版本。?Spring framework 。本教程附带的示例代码已经在Spring 上测试过。?MySQL 或更新版本。
?
Spring 事务属性分析
事务管理对于企业应用而言至关重要。它保证了用户的每一次操作都是可靠的，即便出现了异常的访问情况，也不至于破坏后台数据的完整性。就像银行的自助取款机，通常都能正常为客户服务，但是也难免遇到操作过程中机器突然出故障的情况，此时，事务就必须确保出故障前对账户的操作不生效，就像用户刚才完全没有使用过取款机一样，以保证用户和银行的利益都不受损失。
在Spring 中，事务是通过TransactionDefinition 接口来定义的。该接口包含与事务属性有关的方法。具体如清单1所示：
清单1. TransactionDefinition 接口中定义的主要方法
public interface TransactionDefinition{
int getIsolationLevel();
int getPropagationBehavior();
int getTimeout();
boolean isReadOnly();
}
也许你会奇怪，为什么接口只提供了获取属性的方法，而没有提供相关设置属性的方法。其实道理很简单，事务属性的设置完全是程序员控制的，因此程序员可以自定义任何设置属性的方法，而且保存属性的字段也没有任何要求。唯一的要求的是，Spring 进行事务操作的时候，通过调用以上接口提供的方法必须能够返回事务相关的属性取值。
事务隔离级别
隔离级别是指若干个并发的事务之间的隔离程度。TransactionDefinition 接口中定义了五个表示隔离级别的常量：
?：这是默认值，表示使用底层数据库的默认隔离级别。对大部分数据库而言，通常这值就是。
?
?：该隔离级别表示一个事务可以读取另一个事务修改但还没有提交的数据。该级别不能防止脏读和不可重复读，因此很少使用该隔离级别。
?
?：该隔离级别表示一个事务只能读取另一个事务已经提交的数据。该级别可以防止脏读，这也是大多数情况下的推荐值。
?
?：该隔离级别表示一个事务在整个过程中可以多次重复执行某个查询，并且每次返回的记录都相同。即使在多次查询之间有新增的数据满足该查询，这些新增的记录也会被忽略。该级别可以防止脏读和不可重复读。
?
?：所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别。
?
事务传播行为
所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。在
TransactionDefinition定义中包括了如下几个表示传播行为的常量：
?：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。
?
?：创建一个新的事务，如果当前存在事务，则把当前事务挂起。
?
?：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
?
?：以非事务方式运行，如果当前存在事务，则把当前事务挂起。
?
?：以非事务方式运行，如果当前存在事务，则抛出异常。
?
?：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。
?
?：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于。
这里需要指出的是，前面的六种事务传播行为是Spring 从EJB 中引入的，他们共享相同的概念。而PROPAGATION_NESTED是Spring 所特有的。以PROPAGATION_NESTED 启动的事务内嵌于外部事务中（如果存在外部事务的话），此时，内嵌事务并不是一个独立的事务，它依赖于外部事务的存在，只有通过外部的事务提交，才能引起内部事务的提交，嵌套的子事务不能单独提交。如果熟悉JDBC 中的保存点（SavePoint）的概念，那嵌套事务就很容易理解了，其实嵌套的子事务就是保存点的一个应用，一个事务中可以包括多个保存点，每一个嵌套子事务。另外，外部事务的回滚也会导致嵌套子事务的回滚。
事务超时
所谓事务超时，就是指一个事务所允许执行的最长时间，如果超过该时间限制但事务还没有完成，则自动回滚事务。在TransactionDefinition 中以int 的值来表示超时时间，其单位是秒。
事务的只读属性
事务的只读属性是指，对事务性资源进行只读操作或者是读写操作。所谓事务性资源就是指那些被事务管理的资源，比如数据源、JMS 资源，以及自定义的事务性资源等等。如果确定只对事务性资源进行只读操作，那么我们可以将事务标志为只读的，以提高事务处理的性能。在TransactionDefinition 中以boolean 类型来表示该事务是否只读。
事务的回滚规则
通常情况下，如果在事务中抛出了未检查异常（继承自RuntimeException 的异常），则默认将回滚事务。如果没有抛出任何异常，或者抛出了已检查异常，则仍然提交事务。这通常也是大多数开发者希望的处理方式，也是EJB 中的默认处理方式。但是，我们可以根据需要人为控制事务在抛出某些未检查异常时任然提交事务，或者在抛出某些已检查异常时回滚事务。
Spring 事务管理API 分析
Spring 框架中，涉及到事务管理的API 大约有100个左右，其中最重要的有三个：TransactionDefinition、PlatformTransactionManager、TransactionStatus。所谓事务管理，其实就是“按照给定的事务规则来执行提交或者回滚操作”。“给定的事务规则”就是用TransactionDefinition 表示的，“按照……来执行提交或者回滚操作”便是用PlatformTransactionManager 来表示，而TransactionStatus 用于表示一个运行着的事务的状态。打一个不恰当的比喻，TransactionDefinition 与TransactionStatus 的关系就像程序和进程的关系。
TransactionDef...
该接口在前面已经介绍过，它用于定义一个事务。它包含了事务的静态属性，比如：事务传播行为、超时时间等等。Spring 为我们提供了一个默认的实现类：DefaultTransactionDefinition，该类适用于大多数情况。如果该类不能满足需求，可以通过实现TransactionDefinition 接口来实现自己的事务定义。
PlatformTrans...
PlatformTransactionManager 用于执行具体的事务操作。接口定义如清单2所示：
清单2. PlatformTransactionManager 接口中定义的主要方法
Public interface PlatformTransactionManager{
?TransactionStatus getTransaction(TransactionDefinition definition) ? throws TransactionException;
? void commit(TransactionStatus status)throws TransactionException;
? void rollback(TransactionStatus status)throws
TransactionException;
}
根据底层所使用的不同的持久化API 或框架，PlatformTransactionManager 的主要实现类大致如下：
?DataSourceTransactionManager：适用于使用JDBC和iBatis进行数据持久化操作的情况。
?
?HibernateTransactionManager：适用于使用Hibernate进行数据持久化操作的情况。
?
?JpaTransactionManager：适用于使用JPA进行数据持久化操作的情况。
?
?另外还有JtaTransactionManager 、JdoTransactionManager、JmsTransactionManager等等。
如果我们使用JTA进行事务管理，我们可以通过JNDI 和Spring 的
JtaTransactionManager 来获取一个容器管理的DataSource。
JtaTransactionManager 不需要知道DataSource 和其他特定的资源，因为它将使用容器提供的全局事务管理。而对于其他事务管理器，比如
DataSourceTransactionManager，在定义时需要提供底层的数据源作为其属性，也就是DataSource。与HibernateTransactionManager 对应的是
SessionFactory，与JpaTransactionManager 对应的是
EntityManagerFactory 等等。
TransactionStatus
(…) 方法返回一个TransactionStatus 对象。返回的TransactionStatus 对象可能代表一个新的或已经存在的事务（如果在当前调用堆栈有一个符合条件的事务）。TransactionStatus 接口提供了一个简单的控制事务执行和查询事务状态的方法。该接口定义如清单3所示：
清单3. TransactionStatus 接口中定义的主要方法
public ?interface TransactionStatus{
? boolean isNewTransaction();
? void setRollbackOnly();
? boolean isRollbackOnly();
}
编程式事务管理
Spring 的编程式事务管理概述
在Spring 出现以前，编程式事务管理对基于POJO 的应用来说是唯一选择。用过Hibernate 的人都知道，我们需要在代码中显式调用beginTransaction()、commit()、rollback()等事务管理相关的方法，这就是编程式事务管理。通过Spring 提供的事务管理API，我们可以在代码中灵活控制事务的执行。在底层，Spring 仍然将事务操作委托给底层的持久化框架来执行。
基于底层API 的编程式事务管理
根据PlatformTransactionManager、TransactionDefinition 和TransactionStatus 三个核心接口，我们完全可以通过编程的方式来进行事务管理。示例代码如清单4所示：
清单4. 基于底层API 的事务管理示例代码
public class BankServiceImpl implements BankService {
private BankDao bankDao;
private TransactionDefinition txDefinition;
private PlatformTransactionManager txManager;
......
public boolean transfer(Long fromId， Long toId， double amount) { TransactionStatus txStatus = (txDefinition);
boolean result = false;
try {
result = (fromId， toId， amount);
(txStatus);
} catch (Exception e) {
result = false;
(txStatus);
"Transfer Error!");
}
return result;
}
}
相应的配置文件如清单5所示：
清单5. 基于底层API的事务管理示例配置文件
value="PROPAGATION_REQUIRED"/>
如上所示，我们在类中增加了两个属性：一个是TransactionDefinition 类型的属性，它用于定义一个事务；另一个是PlatformTransactionManager 类型的属性，用于执行事务管理操作。
如果方法需要实施事务管理，我们首先需要在方法开始执行前启动一个事务，调用(...) 方法便可启动一个事务。创建并启动了事务之后，便可以开始编写业务逻辑代码，然后在适当的地方执行事务的提交或者回滚。
基于TransactionTemplate 的编程式事务管理
通过前面的示例可以发现，这种事务管理方式很容易理解，但令人头疼的是，事务管理的代码散落在业务逻辑代码中，破坏了原有代码的条理性，并且每一个业务方法都包含了类似的启动事务、提交/回滚事务的样板代码。幸好，Spring 也意识到了这些，并提供了简化的方法，这就是Spring 在数据访问层非常常见的模板回调模式。如清单6所示：
清单6. 基于TransactionTemplate 的事务管理示例代码
public class BankServiceImpl implements BankService {
private BankDao bankDao;
private TransactionTemplate transactionTemplate;
......
public boolean transfer(final Long fromId， final Long toId， final double amount) {
return (Boolean) (new TransactionCallback(){
public Object doInTransaction(TransactionStatus status) {
Object result;
try {
result = (fromId， toId， amount);
} catch (Exception e) {
();
result = false;
"Transfer Error!");
}
return result;
}
});
}
}
相应的XML配置如下：
清单7. 基于TransactionTemplate 的事务管理示例配置文件
class="">
TransactionTemplate 的execute() 方法有一个TransactionCallback 类型的参数，该接口中定义了一个doInTransaction() 方法，通常我们以匿名内部类的方式实现TransactionCallback 接口，并在其doInTransaction() 方法中书写业务逻辑代码。这里可以使用默认的事务提交和回滚规则，这样在业务代码中就不需要显式调用任何事务管理的API。doInTransaction() 方法有一个TransactionStatus 类型的参数，我们可以在方法的任何位置调用该参数的setRollbackOnly() 方法将事务标识为回滚的，以执行事务回滚。
根据默认规则，如果在执行回调方法的过程中抛出了未检查异常，或者显式调用了() 方法，则回滚事务；如果事务执行完成或者抛出了checked 类型的异常，则提交事务。
TransactionCallback 接口有一个子接口TransactionCallbackWithoutResult，该接口中定义了一个doInTransactionWithoutResult() 方法，TransactionCallbackWithoutResult 接口主要用于事务过程中不需要返回值的情况。当然，对于不需要返回值的情况，我们仍然可以使用TransactionCallback 接口，并在方法中返回任意值即可。
声明式事务管理
Spring 的声明式事务管理概述
Spring 的声明式事务管理在底层是建立在AOP 的基础之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。
声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明（或通过等价的基于标注的方式），便可以将事务规则应用到业务逻辑中。因为事务管理本身就是一个典型的横切逻辑，正是AOP 的用武之地。Spring 开发团队也意识到了这一点，为声明式事务提供了简单而强大的支持。
声明式事务管理曾经是EJB 引以为傲的一个亮点，如今Spring 让POJO 在事务管理方面也拥有了和EJB 一样的待遇，让开发人员在EJB 容器之外也用上了强大的声明式事务管理功能，这主要得益于Spring 依赖注入容器和Spring AOP 的支持。依赖注入容器为声明式事务管理提供了基础设施，使得Bean 对于Spring 框架而言是可管理的；而Spring AOP 则是声明式事务管理的直接实现者，这一点通过清单8可以看出来。
通常情况下，笔者强烈建议在开发中使用声明式事务，不仅因为其简单，更主要是因为这样使得纯业务代码不被污染，极大方便后期的代码维护。
和编程式事务相比，声明式事务唯一不足地方是，后者的最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。但是即便有这样的需求，也存在很多变通的方法，比如，可以将需要进行事务管理的代码块独立为方法等等。
下面就来看看Spring 为我们提供的声明式事务管理功能。
基于TransactionInter... 的声明式事务管理
最初，Spring 提供了TransactionInterceptor 类来实施声明式事务管理功能。先看清单8的配置文件：
清单8. 基于TransactionInterceptor 的事务管理示例配置文件
......
class="">
class="">
class="">
......
首先，我们配置了一个TransactionInterceptor 来定义相关的事务规则，他有两个主要的属性：一个是transactionManager，用来指定一个事务管理器，并将具体事务相关的操作委托给它；另一个是Properties 类型的
transactionAttributes 属性，它主要用来定义事务规则，该属性的每一个键值对中，键指定的是方法名，方法名可以使用通配符，而值就表示相应方法的所应用的事务属性。
指定事务属性的取值有较复杂的规则，这在Spring 中算得上是一件让人头疼的事。具体的书写规则如下：
传播行为 [，隔离级别] [，只读属性] [，超时属性] [不影响提交的异常] [，导致回滚的异常]
?传播行为是唯一必须设置的属性，其他都可以忽略，Spring为我们提供了合理的默认值。
?
?传播行为的取值必须以“PROPAGATION_”开头，具体包括：
PROPAGATION_MANDATORY、PROPAGATION_NESTED、
PROPAGATION_NEVER、PROPAGATION_NOT_SUPPORTED、
PROPAGATION_REQUIRED、PROPAGATION_REQUIRES_NEW、
PROPAGATION_SUPPORTS，共七种取值。
?
?隔离级别的取值必须以“ISOLATION_”开头，具体包括：
ISOLATION_DEFAULT、ISOLATION_READ_COMMITTED、
ISOLATION_READ_UNCOMMITTED、ISOLATION_REPEATABLE_READ、ISOLATION_SERIALIZABLE，共五种取值。
?
?如果事务是只读的，那么我们可以指定只读属性，使用“readOnly”指定。否则我们不需要设置该属性。
?
?超时属性的取值必须以“TIMEOUT_”开头，后面跟一个int类型的值，表示超时时间，单位是秒。
?
?不影响提交的异常是指，即使事务中抛出了这些类型的异常，事务任然正常提交。必须在每一个异常的名字前面加上“+”。异常的名字可以是类名的一部分。
比如“+RuntimeException”、“+tion”等等。
?
?导致回滚的异常是指，当事务中抛出这些类型的异常时，事务将回滚。必须在每一个异常的名字前面加上“-”。异常的名字可以是类名的全部或者部分，比如“-RuntimeException”、“-tion”等等。
以下是两个示例：
PROPAGATION_REQUIRED，ISOLATION_READ_COMMITTED，TIMEOUT_20，
+AbcException，+DefException，-HijException
以上表达式表示，针对所有方法名以Service 结尾的方法，使用
PROPAGATION_REQUIRED 事务传播行为，事务的隔离级别是
ISOLATION_READ_COMMITTED，超时时间为20秒，当事务抛出
AbcException 或者DefException 类型的异常，则仍然提交，当抛出
HijException 类型的异常时必须回滚事务。这里没有指定"readOnly"，表示事务不是只读的。
以上表达式表示，针对所有方法名为test 的方法，使用
PROPAGATION_REQUIRED 事务传播行为，并且该事务是只读的。除此之外，其他的属性均使用默认值。比如，隔离级别和超时时间使用底层事务性资源的默认值，并且当发生未检查异常，则回滚事务，发生已检查异常则仍提交事务。
配置好了TransactionInterceptor，我们还需要配置一个ProxyFactoryBean 来组装target 和advice。这也是典型的Spring AOP 的做法。通过
ProxyFactoryBean 生成的代理类就是织入了事务管理逻辑后的目标类。至此，声明式事务管理就算是实现了。我们没有对业务代码进行任何操作，所有设置均在配置文件中完成，这就是声明式事务的最大优点。
基于TransactionProxy... 的声明式事务管理
前面的声明式事务虽然好，但是却存在一个非常恼人的问题：配置文件太多。我们必须针对每一个目标对象配置一个ProxyFactoryBean；另外，虽然可以通过父子Bean 的方式来复用TransactionInterceptor 的配置，但是实际的复用几率也不高；这样，加上目标对象本身，每一个业务类可能需要对应三个
为了缓解这个问题，Spring 为我们提供了TransactionProxyFactoryBean，用于将TransactionInterceptor 和ProxyFactoryBean 的配置合二为一。如清单9所示：
清单9. 基于TransactionProxyFactoryBean 的事务管理示例配置文件
......
class="">
class="">
......
如此一来，配置文件与先前相比简化了很多。我们把这种配置方式称为Spring 经典的声明式事务管理。相信在早期使用Spring 的开发人员对这种配置声明式事务的方式一定非常熟悉。
但是，显式为每一个业务类配置一个TransactionProxyFactoryBean 的做法将使得代码显得过于刻板，为此我们可以使用自动创建代理的方式来将其简化，使用自动创建代理是纯AOP 知识，请读者参考相关文档，不在此赘述。
基于
前面两种声明式事务配置方式奠定了Spring 声明式事务管理的基石。在此基础上，Spring 引入了
如清单10所示：
清单10. 基于
......
class="">
......
如果默认的事务属性就能满足要求，那么代码简化为如清单11 所示：
清单11. 简化后的基于
......
class="">
expression="execution(**.transfer(..))"/> ...... 由于使用了切点表达式，我们就不需要针对每一个业务类创建一个代理对象了。另外，如果配置的事务管理器Bean 的名字取值为“transactionManager”，则我们可以省略 基于@Transactional 的声明式事务管理 除了基于命名空间的事务配置方式，Spring 还引入了基于Annotation 的方式，具体主要涉及@Transactional 标注。@Transactional 可以作用于接口、接口方法、类以及类方法上。当作用于类上时，该类的所有public 方法将都具有该类型的事务属性，同时，我们也可以在方法级别使用该标注来覆盖类级别的定义。如清单12所示： 清单12. 基于@Transactional 的事务管理示例配置文件 @Transactional(propagation = public boolean transfer(Long fromId， Long toId， double amount) { return (fromId， toId， amount); } Spring 使用BeanPostProcessor 来处理Bean 中的标注，因此我们需要在配置文件中作如下声明来激活该后处理Bean，如清单13所示： 清单13. 启用后处理Bean的配置 与前面相似，transaction-manager 属性的默认值是transactionManager，如果事务管理器Bean 的名字即为该值，则可以省略该属性。 虽然@Transactional 注解可以作用于接口、接口方法、类以及类方法上，但是Spring 小组建议不要在接口或者接口方法上使用该注解，因为这只有在使用基于接口的代理时它才会生效。另外，@Transactional 注解应该只被应用 到public 方法上，这是由Spring AOP 的本质决定的。如果你在protected、private 或者默认可见性的方法上使用@Transactional 注解，这将被忽略，也不会抛出任何异常。 基于 另一方面，基于@Transactional 的方式使用起来非常简单明了，没有学习成本。开发人员可以根据需要，任选其中一种使用，甚至也可以根据需要混合使用这两种方式。 如果不是对遗留代码进行维护，则不建议再使用基于TransactionInterceptor 以及基于TransactionProxyFactoryBean 的声明式事务管理方式，但是，学习这两种方式非常有利于对底层实现的理解。 虽然上面共列举了四种声明式事务管理方式，但是这样的划分只是为了便于理解，其实后台的实现方式是一样的，只是用户使用的方式不同而已。 结束语 本教程的知识点大致总结如下： ?基于TransactionDefinition、PlatformTransactionManager、 TransactionStatus 编程式事务管理是Spring 提供的最原始的方式，通常我们不会这么写，但是了解这种方式对理解Spring 事务管理的本质有很大作用。? ?基于TransactionTemplate 的编程式事务管理是对上一种方式的封装，使得编码更简单、清晰。 ? ?基于TransactionInterceptor 的声明式事务是Spring 声明式事务的基础，通常也不建议使用这种方式，但是与前面一样，了解这种方式对理解Spring 声明式事务有很大作用。 ? ?基于TransactionProxyFactoryBean 的声明式事务是上中方式的改进版本，简化的配置文件的书写，这是Spring 早期推荐的声明式事务管理方式，但是在Spring 中已经不推荐了。 ? ?基于 ? ?基于@Transactional 的方式将声明式事务管理简化到了极致。开发人员只需在配置文件中加上一行启用相关后处理Bean 的配置，然后在需要实施事务管理的方法或者类上使用@Transactional 指定事务规则即可实现事务管理，而且功能也不必其他方式逊色。 spring使用基于注解的AOP事务管理 16.6 AOP事务管理 AOP事务管理利用了Spring AOP的基础设施，在大多数情况下，Spring AOP会创建一个JDK代理以拦截方法调用。你可以使用装载时编织以在装载期编织切面，这样就不需要代理了（如果你记不清什么是装载时编织，请参看第6章）。你有两种方式来配置Spring AOP 事务管理，基于注解的配置以及XML配置。 16.6.1 使用基于注解的AOP事务管理 你可以借助于AOP的自动代理，通过注解将事务性行为引入到现有的bean中。让我们以代码清单16-21开始吧，它展示了类DeclarativeTxBankService。 代码清单16-21 DeclarativeTxBankService实现 请注意@Transactional属性，为了让Spring的事务管理基础设施可以利用该属性创建恰当的切入点和通知，我们需要使用AOP的自动代理和注解驱动的事务支持。代码清单16-22展示了与该注解相对应的XML配置。 代码清单16-22 基于注解的事务管理的配置文件 该XML配置文件展示了标准的bankService bean声明，紧跟其后的是 Spring分布式事务实现 分布式事务是指操作多个数据库之间的事务，spring的org.springframework.transaction.jta.JtaTransactionManager，提供了分布式事务支持。如果使用WAS的JTA支持，把它的属性改为WebSphere对应的TransactionManager。 在tomcat下，是没有分布式事务的，不过可以借助于第三方软件jotm（Java Open Transaction Manager ）和AtomikosTransactionsEssentials实现，在spring中分布式事务是通过jta（jotm，atomikos）来进行实现。 1、https://www.doczj.com/doc/1d17719599.html,/ 2、https://www.doczj.com/doc/1d17719599.html,/Main/TransactionsEssentials 一、使用JOTM例子 (1) Dao及实现 GenericDao接口： ? 1 2 3 4 public interface GenericDao { public int save(String ds, String sql, Object[] obj) throws Exception; public intfindRowCount(String ds, String sql); } GenericDaoImpl实现：? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 public class GenericDaoImpl implements GenericDao{ private JdbcTemplatejdbcTemplateA; private JdbcTemplatejdbcTemplateB; public void setJdbcTemplateA(JdbcTemplatejdbcTemplate) { this.jdbcTemplateA = jdbcTemplate; } public void setJdbcTemplateB(JdbcTemplatejdbcTemplate) { this.jdbcTemplateB = jdbcTemplate; } public int save(String ds, String sql, Object[] obj) throws Exception{ if(null == ds || "".equals(ds)) return -1; try{ if(ds.equals("A")){ return this.jdbcTemplateA.update(sql, obj); }else{ return this.jdbcTemplateB.update(sql, obj); } }catch(Exception e){ e.printStackTrace(); throw new Exception("执行" + ds + "数据库时失败！"); } } public intfindRowCount(String ds, String sql) { 开始之前 关于本教程 本教程将深入讲解Spring 简单而强大的事务管理功能，包括编程式事务和声明式事务。通过对本教程的学习，您将能够理解Spring 事务管理的本质，并灵活运用之。 先决条件 本教程假定您已经掌握了Java 基础知识，并对Spring 有一定了解。您还需要具备基本的事务管理的知识，比如：事务的定义，隔离级别的概念，等等。 本文将直接使用这些概念而不做详细解释。另外，您最好掌握数据库的基础知识，虽然这不是必须。 系统需求 要试验这份教程中的工具和示例，硬件配置需求为：至少带有512MB 内存（推荐1GB）的系统。需要安装以下软件： ?Sun JDK 或更新版本或IBM Developer Kit for the Java 5 platform 版本。?Spring framework 。本教程附带的示例代码已经在Spring 上测试过。?MySQL 或更新版本。 ? Spring 事务属性分析 事务管理对于企业应用而言至关重要。它保证了用户的每一次操作都是可靠的，即便出现了异常的访问情况，也不至于破坏后台数据的完整性。就像银行的自助取款机，通常都能正常为客户服务，但是也难免遇到操作过程中机器突然出故障的情况，此时，事务就必须确保出故障前对账户的操作不生效，就像用户刚才完全没有使用过取款机一样，以保证用户和银行的利益都不受损失。 在Spring 中，事务是通过TransactionDefinition 接口来定义的。该接口包含与事务属性有关的方法。具体如清单1所示： 清单1. TransactionDefinition 接口中定义的主要方法 public interface TransactionDefinition{ int getIsolationLevel(); int getPropagationBehavior(); int getTimeout(); boolean isReadOnly(); spring的@Transactional注解详细用法 各位读友大家好！你有你的木棉，我有我的文章，为了你的木棉，应读我的文章！若为比翼双飞鸟，定是人间有情人！若读此篇优秀文，必成天上比翼鸟！ spring的@Transactional注解详细用法Spring Framework对事务管理提供了一致的抽象，其特点如下：为不同的事务API 提供一致的编程模型，比如JTA(Java Transaction API), JDBC, Hibernate, JPA(Java Persistence API和JDO(Java Data Objects)支持声明式事务管理，特别是基于注解的声明式事务管理，简单易用提供比其他事务API如JTA更简单的编程式事务管理API与spring数据访问抽象的完美集成事务管理方式spring支持编程式事务管理和声明式事务管理两种方式。编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。声明式事务管理建立在AOP之上的。其本质是对方法前后进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明(或通过基于@Transactional注解的方式)，便可以将事务规则应用到业务逻辑中。显然声明式事务管理要优于编程式事务管理，这正是spring Spring事务原理 统观spring事务，围绕着两个核心PlatformTransactionManager和TransactionStatus spring提供了几个关于事务处理的类： TransactionDefinition //事务属性定义 TranscationStatus //代表了当前的事务，可以提交，回滚。 PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。 一般事务定义步骤： TransactionDefinition td = new TransactionDefinition(); TransactionStatus ts = transactionManager.getTransaction(td); try { //do sth https://www.doczj.com/doc/1d17719599.html,mit(ts); } catch(Exception e){transactionManager.rollback(ts);} spring提供的事务管理可以分为两类：编程式的和声明式的。编程式的，比较灵活，但是代码量大，存在重复的代码比较多；声明式的比编程式的更灵活。 编程式主要使用transactionTemplate。省略了部分的提交，回滚，一系列的事务对象定义，需注入事务管理对象. void add() { transactionTemplate.execute( new TransactionCallback(){ pulic Object doInTransaction(TransactionStatus ts) { //do sth} } } 声明式： 使用TransactionProxyFactoryBean: 浅析Spring提供的事务管理方法 Spring提供的事务管理可以分为两类：编程式的和声明式的。编程式的，比较灵活，但是代码量大，存在重复的代码比较多；而声明式的比编程式的更灵活方便。本文将讨论这两种事务管理的区别。 传统的JDBC事务管理 以往使用JDBC进行数据操作时，一般采用DataSource,从数据源中得到Connection,我们知道数据源是线程安全的，而连接不是线程安全的，所以对每个请求都是从数据源中重新取出一个连接。一般的数据源由容器进行管理，包括连接池。例如TOMCAT，WEBSPHERE，WEBLOGIC等这些J2EE商业容器都提供了这个功能。 以往的我们使用JDBC在写代码时，事务管理可能会是这样： Connection conn = null; try { conn = DBConnectionFactory.getConnection; conn.setAutoCommit(false); //do something https://www.doczj.com/doc/1d17719599.html,mit(); //commit transcation } catch(Exception e) { conn.rollback(); //do sth } finally { try { conn.close(); catch(SQLException se){ //do sth.} //close ResultSet,PreparedStatement,Connection //notice:Maybe ocurr Exception when u close rs,pstmt,conn } 按照以往的思路来写代码，代码量比较长，而且容易疏忽，忘掉一些try/catch，引发一些异常无法catch，虽然有时候我们会写DBTool类，来关闭这些资源，并且保证在关闭这些资源时，不向外抛异常。 Spring提供的编程式的事务处理 Spring提供了几个关于事务处理的类： ?TransactionDefinition //事务属性定义 ?TranscationStatus //代表了当前的事务，可以提交，回滚。 ?PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。 我们使用编程式的事务管理流程可能如下： 1 声明数据源 2 声明一个事务管理类，例如DataSourceTransactionManager,HibernateTransactionManger,JTATransactionManager等 3 在我们的代码中加入事务处理代码： TransactionDefinition td = new TransactionDefinition(); TransactionStatus ts = transactionManager.getTransaction(td); try { //do sth https://www.doczj.com/doc/1d17719599.html,mit(ts); } catch(Exception e){transactionManager.rollback(ts);} 使用spring提供的事务模板TransactionTemplate void add() 在spring中如何配代码的事务管理 在J2EE的web应用里面配置spring非常简单，最简单的只需要把spring得ContextLoaderListener添加到你的web.xml文件里面就可以了，示例如下：org.springframework.web.context.ContextLoaderListener ContextLoaderListener是一个ServletContextListener, 它在你的web应用启动的时候初始化。缺省情况下，它会在WEB-INF/applicationContext.xml文件找Spring的配置。你可以通过定义一个元素名字为”contextConfigLocation”来改变Spring 配置文件的位置。示例 使用”org.springframework.jdbc.datasource.DriverManagerDataSou rce”数据源来配置数据库驱动。示例如下：org.hsqldb.jdbcDriver jdbc:hsqldb:db/appfuse sa spring提供了几个关于事务处理的类：TransactionDefinition //事务属性定义TranscationStatus //代表了当前的事务，可以提交，回滚。PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransac 在context中定义DataSource，创建SessionFactoy，设置参 数；DAO类继承HibernateDaoSupport，实现具体接口，从中获得HibernateTemplate进行具体操作。在使用中如果遇到OpenSessionInView的问题，可以添加OpenSessionInViewFilter 或OpenSessionInViewIntercepto 一个类需要用到某个接口的方法，我们需要将类A和接口B的实现关联起来，最简单的方法是类A中创建一个对于接口B的实现C 的实例，但这种方法显然两者的依赖（Dependency）太大了。而IoC 的方法是只在类A中定义好用于关联接口B的实现的方法，将类A，接口B和接口B的 spring,mybatis事务管理配置与@Transactional注解使用 [转] spring,mybatis事务管理配置与@Transactional注解使用 概述 事务管理对于企业应用来说是至关重要的，即使出现异常情况，它也可以保证数据的一致性。 Spring Framework对事务管理提供了一致的抽象，其特点如下： 为不同的事务API提供一致的编程模型，比如JTA(Java Transaction API), JDBC, Hibernate, JPA(Java Persistence API和JDO(Java Data Objects)支持声明式事务管理，特别是基于注解的声明式事务管理，简单易用提供比其他事务API如JTA更简单的编程式事务管理API与spring数据访问抽象的完美集成 事务管理方式 spring支持编程式事务管理和声明式事务管理两种方式。 编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。 声明式事务管理建立在AOP之上的。其本质是对方法前后 进行拦截，然后在目标方法开始之前创建或者加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。声明式事务最大的优点就是不需要通过编程的方式管理事务，这样就不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明(或通过基于 @Transactional注解的方式)，便可以将事务规则应用到业 务逻辑中。 显然声明式事务管理要优于编程式事务管理，这正是spring 倡导的非侵入式的开发方式。声明式事务管理使业务代码不受污染，一个普通的POJO对象，只要加上注解就可以获得完全的事务支持。和编程式事务相比，声明式事务唯一不足地方是，后者的最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。但是即便有这样的需求，也存在很多变通的方法，比如，可以将需要进行事务管理的代码块独立为方法等等。 声明式事务管理也有两种常用的方式，一种是基于tx和aop 名字空间的xml配置文件，另一种就是基于@Transactional 注解。显然基于注解的方式更简单易用，更清爽。 自动提交(AutoCommit)与连接关闭时的是否自动提交 自动提交 默认情况下，数据库处于自动提交模式。每一条语句处于一个单独的事务中，在这条语句执行完毕时，如果执行成功则 1.6 Spring事务： 1. 编程式事务管理——编程式的事务管理可以清楚滴控制事务的边界，也就是让您自行实现事务开始时间、撤消操作的时机、结束时间等，可以实现细粒度的事务控制。 2. 声明式事务管理——然而多数的情况下，事务并不需要细粒度的控制，而是采用声明式的事务管理，好处是Spring事务管理的相关API可以不用介入程序之中，从对象的角度来看，它并不知道自己正被纳入事务管理之中，在不需要事务管理的时候，只要在设置文件上修改一下设置，即可移去事务管理服务。 Spring声明式的事务管理依赖它的AOP框架来完成。使用声明式事务管理的好处是，事务管理不能侵入您所开发的组件，具体来说，DAO对象不会意识到正在事务管理之中，事实上也应该如此，因为事务管理是属于系统层面的服务，而不是业务逻辑的一部分，如果想要改变事务管理策略的话，也只需要在定义文件中重新配置。 事务的属性介绍： Spring使用AOP来完成声明式的事务管理，因而声明式事务是以方法为边界的，Spring的事务属性自然就在于描述事务应用至方法上的策略，在Spring 中事务属性分作以下的几个参数：传播行为（Propagation behavior）、隔离层级（Isolation Level）、只读提示（Read-only hints）、事务超时期间（The transaction timeout period） 传播行为（Propagation behavior）：传播行为定义了事务应用于方法的边界（Boundaries），它告知何时该开始一个新的事务，或何时事务被暂停，或方法是否要在事务中进行。如，若传播行为设置为PROPAGATION_REQUIRED，则事务的边界在开始第一个事务的方法呼叫及结束时，如果先前没有事务被开始，则事务边界即为目前方法的执行前后。又如果传播行为被声明为PROPAGATION_REQUIRES_NEW，则事务的边界即为该方法执行的前后。 隔离层级（Isolation Level）：在一个应用程序中，可能有多个事务同时在进行，这些事务应当彼此之间另一个事务的存在，好比现在整个应用程序就只有一个事务存在，由于事务彼此之间独立，若读取的是同一个数据的话，就容易发生问题。如： 脏读：（Dirty Read）脏读就是指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另一个事务也访问了这个数据，然后使用了这个数据，由于这个数据是还没有提交的数据，（有可能回滚）那么另外这个事务读到的数据就是脏数据，依据脏数据所做的操作可能是不正确的。 不可重复读：（Non-repeatable read）指在一个事物中，多次读取同一个数据。当这个事务还没结束时，另外一个事务也访问该同一数据。那么，在第一个事务中 Spring事务配置的五种方法 2009-04-24 10:20 总结如下： Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。 DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化，比如使用Hibernate进行数据访问时，DataSource实际为SessionFactory，TransactionManager的实现为HibernateTransactionManager。 具体如下图： 根据代理机制的不同，总结了五种Spring事务的配置方式，配置文件如下： 第一种方式：每个Bean都有一个代理 Spring中的事务管理实例详解 本文实例讲述了Spring中的事务管理。分享给大家供大家参考。具体分析如下：事务简介：事务管理是企业级应用程序开发中必不可少的技术，用来确保数据的完整性和一致性事务就是一系列的动作，它们被当作一个单独的工作单元。这些动作要么全部完成，要么全部不起作用事务的四个关键属性(ACID)①原子性(atomicity):事务室一个原子操作，有一系列动作组成。事务的原子性确保动作要么全部完成，要么完全不起作用 ②一致性(consistency):一旦所有事务动作完成，事务就被提交。数据和资源就处于一种满足业务规则的一致性状态中 ③隔离性(isolation):可能有许多事务会同时处理相同的数据，因此每个事物都应该与其他事务隔离开来，防止数据损坏 ④持久性(durability):一旦事务完成，无论发生什么系统错误，它的结果都不应该受到影响。通常情况下，事务的结果被写到持久化存储器中Spring中的事务管理作为企业级应用程序框架，Spring在不同的事务管理API之上定义了一个抽象层。而应用程序开发人员不必了解底层的事务管理API，就可以使用Spring的事务管理机制。Spring既支持编程式事务管理，也支持声明式的事务管理编程式事务管理：将事务 管理代码嵌入到业务方法中来控制事务的提交和回滚，在编程式事务中，必须在每个业务操作中包含额外的事务管理代码声明式事务管理：大多数情况下比编程式事务管理更好用。它将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。事务管理作为一种横切关注点，可以通过AOP方法模块化。Spring通过Spring AOP框架支持声明式事务管理。Spring事务的传播属性：当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。事务的传播行为可以由传播属性指定。Spring定义了7种传播行为：Spring支持的事务传播行为传播行为含义PROPAGATION_MANDATORY 表示该 方法必须在事务中运行，如果当前事务不存在，则会抛出一个异常PROPAGATION_NESTED 表示如果当前已经存 在一个事务，那么该方法将会在嵌套事务中运行。嵌套的事务可以独立于当前事务进行单独地提交或回滚。如果当前事务不存在，那么其行为与PROPAGATION_REQUIRED一样。注意各厂商对这种传播行为的支持是有所差异的。可以参考资源管理器的文档来确认它们是否支持嵌套事务PROPAGATION_NEVER表示当前方法不应该运行在 事务上下文中。如果当前正有一个事务在运行，则会抛出异常PROPAGATION_NOT_SUPPORTED 表示该方法不应 Spring提供了一致的事务管理抽象。这个抽象是Spring最重要的抽象之一，它有如下的优点： ?为不同的事务API提供一致的编程模型，如JTA、JDBC、Hibernate、iBATIS 数据库层。 ? ?提供比大多数事务API更简单的，易于使用的编程式事务管理API ? ?整合Spring数据访问抽象 ? ?支持Spring声明式事务管理 JDBC事务容易使用，但也有明显的缺点：它们不能用于多个事务性资源，并且趋向侵入的编程模型。 Spring解决了这些问题。它使应用开发者能够使用在任何环境下使用一致的编程模型。你可以只写一次你的代码，这在不同环境下的不同事务管理策略中很有益处。Spring同时提供声明式和编程式事务管理。 使用编程式事务管理，开发者直接使用Spring事务抽象，这个抽象可以使用在任何底层事务基础之上。使用首选的声明式模型，开发者通常书写很少的事务相关代码，因此不依赖Spring或任何其他事务API。 Spring事务抽象的关键是事务策略的概念。 这个概念 由org.springframework.transaction.PlatformTransactionManager接口体现，如下： public interface PlatformTransactionManager { TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException; void commit(TransactionStatus status) throws TransactionException; Spring事务管理注解开发1.在Spring的配置文件中配置事务管理器 2.在Spring的配置文件中开启注解事务 3.在对应业务层添加@Transactional注解 4.在某些方法上加上事务 5.事物传播行为介绍 6.事务隔离级别 7.@Transactional注解中常用参数说明 参数名称功能描述readOnly该属性用于设置当前事务是否为只读事务，设置为true表示只读，false则表示可读写，默认值为false。例如：@Transactional(readOnly=true) rollbackFor 该属性用于设置需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，则进行事务回滚。例如：指定单一异常类：@Transactional(rollbackFor=RuntimeException.class) 指定多个异常类：@Transactional(rollbackFor={RuntimeException.class, Exception.class}) rollbackForClassName 该属性用于设置需要进行回滚的异常类名称数组，当方法中抛出指定异常名称数组中的异常时，则进行事务回滚。例如：指定单一异常类名称：@Transactional(rollbackForClassName="RuntimeException") 指定多个异常类名称：@Transactional(rollbackForClassName={"RuntimeException","Exception"}) noRollbackFor 该属性用于设置不需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，不进行事务回滚。例如：指定单一异常类：@Transactional(noRollbackFor=RuntimeException.class) 指定多个异常类：@Transactional(noRollbackFor={RuntimeException.class, Exception.class}) noRollbackForClassName 该属性用于设置不需要进行回滚的异常类名称数组，当方法中抛出指定异常名称数组中的异常时，不进行事务回滚。例如：指定单一异常类名称：@Transactional(noRollbackForClassName="RuntimeException") 指定多个异常类名称： @Transactional(noRollbackForClassName={"RuntimeException","Exception"}) propagation 该属性用于设置事务的传播行为，具体取值可参考表6-7。 例如：@Transactional(propagation=Propagation.NOT_SUPPORTED,readOnly=true) isolation该属性用于设置底层数据库的事务隔离级别，事务隔离级别用于处理多事务并发的情况，通常使用数据库的默认隔离级别即可，基本不需要进行设置timeout该属性用于设置事务的超时秒数，默认值为-1表示永不超时 注意：1、@Transactional 只能被应用到public方法上, 对于其它非public的方法,如果标记了@Transactional也不会报错,但方法没有事务功能. spring2.5的事物管理，分为两种方式，一是基于注解方式的，而是基于配置文件方式的 一。基于注解方式 Java代码 1.import java.util.List; 2. 3.import javax.sql.DataSource; 4. 5.import org.springframework.jdbc.core.JdbcTemplate; 6.import org.springframework.transaction.annotation.Propagation; 7.import org.springframework.transaction.annotation.Transactional; 8. 9.import com.mingbai.bean.StudentBean; 10.import com.mingbai.service.StudentService; 11. 12.//将此业务类交由spring的事务管理，这时此方法的某个方法在执行前就开启事务，结束后提 交事务 13.@Transactional 14.public class StudentServiceImpl implements StudentService { 15.private JdbcTemplate jdbcTemplate; 16. 17.public void setDataSource(DataSource dataSource) { 18.this.jdbcTemplate = new JdbcTemplate(dataSource); 19. } 20. 21./* public void delete(Integer sid) { 22. jdbcTemplate.update("delete from student where id=?", 23. new Object[]{sid}, new int[]{java.sql.Types.INTEGE R}); 24. throw new RuntimeException("我是异常"); 25. }*/ 26./* @Transactional(rollbackFor=Exception.class) 27. public void delete(Integer sid) throws Exception { 28. jdbcTemplate.update("delete from student where id=?", 29. new Object[]{sid}, new int[]{java.sql.Types.INTEGE R}); 30. throw new Exception("我是异常"); 31. }*/ 32.@Transactional(noRollbackFor=RuntimeException.class) 33.public void delete(Integer sid) throws Exception { 34. jdbcTemplate.update("delete from student where id=?", 35.new Object[]{sid}, new int[]{java.sql.Types.INTEGER}); 事务的传播行为和隔离级别[transaction behavior and isolated level] Spring中事务的定义： 一、Propagation ： key属性确定代理应该给哪个方法增加事务行为。这样的属性最重要的部份是传播行为。有以下选项可供使用： PROPAGA TION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。 PROPAGA TION_SUPPORTS--支持当前事务，如果当前没有事务，就以非事务方式执行。PROPAGA TION_MANDA TORY--支持当前事务，如果当前没有事务，就抛出异常。PROPAGA TION_REQUIRES_NEW--新建事务，如果当前存在事务，把当前事务挂起。PROPAGA TION_NOT_SUPPORTED--以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。 PROPAGA TION_NEVER--以非事务方式执行，如果当前存在事务，则抛出异常。 很多人看到事务的传播行为属性都不甚了解，我昨晚看了j2ee without ejb的时候，看到这里也不了解，甚至重新翻起数据库系统的教材书，但是也没有找到对这个的分析。今天搜索，找到一篇极好的分析文章，虽然这篇文章是重点分析PROPAGA TION_REQUIRED 和PROPAGA TION_REQUIRED_NESTED的 解惑spring 嵌套事务 /** * @author 王政 * @date 2006-11-24 * @note 转载自https://www.doczj.com/doc/1d17719599.html,/topic/35907?page=1 */ ********TransactionDefinition 接口定义******************* /** * Support a current transaction, create a new one if none exists. * Analogous to EJB transaction attribute of the same name. * This is typically the default setting of a transaction definition. */ int PROPAGATION_REQUIRED = 0; /** * Support a current transaction, execute non-transactionally if none exists. * Analogous to EJB transaction attribute of the same name. * Note: For transaction managers with transaction synchronization, Spring管理事务操作的几种方式 在java工程中，通常会涉及到事务操作处理。通过Spring可以实现对事务操作的管理，简化代码。下面详细介绍Spring管理事务操作的几种方式及其具体应用。 在讲解具体操作方式之前，先定义公共的bean信息，xml文件中实现代码如下： Xml代码 在定义hibernate的配置文件中添加以下代码，声明事物操作bean： spring使用基于注解的AOP事务管理
Spring分布式事务实现
全面分析 Spring 的编程式事务管理及声明式事务管理
spring的@Transactional注解详细用法
Spring事务配置的五种方式
浅析Spring提供的事务管理方法
在spring中如何配代码的事务管理
spring,mybatis事务管理配置与@Transactional注解使用[转]
spring事务
spring事务配置详解
Spring中的事务管理实例详解
Spring事务管理抽象
Spring事务管理注解开发
Spring 事务设置
spring事务锁
Spring管理事务操作的几种方式
相关主题
文本预览