Spring 06 声明式事务
1、事务的概念
将一组操作数据的SQL作为一个整体提交，要么都成功，要么都失败
使用的原因：
保证数据的完整性和一致性，对数据操作是要保证数据的安全
2、事务的特性【ACID】
⑴ 原子性
将多个SQL作为一个整体，不可分割
⑵ 一致性
数据在操作前是正确的，操作后也是正确的
操作的结果应该和业务逻辑保持一致
⑶ 隔离性
多个事务并发操作同一个数据时，保证事务间的数据是隔离开来的，相关不会受到干扰，保证数据的安全
⑷ 持久性
事务操作数据库的结果，应该永久地保存到持久化存储器中
3、事务的隔离级别
分类
未提交读
int TRANSACTION_READ_UNCOMMITTED = 1;
一个事务读取到了另一个事务还没有提交的数据
可能产生脏读，不可重复读，幻读问题。但是它解决了数据丢失问题
例如：
T1正在读取数据，并对数据进行操作
T2 修改了数据，但是还没有提交数据
T1 再次读取数据，可能发生脏读问题。因为T2可能会回滚事务
已提交读
int TRANSACTION_READ_COMMITTED = 2;
一个事务读取到了另外一个事务已经提交过的数据
可能产生不可重复读，幻读问题。但是它解决了数据丢失和脏读问题
例如：
T1 正在读取数据，并对数据进行操作
T2 修改了数据，并提交了数据
T1 再次读取数据，发现两次读取到的数据不一致。这就产生了不可重复读问题
重复读
int TRANSACTION_REPEATABLE_READ = 4;
一个事务只能重复的读取当前事务中的操作数据，而不能读取到另外的事务中未提交和已提交的数据
可能产生幻读。但是它解决了数据丢失，脏读和不可重复读问题
例如：
T1 正在读取数据，并对数据进行操作
T2 修改了数据，并且提交了数据，但是没有提交数据
T1 再次读取数据，两次读取到的数据是一致的
序列化/不可并发
int TRANSACTION_SERIALIZABLE = 8;
可以解决所有的问题，一般配合数据库锁的机制控制数据的安全【统计工作】
幻读问题：一个事务正在进行某种统计操作，其他事务又进行数据的增删改等操作，导致两次统计到的结果不一致
例如：
T1 正在统计表的记录数，得到一个结果
T2 向数据库中添加了一些数据
T3 再次统计表的记录数，得到的结果就比T1统计到的多
Tips：
SELECT * FROM ??? WHERE ??? FOR UPDATE; // 行级锁
数据库的默认隔离级别
MySQL 4（重复读）
Oracle 2（已提交读）
4、事务管理方式
编程式事务
即使用原生的JDBC API进行事务的管理
步骤：
⑴ 获取数据库连接对象【Connection】
⑵ 取消事务的自动提交
⑶ 执行SQL操作
⑷ 正常完成操作时，手动提交事务
⑸ 执行失败时，回滚事务
⑹ 关闭相关资源（释放连接等）
声明式事务
通过相关配置，给程序方法增加事务的操作
5、Spring的声明式事务
相关API
Spring框架提供了PlatformTransactionManager接口，用来管理底层的事务。并且提供了相关的实现类
⑴ DataSourceTransactionManager
Spring和JdbcTemplate或MyBatis框架集成时，提供的事务管理器
⑵ HibernateTransactionManager
Spring和Hibernate框架集成时，提供的事务管理器
使用步骤
⑴ 拷贝jar包
① 和IOC有关的：
commons-logging-1.1.3.jar
spring-beans-4.0.0.RELEASE.jar
spring-context-4.0.0.RELEASE.jar
spring-core-4.0.0.RELEASE.jar
spring-expression-4.0.0.RELEASE.jar
② 和AOP有关的：
spring-aop-4.0.0.RELEASE.jar
spring-aspects-4.0.0.RELEASE.jar
com.springsource.net.sf.cglib-2.2.0.jar
com.springsource.org.aopalliance-1.0.0.jar
com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
③ 和数据库有关的：
spring-jdbc-4.0.0.RELEASE.jar
spring-orm-4.0.0.RELEASE.jar
spring-tx-4.0.0.RELEASE.jar
④ 数据库驱动和c3p0
mysql-connector-java-5.1.7-bin.jar
c3p0-0.9.1.2.jar
⑵ 创建c3p0的properties配置文件
⑶ 创建核心配置文件
添加context和tx名称空间
① 通过
<context:component-scan base-package="要扫描的包及其子包" />
标签，来设置自动扫描包
② 通过
<context:property-placeholder location="???.properties" />
标签，来引入外部配置文件
③ 通过bean 标签，声明c3p0即DataSource对象
④ 通过bean 标签，声明JdbcTemplate对象。注意需要给其dataSource属性赋值，引用DataSource（c3p0）对象
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource" />
</bean>
⑤ 通过bean标签，声明TransactionManager对象。注意需要给其dataSource属性赋值，引用DataSource（c3p0）对象
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
以DataSourceTransactionManager为例
⑥ 通过
<tx:annotation-driven transaction-manager="事务管理器" />
标签，来开启基于注解的声明式事务
⑷ 编写具体的DAO、Service，并在具体的业务方法上，加上@Transactional注解，即可给方法开启事务
6、Transactional【事务】的属性
事务传播行为
【propagation属性】
方法被调用时，事务的开启方式
一共有7个传播行为，常用的有2个：
⑴ Propagation.REQUIRED
表示一个方法被调用时，如果已经存在了一个事务，则加入其中；否则，会开启一个新的事务。【默认值】
⑵ Propagation.REQUIRES_NEW
表示一个方法被调用时，不管调用的方法是否存在事务，都会开启一个新的事务
事务隔离级别
【isolation属性】
Isolation.DEFAULT
表示与数据库的默认隔离级别一致
MySQL 4（重复读）
Isolation.READ_UNCOMMITTED 未提交读
Isolation.READ_COMMITTED 已提交读
Isolation.REPEATABLE_READ 重复读
Isolation.SERIALIZABLE 序列化/不可并发
事务回滚策略
【rollbackFor属性】
当发生什么样的异常（包括其子类）时，进行回滚
对于Spring框架，默认情况下，RuntimeException类型才会回滚；对于编译时异常和Error，是不会回滚的
所以，需要修改Spring的默认回滚策略
例如：rollbackFor = Exception.class
Tips：
⑴ RuntimeException：运行时异常
例如FileNotFoundException，这种可以遇见到的异常
⑵ Exception：编译期异常/检查异常/受控异常
与rollbackFor相对的是：
【noRollbackFor】属性
遇到指定的异常类型（包括其子类），不进行回滚
事务超时属性
【timeout】属性
timeout = 超时时间（秒）
如果一个事务的执行时间，超过了指定的时长（n秒），就被视为超时。当该事务执行完毕时，会抛出异常：
org.springframework.transaction.TransactionTimedOutException: Transaction timed out: deadline was ???
只读属性
【readOnly】属性
一般查询的时候，会将该属性设置为true，表明为只读。这样数据库底层会对查询进行优化处理，提高查询的效率
注意：当一个连接对象（Connection）设置了只读属性，则其再操作增删改时，会报错：
java.sql.SQLException: Connection is read-only. Queries leading to data modification are not allowed
Transaction属性设置示例
【示例一】
// 事务传播行为为当有事务时就加入，没有就新建一个事务；
// 默认隔离级别；
// 事务回滚策略：Exception及其子异常
// 超时：3秒超时
@Transactional(propagation = Propagation.REQUIRED,
isolation = Isolation.DEFAULT,
rollbackFor = Exception.class,
timeout = 3)
public void testTransaction() { }
【示例二】
// 查询业务操作，设置连接属性为只读，提高效率
@Transactional(readOnly = true)
public void testQuery() { }
代码示例
【SQL语句】
USE test;
CREATE TABLE books(
id INT PRIMARY KEY AUTO_INCREMENT,
name VARCHAR(100) NOT NULL,
price INT NOT NULL,
stock INT NOT NULL
);
INSERT INTO books(name, price, stock)
VALUES('小王子', 34, 100),
('圣经', 48, 100),
('福尔摩斯探案集', 84, 100);
【Book类（JavaBean）】
属性：Integer id, String name, Integer price, Integer stock;提供get和set，有参无参构造，重写toString方法
【核心配置文件】
<context:component-scan base-package="com.test.tx" />
<context:property-placeholder location="classpath:/jdbc.properties" />
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="${jdbc.driverClass}" />
<property name="jdbcUrl" value="${jdbc.url}" />
<property name="user" value="${jdbc.user}" />
<property name="password" value="${jdbc.password}" />
</bean>
<!-- 声明JdbcTemplate -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource" />
</bean>
<!-- 声明事务管理器 -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource" />
</bean>
<!-- 开启基于注解的声明式事务 -->
<tx:annotation-driven transaction-manager="transactionManager" />
【BookDao接口】
package com.test.tx.dao;
import java.util.List;
import com.test.tx.bean.Book;
public interface BookDao {
int updateBookPrice(String name, Integer price);
int updateBookStock(String name);
Book getBook(String name);
List<Book> queryBooks();
}
【BookDaoImpl实现类】
package com.test.tx.dao;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Repository;
import com.test.tx.bean.Book;
@Repository
public class BookDaoImpl implements BookDao {
@Autowired
private JdbcTemplate jdbcTemplate;
@Override
public int updateBookPrice(String name, Integer price) {
String sql = "UPDATE test.books SET price = ? WHERE name = ?";
return jdbcTemplate.update(sql, price, name);
}
@Override
public int updateBookStock(String name) {
String sql = "UPDATE test.books SET stock = stock - 1 WHERE name = ?";
return jdbcTemplate.update(sql, name);
}
@Override
public Book getBook(String name) {
String sql = "SELECT id, name, price, stock FROM test.books WHERE name = ?";
RowMapper<Book> rowMapper = new BeanPropertyRowMapper<Book>(Book.class);
return jdbcTemplate.queryForObject(sql, rowMapper, name);
}
@Override
public List<Book> queryBooks() {
String sql = "SELECT id, name, price, stock FROM test.books";
RowMapper<Book> rowMapper = new BeanPropertyRowMapper<Book>(Book.class);
return jdbcTemplate.query(sql, rowMapper);
}
}
【BookService接口】
package com.test.tx.service;
import java.util.List;
import com.test.tx.bean.Book;
public interface BookService {
int updateBookPrice(String name, Integer price) throws Exception;
int updateBookStock(String name) throws Exception;
Book getBook(String name);
List<Book> queryBooks();
}
【BookServiceImpl实现类】
package com.test.tx.service;
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;
import com.test.tx.bean.Book;
import com.test.tx.dao.BookDao;
@Service
public class BookServiceImpl implements BookService {
@Autowired
private BookDao bookDao;
/*
* 测试超时
*
* org.springframework.transaction.TransactionTimedOutException: Transaction
* timed out: deadline was ???
*
* @Transactional(timeout = 3)
*/
// ---------------------------------------------------------------------------------
/*
* 测试更新时，设置连接为只读
*
* Caused by: java.sql.SQLException: Connection is read-only. Queries
* leading to data modification are not allowed
*
* @Transactional(readOnly = true)
*/
// ---------------------------------------------------------------------------------
// 这里设置事务的传播行为是：不管有没有事务，都会开启一个新的事务
// 是为了测试MulService的testTx方法【因为和下面的更新图书库存操作是两个事务，所以这个事务出错了，但是不会回滚。最终效果是价格变了，但库存没有变】
@Transactional(propagation = Propagation.REQUIRES_NEW)
public int updateBookPrice(String name, Integer price) throws Exception {
// 测试超时【让线程休眠】
// Thread.sleep(4000);
return bookDao.updateBookPrice(name, price);
}
/*
* 如果不设置回滚策略，则会造成执行MulService的testTx方法时，图书的价格变了，但是库存没有变，事务并没有回滚
*
* @Transactional(rollbackFor = Exception.class)
*/
// ---------------------------------------------------------------------------------
// 这里设置事务的传播行为是：不管有没有事务，都会开启一个新的事务
// 是为了测试MulService的testTx方法【因为和上面的更新图书价格操作是两个事务，所以这个事务出错了，但是不会回滚。最终效果是价格变了，但库存没有变】
@Transactional(propagation = Propagation.REQUIRES_NEW)
public int updateBookStock(String name) throws Exception {
// 这里抛出一个编译时异常【Spring默认是不回滚的】
// FileInputStream fis = new FileInputStream("a/a/a/a");
// 这里有一个算数异常
int i = 1 / 0;
return bookDao.updateBookStock(name);
}
// 设置为只读的，提高效率
@Transactional(readOnly = true)
public Book getBook(String name) {
return bookDao.getBook(name);
}
// 设置为只读的，提高效率
@Transactional(readOnly = true)
public List<Book> queryBooks() {
return bookDao.queryBooks();
}
}
【MulService类（用于调用BookServiceImpl的两个业务方法）】
package com.test.tx.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
@Service
public class MulService {
@Autowired
private BookService bookService;
@Transactional
public void testTx(String name, Integer price) throws Exception {
bookService.updateBookPrice(name, price);
bookService.updateBookStock(name);
}
}
【测试类】
package junit.test;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.test.tx.bean.Book;
import com.test.tx.service.BookService;
import com.test.tx.service.MulService;
public class TestTx {
private ApplicationContext ioc = new ClassPathXmlApplicationContext("???.xml");
@Test
// 测试执行更新图书价格操作
public void test1() throws Exception {
BookService bookService = ioc.getBean(BookService.class);
bookService.updateBookPrice("小王子", 100);
}
@Test
// 测试更新图书的库存和价格【两个Dao操作】
public void test2() throws Exception {
MulService mulService = ioc.getBean(MulService.class);
String name = "小王子";
Integer price = 200;
mulService.testTx(name, price);
}
@Test
public void test3() {
BookService bookService = ioc.getBean(BookService.class);
Book book = bookService.getBook("小王子");
System.out.println(book);
}
}
7、基于XML的声明式事务
相关标签
<tx:advice id="通知的id" transaction-manager="事务管理器" ></tx:advice>
用于声明通知的事务标签。它有tx:attributes子标签
<tx:attributes></tx:attributes>
tx:advice的子标签，在其里面 声明开启事务的方法标签
<tx:method
name=""
isolation="DEFAULT"
no-rollback-for=""
propagation="REQUIRED"
read-only="false"
rollback-for=""
timeout="-1" />
name：需要开启事务的方法的名字
isolation：事务隔离级别
no-rollback-for：事务不回滚策略
propagation：事务传播行为
read-only：只读属性
rollback：事务回滚策略
timeout：超时【默认值为-1，即不超时】
Tips：name属性可以使用* 来代替多个字符
例如：getUser方法名，可以用get* 来代替
设置开启事务方法的Transaction的属性
<aop:config></aop:config>
在其里面声明切入点表达式和组织者
<aop:pointcut expression="切入点表达式" id="表达式的id" />
用于声明切入点表达式
<aop:advisor advice-ref="所引用的事务标签的组织者的id" pointcut-ref="所引用的切入点表达式的id" />
用于声明组织者，需要引用事务的通知的id（tx:advice）和切入点表达式（aop:pointcut）
该标签用于匹配需要开启事务的业务逻辑方法
示例
<tx:advice id="adviceId" transaction-manager="transactionManager">
<tx:attributes>
<!-- 设置开启事务方法的Transaction的属性 -->
<tx:method name="test*" propagation="REQUIRED" />
<!-- 设置超时为3秒；出现异常就回滚的策略 -->
<tx:method name="update*" timeout="3" rollback-for="java.lang.Exception" />
<!-- 查询业务方法，设置连接为只读，提高效率 -->
<tx:method name="query*" read-only="true" />
<!-- 事务隔离级别：重复读 -->
<tx:method name="get*" read-only="true" isolation="REPEATABLE_READ" />
</tx:attributes>
</tx:advice>
<aop:config>
<!-- 声明切入点表达式 -->
<aop:pointcut expression="execution(* com.test..service..*(..))" id="pointcutId" />
<!-- 声明组织者 -->
<aop:advisor advice-ref="adviceId" pointcut-ref="pointcutId" />
</aop:config>