• MySQL事务（JDBC事务管理）

    目录

    1、什么是事务？

    2、MySQL中的事务

    3、JDBC事务管理

    3.1、API方法

    3.2、环境搭建

    3.3、不使用回滚出现的问题

    3.4、使用事务回滚

    4、事务回滚点

    5、事务的特性ACID

    5.1、事务的隔离级别

    5.1.1、脏读

    5.1.2、不可重复读

    5.1.3、幻读（虚读）

    5.2、数据库的隔离级别

    5.3、隔离级别的性能问题

     

    1、什么是事务？

    指逻辑上一组操作，要么同时成功，要么同时失败。

    2、MySQL中的事务

    mysql中，默认事务是自动事务的。一条sql一个事务

    1. start transaction  -- 开启一个事务。以后的sql都在一个事务中。更改的内容不会自动提交。
    2. rollback        -- 事务的回滚—同时失败的情况。--事务结束，并且全部失败，数据回复到开始之前的状态
    3. commit -- 事务的提交----同时成功---事务结束。全部成功。
    1. -- mysql默认类似这样
    2. start transaction ;
    3. update account set money = money -100 where name = ‘a’;
    4. commit;
    5. start transaction;
    6. update account set money = money +100 where name = ‘b’;
    7. commit;

    我们也可以手动去控制事务

    1. -- 自身手动控制事务。
    2. start transaction ;
    3. update account set money = money -100 where name = ‘a’;
    4.  
    5. update account set money = money +100 where name = ‘b’;
    6. commit;

    3、JDBC事务管理

    3.1、API方法

    方法说明
    setAutoCommit(Boolean boolean)相当于start transaction 设置为false开启事务为手动
    rollback()事务回滚
    commit()事务提交

    3.2、环境搭建

    如下图，创建一个web工程，在WEB-INF下创建lib包，里面放入mysql连接包。

    这里提供了mysql5版本和mysql8版本的jar包，对应的就是mysql的版本，如果是mysql5系列版本的就用5.16的jar包，如果是mysql8系列的版本就用8.0.16版本jar包。

    链接：https://pan.baidu.com/s/1loxaN41BXlfdePT_8DDBDw 
    提取码：388i

    放入后一定要导入，右键jar包点击ADD Library。

    在src包下创建jdbc.properties文件

    1. jdbc.className=com.mysql.jdbc.Driver
    2. jdbc.url=jdbc:mysql://localhost:3306/test6
    3. jdbc.username=root
    4. jdbc.password=xxx

    在src包下创建util包存放JDBC工具类

    1. public class JDBCUtil {
    2.     public JDBCUtil() {
    3.     }
    4.  
    5.     private static String className;
    6.     private static String url;
    7.     private static String username;
    8.     private static String password;
    9.     private static Connection conn = null;
    10.  
    11.     static {
    12.         Properties pro = null;
    13.         InputStream is = null;
    14.         try {
    15.             is = JDBCUtil.class.getClassLoader().getResourceAsStream("jdbc.properties");
    16.             pro = new Properties();
    17.             pro.load(is);
    18.         } catch (IOException e) {
    19.             e.printStackTrace();
    20.         } finally {
    21.             try {
    22.                 is.close();
    23.             } catch (IOException e) {
    24.                 e.printStackTrace();
    25.             }
    26.         }
    27.         className = pro.getProperty("jdbc.className");
    28.         url = pro.getProperty("jdbc.url");
    29.         username = pro.getProperty("jdbc.username");
    30.         password = pro.getProperty("jdbc.password");
    31.         //加载驱动
    32.         try {
    33.             Class.forName(className);
    34.         } catch (ClassNotFoundException e) {
    35.             e.printStackTrace();
    36.         }
    37.         //获取连接
    38.         try {
    39.             conn = DriverManager.getConnection(url, username, password);
    40.         } catch (SQLException e) {
    41.             e.printStackTrace();
    42.         }
    43.     }
    44.  
    45.     public static Connection getConnection() {
    46.         return conn;
    47.     }
    48.  
    49.     public static void close(ResultSet rs, Statement stmt, Connection conn) {
    50.         try {
    51.             if (rs != null) {
    52.                 rs.close();
    53.                 rs = null;
    54.             }
    55.         } catch (SQLException e) {
    56.             e.printStackTrace();
    57.         }
    58.         try {
    59.             if (stmt != null) {
    60.                 stmt.close();
    61.                 stmt = null;
    62.             }
    63.         } catch (SQLException e) {
    64.             e.printStackTrace();
    65.         }
    66.         try {
    67.             if (conn != null) {
    68.                 conn.close();
    69.                 conn = null;
    70.             }
    71.  
    72.         } catch (SQLException e) {
    73.             e.printStackTrace();
    74.         }
    75.     }
    76.  
    77.     public static void close(Statement stmt, Connection conn) {
    78.         try {
    79.             if (stmt != null) {
    80.                 stmt.close();
    81.                 stmt = null;
    82.             }
    83.         } catch (SQLException e) {
    84.             e.printStackTrace();
    85.         }
    86.         try {
    87.             if (conn != null) {
    88.                 conn.close();
    89.                 conn = null;
    90.             }
    91.         } catch (SQLException e) {
    92.             e.printStackTrace();
    93.         }
    94.     }
    95. }

    创建mysql数据库和表

    1. CREATE TABLE `account` (
    2.   `name` varchar(20) NOT NULL,
    3.   `money` int(255) DEFAULT NULL,
    4.   PRIMARY KEY (`name`)
    5. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

    添加数据，模拟a向b进行转账，起始两人都是1000 

     

     

    3.3、不使用回滚出现的问题

    为了演示不使用事务带来的问题，创建一个测试包，在其测试类中进行编写。

    注意事项：该测试方法中finally一定要写commit()方法，因为事务一旦开启，如果不提交，则mysql默认会进行回滚，try里一旦报错，finally里面的代码也会被执行，为了使异常时不让其回滚，方便我们看到效果，我们需要手动加入提交。

    1. public class TransactionTest {
    2.     @Test
    3.     public void test1() {
    4.         Connection conn = JDBCUtil.getConnection();
    5.         Statement stmt = null;
    6.         try {
    7.             stmt = conn.createStatement();
    8.             conn.setAutoCommit(false);
    9.             //模拟a向b转账100元
    10.             stmt.executeUpdate("update  account set money= money-100 where name='a'");
    11.             //手动创建异常  模拟转账期间出现网络异常问题
    12.             int a = 1 / 0;
    13.             //b收到a转账的100元
    14.             stmt.executeUpdate("update account set money=money+100 where name='b'");
    15.  
    16.         } catch (Exception e) {
    17.             e.printStackTrace();
    18.         } finally {
    19.             try {
    20.                 //finally块中加入commit提交，不论try是否报错，一定会进行提交，否则看不到效果
    21.                 conn.commit();
    22.             } catch (SQLException e) {
    23.                 e.printStackTrace();
    24.             }
    25.             JDBCUtil.close(stmt, conn);
    26.         }
    27.     }
    28. }

    运行结果

    可以看到结果报了运算异常的错误，这也是在情理之中的

    那我们去数据库看看数据会发生什么

    可以发现，这时就出现bug了，a少了100元这是对的，但是b缺没有收到a转出去的100元，这a会损失100元，这种严重的问题是绝不能出现在实际开发过程中的，有这种好事电商不亏死O(∩_∩)O。

    那如何解决这种严重的BUG呢，就要使用事务中的回滚进行解决。

    3.4、使用事务回滚

    在catch里面加入了一个rollback回滚，这样try里面一旦报错，进入到catch块中就会进行回滚操作，把finally中的commit删除，因为finally中写commit只是为了让我们看到效果。

    1. public class TransactionTest {
    2.     @Test
    3.     public void test1() {
    4.         Connection conn = JDBCUtil.getConnection();
    5.         Statement stmt = null;
    6.         try {
    7.             stmt = conn.createStatement();
    8.             conn.setAutoCommit(false);
    9.             stmt.executeUpdate("update  account set money= money-100 where name='a'");
    10.             //手动创建异常
    11.             int a = 1 / 0;
    12.             stmt.executeUpdate("update account set money=money+100 where name='b'");
    13.             conn.commit();
    14.  
    15.         } catch (Exception e) {
    16.             try {
    17.                 //调用回滚方法
    18.                 conn.rollback();
    19.                 conn.commit();
    20.             } catch (SQLException e1) {
    21.                 e1.printStackTrace();
    22.             }
    23.             e.printStackTrace();
    24.         }finally{
    25.              //释放资源
    26.              JDBCUtil.close(stmt, conn);
    27.         }
    28.     }
    29. }

    再次测试

    可以发现，这次都没有改变，因为遵循了事务的原则，要不同时失败要不同时成功，一旦有一方失败，则整体失败。

    4、事务回滚点

    方法说明
    setSavepoint()设置回滚点

    如果一遇到错误就回滚，那么也不一定是好事，比如现在有1w条数据，前面9998条数据都修改成功了，当9999条数据修改操作时出现了异常，那么前面9998也会被回滚掉，等于说修改操作白做了，所以，为了解决这一现象，需要使用回滚点，每10条数据设置一个回滚点，当第9999出现问题后，只会回滚9990-9999这10条数据，前面的9990条数据是不会被回滚的。

    首先，先创建一个表为t_user

    1. CREATE TABLE `t_user` (
    2.   `id` int(11) NOT NULL AUTO_INCREMENT,
    3.   `name` varchar(255) DEFAULT NULL,
    4.   PRIMARY KEY (`id`)
    5. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

    下面我演示一下1000条数据

    1.  @Test
    2.     public void test2() {
    3.         Connection conn = JDBCUtil.getConnection();
    4.         PreparedStatement pstmt = null;
    5.         Savepoint save = null;
    6.         try {
    7.  
    8.             pstmt = conn.prepareStatement("insert into user(name) values(?)");
    9.             //开启事务
    10.             conn.setAutoCommit(false);
    11.             for (int i = 1; i < 1000; i++) {
    12.                 //在999条数据时出现异常
    13.                 if (i == 999) {
    14.                     int a = 10 / 0;
    15.                 }
    16.                 pstmt.setString(1, "itssl");
    17.                 pstmt.executeUpdate();
    18.  
    19.                 //每10条数据创建一个回滚点
    20.                 if (i % 10 == 0) {
    21.                     save = conn.setSavepoint();
    22.                 }
    23.             }
    24.             conn.commit();
    25.         } catch (Exception e) {
    26.             try {
    27.                 //回滚并提交
    28.                 conn.rollback(save);
    29.                 conn.commit();
    30.             } catch (SQLException e1) {
    31.                 e1.printStackTrace();
    32.             }
    33.             e.printStackTrace();
    34.         }finally {
    35.             JDBCUtil.close(pstmt,conn);
    36.         }
    37.     }

    可以看到，前面的990条数据都是添加成功的，而后面10条会被回滚掉。

    5、事务的特性ACID

    原子性（Atomicity）
    原子性是指事务是一个不可分割的工作单位（最小的一个整体），事务中的操作要么都发生，要么都不发生。 
    一组操作时一个整体。不能分割。

    一致性（Consistency）
    事务前后数据的完整性必须保持一致。
    一致性和原子性相关。只有都成功或者，都失败（原子性） ，就可以保证事务的一致性。
    事务的前后的内容一直。 
    转账： a 1000 b 1000 a给b转100；
    转账之前 a和b的总额 2000
    转账之后 也要2000；

    隔离性（Isolation）
    事务的隔离性是指多个用户并发访问数据库时，一个用户的事务不能被其它用户的事务所干扰，多个并发事务之间数据要相互隔离。

    多个事务是独立存在的。多个事务不能够相互干扰。
    a –b---事务A
    c-d---事务B
    如果A失败了。不能够影响B

    持久性（Durability）
    持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响。 

    5.1、事务的隔离级别

    5.1.1、脏读

    一个事务读取了另外一个事务没有的提交的数据。非常严重。尽可能去避免掉脏读

    比如：事务一开启事务后进行a减100元，b加100元，但是此时没有提交，而与此同时另一个事务开启事务进行读操作，select该表里的内容，发现a：900，b：1100，后来事务一提交事务（这里指回滚），后来事务二又查询了一次，发现数据又变回1000:1000，这会让事务二的用户感到迷惑

    5.1.2、不可重复读

    一个事务读取另外一个提交过的数据。造成另外一个事务，多次读取的【内容】不一致，数据的内容的改变。 update

    5.1.3、幻读（虚读）

    一个事务读取另外一个事务已经提交的数据。但是这里面强调的数据数目的改变。insert，delete。比如该表原始数据为9个，事务一新增数据后提交，事务二查询该表，数量为10，而事务一又把数据给删除了，事务二又查询该表，发现数量又变为了9。

    5.2、数据库的隔离级别

    读未提交

    Read uncommitted (读未提交) 最低级别，以上情况均无法保证。 两个人的操作都是一样

    事务一 

    1. set session transaction isolation level Read uncommitted;
    2. select @@tx_isolation;
    3. start transaction;
    4. update account set money = money-100 where name ='jack';
    5. update account set money = money+100 where name ='rose';
    6. rollback;

    事务二

    1. set session transaction isolation level Read uncommitted;
    2. select @@tx_isolation;
    3. start transaction;
    4. select * from account;

     

    读已提交

    Read committed；(读已提交) 可避免脏读情况发生（避免不了虚读以及不可重复读）

    1. set session transaction isolation level Read committed;
    2. select @@tx_isolation;
    3. start transaction;
    4. update account set money = money-100 where name ='jack';
    5. update account set money = money+100 where name ='rose';
    6. commit;
    1. set session transaction isolation level Read committed;
    2. select @@tx_isolation;
    3. start transaction;
    4. select * from account;

    可重复读

    Repeatable read ：可以避免脏读，不可重复度。

    1. set session transaction isolation level Repeatable read;
    2. select @@tx_isolation;
    3. start transaction;
    4. update account set money = money-100 where name ='jack';
    5. update account set money = money+100 where name ='rose';
    6. commit;
    1. set session transaction isolation level Repeatable read;
    2. select @@tx_isolation;
    3. start transaction;
    4. select * from account;

     

    可串行化

    串行化的可以避免所有的问题。 数据库让其他的事务进行等待，等待一个事务结束之后，这个事务再去操作。

    1. set session transaction isolation level Serializable;
    2. select @@tx_isolation;
    3. start transaction;
    4. update account set money = money-100 where name ='jack';
    5. update account set money = money+100 where name ='rose';
    6. commit;
    1. set session transaction isolation level Serializable;
    2. select @@tx_isolation;
    3. start transaction;
    4. select * from account;

    5.3、隔离级别的性能问题

    性能比较
    Serializable  性能最差：事务一个一个执行的。排队。

    Serializable  < Repeatable read < Read committed < Read uncommitted

    安全性比较
    Serializable 安全性最好：所有问题避免掉。

    Serializable > Repeatable read > Read committed > Read uncommitted

    Read uncommitted 避免不了最重问题，脏读。
    Serializable：性能太差。

    mysql （默认）-- Repeatable read；（可重复读）
    oracle（默认） -- Read committed；（读已提交）

  • 相关阅读:
    spring boot使用swagger生成api接口文档
    MybatisPlus多表连接查询一对多分页查询数据
    测试平台系列(94) 前置条件该怎么支持Python呢
    Java从入门到精通-数组（二）
    resubmit 渐进式防重复提交框架简介
    【毕业设计】基于单片机的智能饮水机系统 - stm32 物联网 嵌入式
    RSA算法
    auto关键字的妙用
    DSP 应用领域及内部结构
    使用kibana创建索引的时候报错处理
  • 原文地址：https://blog.csdn.net/select_myname/article/details/126763157