Spring事务管理使用详解

最新推荐文章于 2023-06-28 22:38:10 发布

你丶怎么睡得着的？

最新推荐文章于 2023-06-28 22:38:10 发布

阅读量501

点赞数 1

分类专栏： java web框架

本文链接：https://blog.csdn.net/qiuwenjie123/article/details/79761525

版权

java web框架专栏收录该内容

14 篇文章 0 订阅

订阅专栏

1、Spring关于事务管理所定义的三个接口

PlatformTransactionManager

平台事务管理器

TransactionDefinition

事务定义信息(隔离、传播、超时、只读）

TransactionStatus

事务具体运行状态（是否是新的事务，设置是否回滚）

2、接口的分析

（1）、下面是一些常用的平台事务管理器（PlatformTransactionManage）的实现类

（2）、事务的定义信息接口（TransactionDefinition）

主要是定义了事务的隔离级别以及事务的传播属性

隔离级别

传播属性

3、事务的传播属性

一般的三层架构如下图

我们一般都是将事务设置在Service层那么当我们调用Service层的一个方法的时候它能够保证我们的这个方法中执行的所有的对数据库的更新操作保持在一个事务中，在事务层里面调用的这些方法要么全部成功，要么全部失败。那么事务的传播特性也是从这里说起的。

如果你在你的Service层的这个方法中，除了调用了Dao层的方法之外，还调用了本类的其他的Service方法，那么在调用其他的Service方法的时候，这个事务是怎么规定的呢，我必须保证我在我方法里掉用的这个方法与我本身的方法处在同一个事务中，否则如果保证事物的一致性。事务的传播特性就是解决这个问题的

4、事务的管理方式

Spring支持两种事务的管理方式

——编程式的事务管理

在实际应用中很少使用

通过TransactionTemplate手动管理事务（为了方便我们的操作，Spring提供了一个TransactionTemplate）

——使用xml文件配置声明式事务

开发中推荐使用（代码的侵入性小）

Spring的声明式事务是通过AOP来实现的

下面来分别介绍一下

首先是编程式的事务管理

xml文件中进行相应的注入,先注入一个连接池

<!-- 配置c3p0连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driverClass}" />
		<property name="jdbcUrl" value="${jdbc.url}" />
		<property name="user" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
	</bean>

然后注入平台事务管理器和管理器的模板TransactionTemplate

<!-- ==================================1.编程式的事务管理=============================================== -->
	<!-- 配置事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>
	
	<!-- 配置事务管理的模板:Spring为了简化事务管理的代码而提供的类 -->
	<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
		<property name="transactionManager" ref="transactionManager"/>
	</bean>

配置Dao层和业务层，因为业务层中要进行事务管理，所以注入一个事务管理器模板TransactionTemplate

<!-- 配置业务层类 -->
	<bean id="accountService" class="com.zs.spring.demo1.AccountServiceImpl">
		<property name="accountDao" ref="accountDao" />
		<!-- 注入事务管理的模板 -->
		<property name="transactionTemplate" ref="transactionTemplate" />
	</bean>
	
	<!-- 配置DAO类(简化，会自动配置JdbcTemplate) -->
	<bean id="accountDao" class="com.zs.spring.demo1.AccountDaoImpl">
		<property name="dataSource" ref="dataSource" />
	</bean>

最后是业务层中事务管理的写法

import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;

public class AccountServiceImpl implements AccountService {
	//注入Dao层对象
	private AccountDao accountDao;
	//注入模板对象
	private TransactionTemplate transactionTemplate;

	@Override
	public void transfer(final String out, final String in, final Double money) {
		transactionTemplate.execute(new TransactionCallbackWithoutResult() {
                       //该方法内进行事务管理
			@Override
			protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
				accountDao.outMoney(out, money);
				int i = 1/0;
				accountDao.inMoney(in, money);
			}
		});
	}

	public void setAccountDao(AccountDao accountDao) {
		this.accountDao = accountDao;
	}

	public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
		this.transactionTemplate = transactionTemplate;
	}

}

使用xml文件配置声明式事务

这种方式也能细分为三种方式

a、基于TransactionProxyFactoryBean的方式

同样是要配置一个平台事务管理器（里面配置一个连接池）

<!-- 配置事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>

配置Dao层和业务层

<!-- 配置业务层类 -->
	<bean id="accountService" class="com.zs.spring.demo2.AccountServiceImpl">
		<property name="accountDao" ref="accountDao" />
	</bean>
	
	<!-- 配置DAO类(简化，会自动配置JdbcTemplate) -->
	<bean id="accountDao" class="com.zs.spring.demo2.AccountDaoImpl">
		<property name="dataSource" ref="dataSource" />
	</bean>

配置业务层的代理（使用时我们要使用这个加强过的业务代理类）

<!-- 配置业务层的代理 -->
	<bean id="accountServiceProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
		<!-- 配置目标对象 -->
		<property name="target" ref="accountService" />
		<!-- 注入事务管理器 -->
		<property name="transactionManager" ref="transactionManager"></property>
		<!-- 注入事务的属性 -->
		<property name="transactionAttributes">
			<props>
				<!-- 
					prop的格式:
						* PROPAGATION	:事务的传播行为
						* ISOTATION		:事务的隔离级别
						* readOnly		:只读
						* -EXCEPTION	:发生哪些异常回滚事务
						* +EXCEPTION 	:发生哪些异常不回滚事务
				 -->
				<prop key="transfer">PROPAGATION_REQUIRED</prop>
				<!-- <prop key="transfer">PROPAGATION_REQUIRED,readOnly</prop> -->
				<!-- <prop key="transfer">PROPAGATION_REQUIRED,+java.lang.ArithmeticException</prop> -->
			</props>
		</property>
	</bean>

业务层(我们不需要为了实现业务而做任何修改）

public class AccountServiceImpl implements AccountService {
	
	//注入转账的DAO
	private AccountDao accountDao;

	/**
	 * @param out	:转出账号
	 * @param in	:转入账号
	 * @param money	:转账金额
	 */
	@Override
	public void transfer( String out, String in, Double money) {
		accountDao.outMoney(out, money);
		//int i = 1/0;
		accountDao.inMoney(in, money);
		
	}

	public void setAccountDao(AccountDao accountDao) {
		this.accountDao = accountDao;
	}

}

最后是测试类（注意要注入代理后的业务类）

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext2.xml")
public class TransactionTest {

	/**
	 * 一定要注入代理类:因为代理类进行增强的操作
	 */
	//@Resource(name="accountService")
	@Resource(name="accountServiceProxy")
	private AccountService accountService;
	
	@Test
	public void demo1(){
		accountService.transfer("aaa", "bbb", 200d);
	}
}

缺点：每个业务层都要设置一个代理类，当业务层多起来时无疑代码量很大，维护时非常不方便

b、基于AspectJ的XML方式

配置平台事务管理器

<!-- 配置事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>

使用Aspect和aop配置事务（切入点处使用一个表达式就可以匹配多个需要事务处理的方法了）

<!-- ==================================3.使用XML配置声明式的事务管理,基于tx/aop=============================================== -->
	
	<!-- 配置事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>
	
	<!-- 配置事务的通知 -->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<!-- 
				propagation	:事务传播行为
				isolation	:事务的隔离级别
				read-only	:只读
				rollback-for:发生哪些异常回滚
				no-rollback-for	:发生哪些异常不回滚
				timeout		:过期信息
			 -->
			<tx:method name="transfer" propagation="REQUIRED"/>
		</tx:attributes>
	</tx:advice>
	
	<!-- 配置切面 -->
	<aop:config>
		<!-- 配置切入点 -->
		<aop:pointcut expression="execution(* com.zs.spring.demo3.AccountService+.*(..))" id="pointcut1"/>
		<!-- 配置切面 -->
		<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/>
	</aop:config>

测试类

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext3.xml")
public class TransactionTest {

	@Resource(name="accountService")
	private AccountService accountService;
	
	@Test
	public void demo1(){
		accountService.transfer("aaa", "bbb", 200d);
	}
}

c、基于注解的方式

配置一个事务管理器和开启事务管理的注释

<!-- ==================================4.使用注解配置声明式事务============================================ -->

	<!-- 配置事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource" />
	</bean>
	
	<!-- 开启注解事务 -->
	<tx:annotation-driven transaction-manager="transactionManager"/>

然后在需要进行事务处理的的业务层加上注释即可

import org.springframework.transaction.annotation.Transactional;

/**
 * 
 * @author admin
 *
 *
 *@Transactional中的的属性
 *propagation	:事务的传播行为
 *isolation		:事务的隔离级别
 *readOnly		:只读
 *rollbackFor	:发生哪些异常回滚
 *noRollbackFor	:发生哪些异常不回滚
 *rollbackForClassName 根据异常类名回滚
 */
@Transactional
public class AccountServiceImpl implements AccountService {
	
	//注入转账的DAO
	private AccountDao accountDao;
	

	/**
	 * @param out	:转出账号
	 * @param in	:转入账号
	 * @param money	:转账金额
	 */
	@Override
	public void transfer( String out, String in, Double money) {
		accountDao.outMoney(out, money);
		//int i = 1/0;
		accountDao.inMoney(in, money);
		
	}

	public void setAccountDao(AccountDao accountDao) {
		this.accountDao = accountDao;
	}

}

测试类和上一个测试类一样不用做任何的修改

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext3.xml")
public class TransactionTest {

	@Resource(name="accountService")
	private AccountService accountService;
	
	@Test
	public void demo1(){
		accountService.transfer("aaa", "bbb", 200d);
	}
}

优点：简单，方便

缺点：1、增加了程序的耦合性，因为注解保存在class文件中，而且比较分散
2、若要对配置进行修改需要重新编译

你丶怎么睡得着的？

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring事务管理使用详解

1、Spring关于事务管理所定义的三个接口PlatformTransactionManager平台事务管理器TransactionDefinition事务定义信息(隔离、传播、超时、只读）TransactionStatus事务具体运行状态（是否是新的事务，设置是否回滚）2、接口的分析（1）、下面是一些常用的平台事务管理器（PlatformTransactionManage）的实现类（2）、事务的...
复制链接

扫一扫

专栏目录