本文介绍了Spring中的AOP事务管理，包括数据库隔离级别概念、Java异常分类以及注解配置事务管理的细节，如@Transactional注解的timeout、readOnly、rollbackFor、noRollbackFor、isolation和propagation等属性的使用，并通过示例代码展示了如何控制事务的回滚和隔离级别。
事务管理的本质：还是动态代理，将事务方法将给事务管理器代理。对于操作数据库的事务管理器，事务方法一出现异常就回滚，没有异常就正常执行。
事务管理通俗的理解，可以理解为，Service编写业务逻辑代码，可能会涉及到多个表的增删改查等等，如果在业务方法里面某个Dao出错，那整个方法里面都进行数据库的回滚操作，数据库返回到执行该业务方法之前的状态。
一、数据库基本知识
1、隔离级别概念
数据库具有隔离并发运行多个事务的能力，是它们不受影响，避免各种并发问题。一个事务和其他事务隔离的程度称作隔离级别。
2、隔离级别的分类
读未提交：可以读到未提交事务的数据。READ-UNCOMMITTED
读已提交：只能读到已提交事务的数据。READ-COMMITTED
可重复读：保证一次事务中读到的数据是同一个。REPEATABLE-READ
串行化：数据库变成单线程，一个事务执行完了才能轮到下个事务执行。SERIALIZABLE
查看数据库当前会话的隔离级别的DOS指令：select @@数据库名字_isolation;
修改当前会话的隔离级别的DOS指令：set SESSION TRANSACTION ISOLATION LEVEL 隔离级别;
二、java异常分类
三、注解配置事务管理细节
1、开启注解的事务管理步骤
① 开启注解注入事务管理。
② 在XML中配置事务管理器(就是切面类)。
③ 给事务方法加上注解。
在默认情况下，只有运行时异常会回滚，而编译时异常则不会回滚。
2、Transactional注解的属性
公共代码
transaction.xml配置：
<context:component-scan base-package="cj.transaction"></context:component-scan>
<context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
<bean class="org.apache.commons.dbcp.BasicDataSource" id="dataSource">
<property name="username" value="${c.username}"></property>
<property name="password" value="${password}"></property>
<property name="url" value="${url}"></property>
<property name="driverClassName" value="${classname}"></property>
</bean>
<bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">
<property name="dataSource" value="#{dataSource}"></property>
</bean>
<!-- 开启注解的事务管理-->
<bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="dataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<tx:annotation-driven transaction-manager="dataSourceTransactionManager"/>
前五个属性的公共测试代码：
public class TestDemo {
public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("transaction.xml");
BookService bookService = (BookService) applicationContext.getBean("bookService");
bookService.checkout("Sarsh", 1);
}
}
前五个属性的公共Dao代码：
@Repository
public class BookDao {
@Autowired
JdbcTemplate jdbcTemplate;
public int getPrice(int bookId) {
String sql = "select BOOK_PRICE from book where BOOK_ID=?";
return jdbcTemplate.queryForObject(sql, Integer.class, bookId);
}
public void updateStock(int bookId) {
String sql = "update book_stock set BOOK_STOCK=BOOK_STOCK-1 where BOOK_ID=?";
jdbcTemplate.update(sql, bookId);
}
public void updateBalance(String accountName, int bookPrice) {
String sql = "update account set ACCOUNT_BALANCE=ACCOUNT_BALANCE-? where ACCOUNT_NAME=?";
jdbcTemplate.update(sql, bookPrice, accountName);
}
}
初始的三张表(account、book和book_stock)：
① timeout属性
这个属性以秒为单位，当事务方法执行时间超过这个指定时间的是就会报错。
事务方法代码(简单的测试单个事务)：
@Service
public class BookService {
@Autowired
private BookDao bookDao;
@Transactional(timeout = 3)
public void checkout(String accountName, int bookId) {
bookDao.updateStock(bookId);
try {
Thread.sleep(3000); //以毫秒为单位
} catch (InterruptedException e) {
e.printStackTrace();
}
bookDao.updateBalance(accountName, bookDao.getPrice(bookId));
System.out.println("结账成功");
}
}
运行结果：
② readOnly属性
当这个属性为true的时候，表示事务方法只能读取数据而不能修改数据。
事务方法代码(简单的测试单个事务)：
@Service
public class BookService {
@Autowired
private BookDao bookDao;
@Transactional(readOnly = true)
public void checkout(String accountName, int bookId) {
bookDao.updateStock(bookId); //修改了数据
bookDao.updateBalance(accountName, bookDao.getPrice(bookId)); //修改了数据
System.out.println("结账成功");
}
}
运行结果：
③ rollbackFor属性
Spring的事务管理默认不会对编译时异常(非运行时异常)进行回滚，但是可以自己设置编译时异常的回滚。
事务方法代码(简单的测试单个事务)：
@Service
public class BookService {
@Autowired
private BookDao bookDao;
@Transactional(rollbackFor = FileNotFoundException.class)
public void checkout(String accountName, int bookId) throws FileNotFoundException {
bookDao.updateStock(bookId);
bookDao.updateBalance(accountName, bookDao.getPrice(bookId));
System.out.println("结账成功");
new FileInputStream("D:/xxx.xxx.xxx");
}
}
运行结果：
数据库中涉及到的表中数据都没有更改。测试结果表明默认情况下编译时异常不会执行回滚操作。
④ noRollbackFor属性
自己设置运行时除数为零的异常不回滚。
事务方法代码(简单的测试单个事务)：
@Service
public class BookService {
@Autowired
private BookDao bookDao;
@Transactional(noRollbackFor = ArithmeticException.class)
public void checkout(String accountName, int bookId) {
bookDao.updateStock(bookId);
int x = 10 / 0;
bookDao.updateBalance(accountName, bookDao.getPrice(bookId));
System.out.println("结账成功");
}
}
运行结果：
数据库中只改了book_stock表中的BOOK_STOCK，而account表中的ACCOUNT_BALANCE没有改变。测试结果表明默认情况下运行时异常会执行回滚操作。
⑤ isolation属性
改变这次连接的隔离级别。
⑥ propagation属性
指定事物的传播行为。
REQUIRED：如果当前有事务在运行，则该事务方法在事物内部执行。如果当前没有事务运行，就启动新的事物，让事务方法在事物内部执行。
REQUIRED_NEW：不管当前有没有事务在运行，都要启动新事物。如果当前有事务在运行，则会先把当前事务挂起。
具体机制见下面LFY大神的图：
外层事务方法代码：
@Component
public class MutilTA {
@Autowired
private BookService bookService;
@Transactional(timeout = 3, rollbackFor = FileNotFoundException.class)
public void init() {
bookService.checkout1("Sarsh",1);
try {
bookService.checkout2("Wuyifan", 2);
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
}
测试代码：
public class TestDemo2 {
public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("transaction.xml");
MutilTA mutilTA = (MutilTA) applicationContext.getBean("mutilTA");
mutilTA.init();
}
}
内层事务代码1：
@Service
public class BookService {
@Autowired
private BookDao bookDao;
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void checkout1(String accountName, int bookId) {
bookDao.updateStock(bookId);
bookDao.updateBalance(accountName, bookDao.getPrice(bookId));
System.out.println(accountName + "结账成功");
}
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = FileNotFoundException.class)
public void checkout2(String accountName, int bookId) throws FileNotFoundException {
bookDao.updateStock(bookId);
bookDao.updateBalance(accountName, bookDao.getPrice(bookId));
System.out.println(accountName + "结账成功");
new FileInputStream("D:/xxx.xxx.xxx");
}
}
运行结果1(测试双嵌套事务)：
测试结果表明成功将默认情况下编译时异常不会执行回滚操作，改为编译时异常也会执行回滚操作。
内层事务代码2：
@Service
public class BookService {
@Autowired
private BookDao bookDao;
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void checkout1(String accountName, int bookId) {
bookDao.updateStock(bookId);
bookDao.updateBalance(accountName, bookDao.getPrice(bookId));
System.out.println(accountName + "结账成功");
}
@Transactional(propagation = Propagation.REQUIRED, noRollbackFor = ArithmeticException.class)
public void checkout2(String accountName, int bookId) {
bookDao.updateStock(bookId);
int x = 10 / 0;
bookDao.updateBalance(accountName, bookDao.getPrice(bookId));
System.out.println(accountName + "结账成功");
}
}
运行结果2(测试双嵌套事务)：
测试结果表明成功将默认情况下运行时异常会执行回滚操作，改为运行时异常不会执行回滚操作。
四、总结
可以看出，内层事务的一般属性是继承于外层事务的属性的。
rollbackFor属性和noRollbackFor属性，一般都是要内层事务和外层事务配合着使用的。因为异常是由内部事务逐层往外抛的。
个人测试感觉有这么个结论：如果内层事务不通过rollbackFor属性和noRollbackFor属性指定回滚的类型的话，外层是不知道内层事务抛出的异常到底是什么，也无法决定是否回滚。
重点：假设有两层嵌套事务，一旦内部事务方法执行出了错误需要回滚的时候(产生异常顺序是由内层逐层往外层抛异常的)，在外部事务下面的事务方法不会再执行，而且已经执行过的REQUIRED_NEW事务方法则不会收到影响。
扫一扫
1125
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
