使用Spring配置文件实现事务管理

最新推荐文章于 2021-12-30 15:19:18 发布
最新推荐文章于 2021-12-30 15:19:18 发布
阅读量2.2k 收藏 1
点赞数
分类专栏： Spring 文章标签： spring aop delete exception attributes class

  在前面我们介绍的都是基于注解的方式来使用事务，现在来学习下基于XML的方式怎样来配置事务，先把PersonServiceBean.java里的注解去掉，
PersonServiceBean.java

Java代码 复制代码
  1. package cn.itcast.service.impl;   
  2.   
  3. import java.util.List;   
  4.   
  5. import javax.sql.DataSource;   
  6.   
  7. import org.springframework.jdbc.core.JdbcTemplate;   
  8.   
  9. import cn.itcast.bean.Person;   
  10. import cn.itcast.service.PersonService;   
  11.   
  12. public class PersonServiceBean implements PersonService {   
  13.     private JdbcTemplate jdbcTemplate;   
  14.        
  15.     public void setDataSource(DataSource dataSource) {   
  16.         this.jdbcTemplate = new JdbcTemplate(dataSource);   
  17.     }   
  18.        
  19.     public void delete(Integer personid) throws Exception{   
  20.         jdbcTemplate.update("delete from person where id=?", new Object[]{personid},   
  21.                 new int[]{java.sql.Types.INTEGER});   
  22.     }   
  23.        
  24.     public Person getPerson(Integer personid) {        
  25.         return (Person)jdbcTemplate.queryForObject("select * from person where id=?", new Object[]{personid},    
  26.                 new int[]{java.sql.Types.INTEGER}, new PersonRowMapper());   
  27.     }   
  28.   
  29.     @SuppressWarnings("unchecked")   
  30.     public List<Person> getPersons() {   
  31.         return (List<Person>)jdbcTemplate.query("select * from person", new PersonRowMapper());   
  32.     }   
  33.   
  34.     public void save(Person person) {   
  35.         jdbcTemplate.update("insert into person(name) values(?)", new Object[]{person.getName()},   
  36.                 new int[]{java.sql.Types.VARCHAR});   
  37.     }   
  38.   
  39.     public void update(Person person) {   
  40.         jdbcTemplate.update("update person set name=? where id=?", new Object[]{person.getName(), person.getId()},   
  41.                 new int[]{java.sql.Types.VARCHAR, java.sql.Types.INTEGER});   
  42.     }   
  43. }  
package cn.itcast.service.impl;

import java.util.List;

import javax.sql.DataSource;

import org.springframework.jdbc.core.JdbcTemplate;

import cn.itcast.bean.Person;
import cn.itcast.service.PersonService;

public class PersonServiceBean implements PersonService {
	private JdbcTemplate jdbcTemplate;
	
	public void setDataSource(DataSource dataSource) {
		this.jdbcTemplate = new JdbcTemplate(dataSource);
	}
	
	public void delete(Integer personid) throws Exception{
		jdbcTemplate.update("delete from person where id=?", new Object[]{personid},
				new int[]{java.sql.Types.INTEGER});
	}
	
	public Person getPerson(Integer personid) {		
		return (Person)jdbcTemplate.queryForObject("select * from person where id=?", new Object[]{personid}, 
				new int[]{java.sql.Types.INTEGER}, new PersonRowMapper());
	}

	@SuppressWarnings("unchecked")
	public List<Person> getPersons() {
		return (List<Person>)jdbcTemplate.query("select * from person", new PersonRowMapper());
	}

	public void save(Person person) {
		jdbcTemplate.update("insert into person(name) values(?)", new Object[]{person.getName()},
				new int[]{java.sql.Types.VARCHAR});
	}

	public void update(Person person) {
		jdbcTemplate.update("update person set name=? where id=?", new Object[]{person.getName(), person.getId()},
				new int[]{java.sql.Types.VARCHAR, java.sql.Types.INTEGER});
	}
}


目前这个bean是不受Spring管理的，我们通过配置文件的方式，在XML文件中对这个bean进行事务配置。
如果我们采用基于XML方式来配置事务的话，beans.xml里的<tx:annotation-driven transaction-manager="txManager"/>
这个就不再需要使用，删掉。
我们介绍下，如何使用基于XML方式配置事务，


采用基于XML方式配置事务
--------------------------------------------------------------------

Xml代码 复制代码
  1. <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
  2.     <property name="dataSource" ref="dataSource"/>  
  3. </bean>  
  4. <aop:config>  
  5.     <aop:pointcut id="transactionPointcut" expression="execution(* cn.itcast.service..*.*(..))"/>  
  6.     <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>  
  7. </aop:config>    
  8. <tx:advice id="txAdvice" transaction-manager="txManager">  
  9.       <tx:attributes>  
  10.         <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>  
  11.         <tx:method name="*"/>  
  12.             <!--其它方法使用默认的事务行为-->  
  13.       </tx:attributes>  
  14. </tx:advice>  



我们配置了一个<aop:config>,里面的切入点pointcut，它对哪些方法进行拦截呢？对cn.itcast.service这个包，及其子包底下的所有类的所有方法，实现拦截。  拦截到方法后，运用一个advisor（通知）,这个通知大家要注意，Spring里面已经给我们提供了一个事务通知了，通过<aop:advisor advice-ref...这个配置把它引入进来，这个通知，使用了上面的切入点，也就是说当拦截到这些业务方法的执行的时候呢，它会交给txAdvice这个事务通知进行处理.
txAdvice这个bean的定义，实际上在Spring容器里它也会注册一个事务管理器，应该说是注册一个通知管理器，专门用来做事务处理的这么一个bean。

接下来配置beans.xml

Xml代码 复制代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.        xmlns:context="http://www.springframework.org/schema/context"    
  5.        xmlns:aop="http://www.springframework.org/schema/aop"  
  6.        xmlns:tx="http://www.springframework.org/schema/tx"  
  7.        xsi:schemaLocation="http://www.springframework.org/schema/beans   
  8.            http://www.springframework.org/schema/beans/spring-beans-2.5.xsd   
  9.            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd   
  10.            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd   
  11.            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">  
  12.   
  13.      <context:property-placeholder location="classpath:jdbc.properties"/>  
  14.      <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">  
  15.         <property name="driverClassName" value="${driverClassName}"/>  
  16.         <property name="url" value="${url}"/>  
  17.         <property name="username" value="${username}"/>  
  18.         <property name="password" value="${password}"/>  
  19.          <!-- 连接池启动时的初始值 -->  
  20.          <property name="initialSize" value="${initialSize}"/>  
  21.          <!-- 连接池的最大值 -->  
  22.          <property name="maxActive" value="${maxActive}"/>  
  23.          <!-- 最大空闲值.当经过一个高峰时间后，连接池可以慢慢将已经用不到的连接慢慢释放一部分，一直减少到maxIdle为止 -->  
  24.          <property name="maxIdle" value="${maxIdle}"/>  
  25.          <!--  最小空闲值.当空闲的连接数少于阀值时，连接池就会预申请去一些连接，以免洪峰来时来不及申请 -->  
  26.          <property name="minIdle" value="${minIdle}"/>  
  27.      </bean>  
  28.   
  29.     <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">  
  30.        <property name="dataSource" ref="dataSource"/>  
  31.     </bean>  
  32.   
  33.     <aop:config>  
  34.         <aop:pointcut id="transactionPointcut" expression="execution(* cn.itcast.service..*.*(..))"/>  
  35.         <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>  
  36.     </aop:config>    
  37.     <tx:advice id="txAdvice" transaction-manager="txManager">  
  38.           <tx:attributes>  
  39.             <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>  
  40.             <tx:method name="*"/>  
  41.           </tx:attributes>  
  42.     </tx:advice>  
  43.   
  44.     <bean id="personService" class="cn.itcast.service.impl.PersonServiceBean">  
  45.         <property name="dataSource" ref="dataSource"/>  
  46.     </bean>  
  47. </beans>  


配置好事务了，PersonServiceBean这业务bean就可以受事务管理了。现在就可以使用Spring里面的声明式事务对它进行管理了，现在做一下测试，看事务是否应用起来了。
打开单元测试，执行save方法，保存一些数据进去。。
PersonServiceTest.java

Java代码 复制代码
  1. package junit.test;    
  2. import org.junit.BeforeClass;   
  3. import org.junit.Test;   
  4. import org.springframework.context.ApplicationContext;   
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;   
  6.   
  7. import cn.itcast.bean.Person;   
  8. import cn.itcast.service.PersonService;   
  9.   
  10. public class PersonServiceTest {   
  11.     private static PersonService personService;   
  12.   
  13.     @BeforeClass  
  14.     public static void setUpBeforeClass() throws Exception {   
  15.         try {   
  16.             ApplicationContext cxt = new ClassPathXmlApplicationContext("beans.xml");   
  17.             personService = (PersonService) cxt.getBean("personService");   
  18.         } catch (RuntimeException e) {   
  19.             e.printStackTrace();   
  20.         }   
  21.     }   
  22.   
  23.     @Test public void save(){   
  24.         for(int i=10; i<15; i++)   
  25.             personService.save(new Person("传智播客"+ i));   
  26.     }   
  27.   
  28.     ..................................   
  29.   
  30.     @Test public void delete(){   
  31.         try {   
  32.             personService.delete(3);   
  33.         } catch (Exception e) {   
  34.             e.printStackTrace();   
  35.         }   
  36.     }   
  37.   
  38.     ..................................   
  39. }  
package junit.test; 
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import cn.itcast.bean.Person;
import cn.itcast.service.PersonService;

public class PersonServiceTest {
	private static PersonService personService;

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
		try {
			ApplicationContext cxt = new ClassPathXmlApplicationContext("beans.xml");
			personService = (PersonService) cxt.getBean("personService");
		} catch (RuntimeException e) {
			e.printStackTrace();
		}
	}

	@Test public void save(){
		for(int i=10; i<15; i++)
			personService.save(new Person("传智播客"+ i));
	}

	..................................

	@Test public void delete(){
		try {
			personService.delete(3);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	..................................
}


现在数据库person表的记录如下：看图


为了进一步验证事务配置起作用了，我们可以这样做

Java代码 复制代码
  1. public void delete(Integer personid) throws Exception{   
  2.         jdbcTemplate.update("delete from person where id=?", new Object[]{personid},   
  3.                 new int[]{java.sql.Types.INTEGER});   
  4.         jdbcTemplate.update("delete from person_wrong_name where id=7");   
  5.     }  
public void delete(Integer personid) throws Exception{
		jdbcTemplate.update("delete from person where id=?", new Object[]{personid},
				new int[]{java.sql.Types.INTEGER});
		jdbcTemplate.update("delete from person_wrong_name where id=7");
	}


在PersonServiceBean.java的delete方法里面，执行两条update语句，默认情况下这两条语句都会在同一个事务里执行，如果说这个方法没有开启事务的话，这两条update语句会在各自的事务里执行（也就是说他们不能在同一事务里执行），我们通过这样来判断delete方法是否开了事务，如果开了事务，两条update语句就在同一事务里执行，如果没开事务，就会在各自的事务里执行，也就是说第二个update语句故意写错了，第二条语句会出错，它是否会引起第一条update语句的回滚呢？如果我们应用上了Spring的事务管理，他必然会一起回滚，如果没应用上的话，第一条update语句是会运行成功的。
运行单元测试的delete方法，

Java代码 复制代码
  1. @Test public void delete(){   
  2.     try {   
  3.         personService.delete(3);   
  4.     } catch (Exception e) {   
  5.         e.printStackTrace();   
  6.     }   
  7. }  
@Test public void delete(){
    try {
        personService.delete(3);
    } catch (Exception e) {
        e.printStackTrace();
    }
}



JUnit显示出错，查看数据库person表记录，发现id为3和7的记录还在，如图：



说明开了事务，两条都不被删。
假如我们没有应用事务管理的话，在beans.xml里，把下面的语句注释掉

Xml代码 复制代码
  1. <!--   
  2.     <aop:config>  
  3.         <aop:pointcut id="transactionPointcut" expression="execution(* cn.itcast.service..*.*(..))"/>  
  4.         <aop:advisor advice-ref="txAdvice" pointcut-ref="transactionPointcut"/>  
  5.     </aop:config>    
  6.     <tx:advice id="txAdvice" transaction-manager="txManager">  
  7.           <tx:attributes>  
  8.             <tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>  
  9.             <tx:method name="*"/>  
  10.           </tx:attributes>  
  11.     </tx:advice>  
  12. -->  


看下当我们没有应用Spring的事务管理器的时候，它是否能删除id=3这条记录（既是第一个update语句顺利提交不回滚）呢？
现在数据库person表的记录如下，看图：


运行单元测试的delete方法，JUnit说运行时出错，看数据库，如图：


id=3的记录不见了，id=7的记录还存在，这代表，事务管理器没有应用上，因为第一条update语句是在一个事务里执行，第二条update语句是在另一个事务里执行，因为它没有应用上Spring提供的事务管理，所以说他们两个update语句会在单独的事务中执行。 第一条是执行成功的，第二条是执行失败的。我们通过观察结果就可以看到它目前并没有应用上事务管理，所以一定要注意：以后在开发的时候，一定要确保你们的bean是受Spring的事务管理的。如果不受管理的话，你们就无法应用Spring给我们提供的这些功能，也就是说业务方法开启的时候给我们打开事务，在业务方法结束的时候根据运行情况如果没有抛出运行期例外的话，那么它就给我们提交事务，否则它就给我们回滚事务，这点大家是要注意的。

  基于XML方式使用事务就给大家介绍完了，具体使用XML方式配置事务，还是使用注解方式配置事务，Spring开发团队就建议我们采用注解方式来配置事务，因为采用注解方式来使用事务的话，我们的配置可以做到精确控制，可以针对某一个方法,使用起来比较灵活。如果采用配置方式为某个业务方法定义某些事务行为的话，那么这个配置文件配置内容会很臃肿，所以Spring的开发团队建议我们采用注解方式来配置事务。
   但是目前在企业开发中，目前大部分项目使用的还是基于XML配置方式来使用事务，但是以后很多新项目也慢慢开始转向到了注解方式，这两种方式大家都需要去熟悉。

xiaolang8762400
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring学习笔记(18)----使用Spring配置文件实现事务管理
03-17
NULL 博文链接：https://coolszy.iteye.com/blog/542781
spring 事务管理配置
不积跬步无以至千里，不积小流无以成江海
06-06 1222
一般的，我们把事务配在service层，利用service的业务逻辑接口统一的管理。 为什么不用在dao层呢？ 因为一个service有可能调用多个dao，而这多个dao有可能相互联系，有时候一个操作需要调用多次数据库，但是这多次调用要么全提交，要么全回滚。  因此，在dao层调用事务理论上说不是一个很明智的选择。应该有业务逻辑层service层负责事务，统一处理。  Spring
spring学习(十)—事务管理（配置文件方式实现）
alvin的博客
02-20 423
1.代码组织结构 2.服务层类package service;import dao.OrderDao;public class OrdersService { public OrderDao orderDao; public void setOrderDao(OrderDao orderDao) { this.orderDao = orderDao; }
spring配置文件中的事务管理问题
hy1255564202的博客
12-18 127
教程是这么写的： 应该是用的这里面的Spring事务配置的五种方式第五种 ：全注解方式 其中datasources是上面写的数据库连接池 这个写的看下入门：Spring中的Jdbc事务管理 这个很好，也没太懂，看先简书下面的参考文章 很详细：添加链接描述Spring入门——事务管理Transaction Manager ...
spring框架利用xml配置文件配置事务的方法
小白的记录
12-30 531
背景：模拟银行转账，为确保安全性，一般都要使用事务： 比如有转账的业务，其中有转账的方法，dao层略： public class AccountServiceImpl implements AccountService { private AccountDao accountDao; public void setAccountDao(AccountDao accountDao) { this.accountDao = accountDao; } @Ov
Spring事务管理配置文件问题排查
08-19
主要介绍了Spring事务管理配置文件问题排查,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring声明式事务配置管理方法
03-02
发布于2013-5-6项目使用SSH架构，现在要添加Spring事务管理功能，针对当前环境，只需要添加Spring2.0AOP类库即可。添加方法：点击项目右键->BuildPath->Addlibrarys:打开AddLibraries对话框，然后选定...
spring mvc+hibernate实现事务管理（配置文件版）
08-29
spring mvc hibernate整合，采用MyEclipse自动生成包和配置文件，jar包可能有多余，但是不影响整体效果。服务器tomcat。数据库mysql。
【Spring】怎么配置事务？看这一篇就够了
weixin_45321793的博客
04-27 3147
0、什么是事务 想象一个场景，A给B转账，A的钱转出去之后发生异常B没有收到钱，A的钱少了B的钱没有多，这不就乱套了吗？ 所以就引出了事务这个概念：事务是数据库操作最基本的单元，逻辑上的一组操作，这一组操作要么都执行成功，要么都失败 事务的作用就是为了保证用户的每一个操作都是可靠的，事务中的每一步操作都 必须成功执行，只要有发生异常就回退到事务开始未进行操作的状态,这些操作 要么都完成，要么都取消，从而保证数据满足一致性的要求 如下这段代码，如果不添加事务管理，就会导致A的钱减少，但是B的钱没有增多，所以在
使用Spring为业务层添加声明式事务
wzy18210825916的博客
09-17 4042
前言 业务层的职能不仅仅是调用DAO层这么简单，它在进行一个业务的时候，还有一件重要的事要兼顾——事务处理。事务处理是任何企业级应用开发中不能回避的一个重要问题，以往我们通过在业务方法中硬编码的方式进行事务控制，比如这样： Connection connection=null; try { connection=DatabaseUtil.getConnection(); co...
springmvc开启事务_在Controller中添加事务管理
weixin_42374930的博客
12-30 2546
写这篇文章之前先说明一下:1. Controller中添加事务管理,是可行的,但是强烈不推荐,因为不符合实际开发场景,还会导致一系列问题2. 事务请在Service处理,所有的业务逻辑请写在 Service,Service中异常请抛出,慎用 try...catch捕获异常写这边文章的背景:公司有个老的项目,springMVC + spring + mybatis,事务是在Service层处理的,...
配置文件来完成事务管理(AOP思想)
qq_37186314的博客
10-13 381
1. 声明式事务管理又分成两种方式 * 基于AspectJ的XML方式（重点掌握） * 基于AspectJ的注解方式（重点掌握） **Spring框架的事务管理之基于AspectJ的XML方式（重点掌握）** 1. 步骤一:恢复转账开发环境 2. 步骤二:引入AOP的开发包   3. 步骤三:配置事务管理器 &lt;!-- 配置事务管理器 --&gt; &lt;bean id="...
Spring事务配置的五种方式
xuanjiewu的专栏
06-07 3万+
转自：http://www.blogjava.net/robbie/archive/2009/04/05/264003.html  、  http://developer.51cto.com/art/200906/129854.htm 、 http://www.cnblogs.com/rushoooooo/archive/2011/08/28/2155960.html Spring 的事务管理
Spring 事务的配置和使用详解（包括手动对事务的控制部分）
whbing1471的博客
01-05 1万+
最近项目中用到了spring的注解类的事务管理，所以特地学习和记录一下spring的配置和使用。项目中使用的是springMVC + mybatis + mysql。spring的版本是4.3.0.RELEASE。1. spring 注解事务的配置Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式
Spring事务管理之几种方式实现事务
热门推荐
ChinaCR07的博客
12-15 10万+
1、事务认识 事务，大家所熟悉的事务（Transaction），基本上会就往Spring事务靠。其实Spring事务管理基于底层数据库本身的事务处理机制。数据库事务的基础，是掌握Spring事务管理的基础。这篇总结下Spring事务。 事务具备ACID四种特性，ACID是Atomic（原子性）、Consistency（一致性）、Isolation（隔离性）和Durability
spring事物管理(配置文件方式)
weixin_34216196的博客
04-16 55
1 <!-- 配置c3p0连接池 --> 2 <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> 3 <!-- 注入属性值 --> 4 <property name="driverClass" value="com...
Spring事务配置（配置文件的形式）
lxlong的博客
11-14 934
     声明了事务通知后, 就需要将它与切入点关联起来. 由于事务通知是在 &lt;aop:config&gt; 元素外部声明的, 所以它无法直接与切入点产生关联. 所以必须在 &lt;aop:config&gt; 元素中声明一个增强器通知与切入点关联起来. 由于 Spring AOP 是基于代理的方法, 所以只能增强公共方法. 因此, 只有公有方法才能通过 Spring AOP 进行事务管理...
使用 Spring 等框架进行事务管理
最新发布
05-30
1. 配置事务管理器：在 Spring 配置文件中配置事务管理器，例如： ``` <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> ``` 其中，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值