详述Spring 框架事务和@Transactional常用属性说明

最新推荐文章于 2023-02-10 12:59:39 发布

www.﹋o﹋ang

最新推荐文章于 2023-02-10 12:59:39 发布

阅读量166

点赞数

分类专栏：个人

本文链接：https://blog.csdn.net/wangdada___/article/details/104881970

版权

个人专栏收录该内容

64 篇文章 0 订阅

订阅专栏

为什么用Spring框架事务？

用来确保数据的完整性和一致性。

怎么做？

实现声明式事务：

1、添加spring-aspects-4.3.10.RELEASE.jar包

2、在Spring配置文件中添加如下配置：

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

<!-- 启用事务注解 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

3、在Service层public方法上添加事务注解——@Transactional

注意：

①、一个类含有@Transactional注解修饰的方法，则Spring框架自动为该类创建代理对象，默认使用JDK创建代理对象，可以通过添加<aop:aspectj-autoproxy proxy-target-class="true"/>使用CGLib创建代理对象，此时需要添加aspectjweaver-x.x.x.jar包，具体代码参见《@Transactional注解》Java工程。

②、不能在protected、默认或者private的方法上使用@Transactional注解，否则无效。

@Transactional注解属性：

rollbackFor和rollbackForClassName：指定对哪些异常回滚事务。默认情况下，如果在事务中抛出了运行时异常（继承自RuntimeException异常类），则回滚事务；如果没有抛出任何异常，或者抛出了检查时异常，则依然提交事务。这种处理方式是大多数开发者希望的处理方式，也是 EJB 中的默认处理方式；但可以根据需要人为控制事务在抛出某些运行时异常时仍然提交事务，或者在抛出某些检查时异常时回滚事务。

示例：

注意：上例红框中代码不能try-catch处理异常，否则即便@Transactional注解中添加了rollbackFor=MoneyException.class，事务也不会回滚，如下代码：

readOnly：事务只读，指对事务性资源进行只读操作。所谓事务性资源就是指那些被事务管理的资源，比如数据源、 JMS 资源，以及自定义的事务性资源等等。如果确定只对事务性资源进行只读操作，那么可以将事务标志为只读的，以提高事务处理的性能。在 TransactionDefinition 中以 boolean 类型来表示该事务是否只读。由于只读的优化措施是在一个事务启动时由后端数据库实施的，因此，只有对于那些具有可能启动一个新事务的传播行为（PROPAGATION_REQUIRES_NEW、PROPAGATION_REQUIRED、 ROPAGATION_NESTED）的方法来说，将事务声明为只读才有意义。

timeout：设置一个事务所允许执行的最长时长（单位：秒），如果超过该时长且事务还没有完成，则自动回滚事务且出现org.springframework.transaction.TransactionTimedOutException异常，如下代码：

注意：

1、事务的开始往往会发生数据库的表锁或者被数据库优化为行锁，如果允许时间过长，那么这些数据会一直被锁定，最终影响系统的并发性，因此可以给这些事务设置超时时间以规避该问题。

2、由于超时是在一个事务启动的时候开始的，因此，只有对于那些具有可能启动一个新事务的传播行为（PROPAGATION_REQUIRES_NEW、PROPAGATION_REQUIRED、ROPAGATION_NESTED）的方法来说，声明事务超时才有意义。

propagation：指定事务传播行为，一个事务方法被另一个事务方法调用时，必须指定事务应该如何传播，例如：方法可能继承在现有事务中运行，也可能开启一个新事物，并在自己的事务中运行。Spring定义了如下7种事务传播行为：

REQUIRED：默认值，如果有事务在运行，当前的方法就在这个事务内运行，否则，就启动一个新的事务，并在自己的事务内运行。

REQUIRES_NEW：当前方法必须启动新事务，并在它自己的事务内运行，如果有事务在运行，则把当前事务挂起，直到新的事务提交或者回滚才恢复执行。

REQUIRED：

测试类：

场景：一个人（id为aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa）的钱包有10元，它想买两类书，第一类id为a2f39533-659f-42ca-af91-c688a83f6e49，数量为1本，单价为10元，该书库存为1本；第二类id为4c37672a-653c-4cc8-9ab5-ee0c614c7425，数量为1，单价为10元，该书库存为1本；

package com.jd.test;

import java.util.*;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.jd.car.ICarService;
import com.jd.car.imp.CarService;

public class Test {
	
	public static void main(String[] args) {
		ClassPathXmlApplicationContext application = new ClassPathXmlApplicationContext("application.xml");
		ICarService carService = application.getBean(CarService.class);
		String userId = "aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa";
		Map<String,Integer> commodities = new HashMap<String,Integer>();
		commodities.put("a2f39533-659f-42ca-af91-c688a83f6e49",1);
		commodities.put("4c37672a-653c-4cc8-9ab5-ee0c614c7425",10);
		carService.batch(userId, commodities);
		application.close();
	}
}

CarService类

package com.jd.car.imp;

import java.util.*;
import java.util.Map.Entry;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.jd.car.ICarService;
import com.jd.coupon.ICouponService;

@Service
public class CarService implements ICarService {

	@Autowired
	private ICouponService couponService;

	//购物车购买
	@Override
	@Transactional
	public boolean batch(String userId,Map<String,Integer> commodities) {
		Set<Entry<String, Integer>> set = commodities.entrySet();
		for (Entry<String, Integer> commodity : set) {
			String bookId = commodity.getKey();
			int count = commodity.getValue();
			System.out.println(bookId+","+count);
			couponService.insert(userId,bookId, count);
		}
		return true;
	}
}

CouponService类

package com.jd.coupon.imp;

import java.util.*;
import java.util.Map.Entry;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.jd.book.IBookDao;
import com.jd.coupon.ICouponDao;
import com.jd.coupon.ICouponService;
import com.jd.money.IMoneyDao;
import com.jd.vo.Coupon;

@Service
public class CouponService implements ICouponService {

	@Autowired
	private IBookDao bookDao;
	@Autowired
	private IMoneyDao moneyDao;
	@Autowired
	private ICouponDao couponDao;
	
	//立即购买
	@Override
	@Transactional/*(propagation=Propagation.REQUIRED)*/
	public boolean insert(String userId,String bookId, int count){
		
		if(bookDao.enough(bookId, count)) {//书籍足够
			//书籍表库存递减
			bookDao.update(bookId, count);
		}
		double price = bookDao.getPrice(bookId);
		double total = price*count;
		if(moneyDao.enough(userId, total)) {//余额足够
			//订单表添加数据
			Coupon coupon = new Coupon();
			coupon.setId(UUID.randomUUID().toString());
			coupon.setUserId(userId);
			coupon.setBookId(bookId);
			coupon.setTotal(total);
			couponDao.insert(coupon);
			//钱包表递减
			moneyDao.update(userId, total);
		}
		return true;
	}
}

分析：

事务方法insert被另一个事务方法batch调用时，事务方法insert默认在batch方法的事务内运行，即insert方法和batch方法在同一个事务中（相当于修饰insert方法的@Transactional注解中添加了“propagation=Propagation.REQUIRED”属性），因此结算第二类书籍时钱包钱不够，insert方法抛出了异常以至于insert方法和batch方法所在的事务进行了回滚，最终导致第一类书籍的结算也失效。

REQUIRES_NEW：当前方法必须启动新事务，并在它自己的事务内运行，如果有事务在运行，则把当前事务挂起

测试类：

与上面不同的是CouponService类

package com.jd.coupon.imp;

import java.util.*;
import java.util.Map.Entry;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.jd.book.IBookDao;
import com.jd.coupon.ICouponDao;
import com.jd.coupon.ICouponService;
import com.jd.money.IMoneyDao;
import com.jd.vo.Coupon;

@Service
public class CouponService implements ICouponService {

	@Autowired
	private IBookDao bookDao;
	@Autowired
	private IMoneyDao moneyDao;
	@Autowired
	private ICouponDao couponDao;
	
	//立即购买
	@Override
	@Transactional(propagation=Propagation.REQUIRES_NEW)
	public boolean insert(String userId,String bookId, int count){
		
		if(bookDao.enough(bookId, count)) {//书籍足够
			//书籍表库存递减
			bookDao.update(bookId, count);
		}
		double price = bookDao.getPrice(bookId);
		double total = price*count;
		if(moneyDao.enough(userId, total)) {//余额足够
			//订单表添加数据
			Coupon coupon = new Coupon();
			coupon.setId(UUID.randomUUID().toString());
			coupon.setUserId(userId);
			coupon.setBookId(bookId);
			coupon.setTotal(total);
			couponDao.insert(coupon);
			//钱包表递减
			moneyDao.update(userId, total);
		}
		return true;
	}
}

分析：

修饰insert方法的@Transactional注解中添加了“propagation=Propagation.REQUIRES_NEW”属性，则每次执行该方法时都会启动新事务，所以结算第一类书籍时钱够库存也够则购买成功并提交当次事务，但结算第二类书籍时由于钱包钱不够导致支付失败，致使此次事务回滚。

www.﹋o﹋ang

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
详述Spring 框架事务和@Transactional常用属性说明

为什么用Spring框架事务？用来确保数据的完整性和一致性。怎么做？实现声明式事务：1、添加spring-aspects-4.3.10.RELEASE.jar包 2、在Spring配置文件中添加如下配置：<bean id="transactionManager" class="org.springframewor...
复制链接

扫一扫