spring事务隔离级别默认

Spring中的事务管理

Spring中的事务管理器

• 实验代码

• MySQL中的表

• book表
• book_stock表
• account表

• 两个接口

• BookShopDao.java

public interface BookShopDao {
	
	//根据书号获取书的单价
	public int findBookPriceByIsbn(String isbn);
	//更新数的库存. 使书号对应的库存 - 1
	public void updateBookStock(String isbn);
		
	//更新用户的账户余额: 使 username 的 balance - price
	public void updateUserAccount(String username, int price);
}

• BookShopService.java

public interface BookShopService {
	
	public void purchase(String username, String isbn);
	
}

• 两个接口的实现类

• BookShopDaoImpl.java

import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
@Repository("bookShopDaoImp")
public class BookShopDaoImpl implements BookShopDao {
	
	
	
	private JdbcTemplate jdbcTemplate;
	@Override
	public int findBookPriceByIsbn(String isbn) {
		String sql="SELECT price FROM book WHERE isbn=?";
		return jdbcTemplate.queryForObject(sql, Integer.class,isbn);
	}

	@Override
	public void updateBookStock(String isbn) {
		//检查书的库存是否足够, 若不够, 则抛出异常
				String sql2 = "SELECT stock FROM book_stock WHERE isbn = ?";
				int stock = jdbcTemplate.queryForObject(sql2, Integer.class, isbn);
				if(stock == 0){
					throw new BookStockException("库存不足!");
				}
				
				String sql = "UPDATE book_stock SET stock = stock -1 WHERE isbn = ?";
				jdbcTemplate.update(sql, isbn);

	}

	@Override
	public void updateUserAccount(String username, int price) {
		//验证余额是否足够, 若不足, 则抛出异常
				String sql2 = "SELECT balance FROM account WHERE username = ?";
				int balance = jdbcTemplate.queryForObject(sql2, Integer.class, username);
				if(balance < price){
					throw new UserAccountException("余额不足!");
				}
				
				String sql = "UPDATE account SET balance = balance - ? WHERE username = ?";
				jdbcTemplate.update(sql, price, username);

	}

}

• BookShopServiceImpl.java

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Service("bookShopService")
public class BookShopServiceImpl implements BookShopService {

	@Autowired
	private BookShopDao bookShopDao;
	
	//添加事务注解 spring的声明式事务
	//1.使用 propagation 指定事务的传播行为, 即当前的事务方法被另外一个事务方法调用时
	//如何使用事务, 默认取值为 REQUIRED, 即使用调用方法的事务
	//REQUIRES_NEW: 事务自己的事务, 调用的事务方法的事务被挂起. 
	//2.使用 isolation 指定事务的隔离级别, 最常用的取值为 READ_COMMITTED
	//3.默认情况下 Spring 的声明式事务对所有的运行时异常进行回滚. 也可以通过对应的
	//属性进行设置. 通常情况下去默认值即可. 
	//4.使用 readOnly 指定事务是否为只读. 表示这个事务只读取数据但不更新数据, 
	//这样可以帮助数据库引擎优化事务. 若真的事一个只读取数据库值的方法, 应设置 readOnly=true
	//5.使用 timeout 指定强制回滚之前事务可以占用的时间.  
//	@Transactional(propagation=Propagation.REQUIRES_NEW,
//			isolation=Isolation.READ_COMMITTED,
//			noRollbackFor={UserAccountException.class})
	@Transactional(propagation=Propagation.REQUIRES_NEW,
			isolation=Isolation.READ_COMMITTED,
			readOnly=false,
			timeout=3)
	//使用Transactional前需要在xml文件中1.配置事务管理器2.启动事务注解。然后在对应的方法上添加上@Transactional即可
	@Override
	public void purchase(String username, String isbn) {
		
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {}
		
		//1. 获取书的单价
		int price = bookShopDao.findBookPriceByIsbn(isbn);
		
		//2. 更新数的库存
		bookShopDao.updateBookStock(isbn);
		
		//3. 更新用户余额
		bookShopDao.updateUserAccount(username, price);
	}

}

• 测试方法

import static org.junit.Assert.*;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTransactionTest {
	
	private ApplicationContext ctx=null;
	private BookShopDao bookShopDao=null;
	
	{
		ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
		bookShopDao=ctx.getBean(BookShopDao.class);
	}

	
//	@Test
//	public void testTransactionlPropagation(){
//		cashier.checkout("AA", Arrays.asList("1001", "1002"));
//	}
//	
//	@Test
//	public void testBookShopService(){
//		bookShopService.purchase("AA", "1001");
//	}
	
	@Test
	public void testBookShopDaoUpdateUserAccount(){
		bookShopDao.updateUserAccount("AA", 200);
	}
	
	@Test
	public void testBookShopDaoUpdateBookStock(){
		bookShopDao.updateBookStock("1001");
	}
	@Test
	public void testBookShopDaoFiindPriceByIsbn() {
		System.out.println(bookShopDao.findBookPriceByIsbn("1001"));
	}

}

• 两个异常类

• UserAccountException.java

public class UserAccountException extends RuntimeException{

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	public UserAccountException() {
		super();
		// TODO Auto-generated constructor stub
	}

	public UserAccountException(String message, Throwable cause,
			boolean enableSuppression, boolean writableStackTrace) {
		super(message, cause, enableSuppression, writableStackTrace);
		// TODO Auto-generated constructor stub
	}

	public UserAccountException(String message, Throwable cause) {
		super(message, cause);
		// TODO Auto-generated constructor stub
	}

	public UserAccountException(String message) {
		super(message);
		// TODO Auto-generated constructor stub
	}

	public UserAccountException(Throwable cause) {
		super(cause);
		// TODO Auto-generated constructor stub
	}
}

• BookStockException.java

public class UserAccountException extends RuntimeException{

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	public UserAccountException() {
		super();
		// TODO Auto-generated constructor stub
	}

	public UserAccountException(String message, Throwable cause,
			boolean enableSuppression, boolean writableStackTrace) {
		super(message, cause, enableSuppression, writableStackTrace);
		// TODO Auto-generated constructor stub
	}

	public UserAccountException(String message, Throwable cause) {
		super(message, cause);
		// TODO Auto-generated constructor stub
	}

	public UserAccountException(String message) {
		super(message);
		// TODO Auto-generated constructor stub
	}

	public UserAccountException(Throwable cause) {
		super(cause);
		// TODO Auto-generated constructor stub
	}
}

• xml文件

<?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:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx"
	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-4.0.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">
	<!-- 扫描包 -->
	<context:component-scan base-package="com.atguigu.spring"/>
	<!-- 导入资源文件 -->
	<context:property-placeholder location="classpath:db.properties"/> 
	<!-- 配置C3P0 数据源 -->
	<bean id="dataSource" 
		class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="user" value="${jdbc.user}"></property>
		<property name="password" value="${jdbc.password}"></property>
		<property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
		<property name="driverClass" value="${jdbc.driverClass}"></property>
		<property name="initialPoolSize" value="${jdbc.initialPoolSize}"></property>
		<property name="maxPoolSize" value="${jdbc.maxPoolSize}"></property>
	</bean>
	
	<!-- 配置Spring的JdbcTemplate -->
	<bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">
		<property name="dataSource" ref="dataSource"/>
	</bean>
	<!-- 配置 NamedParameterJdbcTemplate, 该对象可以使用具名参数, 其没有无参数的构造器, 所以必须为其构造器指定参数 -->
	<bean id="namedParameterJdbcTemplate"
		class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
		<constructor-arg ref="dataSource"></constructor-arg>
	</bean>
	<!-- 配置事务管理器 -->
	<bean id="transactionManager" 
			class="org.springframework.jdbc.datasource.DataSourceTransactionManager">	
			<property name="dataSource" ref="dataSource"></property>
	</bean>
	<!-- 启动事务注解 -->
	<tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

• properties文件中

jdbc.user=xuefeng
jdbc.password=1234
jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.jdbcUrl=jdbc:mysql:///xuefeng

jdbc.initialPoolSize=5
jdbc.maxPoolSize=10

---

Spring中事务的传播&事务的隔离级别

• 需求

• 代码

• 接口

import java.util.List;

public interface Cashier {

	public void checkout(String username, List<String> isbns);
	
}

• 接口实现方法

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service("cashier")
public class CashierImpl implements Cashier {

	@Autowired
	private BookShopService bookShopService;
	
	@Transactional
	@Override
	public void checkout(String username, List<String> isbns) {
		for(String isbn: isbns){//一个人要买多本书
			bookShopService.purchase(username, isbn);
		}
	}
}

• bookShopService的purchase方法

@Autowired
	private BookShopDao bookShopDao;
	
	//添加事务注解 spring的声明式事务
	//1.使用 propagation 指定事务的传播行为, 即当前的事务方法被另外一个事务方法调用时
		//如何使用事务, 默认取值为 REQUIRED, 即使用调用方法的事务
	//REQUIRES_NEW: 事务自己的事务, 调用的事务方法的事务被挂起. 
	//2.使用 isolation 指定事务的隔离级别, 最常用的取值为 READ_COMMITTED
	//3.默认情况下 Spring 的声明式事务对所有的运行时异常进行回滚. 也可以通过对应的
		//属性进行设置. 通常情况下去默认值即可. 
	//4.使用 readOnly 指定事务是否为只读. 表示这个事务只读取数据但不更新数据,      事务的只读属性
		//这样可以帮助数据库引擎优化事务. 若真的事一个只读取数据库值的方法, 应设置 readOnly=true
	//5.使用 timeout 指定强制回滚之前事务可以占用的时间.  
//	@Transactional(propagation=Propagation.REQUIRES_NEW,
//			isolation=Isolation.READ_COMMITTED,
//			noRollbackFor={UserAccountException.class})
	@Transactional(propagation=Propagation.REQUIRES_NEW,
			isolation=Isolation.READ_COMMITTED,
			readOnly=false,
			timeout=3)
	//使用Transactional前需要在xml文件中1.配置事务管理器2.启动事务注解。然后在对应的方法上添加上@Transactional即可
	@Override
	public void purchase(String username, String isbn) {
		
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {}
		
		//1. 获取书的单价
		int price = bookShopDao.findBookPriceByIsbn(isbn);
		
		//2. 更新数的库存
		bookShopDao.updateBookStock(isbn);
		
		//3. 更新用户余额
		bookShopDao.updateUserAccount(username, price);
	}

• 测试方法

@Test
  	public void testTransactionlPropagation(){
  		cashier.checkout("AA", Arrays.asList("1001", "1002"));
  	}
  	//设AA总共有120元,1001是100元,1002是60元.如果是propagation=Propagation.REQUIRES的话,那么在买第二本时余额不足事务就会回滚,结果AA用户还会有160元,他一本也没买.
  	//如果propagation=Propagation.REQUIRES_NEW的话,那么AA最后会买到1001这本书,1002因为余额不足无法购买,事务回滚也只会回滚到买1002之前.

• Spring 支持的事务传播行为
• REQUIRED传播行为

• REQUIRED传播行为
• REQUIRED_NEW 传播行为

---

Spring使用XML文件的形式配置事务

• xml文件中

<?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:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	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-4.0.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">
	<!-- 扫描包 -->
	<context:component-scan base-package="com.atguigu.spring"/>
	<!-- 导入资源文件 -->
	<context:property-placeholder location="classpath:db.properties"/> 
	<!-- 配置C3P0 数据源 -->
	<bean id="dataSource" 
		class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="user" value="${jdbc.user}"></property>
		<property name="password" value="${jdbc.password}"></property>
		<property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
		<property name="driverClass" value="${jdbc.driverClass}"></property>
		<property name="initialPoolSize" value="${jdbc.initialPoolSize}"></property>
		<property name="maxPoolSize" value="${jdbc.maxPoolSize}"></property>
	</bean>
	
	<!-- 配置Spring的JdbcTemplate -->
	<bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">
		<property name="dataSource" ref="dataSource"/>
	</bean>
	<!-- 配置bean -->
	<bean id="bookShopDao" class="com.atguigu.spring.tx.xml.BookShopDaoImpl">
		<property name="jdbcTemplate" ref="jdbcTemplate"></property>
	</bean>
	<bean id="bookShopService" class="com.atguigu.spring.tx.xml.service.Impl.BookShopServiceImpl">
		<property name="bookShopDao" ref="bookShopDao"></property>
	</bean>
	<bean id="cashier" class="com.atguigu.spring.tx.xml.service.Impl.CashierImpl">
		<property name="bookShopService" ref="bookShopService"></property>
	</bean>
	
	<!-- 1.配置事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	<!-- 2.配置事务属性 -->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
		<!-- 根据方法名指定事务的属性 -->
			<tx:method name="purchase" propagation="REQUIRES_NEW"/>
			<tx:method name="get*" read-only="true"/>
			<tx:method name="find*" read-only="true"/>
			<tx:method name="*"/>
		</tx:attributes>
	</tx:advice>
	<!-- 3.配置事务切入点,以及把事务切入点和事务属性关联起来 -->
	<aop:config>                   <!--* com.atguigu.spring.tx.xml.service.*.*(..)  这是为了把service包下两个接口都声明为切点  -->
		<aop:pointcut expression="execution(* com.atguigu.spring.tx.xml.service.*.*(..))" 
			id="txPointCut"/>
		<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>	
	</aop:config>
</beans>

• 首先配置bean

• BookShopDaoImpl实现类

public class BookShopDaoImpl implements BookShopDao {
	private JdbcTemplate jdbcTemplate;
	public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
		this.jdbcTemplate = jdbcTemplate;
	}//这里的set方法是为了xml中bean获取
	
    @Override
	public int findBookPriceByIsbn(String isbn) {
		String sql="SELECT price FROM book WHERE isbn=?";
		return jdbcTemplate.queryForObject(sql, Integer.class,isbn);
	}
	@Override
	public void updateBookStock(String isbn) {
		//检查书的库存是否足够, 若不够, 则抛出异常
				String sql2 = "SELECT stock FROM book_stock WHERE isbn = ?";
				int stock = jdbcTemplate.queryForObject(sql2, Integer.class, isbn);
				if(stock == 0){
					throw new BookStockException("库存不足!");
				}
				
				String sql = "UPDATE book_stock SET stock = stock -1 WHERE isbn = ?";
				jdbcTemplate.update(sql, isbn);

	}

	@Override
	public void updateUserAccount(String username, int price) {
		//验证余额是否足够, 若不足, 则抛出异常
				String sql2 = "SELECT balance FROM account WHERE username = ?";
				int balance = jdbcTemplate.queryForObject(sql2, Integer.class, username);
				if(balance < price){
					throw new UserAccountException("余额不足!");
				}
				
				String sql = "UPDATE account SET balance = balance - ? WHERE username = ?";
				jdbcTemplate.update(sql, price, username);

	}
}

• BookShopServiceImpl实现类

public class BookShopServiceImpl implements BookShopService {
	
    private BookShopDao bookShopDao;
	public void setBookShopDao(BookShopDao bookShopDao) {
		this.bookShopDao = bookShopDao;
	}//这里的set方法是为了xml中bean获取
	
	@Override
	public void purchase(String username, String isbn) {
		
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {}
		
		//1. 获取书的单价
		int price = bookShopDao.findBookPriceByIsbn(isbn);
		
		//2. 更新数的库存
		bookShopDao.updateBookStock(isbn);
		
		//3. 更新用户余额
		bookShopDao.updateUserAccount(username, price);
	}
}

• CashierImpl实现类

public class CashierImpl implements Cashier {

	
	private BookShopService bookShopService;
	public void setBookShopService(BookShopService bookShopService) {
		this.bookShopService = bookShopService;
	}
	
	@Override
	public void checkout(String username, List<String> isbns) {
		for(String isbn: isbns){//一个人要买多本书
			bookShopService.purchase(username, isbn);
		}
	}
}

• 1.配置事务管理器

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>

• 2.配置事务属性

<!-- 2.配置事务属性 -->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
		<!-- 根据方法名指定事务的属性 -->
			<tx:method name="purchase" propagation="REQUIRES_NEW"/>
			<tx:method name="get*" read-only="true"/>
			<tx:method name="find*" read-only="true"/>
			<tx:method name="*"/>
		</tx:attributes>
	</tx:advice>

• 3.配置事务切入点,以及把事务切入点和事务属性关联起来

<!-- 3.配置事务切入点,以及把事务切入点和事务属性关联起来 -->
	<aop:config>                   
        <!--* com.atguigu.spring.tx.xml.service.*.*(..)  这是为了把service包下两个接口都声明为切点  -->
		<aop:pointcut expression="execution(* com.atguigu.spring.tx.xml.service.*.*(..))" 
			id="txPointCut"/>
		<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>	
	</aop:config>

• 测试方法

import static org.junit.Assert.*;

import java.util.Arrays;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.transaction.annotation.Propagation;

public class SpringTransactionTest {
	
	private ApplicationContext ctx=null;
	private BookShopDao bookShopDao=null;
	private BookShopService bookShopService=null;
	private Cashier cashier=null;
	{
		ctx=new ClassPathXmlApplicationContext("applicationContext-tx-xml.xml");
		bookShopDao=ctx.getBean(BookShopDao.class);
	}

	@Test
	public void testTransactionlPropagation(){
		cashier.checkout("AA", Arrays.asList("1001", "1002"));
	}
	
	@Test
	public void testBookShopService(){
		bookShopService.purchase("AA", "1001");
	}
}