第5章 Spring的事务管理

合集下载

Spring系列之事务是如何管理的

Spring系列之事务是如何管理的前⾔我们都知道Spring给我们提供了很多抽象，⽐如我们在操作数据库的过程中，它为我们提供了事务⽅⾯的抽象，让我们可以⾮常⽅便的以事务⽅式操作数据库。

不管你⽤JDBC、Mybatis、Hibernate等任何⼀种⽅式操作数据库，也不管你使⽤DataSource还是JTA的事务，Spring 事务抽象管理都能很好的把他统⼀在⼀起。

接下来看⼀下事务的抽象核⼼接⼝Spring事务抽象PlatformTransactionManager是事务管理器接⼝//事务管理器接⼝有以下⼏个接⼝，获取事务信息，提交和回滚public interface PlatformTransactionManager {TransactionStatus getTransaction(@Nullable TransactionDefinition var1) throws TransactionException;void commit(TransactionStatus var1) throws TransactionException;void rollback(TransactionStatus var1) throws TransactionException;}常见的事务管理器有以下⼏种DataSourceTransactionManagerHibernateTransactionManagerJtaTransactionManager这些管理器都实现了PlatformTransactionManager中的三个接⼝，实现逻辑略有差别，但是对⽤户来讲区别不⼤定义事务的⼀些参数：⼀些事务的参数在TransactionDefinition.java中，详情如下：public interface TransactionDefinition {int PROPAGATION_REQUIRED = 0;int PROPAGATION_SUPPORTS = 1;int PROPAGATION_MANDATORY = 2;int PROPAGATION_REQUIRES_NEW = 3;int PROPAGATION_NOT_SUPPORTED = 4;int PROPAGATION_NEVER = 5;int PROPAGATION_NESTED = 6;//默认隔离级别，和数据库的隔离级别⼀致int ISOLATION_DEFAULT = -1;int ISOLATION_READ_UNCOMMITTED = 1;int ISOLATION_READ_COMMITTED = 2;int ISOLATION_REPEATABLE_READ = 4;int ISOLATION_SERIALIZABLE = 8;//默认不超时int TIMEOUT_DEFAULT = -1;}下⾯两张图对这些参数进⾏了说明：7种事务传播特性：file四种事务隔离级别：在看事务隔离级别前需要先了解下什么是脏读、不可重复读、幻读脏读：脏读就是⼀个事物未提交的数据，被另外⼀个事务读到了，显然这种情况不可接受不可重复读：不可重复读是指在⼀个事务内，多次读同⼀数据，前后读取的结果不⼀致。

spring事务管理

2023/10/23
易可导航
示例代码：
UserManagerImpl类代码：
public void addUser(User user) { Session session = null; try { //session = HibernateUtils.getSession(); session = HibernateUtils.getSessionFactory().getCurrentSession(); session.beginTransaction(); session.save(user); //保存日志 Log log = new Log(); log.setType("安全日志"); log.setDetail("xxx进入系统"); log.setDate(new Date()); LogManagerImpl logManager = new LogManagerImpl(); logManager.addLog(log); session.getTransaction().commit(); } catch(Exception e) { e.printStackTrace(); session.getTransaction().rollback(); }
2023/10/23
易可导航
getCurrentSession()与openSession()的区别
❖ 采用getCurrentSession()创建的session会绑定到当前线程中，而采用openSession()创建的session则不会。
❖ 采用getCurrentSession()创建的session在commit或 rollback时会ห้องสมุดไป่ตู้动关闭，而采用openSession()创建的 session必须手动关闭

应用Spring框架中的事务管理应用技术

Spring声明式事务管理和EJB CMT它们两者的基本实现方法在某些方面是相似的-----比如，都可以指定事务管理到单独的方法；如果需要可以在事务上下文调用setRollbackOnly() 方法。
（4）Spring声明式事务管理和EJB CMT的不同之处
不象 EJB CMT 绑定在 JTA 上， Spring 声明式事务管理可以在任何环境下使用；同时，我们只需更改配置文件，它就可以和 JDBC 、JDO 、 Hibernate 或其它的事务实现的机制一起工作，相互集成在一起。 Spring 可以使声明式事务管理应用到普通 Java 对象，不仅仅是特殊的类，如EJB组件类。 Spring 允许我们通过 AOP 定制事务行为。如果我们的应用系统需要此功能，我们则可以在事务回滚中插入定制的行为。
（2）优缺点
优点：保持与 JDBC 的事务处理的编程相兼容；程序高效并且比较灵活。其缺点代码量大，存在重复的代码比较多；侵入性太强。
6、声明控制的事务管理的一般实现方式
（1）Spring对于声明式事务划分的支持实际上是利用了它的AOP机制
相对于编程式事务划分，这种基于AOP的方式比较灵活，而且对代码的侵入性几乎为零。因此，如果没有特殊需要推荐使用这种事务划分方式。
2、JDBC标准的事务管理实现的代码（1）代码示例
（2）JDBC标准的事务管理实现的代码的缺点
按照以往的思路来写代码，不仅代码量比较长，而且也很容易疏忽或者忘掉一些 try/catch 语句，引发一些异常无法catch 因此我们会写 DBTool类，来关闭这些资源，并且保证在关闭这些资源时，不向外抛异常。
5、Spring声明式的事务管理的配置示例

第5章 Spring的事务管理

学习目标掌握基于XML和Annotation的声明式事务的使用了解Spring事务管理的两种方式熟悉Spring事务管理的三个核心接口5.1 Spring事务管理概述什么是Spring的事务管理？在实际开发中，操作数据库时都会涉及到事务管理问题，为此Spring提供了专门用于事务处理的API。

Spring的事务管理简化了传统的事务管理流程，并且在一定程度上减少了开发者的工作量。

在Spring的所有JAR包中，包含一个名为spring-tx-4.3.6.RELEASE的JAR包，该包就是Spring提供的用于事务管理的依赖包。

在该JAR包的org.springframework.transaction包中，有3个接口文件PlatformTransactionManager、TransactionDefinition和TransactionStatus，如下图所示：5.1.1 事务管理的核心接口1.Platform TransactionManagerPlatformTransactionManager接口是Spring提供的平台事务管理器，主要用于管理事务。

该接口中提供了三个事务操作的方法，具体如下：➢TransactionStatus getTransaction(TransactionDefinition definition);用于获取事务状态信息➢void commit(TransactionStatus status);用于提交事务➢void rollback(TransactionStatus status);用于回滚事务PlatformTransactionManager接口只是代表事务管理的接口，并不知道底层是如何管理事务的，具体如何管理事务则由它的实现类来完成。

该接口常见的几个实现类如下：当底层采用不同的持久层技术时，系统只需使用不同的PlatformTransactionManager实现类即可。

《Java EE企业级应用开发教程(Spring+Spring MVC+MyBatis)》_课后习题

第一章【思考题】1、请简述Spring框架的优点。

2、请简述什么是Spring的IoC和DI。

【答案】1、Spring框架的优点如下：（1）非侵入式设计：Spring是一种非侵入式（non-invasive）框架，它可以使应用程序代码对框架的依赖最小化。

（2）方便解耦、简化开发：Spring就是一个大工厂，可以将所有对象的创建和依赖关系的维护工作都交给Spring容器管理，大大的降低了组件之间的耦合性。

（3）支持AOP：Spring提供了对AOP的支持，它允许将一些通用任务，如安全、事务、日志等进行集中式处理，从而提高了程序的复用性。

（4）支持声明式事务处理：只需要通过配置就可以完成对事务的管理，而无需手动编程。

（5）方便程序的测试：Spring提供了对Junit4的支持，可以通过注解方便的测试Spring 程序。

（6）方便集成各种优秀框架：Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持。

（7）降低了Java EE API的使用难度：Spring对Java EE开发中非常难用的一些API （如：JDBC、JavaMail等），都提供了封装，使这些API应用难度大大降低。

2、IoC的全称是Inversion of Control，中文名称为控制反转。

控制反转就是指在使用Spring框架之后，对象的实例不再由调用者来创建，而是由Spring容器来创建，Spring 容器会负责控制程序之间的关系，而不是由调用者的程序代码直接控制。

这样，控制权由应用代码转移到了Spring容器，控制权发生了反转。

DI的全称是Dependency Injection，中文称之为依赖注入。

它与控制反转（IoC）的含义相同，只不过这两个称呼是从两个角度描述的同一个概念。

从Spring容器的角度来看，Spring容器负责将被依赖对象赋值给调用者的成员变量，这相当于为调用者注入了它依赖的实例，这就是Spring的依赖注入。

简述spring的事物管理原理

简述spring的事物管理原理
Spring的事务管理原理是基于AOP（面向切面编程）和代理模式实现的。

Spring的事务管理实现主要包括以下几个步骤：
1. 配置事务管理器：通过配置需要使用的事务管理器，如DataSourceTransactionManager或JtaTransactionManager，来管理事务。

2. 使用@Transactional注解标记事务方法：在需要进行事务管理的方法上添加@Transactional注解，Spring会通过AOP将该方法进行代理，以实现在方法执行前后进行事务的开启、提交或回滚。

3. 执行代理方法：当调用被@Transactional注解标记的方法时，实际执行的是代理对象的方法。

代理对象会在方法执行前后执行一系列的操作，包括开启事务、执行业务逻辑、提交事务或回滚事务。

4. AOP拦截：Spring使用AOP在代理对象的方法执行前后拦截方法调用，并根据方法上的@Transactional注解来判断是否需要进行事务管理。

5. 事务切面的应用：通过配置事务切面，将被@Transactional注解标记的方法组合为一个切面，然后在需要进行事务管理的地方将切面应用到目标对象上，实现对目标方法的事务管理。

总结起来，Spring的事务管理原理是通过AOP拦截方法调用，代理目标方法，并根据@Transactional注解的配置来进行事务的管理。

这样可以将事务的开启、提交或回滚等操作与业务逻辑解耦，提高代码的重用性和可维护性。

spring事务管理

Spring有可能成为所有企业应用程序的一站式服务，然而，Spring是模块化的，使您可以挑选哪些模块是适用的，而不必把在余下的也引入。

以下部分给出详细介绍在Spring框架中所有可用的模块。

Spring框架提供约20个模块，可以根据应用程序的要求来使用。

核心容器：核心容器组成的核心，Beans，上下文和表达式语言模块，其细节如下：∙核心模块提供了框架的基本组成部分，包括IoC和依赖注入功能。

∙Bean模块提供BeanFactory是工厂模式的经典实现。

∙Context 上下文模块建立在由核心和Bean类模块提供了坚实的基础，它是访问定义和配置的任何对象的媒介。

在ApplicationContext接口是上下文模块的焦点。

.∙表达式语言模块提供了在运行时查询和操作对象图的强大的表达式语言。

数据访问/集成：数据访问/集成层包括JDBC，ORM，OXM，JMS和事务处理模块，其细节如下：∙JDBC模块提供了不再需要冗长的JDBC编码相关了JDBC的抽象层。

∙ORM模块提供的集成层。

流行的对象关系映射API，包括JPA，JDO，Hibernate 和iBatis。

∙OXM模块提供了一个支持对象/ XML映射实现对JAXB，Castor，使用XMLBeans，JiBX和XStream 的抽象层。

∙Java消息服务JMS模块包含的功能为生产和消费的信息。

∙事务模块支持编程和声明式事务管理实现特殊接口类，并为所有的POJO。

Web:在Web层包括网络，Web-Servlet，Web-Struts和网络的Portlet 组件，其细节如下：∙Web模块提供了基本的Web开发的集成特性，例如多方文件上传功能和使用的servlet监听器的IoC容器初始化和针对Web的应用程序上下文。

∙Web-Servlet 模块包含Spring的模型- 视图- 控制器（MVC）实现Web应用程序。

∙Web-Struts 模块包含支持类内的Spring应用程序集成了经典的Struts Web 层。

Spring中的事务管理实例详解

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 表示如果当前已经存在一个事务，那么该方法将会在嵌套事务中运行。

Spring中的事务管理详解

Spring中的事务管理详解在这⾥主要介绍Spring对事务管理的⼀些理论知识，实战⽅⾯参考上⼀篇博⽂:1. 事务简介：事务管理是企业级应⽤程序开发中必不可少的技术，⽤来确保数据的完整性和⼀致性事务就是⼀系列的动作，它们被当作⼀个单独的⼯作单元。

这些动作要么全部完成，要么全部不起作⽤2. 事务的四个关键属性(ACID)①原⼦性(atomicity):事务是⼀个原⼦操作，有⼀系列动作组成。

事务的原⼦性确保动作要么全部完成，要么完全不起作⽤②⼀致性(consistency):⼀旦所有事务动作完成，事务就被提交。

数据和资源就处于⼀种满⾜业务规则的⼀致性状态中③隔离性(isolation):可能有许多事务会同时处理相同的数据，因此每个事物都应该与其他事务隔离开来，防⽌数据损坏④持久性(durability):⼀旦事务完成，⽆论发⽣什么系统错误，它的结果都不应该受到影响。

通常情况下，事务的结果被写到持久化存储器中3. Spring中的事务管理作为企业级应⽤程序框架，Spring在不同的事务管理API之上定义了⼀个抽象层。

⽽应⽤程序开发⼈员不必了解底层的事务管理API，就可以使⽤Spring的事务管理机制。

Spring既⽀持编程式事务管理(也称编码式事务)，也⽀持声明式的事务管理编程式事务管理：将事务管理代码嵌⼊到业务⽅法中来控制事务的提交和回滚，在编程式事务中，必须在每个业务操作中包含额外的事务管理代码声明式事务管理：⼤多数情况下⽐编程式事务管理更好⽤。

它将事务管理代码从业务⽅法中分离出来，以声明的⽅式来实现事务管理。

事务管理作为⼀种横切关注点，可以通过AOP⽅法模块化。

Spring通过Spring AOP框架⽀持声明式事务管理。

4. Spring的事务管理器Spring并不直接管理事务，⽽是提供了多种事务管理器，它们将事务管理的职责委托给JTA或其他持久化机制所提供的平台相关的事务实现。

每个事务管理器都会充当某⼀特定平台的事务实现的门⾯，这使得⽤户在Spring中使⽤事务时，⼏乎不⽤关注实际的事务实现是什么。

Spring 事务管理

一、概述（一）基本概念1、什么是Spring事务处理？什么是事务处理我就不想回答了。

Spring 的事务处理，可以说是Spring AOP 的一种实现。

因为事务处理是所谓方面（Aspect ）的一个子集。

因此默认情况下，事务处理是利用Java 动态代理机制实现的，这样就必须先定义一个接口，然后再编写实现；而对于没有接口的Javabean ，则通过CGLIB 实现。

这部分是Spring AOP 部分的内容。

2、两种事务处理方式和EJB 一样，Spring 也提供两种事务处理方式，一种是编程式事务处理；一种是声明式事务处理。

（二）框架图实现事务处理的两种方两种事务处理方式（三）何时使用什么如果需要大量的事务处理，就用声明式事务处理，如果很少的事务处理，就用编程式二、详细编程式事务处理与声明式事务处理（一）编程式事务处理1、使用TransactionTemplate进行事务处理（Spring进行commit和rollback）（1 ）使用事务处理的类import javax.sql.DataSource;import org.springframework.jdbc.core.*;import org.springframework.transaction.*;import org.springframework.dao.*;public class bookDAO{private DataSource dataSource;//依赖注入dataSource，管理数据库private PlatformTransationManager transactionManager;//依赖注入管理事务public void setDataSource(DataSource dataSource){this.dataSource=dataSource;}public void setTransactionManager(PlatformTransationManager transactionManager){this. transactionManager= transactionManager;}public int create(String msg){TransactionT emplate transactionT emplate=new TransactionT emplate(transactionManager);//调用transactionTemplate的execute方法进行事务管理Object result= transactionTemplate.execute(//这是一个回调函数，实现了TransactionCallback接口的doInTransaction 方法，就是在这个方法里写数据库新增数据的操作new TransactionCallback(){public Object doInTransaction(TransactionStatus status){//数据库操作代码return resultObject;}}[U1])}}如果不想返回结果（resultObject ），则可以用TransactionCallbackWithoutResult 来实现TransactionCallback 接口，代码如下：new TransactionCallback WithoutResult(){public Object doInTransaction WithoutResult(TransactionStatus status){//数据库操作代码}}（2 ）配置文件<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN""/dtd/spring-beans.dtd"><beans><!—设定dataSource→<bean id=”dataSource”class=”org.springframework.jdbc.datasource.DriverManagerDataSource”><!—使用SQL Server数据库→<property name=”driverClassName”><value>com.microsoft.jdbc.sqlserver.SQLServerDriver</value> </property><property name=”url”><value>jdbc:Microsoft:sqlserver://localhost:1433/stdb</value> </property><property name=”name”><value>admin</value></property><property name=”msg”><value>admin</value></property></bean><!—设定transactionManager→<bean id=”transactionManager”class=”org.springframework.jdbc.datasource.DataSourceTransactionManager”> <property name=”dataSource”><ref bean=”dataSource”/></property></bean><!—示例中DAO--><bean id=”bookDAO” class=”com.bookDAO”><property name=”dataSource”><ref bean=”dataSource”/></property><property name=”transactionManager”><ref bean=”transactionManager”></property></bean></beans>这样Spring 就可以自动进行commit 和rollback 这两个操作了。

Spring的事务管理

配置JDO事务管理器事务管理器配置
<bean id=“transactionManager” class=“org.springframework.orm.jdo.JdoTransact ionManager”> <property name=“persistenceManagerFactory”> <ref bean=“persistenceManagerFactory”/> </property> </bean>
Spring的事务传播规则的事务传播规则
传播行为
PROPAGATION_MANDATORY PROPAGATION_NESTED
意
义
表示该方法必须运行在一个事务中。如果当前事务不存在，抛出异常如果存在事务，那么该方法运行在一个嵌套的事务中；不存在，和REQUIRED一样；需要厂商支持表示该方法不应该运行在一个事务上下文中。如果存在一个事务，则会抛出一个异常表示该方法不应该在事务中运行。如果一个现有的事务正在运行，该方法在运行期被挂起表示该方法必须运行在一个事务中。如果一个现有的事务正在运行中，该方法将运行在这个事务中。否则，开始一个新事务表示当前方法必须运行在它自己的事务里。它将启动一个新的事务，如果已经有事务运行，挂起当前方法不需要事务处理环境，但如果有一个事务在运行，这个方法也可以在这个事务里运行
配置Hibernate事务管理器事务管理器配置
<bean id=“transactionManager” class=“org.springframework.orm.hibernate3.HibernateTr ansactionManager”> <property name=“sessionFactory”> <ref bean=“sessionFactory”/> </property> </bean>

spring事务管理

5事务管理为了描述事务的概念，我们拿买电影票来举例。

买一张电影票通常有一下步骤：检查剩余座位的数量，确定是否能给你提供你需要的座位个数每卖出一张票，可用座位的数量就应该减一付款售票员把票给你如果一切顺利的话，你就可以欣赏到一场一鸣惊人的电影，而影院也增加了收入。

但是如果有环节出差错了怎么办呢？比如说：你用来付款的信用卡没钱了？显然，你不会拿到票，影院也拿不到钱。

但是如果说座位的数量在下个人购买之前没有被恢复到原来的状态，那么电影也许因为人为原因而不会满场了。

或者如果出现这样的情况：一切都很顺利，但是发放票的时候出了问题。

你只好乖乖的呆在家里看电视了，而且还损失了一小笔钱。

为了保证剧院和你都不受到损失，上面的操作应该用事务封装起来。

作为事务，它应该被看成是一个单独的动作，以保证要么所有的操作都成功，或者所有的操作都回滚到初始的状态。

在软件中，事务有着举足轻重的地位，确保数据和资源保持一致的状态。

如果没有事务，那么数据有可能因为应用程序的业务逻辑而变成脏数据，或者变成与其他数据不统一的数据。

让我们快速浏览一下事务向导和他是如何工作的。

有以下四个因素。

5.1.1 用四句话来解释事务在软件开发的一个重要传统里，可以用一个单词首字母的缩写来描述一个事务：ACID，简言之，ACID代表Atomic（原子性）事务由一个或多个动作绑定起来作为一个单独的工作单元。

原子性保证事务中所有的操作要么都执行，或者都不执行。

如果所有的动作都执行了，那么事务就是成功的，如果其中有一个动作失败了，那么整个事务都失败，而且要执行回滚操作。

Consistent（一致性）一旦事务结束（可能成功了也可能失败了），那么系统所模拟的业务逻辑要处于一致的状态。

数据不应该被实体关系破坏。

Isolated（隔离性）事务应该允许多个用户操作一个数据，一个用户的操作应该不受另一个用户操作的影响。

因此事务之间应该是相互隔离的，以阻止他们在操作中同时读写同一数据。

spring的5中事务配置方式

Spring事务配置的五种方式这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。

Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。

DataSource、TransactionManager这两部分只是会根据数据访问方式有所变化，比如使用Hibernate 进行数据访问时，DataSource实际为SessionFactory，TransactionManager的实现为HibernateTransactionManager。

具体如下图：Spring事务配置根据代理机制的不同，总结了五种Spring事务的配置方式，配置文件如下：第一种方式：每个Bean都有一个代理1.<?xml version="1.0"encoding="UTF-8"?>2.<beans xmlns="/schema/beans"3.xmlns:xsi="/2001/XMLSchema-instance"4.xmlns:context="/schema/context"5.xmlns:aop="/schema/aop"6.xsi:schemaLocation="/schema/beans7. /schema/beans/spring-beans-2.5.xsd8. /schema/context9. /schema/context/spring-context-2.5.xsd10. /schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">11.12.<bean id="sessionFactory"13.class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">14.<property name="configLocation"value="classpath:hibernate.cfg.xml"/>15.<property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/>16.</bean>17.18.19.<bean id="transactionManager"20.class="org.springframework.orm.hibernate3.HibernateTransactionManager">21.<property name="sessionFactory"ref="sessionFactory"/>22.</bean>23.24.25.<bean id="userDaoTarget"class="erDaoImpl">26.<property name="sessionFactory"ref="sessionFactory"/>27.</bean>28.29.<bean id="userDao"30.class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">31.32.<property name="transactionManager"ref="transactionManager"/>33.<property name="target"ref="userDaoTarget"/>34.<property name="proxyInterfaces"value="com.bluesky.spring.dao.GeneratorDao"/>35.36.<property name="transactionAttributes">37.<props>38.<prop key="*">PROPAGATION_REQUIRED</prop>39.</props>40.</property>41.</bean>42.</beans>第二种方式：所有Bean共享一个代理基类1.<?xml version="1.0"encoding="UTF-8"?>2.<beans xmlns="/schema/beans"3.xmlns:xsi="/2001/XMLSchema-instance"4.xmlns:context="/schema/context"5.xmlns:aop="/schema/aop"6.xsi:schemaLocation="/schema/beans7. /schema/beans/spring-beans-2.5.xsd8. /schema/context9. /schema/context/spring-context-2.5.xsd10. /schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">11.12.<bean id="sessionFactory"13.class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">14.<property name="configLocation"value="classpath:hibernate.cfg.xml"/>15.<property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/>16.</bean>17.18.19.<bean id="transactionManager"20.class="org.springframework.orm.hibernate3.HibernateTransactionManager">21.<property name="sessionFactory"ref="sessionFactory"/>22.</bean>23.24.<bean id="transactionBase"25.class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"zy-init="true"abstract="true">27.28.<property name="transactionManager"ref="transactionManager"/>29.30.<property name="transactionAttributes">31.<props>32.<prop key="*">PROPAGATION_REQUIRED</prop>33.</props>34.</property>35.</bean>36.37.38.<bean id="userDaoTarget"class="erDaoImpl">39.<property name="sessionFactory"ref="sessionFactory"/>40.</bean>41.42.<bean id="userDao"parent="transactionBase">43.<property name="target"ref="userDaoTarget"/>44.</bean>45.</beans>第三种方式：使用拦截器1.<?xml version="1.0"encoding="UTF-8"?>2.<beans xmlns="/schema/beans"3.xmlns:xsi="/2001/XMLSchema-instance"4.xmlns:context="/schema/context"5.xmlns:aop="/schema/aop"6.xsi:schemaLocation="/schema/beans7. /schema/beans/spring-beans-2.5.xsd8. /schema/context9. /schema/context/spring-context-2.5.xsd10. /schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">11.12.<bean id="sessionFactory"13.class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">14.<property name="configLocation"value="classpath:hibernate.cfg.xml"/>15.<property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/>16.</bean>17.18.19.<bean id="transactionManager"20.class="org.springframework.orm.hibernate3.HibernateTransactionManager">21.<property name="sessionFactory"ref="sessionFactory"/>22.</bean>23.24.<bean id="transactionInterceptor"25.class="org.springframework.transaction.interceptor.TransactionInterceptor">26.<property name="transactionManager"ref="transactionManager"/>27.28.<property name="transactionAttributes">29.<props>30.<prop key="*">PROPAGATION_REQUIRED</prop>31.</props>32.</property>33.</bean>34.35.<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">36.<property name="beanNames">37.<list>38.<value>*Dao</value>39.</list>40.</property>41.<property name="interceptorNames">42.<list>43.<value>transactionInterceptor</value>44.</list>45.</property>46.</bean>47.48.49.<bean id="userDao"class="erDaoImpl">50.<property name="sessionFactory"ref="sessionFactory"/>51.</bean>52.</beans>第四种方式：使用tx标签配置的拦截器1.<?xml version="1.0"encoding="UTF-8"?>2.<beans xmlns="/schema/beans"3.xmlns:xsi="/2001/XMLSchema-instance"4.xmlns:context="/schema/context"5.xmlns:aop="/schema/aop"6.xmlns:tx="/schema/tx"7.xsi:schemaLocation="/schema/beans8. /schema/beans/spring-beans-2.5.xsd9. /schema/context10. /schema/context/spring-context-2.5.xsd11. /schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd12. /schema/tx /schema/tx/spring-tx-2.5.xsd">13.14.<context:annotation-config/>15.<context:component-scan base-package="com.bluesky"/>16.17.<bean id="sessionFactory"18.class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">19.<property name="configLocation"value="classpath:hibernate.cfg.xml"/>20.<property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/>21.</bean>22.23.24.<bean id="transactionManager"25.class="org.springframework.orm.hibernate3.HibernateTransactionManager">26.<property name="sessionFactory"ref="sessionFactory"/>27.</bean>28.29.<tx:advice id="txAdvice"transaction-manager="transactionManager">30.<tx:attributes>31.<tx:method name="*"propagation="REQUIRED"/>32.</tx:attributes>33.</tx:advice>34.35.<aop:config>36.<aop:pointcut id="interceptorPointCuts"37.expression="execution(* com.bluesky.spring.dao.*.*(..))"/>38.<aop:advisor advice-ref="txAdvice"39.pointcut-ref="interceptorPointCuts"/>40.</aop:config>41.</beans>第五种方式：全注解1.<?xml version="1.0"encoding="UTF-8"?>2.<beans xmlns="/schema/beans"3.xmlns:xsi="/2001/XMLSchema-instance"4.xmlns:context="/schema/context"5.xmlns:aop="/schema/aop"6.xmlns:tx="/schema/tx"7.xsi:schemaLocation="/schema/beans8. /schema/beans/spring-beans-2.5.xsd9. /schema/context10. /schema/context/spring-context-2.5.xsd11. /schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd12. /schema/tx /schema/tx/spring-tx-2.5.xsd">13.14.<context:annotation-config/>15.<context:component-scan base-package="com.bluesky"/>16.17.<tx:annotation-driven transaction-manager="transactionManager"/>18.19.<bean id="sessionFactory"20.class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">21.<property name="configLocation"value="classpath:hibernate.cfg.xml"/>22.<property name="configurationClass"value="org.hibernate.cfg.AnnotationConfiguration"/>23.</bean>24.25.26.<bean id="transactionManager"27.class="org.springframework.orm.hibernate3.HibernateTransactionManager">28.<property name="sessionFactory"ref="sessionFactory"/>29.</bean>30.31.</beans>此时在DAO上需加上@Transactional注解，如下：1.package com.dawnsky.spring.dao;2.3.import java.util.List;4.5.import org.hibernate.SessionFactory;6.import org.springframework.beans.factory.annotation.Autowired;7.import org.springframework.orm.hibernate3.support.HibernateDaoSupport;8.import ponent;9.10.import er;11.12.@Transactional13.@Component("userDao")14.public class UserDaoImpl extends HibernateDaoSupport implements UserDao {15.16.public List<User> listUsers() {17.return this.getSession().createQuery("from User").list();18. }19.}。

Spring的事务管理

Spring的事务管理什么是事务？数据库事务是指作为单个逻辑单元存在的⼀系列操作，要么完全执⾏，要么完全不执⾏。

事务的⼏个属性：原⼦性，⼀致性，隔离性，持久性原⼦性：事务是最⼩的执⾏单元，不允许分割，事务的原⼦操作确保动作要完全完成，要么就是完全不起作⽤。

⼀致性：执⾏事务的前后，数据要保持⼀致；隔离性：并发访问数据库，⼀个⽤户的事务不被其他的事务所⼲预，数据库是独⽴的。

持久性：⼀个事务被提交后，他对数据库的改变是持久的；事务管理？所谓的事务管理是指 "按照给定的事务规则来执⾏提交或者回滚操作"；Spring中的事务管理在Spring的所有包中，有⼀个名为spring-tx-xxx的Jar包，该包就是Spring所提供的事务管理的依赖包，在该包的org.springframework.transaction包中，含有3个接⼝，该三个接⼝就是PlatformTransactionManager,TransactionDefinition和TransactionStatus,这三个核⼼API的关系就是：PlatformTransactionManager是根据TransactionDefinition来进⾏事务管理，在管理的过程中事务存在多个状态信息，每个状态信息是通过TransactionStatus来表⽰的。

在项⽬中，Spring是将XML中的配置的事务详细信息封装到TransactionDefinition对象中，然后通过事务管理器PlatformTransactionManager的getTransaction(TransactionDefinition ddfinition)来获得事务的状态TransactionStatus1.PlatformTransactionManager PlatformTransactionManager接⼝是Spring提供的平台事务管理器，主要是⽤于管理事务。

Spring事务管理

Spring事务管理Spring提供了一流的事务管理。

在Spring中可以支持声明式事务和编程式事务。

本章主要目标如下：1，Spring事务2，事务属性3，事务管理器4，声明式事务1.1Spring的事务事务管理在应用程序中起着至关重要的作用：它是一系列任务的组成工作单元，在这个工作单元中，所有的任务必须同时执行。

它们只有二种可能执行结果，要么所有任务全部执行成功，要么所有任务全部执行失败。

Spring中提供了丰富的事务管理功能，它们超过了EJB并且和EJB一样支持声明式事务，重要的是Spring提供了致的事务管理，它有如下优点。

1，为不同的事务的API提供一致的编程模式2，提供更简单，更易地使用的编程式事务管理3，支持Spring声明事务4，整合Spring对数据访问的抽像1.2事务的ACID特性事务使用ACID特性来衡量事务的质量。

介绍如下：1，原子性事务必须是原子的，在事务结束的时候，事务中的所有任务必须全部成功完成，否则全部失败，事务回滚到事务开始之间的状态。

2，一致性事务必须保证和数据库的一致性，即数据库中的所有数据和现实保持一致。

如果事务失败数据必须返回到事务执行之前的状态，反之修改数据和现实的同步。

3，隔离性隔离性是事务与事务之间的屏障，每个事务必须与其他事务的执行结果隔离开，直到该事务执行完毕，它保证了事务的访问的任何数据不会受其他事务执行结果的影响。

4，持久性如果事务成功执行，无论系统发生任何情况，事务的持久性都必须保证事务的执行结果是永久的。

1.3事务之间的缺陷在事务处理中有违返ACID特性的3个问题：脏读取，不可重复读和幻读行。

如果存在多个并发事务在运行，而这种事务操作了同一个数据来完成它们的任务，就会导致3个问题的存生。

要解决它们，就必须在事务之间定义合适的隔离级别。

为保证事务的完整性，必须解决事务之间可能存在的3个问题。

（1）脏读取当一个事务读取了另一个事务尚未提交的更新，就叫脏读取。

spring事务管理全解析

spring事务管理全解析事务是一组原子（Atomic）操作的工作单元，以数据库存取的实例来说，就是一组SQL指令，这一组SQL指令必须全部执行成功，若因为某个原因未全部执行成功（例如其中一行SQL有错误），则先前所有执行过的SQL指令都会被撤消。

JDBC是如何控制事务的try ...{.....connection.setAutoCommit(false);.....// 一连串SQL操作mit();} catch(SQLException) ...{// 发生错误，撤消所有变更connection.rollback();}Spring是把JDBC事务管理进来了封装，Spring事务管理的抽象关键在于org.springframework.transaction.PlatformTransactionManager接口里面有commit 和rollbackpublic interface PlatformTransactionManager ...{TransactionStatus getTransaction(TransactionDefinitiondefinition) throws TransactionException;void commit(TransactionStatus status)throws TransactionException;void rollback(TransactionStatus status)throws TransactionException;}TransactionDefinition接口的实例定义了事务的隔离程度（Isolation level）传播行为（Propagation behavior）超时（Timeout）只读（Read-only）等DataSourceTransactionManager、HibernateTransactionManager、JdoTransaction- Manager、JtaTransactionManager等是实现了该接口Spring提供编程式的事务管理（Programmatic transaction management）与声明式的事务管理（Declarative transaction management）：1、编程式的事务管理可以清楚地控制事务的边界，也就是让您自行实现事务开始时间、撤消操作的时机、结束时间等，可以实现细粒度的事务控制。

J2EE进阶：Spring框架的事务管理及应用

Spring AOP，借助于Spring实现拦截器，开发者能够实现以声名方式使用企业级服务，比如安全性服务、事务服务。AOP 合理的补充了OOP，借助于Spring AOP，开发者能够高效的使用J2EE服务。
Spring服务抽象，借助于各种J2EE API抽象，使得开发者能够一致地使用J2EE 技术，而不管具体是使用什么J2EE API，借助于Spring服务抽象，使代码大大减少，满足“更少代码，更少BUG”的软件设计原则。
//notice:Maybe ocurr Exception when u close rs,pstmt,conn
}
按照以往的思路来写代码，代码量比较长，而且容易疏忽，忘掉一些try/catch，引发一些异常无法catch，虽然有时候我们会写DBTool类，来关闭这些资源，并且保证在关闭这些资源时，不向外抛异常，但是这样做会导致额外的麻烦。
1、传统使用JDBC的事务管理
以往使用JDBC进行数据操作，使用DataSource，从数据源中得到Connection，我们知道数据源是线程安全的，而连接不是线程安全的，所以对每个请求都是从数据源中重新取出一个连接。一般的数据源由容器进行管理，包括连接池。例如TOMCAT，WEBSPHERE，WEBLOGIC等这些J2EE商业容器都提供了这个功能。
＜/property＞
＜/bean＞
（3）为组件声明一个代理类：ProxyFactoryBean
＜bean id="userManager"
class="org.springframework.aop.framework.ProxyFactoryBean"＞
＜property name="proxyInterfaces"＞

Spring事务管理及与mybatis整合的事务管理

数据访问事务处理in Spring+Mybatis3.0事务---保证了用户的每一次操作都是可靠的，即使出现了异常的访问，也不至于破坏后台数据的完整性;Java事务简介事务必须符合ISO/IEC所定制的ACID原则1)A(atomicity):原子性在事务执行的过程中,任何的失败就将导致事务的任何修改失效,2)C(consistency):一致性事务回滚时,事务所执行的内容必须恢复到初始状态,即事务执行前的状态3)I(isolation):隔离性事务执行过程中对数据的修改,在提交之前的数据对其他事务不可见4)D(durability):持久性已经提交的数据在事务执行失败时,数据的状态都是正确的.事务分类:全局事务(分布式事务):由应用服务器来管理(如JTA),同时可以用于多个事务性的资源;本地事务本地事务和资源相关,主要通过JDBC来实现在实际应用中,存在一种容器管理事务,容器事务主要是由javaEE应用服务器提供,容器事务大多给予JTA完成,事实上这是在容器中覆盖了JDBC和JTA事务.事务特性分析(use spring)TransactionDefinition 接口来定义事务属性。

Code:public interface TransactionDefinition{int getIsolationLevel();int getPropagationBehavior();int getTimeout();boolean isReadOnly();}事务机制a)事务隔离级别隔离级别是指若干个并发的事务之间的隔离程度。

TransactionDefinition 接口中定义了五个表示隔离级别的常量：TransactionDefinition.ISOLATION_DEFAULT(默认值)：表示使用底层数据库的默认隔离级别。

对大部分数据库而言，通常这值就是TransactionDefinition.ISOLATION_READ_COMMITTED。