1. 事务
1.1 4个基本特性（ACID）
4个基本属性：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability）：
- 原子性：事务内容要么全部执行成功，要么全部执行失败，成功则写入数据库，失败则对数据库不产生影响；
- 隔离性：用户并发访问时会同时存在多个事务，多个并发事务之间相互隔离；
- 一致性：事务执行前和执行后状态保持一致，比如A向B转账，A扣钱后B必定收到等额入账，且总数不变；
- 持久性：事务完成后，事务对数据库的所有更新执行都永久性保存到数据库，不能再被回滚；
1.2 事务并发问题
多个事务并发时可能出现以下并发问题：
- 脏读：事务A读取了事务B更新的数据，然后B回滚操作，那么A读取到的数据是脏数据；
- 不可重复读：事务 A 多次读取同一数据，事务 B 在事务A多次读取的过程中，对数据作了更新并提交，导致事务A多次读取同一数据的结果不一致；
- 幻读：系统管理员A将数据库中所有学生的成绩从具体分数改为ABCDE等级，但是系统管理员B就在这个时候插入了一条具体分数的记录，当系统管理员A改结束后发现还有一条记录没有改过来，就好像发生了幻觉一样，这就叫幻读。
小结：不可重复读的和幻读很容易混淆，不可重复读侧重于修改，幻读侧重于新增或删除。解决不可重复读的问题只需锁住满足条件的行，解决幻读需要锁表
1.3 事务隔离级别
为了处理事务并发问题，可以为事务设置不同的隔离级别。
MySQL数据库支持4种隔离级别：
- Read Uncommitted（读未提交）：最低级别，任何情况都可能发生；
- Read Committed（读已提交）：可避免脏读的发生；
- Repeatable Read（可重复读）：可避免脏读、不可重复读的发生；
- Serializable（串行化）：最高级别，避免脏读、不可重复读、幻读的发生；
需要注意一下几点：
- 四种隔离级别最高的是Seralizable级别，最低的是Read Uncommitted级别，级别越高执行效率就越低；
- 隔离级别的设置只对当前链接有效，对JDBC操作数据库来说，一个Connection对象相当于一个链接；
- Mysql的默认隔离级别是：可重复读（Repeatable Read）；
- Oracle只支持串行化（Seralizable)级别和读已提交（Read committed）级别，默认是读已提交（Read Committed）级别。
- 采用最高事务隔离级别Serializable（串行化）时事务顺序执行，能避免并发问题，但性能很低，很少使用。
验证事务隔离级别：Read-Uncommitted（读未提交），其它级别操作雷同，故不再演示；
打开2个MySQL客户端，先修改隔离级别为Read Uncommitted，然后依次按照
第一步：客户端A——修改当前连接的隔离级别，查询表t_user的初始状态
mysql> setsessiontransactionisolationlevelreaduncommitted; QueryOK, 0rows affected (0.00sec) ? mysql> select* fromt_user; +----+-----------+-----------+ | id | user_name | nick_name | +----+-----------+-----------+ | 1| qiaofeng | qf | +----+-----------+-----------+ 1rowinset(0.00sec)
第二步：客户端B——开启事务，插入一条数据但不提交
mysql> setsessiontransactionisolationlevelreaduncommitted;
QueryOK, 0rows affected (0.00sec)
?
mysql> starttransaction;
QueryOK, 0rows affected (0.00sec)
?
mysql> insertintot_user(user_name,nick_name)value('xuzhu','xz');
QueryOK, 1rowaffected (0.00sec)
?
第三步：客户端A——当前隔离级别下，A可以查询到B未提交的数据
mysql> select* fromt_user; +----+-----------+-----------+ | id | user_name | nick_name | +----+-----------+-----------+ | 1| qiaofeng | qf | | 2| xuzhu | xz | +----+-----------+-----------+ 2rows inset(0.00sec)
第四步：客户端B——回滚事务
mysql> rollback; QueryOK, 0rows affected (0.00sec)
第五步：客户端A——B事务回滚后，再次查询表的数据
mysql> select* fromt_user; +----+-----------+-----------+ | id | user_name | nick_name | +----+-----------+-----------+ | 1| qiaofeng | qf | +----+-----------+-----------+ 1rowinset(0.00sec)
2. Spring的事务管理
2.1 概述
- 作为企业级应用程序框架，Spring 在不同的事务管理 API 之上定义了一个抽象层，而应用程序开发人员不必了解底层的事务管理 API， 就可以使用 Spring 的事务管理机制；有了这些事务机制，事务管理器代码就能独立于特定的事务技术了；
- Spring 既支持编程式事务管理，也支持声明式的事务管理；
- 编程式事务管理：将事务管理代码嵌入到业务方法中来控制事务的提交和回滚；在编程式管理事务时，必须在每个事务操作中包含额外的事务管理代码；
- 声明式事务管理：大多数情况下比编程式事务管理更好用；它将事务管理代码从业务方法中分离出来, 以声明的方式来实现事务管理；事务管理作为一种横切关注点，可以通过 AOP 方法模块化，Spring 通过 Spring AOP 框架支持声明式事务管理；
- Spring 的核心事务管理抽象是org.springframework.transaction.PlatformTransactionManager， 它为事务管理封装了一组独立于技术的方法；无论使用Spring的哪种事务管理策略（编程式或声明式），事务管理器都是必须的。
- 事务管理器以普通的 Bean 形式声明在Spring IOC 容器中；
2.2 常见的事务管理器
- org.springframework.jdbc.datasource.DataSourceTransactionManager ： 应用程序只需要处理一个数据源，并且通过JDBC存取；
- org.springframework.transaction.jta.JtaTransactionManager ： 在JavaEE应用服务器上用JTA（Java Transaction API）进行事务管理；
- org.springframework.orm.hibernate3.HibernateTransactionManager ：使用Hibernate框架存取数据库并进行事务管理；
2.3 使用@Transactional实现的声明式事务管理：
- 除了在带有切入点、通知和增强器的 Bean 配置文件中声明事务外， Spring 还允许简单地用 @Transactional 注解来标注事务方法；
- 为了将方法定义为支持事务处理的，可以为方法添加 @Transactional 注解，根据 Spring AOP 基于代理机制，只能标注公有方法；
- 可以在方法或者类级别上添加 @Transactional 注解，当把这个注解应用到类上时，这个类中的所有公共方法都会被定义成支持事务处理的；
- 在 Bean 配置文件中只需要启用 tx:annotation-driven 元素，并为之指定事务管理器就可以了；
- 如果事务处理器的名称是 transactionManager，就可以在tx:annotation-driven 元素中省略 transaction-manager 属性，这个元素会自动检测该名称的事务处理器。
2.4 使用事务通知实现的声明式事务管理：
- 事务管理是一种横切关注点；
- 为了在 Spring 2.x 中启用声明式事务管理，可以通过 tx Schema 中定义的 tx:advice 元素声明事务通知，为此必须事先将这个 Schema 定义添加到 <beans> 根元素中去；
- 声明了事务通知后， 就需要将它与切入点关联起来；由于事务通知是在 aop:config 元素外部声明的，所以它无法直接与切入点产生关联，所以必须在 aop:config 元素中声明一个增强器通知与切入点关联起来；
- 由于 Spring AOP 是基于代理的方法，所以只能增强公共方法；因此，只有公有方法才能通过 Spring AOP 进行事务管理。
3. 基于注解实现的事务控制
3.1 小需求
关于事务的小需求：用户购买指定图书，图书有一定库存，用户有一定的金钱，每次只能购买一本图书，购买需要花费对应书价的金钱，购买方法使用事务管理，过程分为三步：
- 根据书号ISBN号查询图书价格；
- 扣减图书库存，每次只能扣减一本，库存不足时抛出异常；
- 扣减用户账户余额，扣减数目与图书价格相同，余额不足时购买失败并抛出异常。
3.2 关键实现代码
第一步：初始化表结构
insertintot_book(isbn,book_name,price)values('IB1234','Java编程思想',50);
insertintot_book(isbn,book_name,price)values('IB1235','C++高级编程',100);
?
insertintot_book_stock values('IB1234', 20),('IB1235',20);
insertintot_account values('qiaofeng',50),('duanyu',150);
第二步：引入指定包
<!-- https://mvnrepository.com/artifact/org.springframework/spring-tx -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>5.1.3.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>6.0.6</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
<dependency>
<groupId>com.mchange</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.5.1</version>
</dependency>
第三步：XML配置关键信息
<?xmlversion="1.0" encoding="UTF-8"?>
<beansxmlns="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.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<!-- 开启注解扫描，指定扫描的包范围 -->
<context:component-scanbase-package="com.tengol.demo.spring.tx"/>
<!-- 加载属性文件 -->
<context:property-placeholderlocation="classpath:db-tx.properties"/>
<!-- 配置连接池 -->
<beanid="dataSource"class="com.mchange.v2.c3p0.ComboPooledDataSource">
<propertyname="driverClass"value="${jdbc.driverClass}"/>
<propertyname="jdbcUrl"value="${jdbc.url}"/>
<propertyname="user"value="${jdbc.user}"/>
<propertyname="password"value="${jdbc.password}"/>
</bean>
<!-- 配置JdbcTemplate模板 -->
<beanid="jdbcTemplate"class="org.springframework.jdbc.core.JdbcTemplate">
<propertyname="dataSource"ref="dataSource"/>
</bean>
<!-- 事务管理器，此处使用数据源的事务管理器 -->
<beanid="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<propertyname="dataSource"ref="dataSource"/>
</bean>
<!-- 开启事务注解 -->
<tx:annotation-driven/>
</beans>
第四步：数据库信息的属性文件
jdbc.driverClass=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/jwms_auth?useSSL=true jdbc.user=root jdbc.password=Jwms@2018
第五步：关键代码-业务层
publicinterfaceBookShopService{
/**
* 模拟用户购买图书
*/
publicvoidpurchase(Stringusername, Stringisbn);
}
?
@Service
publicclassBookShopServiceImplimplementsBookShopService{
/**
* 图书销售的持久化操作类
*/
privateBookShopDaobookShopDao;
/**
* Spring推荐使用构造器或Setter方式进行强依赖注入，不推荐属性注入
*/
@Autowired
publicBookShopServiceImpl(BookShopDaobookShopDao) {
this.bookShopDao=bookShopDao;
}
?
@Transactional
@Override
publicvoidpurchase(Stringusername, Stringisbn) {
//1.获取图书的单价
IntegerbookPrice=bookShopDao.findBookPriceByIsbn(isbn);
System.out.println("图书"+isbn+"的单价为："+bookPrice);
//2.更新图书的库存
bookShopDao.updateBookStock(isbn);
System.out.println("图书"+isbn+"的库存成功被扣减1个");
//3.更新用户的账户
bookShopDao.updateUserAccount(username, bookPrice);
System.out.println("用户"+username+"花费掉"+bookPrice+"元购买了图书"+isbn);
}
}
第六步：关键代码-持久层
publicinterfaceBookShopDao{
/**
* 根据书号获取图书的销售单价
*/
publicIntegerfindBookPriceByIsbn(Stringisbn);
?
/**
* 更新图书库存，使库存减一个（stock=stock-1）
*/
publicvoidupdateBookStock(Stringisbn);
?
/**
* 更新用户账户，使用户当前余额减去price（balance=balance-price）
*/
publicvoidupdateUserAccount(Stringusername, Integerprice);
}
?
@Repository
publicclassBookShopDaoImplimplementsBookShopDao{
?
/**
* Spring的JDBC操作模板
*/
privateJdbcTemplatejdbcTemplate;
?
/**
* 用于依赖注入的构造器
*/
@Autowired
publicBookShopDaoImpl(JdbcTemplatejdbcTemplate) {
this.jdbcTemplate=jdbcTemplate;
}
?
/**
* 根据书号获取图书的销售单价
*/
@Override
publicIntegerfindBookPriceByIsbn(Stringisbn) {
Stringsql="select price from t_book where isbn = ?";
IntegerbookPrice=jdbcTemplate.queryForObject(sql, Integer.class, isbn);
returnbookPrice;
}
?
/**
* 更新图书库存，使库存减一个（stock=stock-1）
*/
@Override
publicvoidupdateBookStock(Stringisbn) {
//检查书的库存是否足够, 若不够, 则抛出异常
StringcheckSql="select stock from t_book_stock where isbn=?";
IntegercurrentStock=jdbcTemplate.queryForObject(checkSql, Integer.class, isbn);
if(currentStock==null||currentStock<=0){
thrownewBookStockException("图书"+isbn+"库存不足！");
}
Stringsql="update t_book_stock set stock=stock-1 where isbn=?";
jdbcTemplate.update(sql, isbn);
}
?
/**
* 更新用户账户，使用户当前余额减去price（balance=balance-price）
*/
@Override
publicvoidupdateUserAccount(Stringusername, Integerprice) {
//检查用户余额是否充裕
StringcheckSql="select balance from t_account where username=?";
Integerbalance=jdbcTemplate.queryForObject(checkSql, Integer.class, username);
if(balance==null||balance<price){
thrownewUserAccountException("用户"+username+"的账户余额不足！");
}
Stringsql="update t_account set balance=balance-? where username=?";
jdbcTemplate.update(sql, price, username);
}
}
第七步：关键代码-测试用例
publicclassTransactionTest{
?
privateApplicationContextcontext;
privateBookShopDaobookShopDao;
privateBookShopServicebookShopService;
privateCashierServicecashierService;
?
{
context=newClassPathXmlApplicationContext("spring-tx.xml");
bookShopDao=context.getBean(BookShopDao.class);
bookShopService=context.getBean(BookShopService.class);
cashierService=context.getBean(CashierService.class);
}
/**
* 测试事务控制是否生效
* (1) 假如库存不足，用户扣款是否成功 (答案：否，还未执行到)
* (2) 假如库存充裕，用户账户余额不足，是否库存扣减成功 (答案：否，错误回滚)
* (3) 假如库存充裕，用于账户余额充裕，是否可以购买成功 (答案：是，能够正确执行)
* (4) 假如去掉事务控制标签@Transactional，上述事务控制是否生效 (答案：否，只有部分成功)
*/
@Test
publicvoidtestPurchase(){
bookShopService.purchase("qiaofeng","IB1234");
}
?
@Test
publicvoidtestFindBookPrice() {
System.out.println(bookShopDao.findBookPriceByIsbn("IB1234"));
}
?
@Test
publicvoidtestUpdateBookStock() {
Stringisbn="IB1235";
bookShopDao.updateBookStock(isbn);
System.out.println("图书"+isbn+"的库存更新成功");
}
?
@Test
publicvoidtestUpdateUserAccount() {
StringuserName="qiaofeng";
Integerprice=50;
bookShopDao.updateUserAccount(userName, price);
System.out.println("用户"+userName+"买书花费了"+price);
}
}
?
3.3 细节-事务传播机制
3.3.1 概述
当事务方法被另一个事务方法调用时，必须指定事务应该如何传播，例如：方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。
事务的传播行为可以由传播属性指定，Spring 定义了 7 种类传播行为（如下图所示），在实际工作中，最常使用的事务传播行为是：REQUIRED 和 REQUIRED_NEW。
3.3.2 关键代码
为了方便测试，增加一个客户结账操作（CashierService），用于结算用户购买的多本图书，当用户余额不足时可指定用户的购买行为：只能买N本，或者，一本都买不了。
需要设置：
- 用户qiaofeng账户余额为50元，图书IB1234售价为50元，库存为20；图书IB1235售价为100元，库存为20；
- 用户qiaofeng账户余额只能购买一本图书IB1234，无法购买图书IB1235；
假如用户要购买2本不同图书，在此场景下验证事务传播机制：
增加结账操作（CashierService）
publicinterfaceCashierService{
/**
* 客户结账操作：用户购买多本图书
*/
publicvoidcheckout(Stringusername, List<String>isbnList);
}
?
@Service
publicclassCashierServiceImplimplementsCashierService{
privateBookShopServicebookShopService;
?
@Autowired
publicCashierServiceImpl(BookShopServicebookShopService) {
this.bookShopService=bookShopService;
}
?
/**
* 客户结账操作：用户购买多本图书
*/
@Transactional
@Override
publicvoidcheckout(Stringusername, List<String>isbnList) {
for(Stringisbn: isbnList) {
//调用BookShopService的purchase方法，购买一本图书
bookShopService.purchase(username, isbn);
}
}
}
?
3.3.3 验证REQUIRED行为
REQUIRED行为是默认的事务传播行为，也可以设置属性propagation = Propagation.REQUIRED；
表示purchase()方法使用checkout()方法的事务处理该方法的操作，故由于用户账户余额不足，导致checkout方法的2本图书均无法购买成功，也就是用户一本都没买成。
在checkout()方法的开始和终止边界内只有一个事务，这个事务只在checkout()方法结束的时候被提交，结果用户一本书都买不了，过程如下图所示：
代码实现如下:
@Transactional
@Override
publicvoidcheckout(Stringusername, List<String>isbnList) {
for(Stringisbn: isbnList) {
bookShopService.purchase(username, isbn);
}
}
?
@Transactional(propagation=Propagation.REQUIRED)
@Override
publicvoidpurchase(Stringusername, Stringisbn) {
//1.获取图书的单价
IntegerbookPrice=bookShopDao.findBookPriceByIsbn(isbn);
//2.更新图书的库存
bookShopDao.updateBookStock(isbn);
//3.更新用户的账户
bookShopDao.updateUserAccount(username, bookPrice);
}
3.3.4 验证REQUIRED_NEW模式
另一种常见的传播行为是 REQUIRES_NEW，它表示该方法必须启动一个新事务，并在自己的事务内运行；如果有事务在运行，就应该先挂起它。
代码实现如下：
在方法purchase()中设置propagation = Propagation.REQUIRES_NEW，则调用此方法时开启本方法的新事务；
@Transactional
@Override
publicvoidcheckout(Stringusername, List<String>isbnList) {
for(Stringisbn: isbnList) {
bookShopService.purchase(username, isbn);
}
}
?
@Transactional(propagation=Propagation.REQUIRES_NEW)
@Override
publicvoidpurchase(Stringusername, Stringisbn) {
//1.获取图书的单价
IntegerbookPrice=bookShopDao.findBookPriceByIsbn(isbn);
//2.更新图书的库存
bookShopDao.updateBookStock(isbn);
//3.更新用户的账户
bookShopDao.updateUserAccount(username, bookPrice);
}
3.4 细节-隔离级别
事务的4种隔离级别（级别右低变高）：
- Read Uncommitted（读未提交）：最低级别，任何情况都可能发生；
- Read Committed（读已提交）：可避免脏读的发生；
- Repeatable Read（可重复读）：可避免脏读、不可重复读的发生；
- Serializable（串行化）：最高级别，避免脏读、不可重复读、幻读的发生；
关于事务的隔离级别，需要注意的是：
- 从理论上来说，事务应该彼此完全隔离，以避免并发事务所导致的问题，然而，那样会对性能产生极大的影响, 因为事务必须按顺序运行；
- 在实际开发中，为了提升性能，事务会以较低的隔离级别运行；
- MySQL数据库支持4种事务隔离级别，Oracle数据库只支持其中2种：READ_COMMITED , SERIALIZABLE；
- 事务的隔离级别要得到底层数据库引擎的支持，而不是应用程序或者框架的支持。
事务的隔离级别可以通过隔离事务属性指定，指定属性isolation = Isolation.READ_COMMITTED。
@Transactional(isolation=Isolation.READ_COMMITTED)
@Override
publicvoidpurchase(Stringusername, Stringisbn) {
//1.获取图书的单价
IntegerbookPrice=bookShopDao.findBookPriceByIsbn(isbn);
//2.更新图书的库存
bookShopDao.updateBookStock(isbn);
//3.更新用户的账户
bookShopDao.updateUserAccount(username, bookPrice);
}
3.5 细节-设置回滚事务属性
默认情况下只有未检查异常(RuntimeException和Error类型的异常)会导致事务回滚，而受检查异常不会；
事务的回滚规则可以通过 @Transactional 注解的 rollbackFor 和 noRollbackFor 属性来定义，这两个属性被声明为 Class[] 类型的，因此可以为这两个属性指定多个异常类。
- rollbackFor： 遇到时必须进行回滚
- noRollbackFor：一组异常类，遇到时必须不回滚
@Transactional(propagation=Propagation.REQUIRES_NEW,
isolation=Isolation.READ_COMMITTED,
rollbackFor={IOException.class, SQLException.class},
noRollbackFor=ArithmeticException.class)
@Override
publicvoidpurchase(Stringusername, Stringisbn) {
//1.获取图书的单价
IntegerbookPrice=bookShopDao.findBookPriceByIsbn(isbn);
//2.更新图书的库存
bookShopDao.updateBookStock(isbn);
//3.更新用户的账户
bookShopDao.updateUserAccount(username, bookPrice);
}
3.6 细节-超时和只读属性
由于事务可以在行和表上获得锁，因此长事务会占用资源，并对整体性能产生影响；
如果一个事物只读取数据但不做修改，数据库引擎可以对这个事务进行优化；
- 超时事务属性：事务在强制回滚之前可以保持多久，这样可以防止长期运行的事务占用资源；
- 只读事务属性：表示这个事务只读取数据但不更新数据，这样可以帮助数据库引擎优化事务。
超时和只读属性可以在@Transactional注解中定义，超时属性以秒为单位来计算。
@Transactional(propagation=Propagation.REQUIRES_NEW,
isolation=Isolation.READ_COMMITTED,
rollbackFor={IOException.class, SQLException.class},
noRollbackFor=ArithmeticException.class,
readOnly=false,
timeout=5)
@Override
publicvoidpurchase(Stringusername, Stringisbn) {
//1.获取图书的单价
IntegerbookPrice=bookShopDao.findBookPriceByIsbn(isbn);
//2.更新图书的库存
bookShopDao.updateBookStock(isbn);
//3.更新用户的账户
bookShopDao.updateUserAccount(username, bookPrice);
}
4. 基于XML配置实现的事务控制
4.1 事务配置
<!-- 定义持久层 --> <beanid="bookShopDao"class="com.tengol.demo.spring.tx.dao.BookShopDaoImpl"> <constructor-argname="jdbcTemplate"ref="jdbcTemplate"/> </bean> <!-- 定义业务层 --> <beanid="bookShopService"class="com.tengol.demo.spring.tx.service.BookShopServiceImpl"> <constructor-argname="bookShopDao"ref="bookShopDao"/> </bean> <!-- 事务配置第一步：声明事务管理器 --> <beanid="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <propertyname="dataSource"ref="dataSource"/> </bean> <!-- 事务配置第二步：声明事务通知 --> <tx:adviceid="bookShopTxAdvice"transaction-manager="transactionManager"/> <!-- 事务配置第三步：声明事务管理的范围 --> <aop:config> <aop:pointcutid="bookShopPoint"expression="execution(* *.BookShopService.*(..))"/> <aop:advisoradvice-ref="bookShopTxAdvice"pointcut-ref="bookShopPoint"/> </aop:config>
4.2 细节-事务传播机制
<!-- 事务配置第二步：声明事务通知 --> <tx:adviceid="bookShopTxAdvice"transaction-manager="transactionManager"> <tx:attributes> <tx:methodname="purchase"propagation="REQUIRES_NEW"/> </tx:attributes> </tx:advice>
4.3 细节-隔离级别
<!-- 事务配置第二步：声明事务通知 --> <tx:adviceid="bookShopTxAdvice"transaction-manager="transactionManager"> <tx:attributes> <tx:methodname="purchase"propagation="REQUIRES_NEW" isolation="READ_COMMITTED" roo/> </tx:attributes> </tx:advice>
4.4 细节-设置回滚事务属性
<!-- 事务配置第二步：声明事务通知 --> <tx:adviceid="bookShopTxAdvice"transaction-manager="transactionManager"> <tx:attributes> <tx:methodname="purchase"propagation="REQUIRES_NEW"isolation="READ_COMMITTED" rollback-for="java.io.IOException,java.sql.SQLException" no-rollback-for="java.lang.ArithmeticException"/> </tx:attributes> </tx:advice>
4.5 细节-超时和只读属性
<!-- 事务配置第二步：声明事务通知 --> <tx:adviceid="bookShopTxAdvice"transaction-manager="transactionManager"> <tx:attributes> <tx:methodname="purchase"propagation="REQUIRES_NEW"isolation="READ_COMMITTED" rollback-for="java.io.IOException,java.sql.SQLException" no-rollback-for="java.lang.ArithmeticException" read-only="false" timeout="5"/> </tx:attributes> </tx:advice>
5. Spring Jdbc Template
为了使 JDBC 更加易于使用，Spring 在 JDBC API 上定义了一个抽象层，以此建立一个JDBC存取框架；
JdbcTemplate 类被设计成为线程安全的，故可以在IOC容器中声明它的单个实例，并注入给所有的DAO实例；
常用操作如下：
5.1 HelloWorld
第一步：引入jar包
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>6.0.6</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
<dependency>
<groupId>com.mchange</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.5.1</version>
</dependency>
第二步：XML配置及属性文件
<?xmlversion="1.0" encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
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.xsd">
<!-- 加载属性文件 -->
<context:property-placeholderlocation="classpath:db.properties"/>
<!-- 配置连接池 -->
<beanid="dataSource"class="com.mchange.v2.c3p0.ComboPooledDataSource">
<propertyname="driverClass"value="${jdbc.driverClass}"/>
<propertyname="jdbcUrl"value="${jdbc.url}"/>
<propertyname="user"value="${jdbc.user}"/>
<propertyname="password"value="${jdbc.password}"/>
</bean>
<!-- 配置JdbcTemplate模板 -->
<beanid="jdbcTemplate"class="org.springframework.jdbc.core.JdbcTemplate">
<propertyname="dataSource"ref="dataSource"/>
</bean>
</beans>
第三步：编写测试用例
publicclassJdbcTemplateTest{
privateJdbcTemplatejdbcTemplate;
?
@Before
publicvoidinit(){
ApplicationContextcontext=
newClassPathXmlApplicationContext("spring-jdbc.xml");
jdbcTemplate=context.getBean(JdbcTemplate.class);
}
?
@Test
publicvoidtestUpdate(){
Stringsql="insert into t_user(user_name,nick_name) value(?,?);";
intupdateRecords=jdbcTemplate.update(sql, "duanyu", "dy");
System.out.println("insert "+updateRecords+" records");
}
}
5.2 执行一条更新语句
方法：org.springframework.jdbc.core.JdbcTemplate#update(java.lang.String, java.lang.Object...)
@Test
publicvoidtestUpdate(){
Stringsql="insert into t_user(user_name,nick_name) value(?,?);";
intupdateRecords=jdbcTemplate.update(sql, "duanyu", "dy");
System.out.println("insert "+updateRecords+" records");
}
5.3 执行批量更新语句
/**
* 执行批量更新: 批量的 INSERT, UPDATE, DELETE
* 最后一个参数是 Object[] 的 List 类型: 因为修改一条记录需要一个 Object 的数组,
* 那么多条不就需要多个 Object 的数组吗
*/
@Test
publicvoid testBatchUpdate(){
Stringsql="insert into t_user(user_name,nick_name)value(?,?)";
List<Object[]>args=newArrayList<Object[]>();
args.add(newObject[]{"qiaofeng","qf"});
args.add(newObject[]{"xuzhu","xz"});
args.add(newObject[]{"duanyu","dy"});
jdbcTemplate.batchUpdate(sql,args);
}
5.4 查询一条结果
/**
* 从数据库中获取一条记录, 实际得到对应的一个对象
* 注意不是调用 queryForObject(String sql, Class<User> requiredType, Object... args)
* 而需要调用 queryForObject(String sql, RowMapper<User> rowMapper, Object... args)
* 1. 其中的 RowMapper 指定如何去映射结果集的行, 常用的实现类为 BeanPropertyRowMapper
* 2. 使用 SQL 中列的别名完成列名和类的属性名的映射. 例如 user_name userName
* 3. 不支持级联属性. JdbcTemplate 到底是一个 JDBC 的小工具, 而不是 ORM 框架
*/
@Test
publicvoidtestQueryForObject(){
Stringsql="select user_name userName, nick_name nickName from t_user where id=?";
RowMapper<User>userRowMapper=newBeanPropertyRowMapper<User>(User.class);
Useruser=jdbcTemplate.queryForObject(sql, userRowMapper, 5);
System.out.println(newGson().toJson(user));
}
5.5 查询多条结果
/**
* 查到实体类的集合
* 注意调用的不是 queryForList 方法
*/
@Test
publicvoidtestQueryForList(){
Stringsql="select user_name userName, nick_name nickName from t_user where id > ?";
RowMapper<User>userRowMapper=newBeanPropertyRowMapper<User>(User.class);
List<User>userList=jdbcTemplate.query(sql, userRowMapper, 5);
System.out.println(newGson().toJson(userList));
}
5.6 获取单个列的值
/**
* 获取单个列的值, 或做统计查询
* 使用 queryForObject(String sql, Class<Long> requiredType)
*/
@Test
publicvoidtestQueryOneColumn(){
Stringsql="select count(id) from t_user";
Integercount=jdbcTemplate.queryForObject(sql, int.class);
System.out.println(count);
}
5.7 执行具名参数语句
/**
* 可以为参数起名字.
* 1. 好处: 若有多个参数, 则不用再去对应位置, 直接对应参数名, 便于维护
* 2. 缺点: 较为麻烦.
*/
@Test
publicvoidtestNamedParameter(){
Stringsql="insert into t_user(user_name,nick_name)value(:uname,:nname)";
Map<String,Object>args=newHashMap<String, Object>();
args.put("uname","xiaofeng");
args.put("nname","xf");
intupdate=namedParameterJdbcTemplate.update(sql, args);
System.out.println("insert records : "+update);
}
?
/**
* 使用具名参数时, 可以使用 update(String sql, SqlParameterSource paramSource) 方法进行更新操作
* 1. SQL 语句中的参数名和类的属性一致!
* 2. 使用 SqlParameterSource 的 BeanPropertySqlParameterSource 实现类作为参数.
*/
@Test
publicvoidtestNamedParameterJdbcTemplate2(){
Stringsql="insert into t_user(user_name,nick_name)values(:userName,:nickName)";
Useruser=newUser("Saodiseng","sds");
SqlParameterSourceparamSource=newBeanPropertySqlParameterSource(user);
namedParameterJdbcTemplate.update(sql, paramSource);
}
附录-参考资料：
本文档参考了尚硅谷Spring教程和网上相关参考资料，感谢互联网的分享。
尚硅谷
[尚硅谷-官网] http://www.atguigu.com/
关于事务及传播行为
[MySQL的四种事务隔离级别] https://www.cnblogs.com/huanongying/p/7021555.html
[事务及其隔离级别] https://www.cnblogs.com/melody210218/p/7120559.html
[浅谈MySQL的事务级别] https://baijiahao.baidu.com/s?id=1572543485267773&wfr=spider&for=pc
[MySQL中的锁（表锁、行锁，共享锁，排它锁，间隙锁）] https://blog.csdn.net/soonfly/article/details/70238902
本文暂时没有评论，来添加一个吧(●'◡'●)