Spring事务管理的使用细则浅析

目录

• Spring 事务管理接口
• 1、事务管理器接口 PlatformTransactionManager
• 2、事务定义接口 TransactionDefinition
• Spring 事务管理的实现方法
• 1、没有事务管理的情况分析
• 2、通过配置 XML 实现事务管理
• 3、利用注解实现事务管理
• 4、在业务层实现事务管理

 &emwww.devze.comsp;事务（Transaction）是访问数据库的一个操作序列，这些操作要么都做，要么都不做，是一个不可分割的工作单元。通过事务，数据库能将逻辑相关的一组操作绑定在一起，以便保持数据的完整性。

事务有4个重要特性，简称 ACID。

• A：Automicity，原子性，即事务中的所有操作要么全部执行，要么全部不执行。
• C：Consistency，一致性，事务执行的结果必须是使数据库从一个一致状态变到另一个一致状态。
• I：Isolation，隔离性，即一个事务的执行不能被另一个事务影响。
• D：Durabillity，持久性，即事务提交后将被永久保存。

  在Java EE开发中，事务原本属于 Dao 层中的范畴，但一般情况下需要将事务提升到业务层（Service层），以便能够使用事务的特性来管理具体的业务。

Spring 事务管理接口

  Spring 的事务管理，主要用到两个事务相关的接口。

1、事务管理器接口 PlatformTransactionManager

  事务管理器接口 PlatformTransactionManager 主要用于完成事务的提交、回滚，及获取事务的状态信息。PlatformTransactionManager 接口有两个常用的实现类：

• DataSourceTransactionManager实现类：使用JDBC或MyBATis进行数据持久化时使用。
• HibernateTransactionManager实现类：使用Hibernate进行数据持久化时使用。

  关于Spring的事务提交与回滚方式，默认是：发生运行时异常时回滚，发生受检查异常时提交， 也就是说程序抛出runtime异常的时候才会进行回滚，其他异常不回滚。

2、事务定义接口 TransactionDefinition

  事务定义接口 TransactionDefinition 中定义了事务描述相关的三类常量：事务隔离级别常量、事务传播http://www.devze.com行为常量、事务默认超时时限常量，及对它们的操作。

【1】事务隔离级别常量

  在应用程序中，多个事务并发运行，操作相同的数据，可能会引起脏读，不可重复读，幻读等问题 。

• 脏读（Dirty reads）:第一个事务访问并改写了数据，尚未提交事务，这时第二个事务进来了，读取了刚刚改写的数据，如果这时第一个事务回滚了，这样第二个事务读取到的数据就是无效的“脏数据”。
• 不可重复读（Nonrepeatable read）：第一个事务在其生命周期内多次查询同一个数据，在两次查询之间，第二个事务访问并改写了该数据，导致第一个事务两次查询同一个数据得到的结果不一样。
• 幻读（Phantom read）——幻读与不可重复读类似。它发生在第一个事务在生命周期进行了两次按同一查询条件查询数据，第一次按该查询条件读取了几行数据，这时第二个事务进来了，插入或删除了一些数据时，然后第一个事务再次按同一条件查询，发现多了一些原本不存在的记录或者原有的记录不见了。

  为了解决并发问题，TransactionDefinition 接口定义了5个事务隔离常量如下：

• DEFAULT：采用数据库 默认 的事务隔离级别。不同数据库不一样，mysql的默认为 REPEATABLE_READ(可重复读)；oracle默认为READ_COMMITTED(读已提交)。
• READ_UNCOMMITTED：读未提交。允许另外一个事务读取到当前事务未提交的数据，隔离级别最低，未解决任何并发问题，会产生脏读，不可重复读和幻像读。
• READ_COMMITTED：读已提交，被一个事务修改的数据提交后才能被另外一个事务读取，另外一个事务不能读取该事务未提交的数据。解决脏读，但还存在不可重复读与幻读。
• REPEATABLE_READ：可重复读。解决了脏读、不可重复读，但还存在幻读。
• SERIALIZABLE：串行化。按时间顺序一一执行多个事务，不存在并发问题，最可靠，但性能与效率最低。

【2】事务传播行为常量

  事务传播行为是指处于不同事务中的方法在相互调用时，执行期间事务的维护情况。例如，当一个事务方法B调用另一个事务方法A时，应当明确规定事务如何传播，比方可以规定A方法继续在B方法的现有事务中运行，也可以规定A方法开启一个新事务，在新事务中运行，现有事务先挂起，等A方法的新事务执行完毕后再恢复。TransactionDefinition 接口一共定义了 七种 传播行为常量说明如下。

• PROPAGATION_ REQUIRED：指定的方法必须在事务内执行。若当前存在事务，就加入到当前事务中；若当前没有事务，则创建一个新事务。这种传播行为是最常见的选择，也是 Spring 默认的事务传播行为。如该传播行为加在actionB ()方法上，该方法将被actionA ()调用，若actionA ()方法在执行时就是在事务内的，则actionB ()方法的执行也加入到该事务内执行。若actionA ()方法没有在事务内执行，则actionB ()方法会创建一个事务，并在其中执行。
• PROPAGATION_ SUPPORTS：指定的方法支持当前事务，但若当前没有事务，也可以以非事务方式执行。
• PROPAGATION_ MANDATORY：指定的方法必须在当前事务内执行，若当前没有事务，则直接抛出异常。
• PROPAGATION_ REQUIRES_NEW：总是新建一个事务，若当前存在事务，就将当前事务挂起，直到新事务执行完毕。
• PROPAGATION_ NOT_SUPPORTED：指定的方法不能在事务环境中执行，若当前存在事务，就将当前事务挂起。
• PROPAGATION_ NEVER：指定的方法不能在事务环境下执行，若当前存在事务，就直接抛出异常。
• PROPAGATION_ NESTED：指定的方法必须在事务内执行。若当前存在事务，则在嵌套事务内执行；若当前没有事务，则创建一个新事务。

【3】默认事务超时时限

  常量 TIMEOUT_DEFAULT 定义了事务底层默认的超时时限，及不支持事务超时时限设置的none值。该值一般使用默认值即可。

Spring 事务管理的实现方法

  Spring 支持编程式事务和声明式事务。

  编程式事务 直接在主业务代码中精确定义事务的边界，事务以硬编码的方式嵌入到了主业务代码里面，好处是能提供更加详细的事务管理，但由于编程式事务主业务与事务代码混在一起，不易分离，耦合度高，不利于维护与重用。

  声明式事务 则基于 AOP 方式，能将主业务操作与事务规则进行解耦。能在不影响业务代码的具体实现情况下实现事务管理。所以比较常用的是声明式事务。声明式事务又有两种具体的实现方式：基于XML配置文件的方式 和 基于注解的方式。

1、没有事务管理的情况分析

  项目案例： 模拟支付宝转账，张三、李四原本各有账户余额 2000 元，张三转账 500 元给李四，但转账过程中出现了异常。

  实现步骤：

【1】在 MySQL 中创建数据库表，代码如下：

create table alipay(
	aliname varchar (60),
	amount double
);

【2】在 dao 层创建 IAccountDao 接口，代码如下

package com.hh.dao;
public interface AlipayDao {
	public void transfer(String fromA,String toB,int amount);
}

【3】创建 IAccountDao 接口的实现类 IAccountDaoImpl，代码如下：

package com.hh.dao;
import org.springframework.jdbc.core.JdbcTemplate;
public class AlipayDaoImpl implements AlipayDao{
	JdbcTemplate jdbcTemplate;	
	public JdbcTemplate getJdbcTemplate() {
		return jdbcTemplate;
	}
	public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
		this.jdbcTemplate = jdbcTemplate;
	}
	@Override
	public void transfer(String fromA, String toB, int amount) {
		jdbcTemplate.update("update alipay set amount=amount-? where aliname=?",amount,fromA);
		Integer.parseInt("a");
		jdbcTemplate.update("update alipay set amount=amount+? where aliname=?",amount,toB);
	}
}

  这个 transfer 方法主要实现两个操作：

  操作一：转出操作，张三的账户钱减少；

  操作二：转入操作，里斯的账户钱增加；

  但两个操作中间模拟出现了差错（异常），这将导致张三的钱少了，而李四的钱却没有增加。

【4】添加 Spring 配置文件，代码如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context" 
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">	
	<!-- 配置数据源 -->
	<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName">
			<value>com.mysql.jdbc.Driver</value>
		</property>
		<property name="url">
			<value>jdbc:mys开发者_JS教程ql://localhost:3306/usersdb </value>
		</property>
		<property name="username">
			<value>root</value>
		</property>
		<property name="password">
			<value>root</value>
		</property>
	</bean>	
	<!-- 配置jdbcTemplate模板 注入dataSource -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource" />	
	</bean>	
	<!-- 配置DAO,注入jdbcTemplate属性值 -->
	<bean id="userDao" class="com.hh.dao.UserDaoImpl">
		<property name="jdbcTemplate" ref="jdbcTemplate"/>
	</bean>	
	<!-- 配置DAO,注入jdbcTemplate属性值 -->
	<bean id="alipayDao" class="com.hh.dao.AlipayDaoImpl">
		<property name="jdbcTemplate" ref="jdbcTemplate"/>
	</bean>
</beans>

【5】添加测试类 TestAlipay

package com.hh.test;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.hh.dao.AlipayDao;
public class TestAlipay {
	public static void main(String[] args) {
		ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
		AlipayDao alipayDao=(AlipayDao) context.getBean("alipayDao");
		alipayDao.transfer("张三", "李四", 500);
	}
}

2、通过配置 XML 实现事务管理

  下面进行事务管理方面的改进，目标是把类 AlipayDaoImpl 里的整个 transfer( ) 方法作为事务管理，这样 transfer( ) 里的所有操作（包括转出/转入操作）都纳入同一个事务，从而使 transfer( ) 里的所有操作要么一起成功，要么一起失败。这里利用了 Spring 的事务管理机制进行处理。

项目案例： 模拟支付宝转账，张三、李四原本各有账户余额 2000 元，张三转账 500 元给李四，但转账过程中间出现异常，导致数据不一致 ，现应用 Spring 的事务管理，配置 XML，避免不一致的情况。

实现步骤：

【1】修改 Spring 配置文件，内容如下：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context" 
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">	
	<!-- 配置数据源 -->
	<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName">
			<value>com.mysql.jdbc.Driver</value>
		</property>
		<property name="url">
			<value>jdbc:mysql://localhost:3306/usersdb </value>
		</property>
		<property name="username">
			<value>root</value>
		</property>
		<property name="password">
			<value>root</value>
		</property>
	</bean>	
	<!-- 配置jdbcTemplate模板 注入dataSource -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource" />	
	</bean>	
	<!-- 配置DAO,注入jdbcTemplate属性值 -->
	<bean id="alipayDao" class="com.lifeng.dao.AlipayDaoImpl">
		<property name="jdbcTemplate" ref="jdbcTemplate"/>
	</bean>
	<!-- 定义事务管理器 -->
	<bean id="txManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>
	<!-- 编写事务通知 -->
	<tx:advice id="txAdvice" transaction-manager="txManager">
		<tx:attributes>
			<tx:method name="*" propagation="REQUIRED" 	isolation="DEFAULT"	 read-only="false" />			
			<!-- 
			<tx:method name="save*" propagation="REQUIRED" />
			<tx:method name="add*" propagation="REQUIRED" />
			<tx:method name="insert*" propagation="REQUIRED" />
			<tx:method name="delete*" propagation="REQUIRED" />
			<tx:method name="update*" propagation="REQUIRED" />
			<tx:method name="search*" propagation="SUPPORTS"python  read-only="true"/>
			<tx:method name="select*" propagation="SUPPORTS"  read-only="true"/>
			<tx:method name="find*" propagation="SUPPORTS"  read-only="true"/>
			<tx:method name="get*" propagation="SUPPORTS"  read-only="true"/> -->	
		</tx:attributes>
	</tx:advice>	
	<!-- 编写AOP,让spring自动将事务切入到目标切点 -->
	<aop:config>
		<!-- 定义切入点 -->
		<aop:pointcut id="txPointcut"
			expression="execution(* com.lifeng.dao.*.*(..))" />
		<!-- 将事务通知与切入点组合 -->
		<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut" />
	</aop:config>	
</beans>

  这里可以把事务功能理解为切面，通过aop配置实现事务（切面）自动切入到切入点（目标方法），从而将目标方法（切入点）纳入事务管理，而目标方法本身可以不用管事务，专心做自已的主业务功能就行了

【2】其它程序代码不变，运行测试。

  测试时尽管转账中间出现了异常，但是张三、李四的钱都没变化，保持了一致性，这样就达到了目的，证明了 transfer 方法中的两个操作都纳php入了同一个事务。发生异常时，事务回滚，保证了数据的一致性。

  上面配置中：

<tx:method name="*" propagation="REQUIRED" 
		isolation="DEFAULT"	 read-only="false" />

  表示匹配的切点方法都进行事务管理，这里*表示匹配所有切点方法，propagation="REQUIRED"表示匹配的切点方法必须在事务内执行，isolation="DEFAULT"表示事务隔离级别默认，对于MySQL数据库，隔离级别为REPEATABLE_READ（可重复读）。read-only="false"表示非只读。

  这个配置粒度太大，所有方法都同一种事务管理模式，要想不同的方法实现不一样的事务管理，还得细化配置。项目中常见的细化配置如下面代码所示。

	<!-- 编写通知 -->
	<tx:advice id="txAdvice" transaction-manager="txManager">
		<tx:attributes>
			<tx:method name="save*" propagation="REQUIRED" />
			<tx:method name="add*" propagation="REQUIRED" />
			<tx:method name="insert*" propagation="REQUIRED" />
			<tx:method name="delete*" propagation="REQUIRED" />
			<tx:method name="update*" propagation="REQUIRED" />
			<tx:method name="search*" propagation="SUPPORTS"  read-only="true"/>
			<tx:method name="select*" propagation="SUPPORTS"  read-only="true"/>
			<tx:method name="find*" propagation="SUPPORTS"  read-only="true"/>
			<tx:method name="get*" propagation="SUPPORTS"  read-only="true"/>
		</tx:attributes>
	</tx:advice>

  这样，不同的方法匹配不同的事务管理模式。

  <tx:method name=“save*” propagation=“REQUIRED” />表示凡是以save开头的切点方法必须在事务内执行，其他增删改都一样的意思，查的话就不同<tx:method name=“select*” propagation=“SUPPORTS” read-only=“true”/>表示心是以select开头的切点方法支持当前事务，但若当前没有事务，也可以以非事务方式执行，read-only="true"表示只读，其他几个类似。

3、利用注解实现事务管理

  上面是利用XML配置文件实现事务管理的办法，下面来学习用注解实现事务管理。

  使用@Transactional注解在类或方法上，即可实现事务管理。 @Transactional注解的属性有下面这些（可选）：

• propagation：用于设置事务传播的属性，该属性类型为propagation枚举，默认值为Propagation.REQUIRED。
• isolation：用于设置事务的隔离级别，该属性类型为Isolation枚举，默认值为Isolation.DEFAULT。
• readOnly：用于设置该方法对数据库的操作是否是只读的，该属性为boolean，默认值false。
• timeout：用于设置本操作与数据库连接的超时时限。单位为秒，类型为int，默认值为-1，即没有时限。
• rollbackFor：指定需要回滚的异常类，类型为 Class[]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。
• rollbackForClassName：指定需要回滚的异常类类名，类型为 String[]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。
• noRollbackFor：指定不需要回滚的异常类。类型为Class[]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。
• noRollbackForClassName：指定不需要回滚的异常类类名。类型为String[]，默认值为空数组。当然，若只有一个异常类时，可以不使用数组。

  需要注意的是，@Transactional 若用在方法上，只能用于public方法上。对于其他非 public方法，如果加上了注解 @Transactional，虽然 Spring 不会报错，但不会将指定事务织入到该方法中。因为Spring会忽略掉所有非public方法上的 @Transaction 注解。若 @Transaction 注解在类上，则表示该类上所有的方法均将在执行时织入事务。

项目案例： 模拟支付宝转账,张三李四原本各有账户余额2000元,张三转账500元给李四,但转账过程中间出现异常，应用spring的事务管理，使用注解,避免不一致的情况。

实现步骤：

【1】修改 Spring 配置文件如下:

	<!-- 定义事务管理器 -->
	<bean id="txManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>
	<!-- 开启事务注解驱动 -->
	<tx:annotation-driven transaction-manager="txManager"/></beans>

  可以发现，配置文件比之前简编程客栈化了很多，事务方面，只需定义好事务管理器，再开启事务注解驱动就行了。其他的交给注解来解决。

【2】利用 @Transactional 注解修改转账方法。

  @Transactional 既可以用来修饰类，也可以修饰方法，如果修饰类，则表示事务的设置对整个类的所有方法都起作用，如果修饰在方法上，则只对该方法起作用，关键代码如下。

public class AlipayDaoImpl implements AlipayDao{
@Override
	@Transactional(propagation=Propagation.REQUIRED,isolation=Isolation.DEFAULT,readOnly=false)
	public void transfer(String fromA, String toB, int amount) {
		jdbcTemplate.update("update alipay set amount=amount-? where aliname=?",amount,fromA);
		Integer.parseInt("a");
		jdbcTemplate.update("update alipay set amount=amount+? where aliname=?",amount,toB);
	}

  将transfer方法注解为事务。

【3】运行测试，发现数据库同样没改变，所以注解事务起到作用了。

4、在业务层实现事务管理

  上面的案例是在DAO层实现事务管理，相对简单一些，但实际上开发时需要在业务层实现事务管理，而不是在DAO层，为此，项目修改如下，特别要注意在业务层的事务管理实现。

项目案例： 模拟支付宝转账,张三李四原本各有账户余额2000元,张三转账500元给李四,但转账过程中间出现异常，在业务层应用spring的事务管理，配置xml,避免不一致的情况。

实现步骤：

【1】修改DAO层，转出转入分拆成两个方法。

	@Override
	public void tranferFrom(String fromA,int amount){
		jdbcTemplate.update("update alipay set amount=amount-? where aliname=?",amount,fromA);
	}
	@Override
	public void tranferTo(String toB,int amount){
		jdbcTemplate.update("update alipay set amount=amount+? where aliname=?",amount,toB);
	}

【2】新建包com.hh.service，创建业务层AlipayService.java类，代码如下：

public class AlipayService {
	private AlipayDao alipayDao;
		public void transfer(String fromA, String toB, int amount) {
		alipayDao.tranferFrom(fromA, amount);
		Integer.parseInt("a");
		alipayDao.tranferTo(toB, amount);
	}
}

  上述代码相当于把有异常问题的 transfer( ) 方法迁移到业务层中来。

【3】修改配置文件。关键配置如下：

	<!-- 定义事务管理器 -->
	<bean id="txManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>
	<!-- 编写事务通知 -->
	<tx:advice id="txAdvice" transaction-manager="txManager">
		<tx:attributes>
			<tx:method name="*" propagation="REQUIRED" 	isolation="DEFAULT"	 read-only="false" />		
		</tx:attributes>
	</tx:advice>	
	<!-- 编写AOP,让spring自动将事务切入到目标切点 -->
	<aop:config>
		<!-- 定义切入点 -->
		<aop:pointcut id="txPointcut"
			expression="execution(* com.lifeng.service.*.*(..))" />
		<!-- 将事务通知与切入点组合 -->
		<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut" />
	</aop:config>

【4】修改测试类，代码如下：

public class TestAlipay {
	public static void main(String[] args) {
		ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
		AlipayService alipayService=(AlipayService) context.getBean("alipayService");
		alipayService.transfer("张三", "李四", 500);
	}
}

  测试结束，数据库的数据保持不变，证明事务管理成功。

到此这篇关于Spring事务管理的使用细则浅析的文章就介绍到这了,更多相关Spring事务管理内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！