spring事务管理

合集下载

Spring事务管理中@Transactional的参数配置

Spring事务管理中@Transactional的参数配置Spring作为低侵⼊的Java EE框架之⼀，能够很好地与其他框架进⾏整合，其中Spring与Hibernate的整合实现的事务管理是常⽤的⼀种功能。

所谓事务，就必须具备ACID特性，即原⼦性、⼀致性、隔离性和持久性，在Hibernate的实现中，需要我们编写代码来完成事务的控制⼯作。

未使⽤Spring的事务管理12 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 static void main(String[] args) {// Configuration cfg = new Configuration();// cfg.configure();// SessionFactory sf = cfg.buildSessionFactory();//因为在HibernateUtil类中已经有⼀部分封装⼯作，所以以上三⾏注释掉了。

Session s = null;Transaction tx = null;try{Class.forName("com.HibernateUtil");s = HibernateUtil.getSession();tx = s.beginTransaction(); //这⾥开启了事务//事务中所需的⼀系列数据库操作。

mit();} catch(HibernateException e) { //如果出现异常，且事务已经开启，则需要回滚。

if(tx != null)tx.rollback();throw e;} catch(ClassNotFoundException e) {e.printStackTrace();} finally{ //⽆论如何都需要关闭Session。

spring成神之路第四十六篇：Spring如何管理多数据源事务？

spring成神之路第四⼗六篇：Spring如何管理多数据源事务？本篇内容：通过原理和⼤量案例带⼤家吃透Spring多数据源事务。

Spring中通过事务管理器来控制事务，每个数据源都需要指定⼀个事务管理器，如果我们的项⽬中需要操作多个数据库，那么需要我们配置多个数据源，也就需要配置多个数据管理器。

多数据源事务使⽤2个步骤1、为每个数据源定义⼀个事务管理器如下⾯代码，有2个数据源分别连接数据库ds1和ds2，然后为每个数据源定义了1个事务管理器，此时spring容器中有2个数据源和2个事务管理器。

//数据源1@Beanpublic DataSource dataSource1() {org.apache.tomcat.jdbc.pool.DataSource dataSource = new org.apache.tomcat.jdbc.pool.DataSource();dataSource.setDriverClassName("com.mysql.jdbc.Driver");dataSource.setUrl("jdbc:mysql://localhost:3306/ds1?characterEncoding=UTF-8");dataSource.setUsername("root");dataSource.setPassword("root123");dataSource.setInitialSize(5);return dataSource;}//事务管理器1，对应数据源1@Beanpublic PlatformTransactionManager transactionManager1(@Qualifier("dataSource1")DataSource dataSource) {return new DataSourceTransactionManager(dataSource);}//数据源2@Beanpublic DataSource dataSource2() {org.apache.tomcat.jdbc.pool.DataSource dataSource = new org.apache.tomcat.jdbc.pool.DataSource();dataSource.setDriverClassName("com.mysql.jdbc.Driver");dataSource.setUrl("jdbc:mysql://localhost:3306/ds2?characterEncoding=UTF-8");dataSource.setUsername("root");dataSource.setPassword("root123");dataSource.setInitialSize(5);return dataSource;}//事务管理器2，对应数据源2@Beanpublic PlatformTransactionManager transactionManager2(@Qualifier("dataSource2")DataSource dataSource) {return new DataSourceTransactionManager(dataSource);}2、指定事务的管理器bean名称使⽤@Transaction中时，需通过@Transaction注解的value或transactionManager属性指定事务管理器bean名称，如：@Transactional(transactionManager ="transactionManager1", propagation =Propagation.REQUIRED)publicvoid required(String name){this.jdbcTemplate1.update("insert into user1(name) VALUES (?)", name);这⾥补充⼀下，之前我们使⽤@Transactional的时候，并没有通过value或者transactionManager设置事务管理器，这是为什么？这是因为我们在spring容器中只定义了⼀个事务管理器，spring启动事务的时候，默认会按类型在容器中查找事务管理器，刚好容器中只有⼀个，就拿过来⽤了，如果有多个的时候，如果你不指定，spring是不知道具体要⽤哪个事务管理器的。

Spring事务配置的五种方式

Spring事务原理统观spring事务，围绕着两个核心PlatformTransactionManager和TransactionStatusspring提供了几个关于事务处理的类：TransactionDefinition //事务属性定义TranscationStatus //代表了当前的事务，可以提交，回滚。

PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。

一般事务定义步骤：TransactionDefinition td = new TransactionDefinition();TransactionStatus ts = transactionManager.getTransaction(td);try{ //do sthmit(ts);}catch(Exception e){transactionManager.rollback(ts);}spring提供的事务管理可以分为两类：编程式的和声明式的。

编程式的，比较灵活，但是代码量大，存在重复的代码比较多；声明式的比编程式的更灵活。

编程式主要使用transactionTemplate。

省略了部分的提交，回滚，一系列的事务对象定义，需注入事务管理对象.void add(){transactionTemplate.execute( new TransactionCallback(){pulic Object doInTransaction(TransactionStatus ts){ //do sth}}}声明式：使用TransactionProxyFactoryBean:<bean id="userManager" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"><property name="transactionManager"><ref bean="transactionManager"/></property><property name="target"><ref local="userManagerTarget"/></property><property name="transactionAttributes"><props><prop key="insert*">PROPAGATION_REQUIRED</prop><prop key="update*">PROPAGATION_REQUIRED</prop><prop key="*">PROPAGATION_REQUIRED,readOnly</prop></props></property></bean>围绕Poxy的动态代理能够自动的提交和回滚事务org.springframework.transaction.interceptor.TransactionProxyFactoryBeanPROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。

spring 事务实现原理

spring 事务实现原理Spring事务的实现原理主要依赖于数据库或者其他存储系统的事务功能。

1. 数据库事务支持：Spring事务的实现依赖于数据库的事务功能。

通常情况下，数据库支持ACID（原子性、一致性、隔离性和持久性）事务特性，可以通过SQL的BEGIN、COMMIT 和ROLLBACK等命令来控制事务的开始、提交和回滚操作。

2. 事务管理器：Spring框架提供了事务管理器（TransactionManager）接口，用于管理事务的开始、提交和回滚等操作。

事务管理器可以根据配置信息选择不同的实现，如使用JDBC事务管理器（DataSourceTransactionManager）或者JTA事务管理器（JtaTransactionManager）等。

3. 编程式事务：Spring框架提供了编程式事务管理的支持，通过编写代码显式地控制事务的边界。

开发者可以在代码中使用事务管理器的API来手动管理事务，包括事务的开始、提交和回滚等操作。

这种方式灵活性较高，但也需要开发者手动处理事务的细节。

4. 声明式事务：Spring框架还提供了声明式事务管理的支持，通过使用注解或者XML配置来定义事务的属性和边界。

开发者可以使用@Transactional注解或者事务配置元素来标记方法或者类，指示该方法或者类在执行时需要开启事务。

Spring会在方法调用前后自动地管理事务的开始、提交和回滚等操作。

5. 事务传播行为：Spring事务还支持事务传播行为的定义，即一个方法调用另一个带有事务的方法时事务该如何传播。

例如，当前方法可能会暂停事务、加入到现有的事务中或者创建一个新的事务。

Spring提供了多种事务传播行为的选项，如REQUIRED、REQUIRES_NEW、NESTED等，可以根据需要进行配置。

总的来说，Spring事务的实现原理是通过与数据库或其他存储系统的事务功能结合，通过事务管理器来管理事务的开始、提交和回滚等操作。

spring事务原理

spring事务原理数据库系统内，事务指一系列连续的操作，这系列操作被看作一个整体，要么完全执行，要么完全不执行，不会出现执行部分的情况，这是数据库系统的基本特征之一。

在传统数据库系统中，事务的管理是由数据库系统自身提供的一种功能，然而随着数据库系统的复杂性的增加，数据库中的事务管理越来越复杂，对数据库操作有更多的要求，这样就催生了应用层事务管理技术，而当前最流行的事务管理技术是Spring事务。

Spring事务是一种基于AOP（面向切面编程）的分布式事务管理技术，它能够帮助系统更好的控制事务的处理过程，从而使系统内的数据更加有效率的共享，降低数据库事务的管理复杂度，提高数据库系统的可用性及性能。

Spring事务原理包括几个要素：事务模型、分布式事务处理框架、事务实现机制以及事务管理工具等。

一、事务模型Spring事务原理的核心是事务模型，即它把事务分为两种：提交成功事务和失败事务，在Spring提供的事务模型中，每个事务都只有两种结果，要么提交成功，要么提交失败，而不存在半提交的状态。

在Spring的事务模型中，事务的分类还要求事务的原子性，它要求一旦提交事务，事务就不会再次改变，或者改变的程度会很小。

原子性还表明事务的执行要么完全成功，要么完全失败，不会出现半成功半失败的情况。

二、分布式事务处理框架Spring提供了基于AOP技术的分布式事务处理框架，这种分布式事务处理框架能够有效地支持不同数据库之间的事务处理，它包括三个部分：事务管理器（TransactionManager）、事务拦截器（TransactionInterceptor）和事务事件监听器（TransactionListener）。

事务管理器是Spring对分布式事务的抽象，它可以处理不同类型的事务，它的实现通常会涉及到一些事务拦截器。

事务拦截器是Spring提供的一种安全机制，它能够在事务处理过程中，根据配置的规则，来拦截事务的执行，以便能够在事务处理过程中发现任何可能存在的问题，并对其进行调整，使得事务能够顺利的提交。

spring,mybatis事务管理配置与@Transactional注解使用[转]

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对象，只要加上注解就可以获得完全的事务支持。

和编程式事务相比，声明式事务唯一不足地方是，后者的最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。

springboot中的声明式事务管理及编程式事务管理

springboot中的声明式事务管理及编程式事务管理这⼏天在做⼀个功能，具体的情况是这样的：项⽬中原有的⼏个功能模块中有数据上报的功能，现在需要在这⼏个功能模块的上报之后⽣成⼀条消息记录，然后⼊库，在写个接⼝供前台来拉取消息记录。

看到这个需求，⾸先想到的是使⽤AOP来实现了，然后，我去看了下现有功能模块中的代码，发现了问题，这些模块中的业务逻辑并没有放在service层来处理，直接在controller中处理了，controller中包含了两个甚⾄多个service处理，这样是不能保证事务安全的，既然这样，那么我们如何实现能保证事务安全呢。

我想直接在controller中定义切⼊点，然后before中⼿动开启事务，在afterReturn之后根据需要来提交或者回滚事务。

然后趁着这个机会就查了下spring boot中的事务这块，就从最基础的说起。

1.spring boot中声明式事务的使⽤想要在spring boot中使⽤声明式事务，有两种⽅式，⼀种是在各个service层中添加注解，还有⼀种是使⽤AOP配置全局的声明式事务管理先来说第⼀种，需要⽤到两个注解就，⼀个是@EnableTransactionManagement⽤来开启注解事务管理，等同于xml配置⽅式的 <tx:annotation-driven />，另⼀个是@Transactional 具体代码如下：1package com.example.demo;23import org.springframework.boot.SpringApplication;4import org.springframework.boot.autoconfigure.SpringBootApplication;5import org.springframework.transaction.annotation.EnableTransactionManagement;67// @SpringBootApplication是Sprnig Boot项⽬的核⼼注解，主要⽬的是开启⾃动配置10 @SpringBootApplication11 @EnableTransactionManagement // 启注解事务管理，等同于xml配置⽅式的 <tx:annotation-driven />12public class DemoApplication {14public static void main(String[] args) {16 SpringApplication.run(DemoApplication.class, args);18 }1920 } 然后，注解@Transactional直接加在service层就可以了，放两个service⽤来验证事务是否按预期回滚package com.example.demo.service;import com.example.demo.bean.ResUser;import org.springframework.transaction.annotation.Transactional;import java.util.List;/*** 注解加在接⼝上表名接⼝的所有⽅法都⽀持事务；* 如果加在⽅法上，则只有该⽅法⽀持事务* 可以根据需要在CUD操作上加注解**/@Transactionalpublic interface IUserService {int insertUser(ResUser resUser);int updateUser(ResUser resUser);List<ResUser> getResUserList();}1package com.example.demo.service;23import com.example.demo.bean.ResPartner;4import org.springframework.transaction.annotation.Transactional;56import java.util.List;7import java.util.Map;89 @Transactional10public interface IPartnerService {1112int add(ResPartner resPartner);1314int deleteByIds(String ids);1516int update(ResPartner resPartner);1718 ResPartner queryById(int id);1920 List<ResPartner> queryList(Map<String, Object> params);2122 } 实现类1package com.example.demo.service.impl;23import com.example.demo.bean.ResPartner;4import com.example.demo.dao.PartnerMapperXml;5import com.example.demo.service.IPartnerService;6import org.slf4j.Logger;7import org.slf4j.LoggerFactory;8import org.springframework.beans.factory.annotation.Autowired;9import ponent;1011import java.util.List;12import java.util.Map;1314 @Component("partnerService")15public class PartnerServiceImpl implements IPartnerService {1617private Logger logger = LoggerFactory.getLogger(this.getClass());18 @Autowired19private PartnerMapperXml partnerMapperXml;2021 @Override22public int add(ResPartner resPartner) {23 StringBuilder sbStr = new StringBuilder();24 sbStr.append("id = ").append(resPartner.getId())25 .append(", name = ").append(resPartner.getName())26 .append(", city = ").append(resPartner.getCity())27 .append(", displayName = ").append(resPartner.getDisplayName());(sbStr.toString());29return this.partnerMapperXml.add(resPartner);30 }31 }1package com.example.demo.service.impl;23import com.example.demo.bean.ResPartner;4import com.example.demo.bean.ResUser;5import com.example.demo.dao.PartnerMapperXml;6import com.example.demo.dao.ResUserMapper;7import com.example.demo.service.IUserService;8import org.springframework.beans.factory.annotation.Autowired;9import ponent;1011import java.util.List;1213 @Component("userService")14public class UserServiceImpl implements IUserService {1516 @Autowired17private ResUserMapper resUserMapper;18 @Autowired19private PartnerMapperXml partnerMapperXml;2021 @Override22public int insertUser(ResUser resUser) {2324int i = resUserMapper.insert(resUser);25// ResPartner partner = new ResPartner();26// partner.setId(resUser.getId());27// partner.setName(resUser.getName());28// partner.setDisplayName(resUser.getLogin());29//30// if (true) // ⽤来验证异常，使事务回滚31// throw new RuntimeException("xxxxxxxxxxxxxxx");32// int a = 1/0;33// partnerMapperXml.add(partner);3435return i;36 }3738 } controller代码，JSONMsg是⼀个⾃定义类，就三个属性code,msg,data⽤来给前台返回数据。

MyBatis-Spring-TransactionManager事务管理

<bean class="org.apache.ibatis.transaction.managed.ManagedTransactionFactory" />
</property>
</bean>
编程式事务管理
MyBatis 的 SqlSession 提供指定的方法来处理编程式的事务。但是当使用 MyBatis-Spring 时, bean 将会使用 Spring 管理的 SqlSession 或映射器来注入。那就是说 Spring 通常是处理事务的。
一旦事务创建之后,MyBatis-Spring 将会透明的管理事务。在你的 DAO 类中就不需要额外的代码了。
标准配置
要开启 Spring 的事务处理 , 在 Spring 的 XML 配置文件中简单创建一个 DataSourceTransactionManager 对象:
DefaultTransactionDefinition def = new DefaultTransactionDefinition();
def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);
TransactionStatus status = txManager.getTransaction(def);
</bean>
指定的 DataSource 一般可以是你使用 Spring 的任意 JDBC DataSource。这包含了连接池和通过 JNDI 查找获得的 DataSource。
要注意, 为事务管理器指定的 DataSource 必须和用来创建 SqlSessionFactoryBean 的是同一个数据源,否则事务管理器就无法工作了。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

9.5. 声明式事务管理大多数Spring用户选择声明式事务管理。

这是对应用代码影响最小的选择，因此也最符合非侵入式轻量级容器的理念。

Spring的声明式事务管理是通过Spring AOP实现的，因为事务方面的代码与Spring绑定并以一种样板式风格使用，不过尽管如此，你一般并不需要理解AOP概念就可以有效地使用Spirng的声明式事务管理。

从考虑EJB CMT和Spring声明式事务管理的相似以及不同之处出发是很有益的。

它们的基本方法是相似的：都可以指定事务管理到单独的方法；如果需要可以在事务上下文调用setRollbackOnly()方法。

不同之处在于：∙不像EJB CMT绑定在JTA上，Spring声明式事务管理可以在任何环境下使用。

只需更改配置文件，它就可以和JDBC、JDO、Hibernate或其他的事务机制一起工作。

∙Spring的声明式事务管理可以被应用到任何类（以及那个类的实例）上，不仅仅是像EJB那样的特殊类。

∙Spring提供了声明式的回滚规则：EJB没有对应的特性，我们将在下面讨论。

回滚可以声明式的控制，不仅仅是编程式的。

∙Spring允许你通过AOP定制事务行为。

例如，如果需要，你可以在事务回滚中插入定制的行为。

你也可以增加任意的通知，就象事务通知一样。

使用EJB CMT，除了使用setRollbackOnly()，你没有办法能够影响容器的事务管理。

∙Spring不提供高端应用服务器提供的跨越远程调用的事务上下文传播。

如果你需要这些特性，我们推荐你使用EJB。

然而，不要轻易使用这些特性。

通常我们并不希望事务跨越远程调用。

TransactionProxyFactoryBean在哪儿？Spring2.0及以后的版本中声明式事务的配置与之前的版本有相当大的不同。

主要差异在于不再需要配置TransactionProxyFactoryBean了。

Spring2.0之前的旧版本风格的配置仍然是有效的；你可以简单地认为新的<tx:tags/>替你定义了TransactionProxyFactoryBean。

回滚规则的概念比较重要：它使我们能够指定什么样的异常（和throwable）将导致自动回滚。

我们在配置文件中声明式地指定，无须在Java代码中。

同时，我们仍旧可以通过调用TransactionStatus的setRollbackOnly()方法编程式地回滚当前事务。

通常，我们定义一条规则，声明MyApplicationException必须总是导致事务回滚。

这种方式带来了显著的好处，它使你的业务对象不必依赖于事务设施。

典型的例子是你不必在代码中导入Spring API，事务等。

对EJB来说，默认的行为是EJB容器在遇到系统异常（通常指运行时异常）时自动回滚当前事务。

EJB CMT 遇到应用异常（例如，除了java.rmi.RemoteException外别的checked exception）时并不会自动回滚。

默认式Spring处理声明式事务管理的规则遵守EJB习惯（只在遇到unchecked exceptions时自动回滚），但通常定制这条规则会更有用。

9.5.1. 理解Spring的声明式事务管理实现本节的目的是消除与使用声明式事务管理有关的神秘性。

简单点儿总是好的，这份参考文档只是告诉你给你的类加上@Transactional注解，在配置文件中添加（'<tx:annotation-driven/>'）行，然后期望你理解整个过程是怎么工作的。

此节讲述Spring的声明式事务管理内部的工作机制，以帮助你在面对事务相关的问题时不至于误入迷途，回朔到上游平静的水域。

提示阅读Spring源码是理解清楚Spring事务支持的一个好方法。

Spring的Javadoc提供的信息丰富而完整。

我们建议你在开发自己的Spring应用时把日志级别设为'DEBUG'级，这样你能更清楚地看到幕后发生的事。

在理解Spring的声明式事务管理方面最重要的概念是：Spring的事务管理是通过AOP代理实现的。

其中的事务通知由元数据（目前基于XML或注解）驱动。

代理对象与事务元数据结合产生了一个AOP代理，要把AnnotationTransactionAspect织入你的应用，你或者基于AspectJ构建你的应用（参考AspectJ Development Guide），或者采取“载入时织入”（load-time weaving），参考第 6.8.4 节“在Spring应用中使用AspectJ Load-time weaving（LTW）”获得关于使用AspectJ进行“载入时织入”的讨论环境：JDK 1.4.x , Hibernate 3.1, Spring 2.0.6, 开发模式: Service + DAO 1. 代理工厂Bean事务管理( *ProxyFactoryBean) + Service + DAO配置我刚开始看Spring时用的书是林信良的《Spring技术手册》，书中对声明式事务主要采用 TransactionProxyFactoryBean，业务Bean如 Service或BO 类继承它来进行事务控制。

代理工厂Bean( *ProxyFactoryBean)这一类Spring 提供的工厂类，可将一个 bean 进行委托代理，从而达到控制方法行为的目的。

此类事务配置一般如下(因为我们未采用这种方式，就以书上的JDBC datasource举例说明。

不同公司采用的格式可能有所不同)：Xml代码1.2.3.4.<bean id="transactionManager"class="org.springframework.jdbc.datasource.DataSourceTransactionManager">5.<property name="dataSource">6.<ref local="dataSource"/>7.</property>8.</bean>9.10.11.<bean id="baseTransactionProxy"12.class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"13.abstract="true">14.<property name="transactionManager"ref="transactionManager"/>15.<property name="transactionAttributes">16.<props>17.<prop key="*">PROPAGATION_REQUIRED</prop> <!-- 本文仅简单用一种方式说明。

所有方法起事务，可以修改以精细和区别性控制事务 -->18.</props>19.</property>20.</bean>21.22.23.24.<bean id="authService"parent="baseTransactionProxy">25.<property name="target">26.<bean class="com.xxxx.cms.service.AuthorityService">27.<property name="authDao"ref="authDao"/>28.</bean>29.</property>30.</bean>31.<bean id="departmentService"parent="baseTransactionProxy">32.<property name="target">33.<bean class="com.xxxx.cms.service.pojo.DepartmentService">34.<property name="departmentDao"ref="departmentDao"/>35.</bean>36.</property>37.</bean>38.39.<bean id="authDao"class="com.xxxx.cms.dao.jdbc.AuthorityDao">40.<property name="dataSource"ref="dataSource"/>41.</bean>42.<bean id="departmentDao"class="com.xxxx.cms.dao.jdbc.DepartmentDao">43.<property name="dataSource"ref="dataSource"/>44.</bean>这种代理工厂Bean的事务管理一般都要求将 Service 的 bean 配置为class="org.springframework.transaction.interceptor.TransactionProxyFa ctoryBean" ，上面的例子使用了 parent="baseTransactionProxy" 继承机制简化了原书中的配置。

spring事务管理