9.事务
1.声明式事物
2.编程式事物
事务就是一组由于逻辑上紧密关联而合并成一个整体(工作单元)的多个数据库操作，
这些操作
1.要么都执行，
2.要么都不执行
1.事务的四个关键属性
1.原子性：
原子本意是不可再分，事物的原子性表现在一个事务中涉及到多个操作在逻辑上缺一不可。事务的原子性要求事务中的所有操作要么都执行，要么都不执行
2.一致性：
一致指的是数据的一致，具体是指;所有数据都处于满足业务规则的一致性状态，一致性原则要求：一个事务中不管涉及到多少个操作，都必须保证事务执行之前数据是正确的，事务执行之后 数据仍然是正确的。如果一个事务在执行过程中，其中某一格或某几个操作失败了，则必须将其他操作撤销，将数据恢复到事务执行之前的状态，这就是回滚
3.隔离性：
在应用程序实际运行过程中，事务往往是并发执行的，所以很有可能有许多事务同时处理相同的数据，因此每个事务都必须应与其他事务隔离开来，防止数据损坏。隔离性原则要求事务在并发执行过程中不会相互干扰
4.持久性：
持久性原则要求事务执行完成后，对数据的修改永久的保存下来，不会因各种系统错误或其他意外情况而受到影响。通常情况下，事务对数据的修改应该被写入到持久化存储器中
2.以数据库保存数据为例
2.1 AOP:环绕通知去做
1.获取连接
2.设置非自动提交
3.目标代码执行
4.正常提交
5.异常回滚
6.最终关闭 和之前的aop代理是一样的
自己写这个切面是非常麻烦的;
spring帮做了：事务管理器
2.2 spring不同的事务管理器
这个事务管理器可以在目标前后进行事务控制
如何快速的为某个方法快速加上事务：
需求说明：
顾客买书，书的库存量减一，查询书价，顾客的会员卡余额减去书价
1.dao层方法
@Repository
public class BookDao {
/**
* 模拟减库存放方法
* @param name：书名
*/
public void uodateStock(String name){
System.out.println(name+"：库存量减一");
};
/**
* 模拟查询书价
* @param name：书名
* @return：书价
*/
public int getPrice(String name){
System.out.println(name+"：查询书价");
return 100;
}
/**
* 模拟减去会员卡余额
* @param username:用户名称
* @param price：书价
*/
public void updateBalance(String username,int price){
System.out.println(username+"会员卡减去"+price+"元！");
}
}
2.sprring的配置文件：
<?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"------------->注意：idea自动导入的tx名称空间改为此。不改会导致<tx:annotation-driven>标签中的transaction-manager找到找不到
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/task http://www.springframework.org/schema/task/spring-task.xsd">
<!--添加包扫描-->
<context:component-scan base-package="com.wmd"></context:component-scan>
<!--引入外部的数据库配置文件-->
<context:property-placeholder location="classpath:"></context:property-placeholder>
<bean id="pooledDataSource" 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>
</bean>
<!--配置jdbcTemplate-->
<bean class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="pooledDataSource"></property>
</bean>
<!--事务控制-->
<!--1：配置事务管理器让其进行事务控制:一定导入面向切面编程的几个包-->
<bean id="tm" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--控制住数据源:因为事务的控制(事务的提交/回滚)都是靠数据库连接进行，所以只要控制住连接即可-->
<property name="dataSource" ref="pooledDataSource"></property>
</bean>
<!--2：开启基于注解的事务控制模式，依赖tx的名称空间-->
<tx:annotation-driven transaction-manager="tm"></tx:annotation-driven>
<!--给事务加注解即可-->
</beans>
3.service层方法
@Service
public class BookService {
@Autowired
private BookDao bookDao;
/**
* 模拟结账功能：
* @param username：用户名称
* @param name：书名
* @Transactional注解的意思是：告诉spring这个方法是一个事务：要么都执行，要么都不执行、
*/
@Transactional-------------->加此标签
public void checkout(String username,String name){
//1.图书库存量减1
bookDao.uodateStock(name);
//2.获取图书价格
int price=bookDao.getPrice(name);
//3.会员卡余额减去书价
bookDao.updateBalance(username,price);
}
}
结果：如果serice层的checkout方法中，一个步骤出错，数据库都会回滚到之前的状态!注意：事务是基于aop的，所以除了导入spring的包，必须要导入aop的相关包
<dependencies>
<!--数据库-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>4.0.0.RELEASE</version>
</dependency>
<dependency>
<groupId>c3p0</groupId>
<artifactId>c3p0</artifactId>
<version>0.9.1.1</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.24</version>
</dependency>
<!--spring基础包-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.0.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.0.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>4.0.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-expression</artifactId>
<version>4.0.0.RELEASE</version>
</dependency>
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.1.1</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-tx</artifactId>
<version>4.0.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>4.0.0.RELEASE</version>
</dependency>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>
<dependency>
<groupId>aopalliance</groupId>
<artifactId>aopalliance</artifactId>
<version>1.0</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.6.8</version>
</dependency>
</dependencies>事务细节
/*
* 事务细节：
* @Transactional(isolation = )---->Isolation：事务的隔离级别
* @Transactional(propagation = )---->Propagation：事务的传播行为
*
* @Transactional(noRollbackFor = )---->Class[]:哪些异常可以不会滚
* @Transactional(noRollbackForClassName = )---->String[]:(String全类名)
*
* @Transactional(rollbackFor = )------>Class[]哪些异常事务需要回滚
* @Transactional(rollbackForClassName = )---->String[]:string全类名不需要回滚
*
* @Transactional(readOnly = )---->boolean:设置事务为只读事务
* @Transactional(timeout = )---->int:超时，超出指定执行时长后自动终止并回滚
*/
1.超时演示(timeout )
@Transactional(timeout = 3)
public void checkout(String username,String name) throws InterruptedException {
//1.图书库存量减1
bookDao.uodateStock(name);
//2.获取图书价格
int price=bookDao.getPrice(name);
Thread.sleep(3000);
//3.会员卡余额减去书价
bookDao.updateBalance(username,price);
}
执行会报：TransactionTimeedOutException
2.只读(readly=true)->默认是false
可以进行查询优化，加快查询速度，但前提必须是数据库操作都是查询操作，因为不需要管事务的那一堆操作，且如果只是查询的话，数据库底层可以不给其加锁，等提高速度
但如果在有增删改的操作，这时会报错
3.noRollbackFor----->哪些异常不用回滚
异常分类：
1.运行时异常(非检查异常):可以不用处理，默认是回滚
例如：int a=100/0;-->运行时会抛出异常：java.lang.ArithmeticException: / by zero
2.编译时异常(检查异常):要么try-catch，要么在方法上生命throws，默认不会滚
线程的休眠：Thread.sleep(1000),必须要try-catch或抛出异常
noRollbackFor：哪些异常事务可以不回滚；(可以让原来默认回归的异常给他不回滚)
示例：
@Transactional( rollbackFor = {ArithmeticException.class,NullPointerException.class})
public void checkout(String username,String name) {
//1.图书库存量减1
bookDao.uodateStock(name);
//2.获取图书价格
int price=bookDao.getPrice(name);
int num=100/0;---------------->此为运行时异常，默认会进行回滚，此时不会回滚
//3.会员卡余额减去书价
bookDao.updateBalance(username,price);
}
事务的隔离级别
数据库事务并发问题：
假设有两个事务;Transaction01和Transaction02并发运行
1.脏读：读取到没有提交的数据-->一定不允许发生
[1]Transaction01将某条记录的age值从20修改为30
[2]Transaction02读取Transaction01更新后的值：30
[3]Transaction01回滚，age值恢复到了20
[4]Transaction02读取到的30就是一个无效值
2.不可重复读:
[1]Transaction01读取age值为20
[2]Transaction02将age值修改为30
[3]Transaction01再次读取值为30，和第一次读取不一致
3.幻读
[1]Transaction01读取student表的一部分数据
[2]Transaction02向student表中插入新的行
[3]Transaction01读取student表时，多出了一些行
数据库事务隔离级别：
数据库系统必须具有隔离并发运行各个事务的能力，使他们不会相互影响，避免各种并发问题。一个事务与其他事务隔离的程度称为隔离级别。sql标准中规定了多种事务隔离级别，不同隔离级别对应不同的干扰程度，隔离级别越高，数据一致性就越好
1.读未提交：READ UNCOMMITTED(不太会使用，因为可以读取出脏读信息：读取到未提交的数据)
允许Transaction01读取Transaction02未提交的修改
2.读已提交：READ COMMITTEN
要求Transaction01只能读取Transaction02已提交的修改
3.可重复读：REPEATABLE READ
确保Transaction01可以多次从一个字段中读取到相同的值，即Transaction01执行期间禁止其他事务对这个字段进行更新
4.串行化;SERIALIZABLE(也不会使用)
确保Transaction01可以多次从一个表中读取到相同的行，在Transaction01执行期间，禁止其他事务对这个表进行增加、更新、删除操作。可以避免任何并发问题，但性能十分低下
|
脏读(读取出未提交的数据)
|
不可重复读(同一事务下某一字段读取结果不同)
|
|
|
READ UNCOMMITTED
|
有
|
有
|
|
READ COMMITTEN
|
无
|
有
|
|
REPEATABLE READ
|
无
|
无
|
|
SERIALIZABLE
|
无
|
无
|
用法：
@Transactional( isolation = Isolation.READ_UNCOMMITTED)
public void checkout(String username,String name) {
//1.图书库存量减1
bookDao.uodateStock(name);
//2.获取图书价格
int price=bookDao.getPrice(name);
int num=100/0;
//3.会员卡余额减去书价
bookDao.updateBalance(username,price);
}
事务的传播行为
传播行为(事务的传播+事务的行为)
具体表现在：如果多个事务进行嵌套运行，子事务是否和父事务公用一个事务
例如：
Aservice{
//a父类事务方法
tx_a(){
a的一些业务方法
//a事务下的b事务方法
tx_b(){
b的业务方法
}
//a事务下的c事务方法
tx_c(){
c的业务方法
}
}
}
考虑：若c事务出现问题，b事务是否需要回滚，a事务是否需要回滚
结论：这些是可控的，通过传播行为()进行控制事务传播行为简介
当事务方法被另外一个事务方法调用时，必须指定事务应该如何传播.例如：方法可以继续在现事务中运行，也可能开启一个新事务，并在自己的事务中运行，事务的传播行为可以由传播属性指定。spring定义了7中类传播行为
|
传播属性
|
描述
|
|
REQUIRED
|
如果有事务在运行，当前的方法就在这个事务内运行，否则就启动一个新的事务，并在自己的事务中运行(一条绳上的蚂蚱，串联，一处挂，全部回滚)
|
|
REQUIRED_NEW
|
当前的方法必须启动新事物，并在他自己的事务中运行，如果有事务正在运行，应该将他挂起(开启新的事务，即并联或开新车，大事务挂了，不会影响小事务，同理，小事务挂了不会影响大事务，互不影响)
|
|
SUPPORTS
|
如果有事务在运行，当前的方法就在这个事务内运行，否则他可以不运行在事务中
|
|
NOT_SUPPORT
|
当前的方法不应该运行在事务中，如果有运行的事务，将他挂起啊
|
|
MANDATORY
|
当前的方法必须运行在事务内部，如果没有运行的事务，就抛出异常
|
|
NEVER
|
当前的方法不应该运行在事务中，如果有运行的事务，就抛出异常
|
|
NESTED
|
如果有事务在运行，当前的方法就应该在这个事务的嵌套事务内运行，否则就启动一个新的事务，并在他自己的事务内运行
|
代码示例
需求：模拟的是买书的结账和更改图书价格操作
dao层代码：
/**
* 模拟dao层的数据库操作
*/
@Repository
public class BookDao {
/**
* 模拟图书的减库存操作
*
* @param bookName
*/
public void updateStock(String bookName) {
System.out.println("模拟图书的减库存操作！");
}
/**
* 模拟查询图书价格操作
*
* @param bookName：书名
* @return：返回图书价格
*/
public int getPrice(String bookName) {
System.out.println("模拟查询图书价格操作！");
return 100;
}
/**
* @param userName：用户名称
* @param price：图书价格
*/
public void updateBalance(String userName, int price) {
System.out.println("模拟用户会员卡账户减余额操作！");
}
/**
* @param bookName：书名
* @param price：书价
*/
public void updatePrice(String bookName, int price) {
System.out.println("模拟更新书价操作");
}
}
service操作：
@Service
public class BookService {
@Autowired
BookDao bookDao;
/**
* 模拟结账
*
* @param userName：用户名称
* @param bookName：书名
*/
@Transactional------------------------------------------------->加了事务
public void chekOut(String userName, String bookName) {
//1.减库存
bookDao.updateStock(bookName);
//2.查询书的价格
int price = bookDao.getPrice(bookName);
//3.减余额
bookDao.updateBalance(userName, price);
}
/**
* 模拟更新书价操作
*
* @param bookName:书名
* @param price：价格
*/
@Transactional------------------------------------------------->加了事务
public void updatePice(String bookName, int price) {
bookDao.updatePrice(bookName, price);
}
}
总的service操作：
@Service
public class MulService {
@Autowired
private BookService bookService;
@Transactional------------------------------------>也加了事务
public void mulTx() {
bookService.chekOut("吴孟达", "java开发");----->这两个方法均有事务
bookService.updatePice("java开发", 200);------->这两个方法均有事务
}
}
形成事务嵌套事务：在此基础上进行测试1.@Transactional(propagation = Propagation.REQUIRED)
2.@Transactional(propagation = Propagation.REQUIRES_NEW)
事务传播的小细节：继承性
REQUIRED:是将之前事务的connection传递给这个方法使用
REQUIRED_NEW:是使用新的connection事务控制细节2：带事务标签的组件是代理对象：
2.为什么大事务小事务写在一个类中时，没有保存成功呢？
原因如下：
@Service
public class BookService {
@Autowired
BookDao bookDao;
/**
* 模拟结账
*/
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void chekOut(String userName, String bookName) {
...
}
/**
* 模拟更新书价操作
*/
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void updatePice(String bookName, int price) {
...
}
@Transactional(timeout = 3000)
public void mulTx() {
//传播行为来设置这个事务方法啊是不是和之前的大事务共享一个事务(使用同一个链接)
chekOut("吴孟达", "java开发");
updatePice("java开发", 200);
int a = 100 / 0;
}
}
当写到同一个类中时：
调用是通过当前类对象进行调用的即：
@Transactional(timeout = 3000)
public void mulTx() {
//传播行为来设置这个事务方法啊是不是和之前的大事务共享一个事务(使用同一个链接)
this.chekOut("吴孟达", "java开发");
this.updatePice("java开发", 200);
int a = 100 / 0;
}
这个方法的实质是把chekOut和updatePice的代码直接复制到该处执行
即：
@Transactional(timeout = 3000)
public void mulTx(){
//chekOut代码
bookDao.updateStock(bookName);
int price = bookDao.getPrice(bookName);
bookDao.updateBalance(userName, price);
//updatePice代码
bookDao.updatePrice(bookName, price);
int a = 100 / 0;
}
由此可见，这几个本身是一个事务，无论小事务如何设置，都不起作用！
结论：
大事务和小事务必须要处于不同的类中，要不会导致小事务的设置失效
