Spring编程式事务实现

编程式事务概述

       所谓编程式事务指的是通过编码方式实现事务,即类似于JDBC编程实现事务管理。

       Spring框架提供一致的事务抽象,因此对于JDBC还是JTA事务都是采用相同的API进行编程。

 

java代码:
  1. Connection conn = null;  
  2. UserTransaction tx = null;  
  3. try {  
  4.     tx = getUserTransaction();                       //1.获取事务  
  5.     tx.begin();                                    //2.开启JTA事务  
  6.     conn = getDataSource().getConnection();           //3.获取JDBC  
  7.     //4.声明SQL  
  8.     String sql = "select * from INFORMATION_SCHEMA.SYSTEM_TABLES";  
  9.     PreparedStatement pstmt = conn.prepareStatement(sql);//5.预编译SQL  
  10.     ResultSet rs = pstmt.executeQuery();               //6.执行SQL  
  11.     process(rs);                                   //7.处理结果集  
  12.     closeResultSet(rs);                             //8.释放结果集  
  13.     tx.commit();                                  //7.提交事务  
  14. catch (Exception e) {  
  15.     tx.rollback();                                 //8.回滚事务  
  16.     throw e;  
  17. finally {  
  18.    conn.close();                                //关闭连接  
  19. }  

       此处可以看到使用UserTransaction而不是Connection连接进行控制事务,从而对于JDBC事务和JTA事务是采用不同API进行编程控制的,并且JTA和JDBC事务管理的异常也是不一样的。

       具体如何使用JTA编程进行事务管理请参考cn.javass.spring.chapter9包下的TranditionalTransactionTest类。

       而在Spring中将采用一致的事务抽象进行控制和一致的异常控制,即面向PlatformTransactionManager接口编程来控制事务。

 Spring对编程式事务的支持

Spring中的事务分为物理事务和逻辑事务;

  • 物理事务:就是底层数据库提供的事务支持,如JDBC或JTA提供的事务;
  • 逻辑事务:是Spring管理的事务,不同于物理事务,逻辑事务提供更丰富的控制,而且如果想得到Spring事务管理的好处,必须使用逻辑事务,因此在Spring中如果没特别强调一般就是逻辑事务;

逻辑事务即支持非常低级别的控制,也有高级别解决方案:

  • 低级别解决方案:

         工具类:使用工具类获取连接(会话)和释放连接(会话),如使用org.springframework.jdbc.datasource包中的ConnectionUtils类来获取和释放具有逻辑事务功能的连接。当然对集成第三方ORM框架也提供了类似的工具类,如对Hibernate提供了SessionFactoryUtils工具类,JPA的EntityManagerFactoryUtils等,其他工具类都是使用类似***Utils命名;

 

java代码:
  1. //获取具有Spring事务(逻辑事务)管理功能的连接  
  2. DataSourceUtils. getConnection(DataSource dataSource)  
  3. //释放具有Spring事务(逻辑事务)管理功能的连接  
  4. DataSourceUtils. releaseConnection(Connection con, DataSource dataSource)  
  5.    

 

         TransactionAwareDataSourceProxy:使用该数据源代理类包装需要Spring事务管理支持的数据源,该包装类必须位于最外层,主要用于遗留项目中可能直接使用数据源获取连接和释放连接支持或希望在Spring中进行混合使用各种持久化框架时使用,其内部实际使用ConnectionUtils工具类获取和释放真正连接;

 

java代码:
  1. <!--使用该方式包装数据源,必须在最外层,targetDataSource 知道目标数据源-->  
  2. <bean id="dataSourceProxy"  
  3. class="org.springframework.jdbc.datasource.  
  4. TransactionAwareDataSourceProxy">  
  5.     <property name="targetDataSource" ref="dataSource"/>  
  6. </bean>  

 

通过如上方式包装数据源后,可以在项目中使用物理事务编码的方式来获得逻辑事务的支持,即支持直接从DataSource获取连接和释放连接,且这些连接自动支持Spring逻辑事务;

  • 高级别解决方案:

         模板类:使用Spring提供的模板类,如JdbcTemplate、HibernateTemplate和JpaTemplate模板类等,而这些模板类内部其实是使用了低级别解决方案中的工具类来管理连接或会话;

 

Spring提供两种编程式事务支持:直接使用PlatformTransactionManager实现和使用TransactionTemplate模板类,用于支持逻辑事务管理。

如果采用编程式事务推荐使用TransactionTemplate模板类和高级别解决方案。

使用PlatformTransactionManager

首先让我们看下如何使用PlatformTransactionManager实现来进行事务管理:

1、数据源定义,此处使用第7章的配置文件,即“chapter7/ applicationContext-resources.xml”文件。

 

2、事务管理器定义(chapter9/applicationContext-jdbc.xml):

 

java代码:
  1. <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">    
  2.     <property name="dataSource" ref="dataSource"/>  
  3. </bean>  

 

3、 准备测试环境:

3.1、首先准备测试时使用的SQL:

 

java代码:
  1. package cn.javass.spring.chapter9;  
  2. //省略import  
  3. public class TransactionTest {  
  4.     //id自增主键从0开始  
  5.     private static final String CREATE_TABLE_SQL = "create table test" +  
  6.     "(id int GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, " +  
  7.     "name varchar(100))";  
  8.     private static final String DROP_TABLE_SQL = "drop table test";  
  9.     private static final String INSERT_SQL = "insert into test(name) values(?)";  
  10.     private static final String COUNT_SQL = "select count(*) from test";  
  11.     ……  
  12. }  

 

3.2、初始化Spring容器

 

java代码:
  1. package cn.javass.spring.chapter9;  
  2. //省略import  
  3. public class TransactionTest {  
  4.     private static ApplicationContext ctx;  
  5.     private static PlatformTransactionManager txManager;  
  6.     private static DataSource dataSource;  
  7.     private static JdbcTemplate jdbcTemplate;  
  8.     ……  
  9.     @BeforeClass  
  10.     public static void setUpClass() {  
  11.         String[] configLocations = new String[] {  
  12.                 "classpath:chapter7/applicationContext-resources.xml",  
  13.                 "classpath:chapter9/applicationContext-jdbc.xml"};  
  14.         ctx = new ClassPathXmlApplicationContext(configLocations);  
  15.         txManager = ctx.getBean(PlatformTransactionManager.class);  
  16.         dataSource = ctx.getBean(DataSource.class);  
  17.         jdbcTemplate = new JdbcTemplate(dataSource);  
  18.     }   
  19.     ……  
  20. }  

 

3.3、使用高级别方案JdbcTemplate来进行事务管理器测试:

 

java代码:
  1. @Test  
  2. public void testPlatformTransactionManager() {  
  3.     DefaultTransactionDefinition def = new DefaultTransactionDefinition();  
  4.     def.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);  
  5.     def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);  
  6.     TransactionStatus status = txManager.getTransaction(def);  
  7.     jdbcTemplate.execute(CREATE_TABLE_SQL);  
  8.     try {  
  9.         jdbcTemplate.update(INSERT_SQL, "test");  
  10.         txManager.commit(status);  
  11.     } catch (RuntimeException e) {  
  12.         txManager.rollback(status);  
  13.     }  
  14.     jdbcTemplate.execute(DROP_TABLE_SQL);  
  15. }  
  • DefaultTransactionDefinition:事务定义,定义如隔离级别、传播行为等,即在本示例中隔离级别为ISOLATION_READ_COMMITTED(提交读),传播行为为PROPAGATION_REQUIRED(必须有事务支持,即如果当前没有事务,就新建一个事务,如果已经存在一个事务中,就加入到这个事务中)。
  • TransactionStatus:事务状态类,通过PlatformTransactionManager的getTransaction方法根据事务定义获取;获取事务状态后,Spring根据传播行为来决定如何开启事务;
  • JdbcTemplate:通过JdbcTemplate对象执行相应的SQL操作,且自动享受到事务支持,注意事务是线程绑定的,因此事务管理器可以运行在多线程环境;
  • txManager.commit(status):提交status对象绑定的事务;
  • txManager.rollback(status):当遇到异常时回滚status对象绑定的事务。

 

3.4、使用低级别解决方案来进行事务管理器测试:

 

java代码:
  1. @Test  
  2. public void testPlatformTransactionManagerForLowLevel1() {  
  3. DefaultTransactionDefinition def = new DefaultTransactionDefinition();      def.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);      def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED);  
  4.   TransactionStatus status = txManager.getTransaction(def);  
  5.   Connection conn = DataSourceUtils.getConnection(dataSource);  
  6.   try {  
  7.       conn.prepareStatement(CREATE_TABLE_SQL).execute();  
  8.       PreparedStatement pstmt = conn.prepareStatement(INSERT_SQL);  
  9.       pstmt.setString(1"test");  
  10.       pstmt.execute();  
  11.       conn.prepareStatement(DROP_TABLE_SQL).execute();  
  12.       txManager.commit(status);  
  13.   } catch (Exception e) {  
  14.       status.setRollbackOnly();  
  15.       txManager.rollback(status);  
  16.   } finally {  
  17.       DataSourceUtils.releaseConnection(conn, dataSource);  
  18. }  
  19. }  
  20.    

 

低级别方案中使用DataSourceUtils获取和释放连接,使用txManager开管理事务,而且面向JDBC编程,比起模板类方式来繁琐和复杂的多,因此不推荐使用该方式。在此就不介绍数据源代理类使用了,需要请参考platformTransactionManagerForLowLevelTest2测试方法。

 

到此事务管理是不是还很繁琐?必须手工提交或回滚事务,有没有更好的解决方案呢?Spring提供了TransactionTemplate模板类来简化事务管理。

9.3.4  使用TransactionTemplate

TransactionTemplate模板类用于简化事务管理,事务管理由模板类定义,而具体操作需要通过TransactionCallback回调接口或TransactionCallbackWithoutResult回调接口指定,通过调用模板类的参数类型为TransactionCallback或TransactionCallbackWithoutResult的execute方法来自动享受事务管理。

TransactionTemplate模板类使用的回调接口:

  • TransactionCallback:通过实现该接口的“T doInTransaction(TransactionStatus status) ”方法来定义需要事务管理的操作代码;
  • TransactionCallbackWithoutResult:继承TransactionCallback接口,提供“void doInTransactionWithoutResult(TransactionStatus status)”便利接口用于方便那些不需要返回值的事务操作代码。

1、接下来演示一下TransactionTemplate模板类如何使用:

 

java代码:
  1. @Test  
  2. public void testTransactionTemplate() {//位于TransactionTest类中  
  3.   jdbcTemplate.execute(CREATE_TABLE_SQL);  
  4.   TransactionTemplate transactionTemplate = new TransactionTemplate(txManager);  
  5.   transactionTemplate.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);  
  6.   transactionTemplate.execute(new TransactionCallbackWithoutResult() {  
  7.       @Override  
  8.       protected void doInTransactionWithoutResult(TransactionStatus status) {  
  9.          jdbcTemplate.update(INSERT_SQL, "test");  
  10.   }});  
  11.   jdbcTemplate.execute(DROP_TABLE_SQL);  
  12. }  
  • TransactionTemplate :通过new TransactionTemplate(txManager)创建事务模板类,其中构造器参数为PlatformTransactionManager实现,并通过其相应方法设置事务定义,如事务隔离级别、传播行为等,此处未指定传播行为,其默认为PROPAGATION_REQUIRED;
  • TransactionCallbackWithoutResult:此处使用不带返回的回调实现,其doInTransactionWithoutResult方法实现中定义了需要事务管理的操作;
  • transactionTemplate.execute():通过该方法执行需要事务管理的回调。

这样是不是简单多了,没有事务管理代码,而是由模板类来完成事务管理。

 

注:对于抛出Exception类型的异常且需要回滚时,需要捕获异常并通过调用status对象的setRollbackOnly()方法告知事务管理器当前事务需要回滚,如下所示:

 

java代码:
  1. try {  
  2.     //业务操作  
  3. catch (Exception e) { //可使用具体业务异常代替  
  4.     status.setRollbackOnly();  
  5. }  

 

 

2、前边已经演示了JDBC事务管理,接下来演示一下JTA分布式事务管理:

 

java代码:
  1. @Test  
  2. public void testJtaTransactionTemplate() {  
  3.     String[] configLocations = new String[] {  
  4.       "classpath:chapter9/applicationContext-jta-derby.xml"};  
  5.     ctx = new ClassPathXmlApplicationContext(configLocations);  
  6.     final PlatformTransactionManager jtaTXManager = ctx.getBean(PlatformTransactionManager.class);  
  7.     final DataSource derbyDataSource1 = ctx.getBean("dataSource1", DataSource.class);  
  8.     final DataSource derbyDataSource2 = ctx.getBean("dataSource2", DataSource.class);  
  9.     final JdbcTemplate jdbcTemplate1 = new JdbcTemplate(derbyDataSource1);  
  10.     final JdbcTemplate jdbcTemplate2 = new JdbcTemplate(derbyDataSource2);  
  11.     TransactionTemplate transactionTemplate = new TransactionTemplate(jtaTXManager);   
  12.     transactionTemplate.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);  
  13.     jdbcTemplate1.update(CREATE_TABLE_SQL);  
  14.     int originalCount = jdbcTemplate1.queryForInt(COUNT_SQL);  
  15.     try {  
  16.         transactionTemplate.execute(new TransactionCallbackWithoutResult() {  
  17.             @Override  
  18.             protected void doInTransactionWithoutResult(TransactionStatus status) {  
  19.                 jdbcTemplate1.update(INSERT_SQL, "test");  
  20.                //因为数据库2没有创建数据库表因此会回滚事务  
  21.               jdbcTemplate2.update(INSERT_SQL, "test");  
  22.           }});  
  23.     } catch (RuntimeException e) {  
  24.         int count = jdbcTemplate1.queryForInt(COUNT_SQL);  
  25.         Assert.assertEquals(originalCount, count);  
  26.     }  
  27.     jdbcTemplate1.update(DROP_TABLE_SQL);  
  28. }  
  • 配置文件:使用此前定义的chapter9/applicationContext-jta-derby.xml;
  • jtaTXManager: JTA事务管理器;
  • derbyDataSource1和derbyDataSource2:derby数据源1和derby数据源2;
  • jdbcTemplate1和jdbcTemplate2:分别使用derbyDataSource1和derbyDataSource2构造的JDBC模板类;
  • transactionTemplate:使用jtaTXManager事务管理器的事务管理模板类,其隔离级别为提交读,传播行为默认为PROPAGATION_REQUIRED(必须有事务支持,即如果当前没有事务,就新建一个事务,如果已经存在一个事务中,就加入到这个事务中);
  • jdbcTemplate1.update(CREATE_TABLE_SQL):此处只有derbyDataSource1所代表的数据库创建了“test”表,而derbyDataSource2所代表的数据库没有此表;
  • TransactionCallbackWithoutResult:在此接口实现中定义了需要事务支持的操作:

         jdbcTemplate1.update(INSERT_SQL, "test"):表示向数据库1中的test表中插入数据;

         jdbcTemplate2.update(INSERT_SQL, "test"):表示向数据库2中的test表中插入数据,但数据库2没有此表将抛出异常,且JTA分布式事务将回滚;

  • Assert.assertEquals(originalCount, count):用来验证事务是否回滚,验证结果返回为true,说明分布式事务回滚了。

到此我们已经会使用PlatformTransactionManager和TransactionTemplate进行简单事务处理了,那如何应用到实际项目中去呢?接下来让我们看下如何在实际项目中应用Spring管理事务。

 

接下来看一下如何将Spring管理事务应用到实际项目中,为简化演示,此处只定义最简单的模型对象和不完整的Dao层接口和Service层接口:

 

1、 首先定义项目中的模型对象,本示例使用用户模型和用户地址模型:

 

模型对象一般放在项目中的model包里。

 

java代码:
  1. package cn.javass.spring.chapter9.model;  
  2. public class UserModel {  
  3.     private int id;  
  4.     private String name;  
  5.     private AddressModel address;  
  6.     //省略getter和setter  
  7. }  

 

 

java代码:
  1. package cn.javass.spring.chapter9.model;  
  2. public class AddressModel {  
  3.     private int id;  
  4.     private String province;  
  5.     private String city;  
  6.     privateString street;  
  7.     private int userId;  
  8.     //省略getter和setter  
  9. }  

 

2.1、定义Dao层接口:

 

java代码:
  1. package cn.javass.spring.chapter9.service;  
  2. import cn.javass.spring.chapter9.model.UserModel;  
  3. public interface IUserService {  
  4.     public void save(UserModel user);  
  5.     public int countAll();  
  6. }  
  7.    

 

 

java代码:
  1. package cn.javass.spring.chapter9.service;  
  2. import cn.javass.spring.chapter9.model.AddressModel;  
  3. public interface IAddressService {  
  4.     public void save(AddressModel address);  
  5.     public int countAll();  
  6. }  

 

2.2、定义Dao层实现:

 

java代码:
  1. package cn.javass.spring.chapter9.dao.jdbc;  
  2. //省略import,注意model要引用chapter包里的  
  3. public class UserJdbcDaoImpl extends NamedParameterJdbcDaoSupport implements IUserDao {  
  4.     private final String INSERT_SQL = "insert into user(name) values(:name)";  
  5.     private final String COUNT_ALL_SQL = "select count(*) from user";  
  6.     @Override  
  7.     public void save(UserModel user) {  
  8.         KeyHolder generatedKeyHolder = new GeneratedKeyHolder();  
  9.         SqlParameterSource paramSource = new BeanPropertySqlParameterSource(user);  
  10.         getNamedParameterJdbcTemplate().update(INSERT_SQL, paramSource, generatedKeyHolder);  
  11.         user.setId(generatedKeyHolder.getKey().intValue());  
  12.     }  
  13.     @Override  
  14.     public int countAll() {  
  15.        return getJdbcTemplate().queryForInt(COUNT_ALL_SQL);  
  16.     }  
  17. }  

 

 

java代码:
  1. package cn.javass.spring.chapter9.dao.jdbc;  
  2. //省略import,注意model要引用chapter包里的  
  3. public class AddressJdbcDaoImpl extends NamedParameterJdbcDaoSupport implements IAddressDao {  
  4.     private final String INSERT_SQL = "insert into address(province, city, street, user_id)" + "values(:province, :city, :street, :userId)";  
  5.     private final String COUNT_ALL_SQL = "select count(*) from address";  
  6.     @Override  
  7.     public void save(AddressModel address) {  
  8.         KeyHolder generatedKeyHolder = new GeneratedKeyHolder();  
  9.         SqlParameterSource paramSource = new BeanPropertySqlParameterSource(address);  
  10.         getNamedParameterJdbcTemplate().update(INSERT_SQL, paramSource, generatedKeyHolder);  
  11.         address.setId(generatedKeyHolder.getKey().intValue());  
  12. }  
  13.     @Override  
  14.     public int countAll() {  
  15.         return getJdbcTemplate().queryForInt(COUNT_ALL_SQL);  
  16.     }  
  17. }  

 

3.1、定义Service层接口,一般使用“I×××Service”命名:

 

java代码:
  1. package cn.javass.spring.chapter9.service;  
  2. import cn.javass.spring.chapter9.model.UserModel;  
  3. public interface IUserService {  
  4.     public void save(UserModel user);  
  5.     public int countAll();  
  6. }  
  7.   
  8.   
  9. package cn.javass.spring.chapter9.service;  
  10. import cn.javass.spring.chapter9.model.AddressModel;  
  11. public interface IAddressService {  
  12.     public void save(AddressModel address);  
  13.     public int countAll();  
  14. }  

 

3.2、定义Service层实现,一般使用“×××ServiceImpl”或“×××Service”命名:

 

java代码:
  1. package cn.javass.spring.chapter9.service.impl;  
  2. //省略import,注意model要引用chapter包里的  
  3. public class AddressServiceImpl implements IAddressService {  
  4.     private IAddressDao addressDao;  
  5.     private PlatformTransactionManager txManager;  
  6.     public void setAddressDao(IAddressDao addressDao) {  
  7.         this.addressDao = addressDao;  
  8.     }  
  9.     public void setTxManager(PlatformTransactionManager txManager) {  
  10.         this.txManager = txManager;  
  11.     }  
  12.     @Override  
  13.     public void save(final AddressModel address) {  
  14.         TransactionTemplate transactionTemplate = TransactionTemplateUtils.getDefaultTransactionTemplate(txManager);  
  15.         transactionTemplate.execute(new TransactionCallbackWithoutResult() {  
  16.            @Override  
  17.            protected void doInTransactionWithoutResult(TransactionStatus status) {  
  18.                 addressDao.save(address);  
  19.            }  
  20.         });  
  21.     }  
  22.     @Override  
  23.     public int countAll() {  
  24.         return addressDao.countAll();  
  25.     }  
  26. }  
  27.    

 

 

java代码:
  1.       
  2. package cn.javass.spring.chapter9.service.impl;  
  3. //省略import,注意model要引用chapter包里的  
  4. public class UserServiceImpl implements IUserService {  
  5.     private IUserDao userDao;  
  6.     private IAddressService addressService;  
  7.     private PlatformTransactionManager txManager;  
  8.     public void setUserDao(IUserDao userDao) {  
  9.         this.userDao = userDao;  
  10.     }  
  11.     public void setTxManager(PlatformTransactionManager txManager) {  
  12.         this.txManager = txManager;  
  13.     }  
  14.     public void setAddressService(IAddressService addressService) {  
  15.         this.addressService = addressService;  
  16.     }  
  17.     @Override  
  18.     public void save(final UserModel user) {  
  19.         TransactionTemplate transactionTemplate =  
  20.             TransactionTemplateUtils.getDefaultTransactionTemplate(txManager);  
  21.         transactionTemplate.execute(new TransactionCallbackWithoutResult() {  
  22.         @Override  
  23.            protected void doInTransactionWithoutResult(TransactionStatus status) {  
  24.                 userDao.save(user);  
  25.                 user.getAddress().setUserId(user.getId());  
  26.                 addressService.save(user.getAddress());  
  27.            }  
  28.         });  
  29.     }  
  30.     @Override  
  31.     public int countAll() {  
  32.         return userDao.countAll();  
  33.     }  
  34. }  
  35.    
  36.    

 

Service实现中需要Spring事务管理的部分应该使用TransactionTemplate模板类来包装执行。

 

4、定义TransactionTemplateUtils,用于简化获取TransactionTemplate模板类,工具类一般放在util包中:

 

java代码:
  1. package cn.javass.spring.chapter9.util;  
  2. //省略import  
  3. public class TransactionTemplateUtils {  
  4.     public static TransactionTemplate getTransactionTemplate(  
  5.             PlatformTransactionManager txManager,  
  6.             int propagationBehavior,  
  7.             int isolationLevel) {  
  8.         
  9.         TransactionTemplate transactionTemplate = new TransactionTemplate(txManager);  
  10.         transactionTemplate.setPropagationBehavior(propagationBehavior);  
  11.         transactionTemplate.setIsolationLevel(isolationLevel);  
  12.         return transactionTemplate;  
  13.     }  
  14.      
  15.     public static TransactionTemplate getDefaultTransactionTemplate(PlatformTransactionManager txManager) {  
  16.         return getTransactionTemplate(  
  17.                 txManager,  
  18.                 TransactionDefinition.PROPAGATION_REQUIRED,  
  19.                 TransactionDefinition.ISOLATION_READ_COMMITTED);  
  20.     }  
  21. }  
  22.    

 

getDefaultTransactionTemplate用于获取传播行为为PROPAGATION_REQUIRED,隔离级别为ISOLATION_READ_COMMITTED的模板类。

      

 

5、数据源配置定义,此处使用第7章的配置文件,即“chapter7/ applicationContext-resources.xml”文件。

 

6、Dao层配置定义(chapter9/dao/applicationContext-jdbc.xml):

 

java代码:
  1. <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">    
  2.     <property name="dataSource" ref="dataSource"/>  
  3. </bean>  
  4. <bean id="abstractDao" abstract="true">  
  5.     <property name="dataSource" ref="dataSource"/>  
  6. </bean>    

 

 

java代码:
  1. <bean id="userDao" class="cn.javass.spring.chapter9.dao.jdbc.UserJdbcDaoImpl" parent="abstractDao"/>  
  2. <bean id="addressDao" class="cn.javass.spring.chapter9.dao.jdbc.AddressJdbcDaoImpl" parent="abstractDao"/>  

 

 

7、Service层配置定义(chapter9/service/applicationContext-service.xml):

 

java代码:
  1. <bean id="userService" class="cn.javass.spring.chapter9.service.impl.UserServiceImpl">  
  2.     <property name="userDao" ref="userDao"/>  
  3.     <property name="txManager" ref="txManager"/>  
  4.     <property name="addressService" ref="addressService"/>  
  5. </bean>  
  6. <bean id="addressService" class="cn.javass.spring.chapter9.service.impl.AddressServiceImpl">  
  7.     <property name="addressDao" ref="addressDao"/>  
  8.     <property name="txManager" ref="txManager"/>  
  9. </bean>  

      

8、准备测试需要的表创建语句,在TransactionTest测试类中添加如下静态变量:

 

java代码:
  1. private static final String CREATE_USER_TABLE_SQL =  
  2.     "create table user" +  
  3.     "(id int GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, " +  
  4.     "name varchar(100))";  
  5. private static final String DROP_USER_TABLE_SQL = "drop table user";  
  6.    
  7. private static final String CREATE_ADDRESS_TABLE_SQL =  
  8.     "create table address" +  
  9.     "(id int GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY, " +  
  10.     "province varchar(100), city varchar(100), street varchar(100), user_id int)";  
  11. private static final String DROP_ADDRESS_TABLE_SQL = "drop table address";  

 

9、 测试一下吧:

 

java代码:
  1. @Test  
  2.     public void testServiceTransaction() {  
  3.         String[] configLocations = new String[] {  
  4.         "classpath:chapter7/applicationContext-resources.xml",  
  5.         "classpath:chapter9/dao/applicationContext-jdbc.xml",  
  6.         "classpath:chapter9/service/applicationContext-service.xml"};  
  7.         ApplicationContext ctx2 = new ClassPathXmlApplicationContext(configLocations);  
  8.          
  9.         DataSource dataSource2 = ctx2.getBean(DataSource.class);  
  10.         JdbcTemplate jdbcTemplate2 = new JdbcTemplate(dataSource2);  
  11.         jdbcTemplate2.update(CREATE_USER_TABLE_SQL);  
  12.         jdbcTemplate2.update(CREATE_ADDRESS_TABLE_SQL);  
  13.          
  14.         IUserService userService = ctx2.getBean("userService", IUserService.class);  
  15.         IAddressService addressService = ctx2.getBean("addressService", IAddressService.class);  
  16.         UserModel user = createDefaultUserModel();  
  17.         userService.save(user);  
  18.         Assert.assertEquals(1, userService.countAll());  
  19.         Assert.assertEquals(1, addressService.countAll());  
  20.         jdbcTemplate2.update(DROP_USER_TABLE_SQL);  
  21.         jdbcTemplate2.update(DROP_ADDRESS_TABLE_SQL);  
  22. }  
  23. private UserModel createDefaultUserModel() {  
  24.     UserModel user = new UserModel();  
  25.     user.setName("test");  
  26.     AddressModel address = new AddressModel();  
  27.     address.setProvince("beijing");  
  28.     address.setCity("beijing");  
  29.     address.setStreet("haidian");  
  30.     user.setAddress(address);  
  31.     return user;  
  32. }  
  33.    

 

从Spring容器中获取Service层对象,调用Service层对象持久化对象,大家有没有注意到Spring事务全部在Service层定义,为什么会在Service层定义,而不是Dao层定义呢?这是因为在服务层可能牵扯到业务逻辑,而每个业务逻辑可能调用多个Dao层方法,为保证这些操作的原子性,必须在Service层定义事务。

展开阅读全文

没有更多推荐了,返回首页