四、Spring5框架之事务

事务

什么是事务

（1）事务是数据库操作最基本单元，逻辑上一组操作，要么都成功，如果有一个失败所有操
作都失败
（2）典型场景：银行转账

• lucy 转账 100 元 给 mary
• lucy 少 100，mary 多 100

事务四个特性（ACID）

（1）原子性
一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做
（2）一致性
事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。
（3）隔离性
一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。
（4）持久性
持久性也称永久性，指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。

事务操作（搭建事务操作环境）

创建表

创建Dao

package com.company.jdbc;

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

public class TestDao {

    @Autowired
    JdbcTemplate jdbcTemplate;
    public void test(){
        String sql = "update test set money=money-? where name=?";
        jdbcTemplate.update(sql,100,"lucy");


        String sql1 = "update test set money=money+? where name=?";
        jdbcTemplate.update(sql1,100,"mandy");
    }
}

正常执行：

加入异常执行：

上面代码，如果正常执行没有问题的，但是如果代码执行过程中出现异常，有问题

（1）上面问题如何解决呢？

• 使用事务进行解决
  （2）事务操作过程
  1、开启事务
  2、进行业务操作
  3、没有发生异常，提交事务
  4、出现异常，回滚事务

事务操作（Spring 事务管理介绍）

1、事务添加到 JavaEE 三层结构里面 Service 层（业务逻辑层）
2、在 Spring 进行事务管理操作
（1）有两种方式：编程式事务管理和声明式事务管理
3、声明式事务管理
（1）基于注解方式
（2）基于 xml 配置文件方式
4、在 Spring 进行声明式事务管理，底层使用 AOP 原理
5、Spring 事务管理 API

事务操作（注解声明式事务管理）

在 spring 配置文件配置事务管理器

<!--创建事务管理器--> <bean id="transactionManager" 
class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
 <!--注入数据源-->
 <property name="dataSource" ref="dataSource"></property>
</bean>

在 spring 配置文件，开启事务注解

（1）在 spring 配置文件引入名称空间 tx

（2）开启事务注解

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

（3）、在 service 类上面（或者 service 类里面方法上面）添加事务注解
（1）@Transactional，这个注解添加到类上面，也可以添加方法上面
（2）如果把这个注解添加类上面，这个类里面所有的方法都添加事务
（3）如果把这个注解添加方法上面，为这个方法添加事务

执行：可以看到出现异常事务回滚

事务操作（声明式事务管理参数配置）

1、在 service 类上面添加注解@Transactional，在这个注解里面可以配置事务相关参数

2、propagation：事务传播行为
（1）多事务方法直接进行调用，这个过程中事务 是如何进行管理的

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

传播属性	描述
REQUIRED	如果有事务在运行，当前的方法就在这个事务内运行，否则，就启动一个新的事务，并在自己的事务内运行
REQUIRED_NEW	当前的方法必须启动新事物，并在他自己的事务内运行，如果有事务正在运行，应该将他挂起
SUPPORTS	如果有事务在运行，当前的方法就在这个事务内运行，否则他可以不运行在事务中
NOT_SUPPORTS	当前的方法不应该运行在事务中，如果有运行的事务，将他挂起
MANDATORY	当前的方法必须运行在事务内部，如果没有正在运行的事务，就抛出异常
NEVER	当前的方法不应该运行在事务中，如果有运行的事务，就抛出异常
NESTED	如果有事务在运行，当前的方法就应该在这个事务的嵌套事务内运行，否则，就启动一个新的事务，并在它自己的事务内运行

3、ioslation：事务隔离级别

（1）事务有特性成为隔离性，多事务操作之间不会产生影响。不考虑隔离性产生很多问题
（2）有三个读问题：脏读、不可重复读、虚（幻）读
（3）脏读：一个未提交事务读取到另一个未提交事务的数据

两个事务同时操作一条记录
B事务修改 money=5000为 money= 60000
A事务读取到B事务修改的money = 60000
此时B事务发生异常，进行回滚，A事务读取的就是错误的

总结：事务A读取到了事务B已修改但是尚未提交的数据，并在此数据上进行了修改，如果B事务发生回滚，A读取的数据就无效，不符合隔离性

（4）不可重复读：一个未提交事务读取到另一提交事务修改数据

两个事务同时操作一条记录
A事务获取数据money=5000，
B事务修改数据money=5000 为 money=900
B事务提交
此时A事务又读取到了B事务提交的数据 money=900

总结：事务A读取到了事务B已经提交的数据，不符合隔离性

（5）幻读：一个未提交事务读取到另一提交事务添加数据
事务安装相同的查询条件重新获取以前检索的数据，却发现其他事务插入了满足查询条件的数据。

总结：事务A读取到了事务B新增的数据，不符合隔离性

（6）解决：通过设置事务隔离级别，解决读问题

4、timeout：超时时间

（1）事务需要在一定时间内进行提交，如果不提交进行回滚
（2）默认值是 -1 ，设置时间以秒单位进行计算

5、readOnly：是否只读

（1）读：查询操作，写：添加修改删除操作
（2）readOnly 默认值 false，表示可以查询，可以添加修改删除操作
（3）设置 readOnly 值是 true，设置成 true 之后，只能查询

6、rollbackFor：回滚

（1）设置出现哪些异常进行事务回滚

7、noRollbackFor：不回滚

（1）设置出现哪些异常不进行事务回滚

事务操作（XML 声明式事务管理）

1、在 spring 配置文件中进行配置

  <!--创建事务管理器-->
    <bean id="transactionManager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!--注入数据源-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>
    <!--2 配置通知-->
    <tx:advice id="txadvice">
        <!--配置事务参数-->
        <tx:attributes>
            <!--指定哪种规则的方法上面添加事务-->
            <tx:method name="accountMoney" propagation="REQUIRED"/>
            <!--<tx:method name="account*"/>-->
        </tx:attributes>
    </tx:advice>
    <!--3 配置切入点和切面-->
    <aop:config>
        <!--配置切入点-->
        <aop:pointcut id="pt" expression="execution(*
        com.company.jdbc.TestDao.*(..))"/>
        <!--配置切面-->
        <aop:advisor advice-ref="txadvice" pointcut-ref="pt"/>
    </aop:config>

第一步 配置事务管理器
第二步 配置通知
第三步 配置切入点和切面

事务操作（完全注解声明式事务管理）

package com.company;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;

@Configuration //配置类
@ComponentScan(basePackages = "com.company") //组件扫描
@EnableTransactionManagement //开启事务
public class Txconfig {
    //创建数据库连接池
    @Bean
    public DruidDataSource getDruidDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql:///user_db");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        return dataSource;
    }
    //创建 JdbcTemplate 对象
    @Bean
    public JdbcTemplate getJdbcTemplate(DataSource dataSource) {
        //到 ioc 容器中根据类型找到 dataSource
        JdbcTemplate jdbcTemplate = new JdbcTemplate();
        //注入 dataSource
        jdbcTemplate.setDataSource(dataSource);
        return jdbcTemplate;
    }
    //创建事务管理器
    @Bean
    public DataSourceTransactionManager
    getDataSourceTransactionManager(DataSource dataSource) {
        DataSourceTransactionManager transactionManager = new
                DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    } }