Spring4-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");
    	}
    }