一起学习Spring4.0（六）Spring中的事务管理

本节讲述Spring中的事务管理。

Spring中的事务管理

事务就是一系列的动作，它们被当做一个单独的工作单元，这些动作要么全部完成，要么全部不起作用。用来确保数据的完整性和一致性。
事务的四个关键属性（ACID）
1.原子性（atomicity）：事务是一个原子操作，由一系列动作组成。事务的原子性确保动作要么全部完成要么完全不起作用。
2.一致性（consistency）：一旦所有事务动作完成，事务就被提交，数据和资源就处于一种满足业务规则的一致性状态中。
3.隔离性（isolation）：可能有许多事务会同时处理相同的数据，因此每个事物都应该与其他事务隔离开来，防止数据破坏。
4.持久性（durability）：一旦事务完成，无论发生什么系统错误，它的结果都不应该受到影响，通常情况下，事务的结果被写到持久化存储器中。

Spring的事务管理机制

Spring在不同的事务管理API之上定义了一个抽象层。而应用程序开发人员不必了解底层的事务管理API，就可以使用Spring的事务管理机制。
Spring既支持编程式事务管理，也支持声明式的事务管理。
编程式事务管理：将事务管理代码嵌入到业务方法中来控制事务的提交和回滚。在编程式管理事务时，必须在每个事务操作中包含额外的事务管理代码。
声明式事务管理：大多数情况下比编程式事务管理更好用。它将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。事务管理作为一种横切关注点，可以通过AOP方法模块化。Spring通过SpringAOP框架支持声明式事务管理。

Spring中的事务管理器

Spring从不同的事务管理API中抽象了一整套的事务机制。开发人员不必了解底层的事务API，就可以利用这些事务机制。有了这些事务机制，事务管理代码就能独立于特定的事务技术了。
Spring的核心事务管理抽象是 org.springframework.transaction Interface Platform TransactionManager管理和封装了一组独立于技术的方法。无论使用Spring的哪种事务管理策略（编程式或声明式），事务管理器都是必须的。

Spring中事务管理器的不同实现

org.springframework.jdbc.datasource
Class DataSource TransactionManager:在应用程序中只需要处理一个数据源，而且通过JDBC存取。

org.springframework.transaction.jta
Class JtaTransactionManager:在JavaEE应用服务器上用JTA（Java Transaction API）进行事务管理。

org.springframework.orm.hibernate3
Class Hibernate TransactionManager:用Hibernate框架存取数据库。

事务管理器以普通的Bean形式声明在SpringIOC容器中。

声明式事务

一共三步。
1.在配置文件中配置事务管理器
2.在配置文件中配置注解驱动
3.在要应用事务的方法前添加@Transaction。

沿用上一节中的项目。在项目下新建包com.leezp.spring.tx。
在该包下新建接口BookShopDao.java。

package com.leezp.spring.tx;

public interface BookShopDao {

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

新建异常类BookStockException.java。

package com.leezp.spring.tx;

//继承RuntimeException,Generate Constructors from SuperClass添加构造器
// Add default serial version ID
public class BookStockException extends RuntimeException {

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

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

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

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

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

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

}

新建异常类UserAccountException.java。

package com.leezp.spring.tx;

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
	}

}

新建接口BookShopDao的实现类BookShopDaoImpl.java。

package com.leezp.spring.tx;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository("bookShopDao")
public class BookShopDaoImpl implements BookShopDao {

	@Autowired
	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);
	}

}

新建接口BookShopService.java。

package com.leezp.spring.tx;

public interface BookShopService {

	public void purchase(String username, String isbn);
}

新建接口BookShopService的实现类BookShopServiceImpl.java。注意在要应用事务的方法上添加@Transaction。

package com.leezp.spring.tx;

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

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

	@Autowired
	private BookShopDao bookShopDao;

	//添加事务注解 @Transactional
	@Transactional
	@Override
	public void purchase(String username, String isbn) {
		// 1.获取书的单价
		int price = bookShopDao.findBookPriceByIsbn(isbn);
		// 2.更新书的库存 -1
		bookShopDao.updateBookStock(isbn);
		// 3.更新用户余额
		bookShopDao.updateUserAccount(username, price);
	}

}

重新配置db.properties属性文件里的连接字符串。

jdbc.jdbcUrl=jdbc:mysql://localhost:3306/spring_demo2

修改applicationContext.xml配置文件。

<context:component-scan base-package="com.leezp.spring"></context:component-scan>

向该配置文件中添加：

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

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

新建测试类（JUnit Test Case）SpringTransactionTest.java。

package com.leezp.spring.tx;

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;
	private BookShopService bookShopService=null;

	{
		ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
		bookShopDao=ctx.getBean(BookShopDao.class);
		bookShopService=ctx.getBean(BookShopService.class);
	}
	
	@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 testBookShopDaoFindPriceByIsbn() {
		System.out.println(bookShopDao.findBookPriceByIsbn("1001"));
	}

}

获取源代码
获取数据库文件

其他细节

事务的属性：
1.事务的传播行为 propagation
2.事务的隔离级别 isolation
3.对哪些异常不回滚 noRollbackFor/rollbackFor
4.事务的过期时间 timeout

事务传播属性

当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。

事务的传播行为可以由传播属性指定。Spring定义了7种传播行为。

Spring支持的事务传播行为

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

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

SUPPORTS：如果有事务在运行，当前的方法就在这个事务内运行，否则它可以不运行在事务中。

NOT_SUPPORTED：当前的方法不应该运行在事务中，如果有运行的事务，将它挂起。

MANDATORY：当前的方法必须运行在事务内部，如果没有正在运行的事务，就抛出异常。

NEVER：当前的方法不应该运行在事务中，如果有运行的事务，就抛出异常。

NESTED：如果有事务在运行，当前的方法就应该在这个事务的嵌套事务内运行，否则，就启动一个新的事务，并在它自己的事务内运行。

事务的传播属性可以在@Transactional注解的propagation属性中定义。eg:@Transactional(propagation=Propagation.REQUIRED)

在项目中新建接口Cashier.java。

package com.leezp.spring.tx;

import java.util.List;

public interface Cashier {

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

新建接口Cashier的实现类CashierImpl.java。

package com.leezp.spring.tx;

import java.util.List;

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

/**
 * 事务的传播行为（事务之间的调用）
 * 
 * @author Lee
 * 
 */
@Service("cashier")
public class CashierImpl implements Cashier {

	@Autowired
	private BookShopService bookShopService;

	/**
	 * 当bookService的purchase()方法被另一个事务方法checkout()调用时，
	 * 
	 * 它默认会在**已有**的事务内运行，这个默认的传播行为就是REQUIRED。
	 * 
	 * 因此在checkout()方法的开始和终止边界内只有一个事务，
	 * 
	 * 这个事务只在checkout()方法结束的时候被提交，
	 * 
	 * 因为用户余额只够买第一本书的，所以最终结果用户一本书都买不了。
	 * 
	 */
	// 使用propagation 指定事务的传播行为，即当前的事务方法被另一个事务方法调用时，如何使用事务
	// 默认取值REQUIRED,即使用调用方法的事务
	// REQUIRES_NEW:使用自己的事务，调用事务的方法的事务被挂起
	@Transactional(propagation = Propagation.REQUIRED)
	@Override
	public void checkout(String username, List<String> isbns) {
		for (String isbn : isbns) {
			bookShopService.purchase(username, isbn);
		}

	}

}

修改SpringTransactionTest.java。

package com.leezp.spring.tx;

import java.util.Arrays;

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;
	private BookShopService bookShopService = null;
	private Cashier cashier = null;
	{
		ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
		bookShopDao = ctx.getBean(BookShopDao.class);
		bookShopService = ctx.getBean(BookShopService.class);
		cashier = ctx.getBean(Cashier.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 testBookShopDaoFindPriceByIsbn() {
		System.out.println(bookShopDao.findBookPriceByIsbn("1001"));
	}

}

获取源代码

并发事务所导致的问题

当同一个应用程序或者不同应用程序中的多个事务在同一个数据集上并发执行时，可能会出现许多意外的问题。

并发事务所导致的问题可以分为下面三种类型：
1.脏读：对于两个事务T1,T2,T1读取了已经被T2更新但还没有被提交的字段。之后，若T2回滚，T1读取的内容就是临时且无效的。
2.不可重复读：对于两个事务T1,T2,T1读取了一个字段，然后T2更新了该字段。之后，T1再次读取同一个字段，值就不同了。
3.幻读：对于两个事务T1,T2,T1从一个表中读取了一个字段，然后T2在该表中插入了一些新的行。之后，如果T1再次读取同一个表，就会多出几行。

事务的隔离级别：
使用isolation指定事务的隔离级别，最常用的取值为 READ_COMMITTED：保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据。

超时和只读属性

由于事务可以在行和表上获得锁，因此长事务会占用资源，并对整体性能产生影响。
如果一个事务只读取数据但不做修改，数据库引擎可以对这个事务进行优化。
超时事务属性：事务在强制回滚之前可以保持多久。这样可以防止长期运行的事务占用资源。
只读事务属性：表示这个事务只读取数据但不更新数据，这样可以帮助数据库引擎优化事务。

修改CashierImpl.java。

package com.leezp.spring.tx;

import java.util.List;

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;

/**
 * 事务的传播行为（事务之间的调用）
 * 
 * @author Lee
 * 
 */
@Service("cashier")
public class CashierImpl implements Cashier {

	@Autowired
	private BookShopService bookShopService;

	/**
	 * 当bookService的purchase()方法被另一个事务方法checkout()调用时，
	 * 
	 * 它默认会在**已有**的事务内运行，这个默认的传播行为就是REQUIRED。
	 * 
	 * 因此在checkout()方法的开始和终止边界内只有一个事务，
	 * 
	 * 这个事务只在checkout()方法结束的时候被提交，
	 * 
	 * 因为用户余额只够买第一本书的，所以最终结果用户一本书都买不了。
	 * 
	 */
	// 1.使用propagation 指定事务的传播行为，即当前的事务方法被另一个事务方法调用时，如何使用事务
	// 默认取值REQUIRED,即使用调用方法的事务
	// REQUIRES_NEW:使用自己的事务，调用事务的方法的事务被挂起
	// 2.使用isolation指定事务的隔离级别，最常用的取值为 READ_COMMITTED
	// 3.默认情况下Spring的声明式事务对所有的运行时异常进行回滚，也可以通过对应的属性进行设置。
	// noRollbackFor:指定对哪些异常不进行回滚，通常情况下取默认值即可。
	// @Transactional(propagation = Propagation.REQUIRED, isolation =
	// Isolation.READ_COMMITTED, noRollbackFor = { UserAccountException.class })
	// 4.使用readOnly指定事务是否只读，即没有写操作，表示这个事务只读取数据但不更新数据，
	// 这样可以帮助数据库引擎优化事务，若真的是一个只读取数据库值的方法，应设置 readOnly=true
	// 5.timeout:单位 秒，使用timeout指定强制回滚之前事务可以占用的时间。
	@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED, readOnly = false, timeout = 3)
	@Override
	public void checkout(String username, List<String> isbns) {
		for (String isbn : isbns) {
			bookShopService.purchase(username, isbn);
		}

	}

}

获取源代码

基于XML文件方式

新建包com.leezp.spring.tx.xml。复制com.leezp.spring.tx包下的BookShopDao.java、BookStockException.java、UserAccountException.java到com.leezp.spring.tx.xml包。
在该包下新建BookShopDaoImpl.java。

package com.leezp.spring.tx.xml;

import org.springframework.jdbc.core.JdbcTemplate;

public class BookShopDaoImpl implements BookShopDao {

	private JdbcTemplate jdbcTemplate;

	public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
		this.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);
	}

}

新建包com.leezp.spring.tx.xml.service。复制com.leezp.spring.tx.xml包下的Cashier.java、BookShopService.java到包com.leezp.spring.tx.xml.service。
新建包com.leezp.spring.tx.xml.service.impl。
在该包下新建BookShopServiceImpl.java。

package com.leezp.spring.tx.xml.service.impl;

import com.leezp.spring.tx.xml.BookShopDao;
import com.leezp.spring.tx.xml.service.BookShopService;

public class BookShopServiceImpl implements BookShopService {

	private BookShopDao bookShopDao;

	public void setBookShopDao(BookShopDao bookShopDao) {
		this.bookShopDao = bookShopDao;
	}

	@Override
	public void purchase(String username, String isbn) {
		// 1.获取书的单价
		int price = bookShopDao.findBookPriceByIsbn(isbn);
		// 2.更新书的库存 -1
		bookShopDao.updateBookStock(isbn);
		// 3.更新用户余额
		bookShopDao.updateUserAccount(username, price);
	}

}

在该包下新建CashierImpl.java。

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

	}

}

新建配置文件applicationContext-tx-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/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

	<context:component-scan base-package="com.leezp.spring"></context:component-scan>

	<!-- 导入资源文件 -->
	<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.initPoolSize}"></property>
		<property name="maxPoolSize" value="${jdbc.maxPoolSize}"></property>
	</bean>

	<!-- 配置Spring 的jdbcTemplate -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>

	<!-- 配置Bean -->
	<bean id="bookShopDao" class="com.leezp.spring.tx.xml.BookShopDaoImpl">
		<property name="jdbcTemplate" ref="jdbcTemplate"></property>
	</bean>

	<bean id="bookShopService"
		class="com.leezp.spring.tx.xml.service.impl.BookShopServiceImpl">
		<property name="bookShopDao" ref="bookShopDao"></property>
	</bean>

	<bean id="cashier" class="com.leezp.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="*" />
		</tx:attributes>
	</tx:advice>

	<!-- 3.配置事务切入点（在哪个方法起作用）以及把事务切入点和事务属性关联起来 -->
	<aop:config>
		<!-- 设置 任意返回值任意类型任意方法任意参数 -->
		<aop:pointcut expression="execution(* com.leezp.spring.tx.xml.service.*.*(..))"
			id="txPointCut" />
		<!-- 用 <aop:advisor>将事务切入点和事务属性关联起来 -->
		<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut" />
	</aop:config>

</beans>

在包com.leezp.spring.tx.xml下新建SpringTransactionTest.java。

package com.leezp.spring.tx.xml;

import java.util.Arrays;

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

import com.leezp.spring.tx.xml.service.BookShopService;
import com.leezp.spring.tx.xml.service.Cashier;

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);
		bookShopService = ctx.getBean(BookShopService.class);
		cashier = ctx.getBean(Cashier.class);
	}

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

	@Test
	public void testBookShopService() {
		bookShopService.purchase("AA", "1001");
	}

}

获取源代码

版权声明：本文为博主原创文章，转载请注明出处 Leezp’s Blog