JavaWeb学习笔记（十六）—— 事务

一、事务概述

1.1 什么是事务

　　银行转账！张三转10000块到李四的账户，这其实需要两条SQL语句：

　　给张三的账户减去10000元；

　　给李四的账户加上10000元。

　　如果在第一条SQL语句执行成功后，在执行第二条SQL语句之前，程序被中断了（可能是抛出了某个异常，也可能是其他什么原因），那么李四的账户没有加上10000元，而张三却减去了10000元。这肯定是不行的！

　　你现在可能已经知道什么是事务了吧！事务中的多个操作，要么完全成功，要么完全失败！不可能存在成功一半的情况！也就是说给张三的账户减去10000元如果成功了，那么给李四的账户加上10000元的操作也必须是成功的；否则给张三减去10000元，以及给李四加上10000元都是失败的！

　　总结：事务指逻辑上的一组操作，组成这组操作的各个单元，要不全部成功，要不全部不成功。

1.2 事务的四大特性（ACID）

　　事务的四大特性是：

• 原子性（Atomicity）：事务中所有操作是不可再分割的原子单位。事务中所有操作要么全部执行成功，要么全部执行失败。
• 一致性（Consistency）：事务执行后，数据库状态与其它业务规则保持一致。如转账业务，无论事务执行成功与否，参与转账的两个账号余额之和应该是不变的。
• 隔离性（Isolation）：隔离性是指在并发操作中，不同事务之间应该隔离开来，使每个并发中的事务不会相互干扰。
• 持久性（Durability）：一旦事务提交成功，事务中所有的数据操作都必须被持久化到数据库中，即使提交事务后，数据库马上崩溃，在数据库重启时，也必须能保证通过某种机制恢复数据。

1.3 MySQL中的事务

　　在默认情况下，MySQL每执行一条SQL语句，都是一个单独的事务。如果需要在一个事务中包含多条SQL语句，那么需要开启事务和结束事务。

• 开启事务：start transaction；
• 结束事务：commit或rollback。

　　在执行SQL语句之前，先执行strat transaction，这就开启了一个事务（事务的起点），然后可以去执行多条SQL语句，最后要结束事务，commit表示提交，即事务中的多条SQL语句所做出的影响会持久化到数据库中（从开启事务到事务提交,中间的所有的sql都认为有效,真正的更新数据库）。或者rollback，表示回滚，即回滚到事务的起点，之前做的所有操作都被撤消了（从开启事务到事务回滚,中间的所有的sql操作都认为无效,数据库没有被更新）！

　　下面演示zs给li转账10000元的示例：

START TRANSACTION;
UPDATE account SET balance=balance-10000 WHERE id=1;
UPDATE account SET balance=balance+10000 WHERE id=2;
-- 回滚结束，事务执行失败
ROLLBACK ; 

START TRANSACTION;
UPDATE account SET balance=balance-10000 WHERE id=1;
UPDATE account SET balance=balance+10000 WHERE id=2;
-- 提交结束，事务执行成功
COMMIT ;

START TRANSACTION;
UPDATE account SET balance=balance-10000 WHERE id=1;
UPDATE account SET balance=balance+10000 WHERE id=2;
-- 退出，MySQL会自动回滚事务。
quit ;

二、JDBC事务

　　在jdbc中处理事务，都是通过Connection完成的！当Jdbc程序向数据库获得一个Connection对象时，默认情况下这个Connection对象会自动向数据库提交在它上面发送的SQL语句。若想关闭这种默认提交方式，让多条SQL在一个事务中执行，可使用下列的JDBC控制事务语句：

• Connection.setAutoCommit(false)：设置是否为自动提交事务，如果true（默认值就是true）表示自动提交，也就是每条执行的SQL语句都是一个单独的事务，如果设置false，那么就相当于开启了事务了(start transaction)；
• Connection.rollback();//回滚事务(rollback)
• Connection.commit();//提交事务(commit)

　　jdbc处理事务的代码格式：

try {
  con.setAutoCommit(false);//开启事务…
  ….
  …
  con.commit();//try的最后提交事务
} catch() {
  con.rollback();//回滚事务
}

　　注意：控制事务的connnection必须是同一个，即执行sql的connection与开启事务的connnection必须是同一个才能对事务进行控制

三、事务的隔离级别

3.1 事务的并发读问题

• 脏读：一个事务读取到另一个事务未提交数据（脏读是不能允许的）

  事务1：张三给李四转账100元
  事务2：李四查看自己的账户
  
  t1：事务1：开始事务
  t2：事务1：张三给李四转账100元
  t3：事务2：开始事务
  t4：事务2：李四查看自己的账户，看到账户多出100元（脏读）
  t5：事务2：提交事务
  t6：事务1：回滚事务，回到转账之前的状态

• 不可重复读：一个事务读到了另一个事务已经提交的update的数据，导致在同一个事务中的多次查询结果不一致。

  事务1：酒店查看两次1048号房间状态
  事务2：预订1048号房间
  
  t1：事务1：开始事务
  t2：事务1：查看1048号房间状态为空闲
  t3：事务2：开始事务
  t4：事务2：预定1048号房间
  t5：事务2：提交事务
  t6：事务1：再次查看1048号房间状态为使用
  t7：事务1：提交事务
  对同一记录的两次查询结果不一致！

• 幻读（虚读)：一个事务读到了另一个事务已经提交的insert的数据，导致在同一个事务中的多次查询结果不一致。

  事务1：对酒店房间预订记录两次统计
  事务2：添加一条预订房间记录
  
  t1：事务1：开始事务
  t2：事务1：统计预订记录100条
  t3：事务2：开始事务
  t4：事务2：添加一条预订房间记录
  t5：事务2：提交事务
  t6：事务1：再次统计预订记录为101记录
  t7：事务1：提交
  对同一表的两次查询不一致！

【不可重复读和幻读的区别】

• 不可重复读是读取到了另一事务的更新；
• 幻读是读取到了另一事务的插入（MySQL中无法测试到幻读）；

3.2 四大隔离级别

　　4个等级的事务隔离级别，在相同数据环境下，使用相同的输入，执行相同的工作，根据不同的隔离级别，可以导致不同的结果。不同事务隔离级别能够解决的数据并发问题的能力是不同的。

【SERIALIZABLE（串行化）】

• 不会出现任何并发问题，因为它是对同一数据的访问是串行的，非并发访问的；
• 性能最差(相当于锁表)

【REPEATABLE READ（可重复读）（MySQL）】

• 防止脏读和不可重复读，不能处理幻读问题；
• 性能比SERIALIZABLE好

【READ COMMITTED（读已提交数据）（Oracle）】

• 防止脏读，没有处理不可重复读，也没有处理幻读；
• 性能比REPEATABLE READ好

【READ UNCOMMITTED（读未提交数据）】

• 可能出现任何事务并发问题
• 性能最好

3.3 MySQL隔离级别

　　mysql数据库默认的事务隔离级别是：Repeatable read(可重复读)

【mysql数据库查询当前事务隔离级别】

select @@tx_isolation

　　例如：

　　

【mysql数据库设置事务隔离级别】

set transaction isolation level 隔离级别名

　　例如：

　　

【使用MySQL数据库演示不同隔离级别下的并发问题】

1、当把事务的隔离级别设置为read uncommitted时，会引发脏读、不可重复读和虚读

　　A窗口
　　　　set transaction isolation level  read uncommitted;--设置A用户的数据库隔离级别为Read uncommitted(读未提交)
　　　　start transaction;--开启事务
　　　　select * from account;--查询A账户中现有的钱，转到B窗口进行操作
　　　　select * from account--发现a多了100元，这时候A读到了B未提交的数据（脏读）

　　B窗口
　　　　start transaction;--开启事务
　　　　update account set money=money+100 where name='A';--不要提交，转到A窗口查询

2、当把事务的隔离级别设置为read committed时，会引发不可重复读和虚读，但避免了脏读

　　A窗口
　　　　set transaction isolation level  read committed;
　　　　start transaction;
　　　　select * from account;--发现a帐户是1000元，转到b窗口
　　　　select * from account;--发现a帐户多了100,这时候，a读到了别的事务提交的数据，两次读取a帐户读到的是不同的结果（不可重复读）
　　B窗口
　　　　start transaction;
　　　　update account set money=money+100 where name='aaa';
　　　　commit;--转到a窗口

3、当把事务的隔离级别设置为repeatable read(mysql默认级别)时，会引发虚读，但避免了脏读、不可重复读

　　A窗口
　　　　set transaction isolation level repeatable read;
　　　　start transaction;
　　　　select * from account;--发现表有4个记录，转到b窗口
　　　　select * from account;--可能发现表有5条记录，这时候发生了a读取到另外一个事务插入的数据（虚读）
　　B窗口
　　　　start transaction;
　　　　insert into account(name,money) values('ggg',1000);
　　　　commit;--转到a窗口

4、当把事务的隔离级别设置为Serializable时，会避免所有问题

　　A窗口
　　　　set transaction isolation level Serializable;
　　　　start transaction;
　　　　select * from account;--转到b窗口

　　B窗口
　　　　start transaction;
　　　　insert into account(name,money) values('ggg',1000);--发现不能插入，只能等待a结束事务才能插入

3.4 JDBC设置隔离级别

con. setTransactionIsolation(int level)

　　参数可选值如下：

• Connection.TRANSACTION_READ_UNCOMMITTED；
• Connection.TRANSACTION_READ_COMMITTED；
• Connection.TRANSACTION_REPEATABLE_READ；
• Connection.TRANSACTION_SERIALIZABLE。

四、JDBC开发中事务的处理

　　在开发中，对数据库的多个表或者对一个表中的多条数据执行更新操作时要保证对多个更新操作要么同时成功，要么都不成功，这就涉及到对多个更新操作的事务管理问题了。比如银行业务中的转账问题，A用户向B用户转账100元，假设A用户和B用户的钱都存储在Account表，那么A用户向B用户转账时就涉及到同时更新Account表中的A用户的钱和B用户的钱，用SQL来表示就是：

update account set money=money-100 where name='A'
update account set money=money+100 where name='B'

4.1 原始版

[transfer.jsp]

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>transfer</title>
</head>
<body>
    <form action="${pageContext.request.contextPath}/transfer" method="post">
        转出账户: <input type="text" name="out"/><br/>
        转入账户: <input type="text" name="in"/></br/>
        转账金额: <input type="text" name="money"/><br/>
        <input type="submit" value="确认转账"/>
    </form>
</body>
</html>

　　

【web层】

public class TransferServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 接收转账的参数
        String out = request.getParameter("out");
        String in = request.getParameter("in");
        String moneyStr = request.getParameter("money");
        double money = Double.parseDouble(moneyStr);

        // 调用业务层的转账方法
        TransferService service = new TransferService();
        boolean isTransferSuccess = service.transfer(out, in, money);

        response.setContentType("text/html;charset=UTF-8");
        if (isTransferSuccess) {
            response.getWriter().write("转账成功");
        } else {
            response.getWriter().write("转账失败");
        }
    }

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        doPost(request, response);
    }
}

【service层】

public class TransferService {
    public boolean transfer(String out, String in, double money) {
        TransferDao dao = new TransferDao();

        boolean isTransferSuccess = true;

        try {
            // 转出钱的方法
            dao.out(out, money);
            int i = 1 / 0;
            // 转入钱的方法
            dao.in(in,money);
        } catch (Exception e) {
            isTransferSuccess = false;
            e.printStackTrace();
        }
        return isTransferSuccess;
    }
}

 【Dao层】

public class TransferDao {

    public void out(String out, double money) throws SQLException {
        QueryRunner qr = new QueryRunner();
        Connection conn = JdbcUtils.getConnection();
        String sql = "update t_account set money=money-? where name=?";
        qr.update(conn, sql, money, out);
    }

    public void in(String in, double money) throws SQLException {
        QueryRunner qr = new QueryRunner();
        Connection conn = JdbcUtils.getConnection();
        String sql = "update t_account set money=money+? where name=?";
        qr.update(conn, sql, money, in);
    }
}

　　上述处理没有加入事务处理，当我们加入int i = 1/0语句时，程序就会报错，转账失败，但是数据库中就会出现tom的钱减了100，而lucy的钱却因为程序报错而没有加上，违背了事务的一致性，这是不能允许的。

 

 　　因此我们需要加入事务控制，在开发中，我们一般都是在业务层加入事务控制。修改service层：

public class TransferService {
    public boolean transfer(String out, String in, double money) {
        TransferDao dao = new TransferDao();

        boolean isTransferSuccess = true;
        Connection conn = null;

        try {
            // 开启事务
            conn = JdbcUtils.getConnection();
            conn.setAutoCommit(false);
            // 转出钱的方法
            dao.out(out, money);
            int i = 1 / 0;
            // 转入钱的方法
            dao.in(in, money);
            // 事务的提交不建议放在这
            // conn.commit();
        } catch (Exception e) {
            isTransferSuccess = false;
            // 回滚事务
            try {
                conn.rollback();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
            e.printStackTrace();
        } finally{
            try {
                // 事务的提交建议放在finally里
                conn.commit();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return isTransferSuccess;
    }
}

　　这里可能会有一个疑问：如果把commit放在finally里面的话，如果程序报错，回滚完后还提交。

　　注意回滚与提交的区别：回滚本身内部不包含提交的功能，回滚是“滚”到事务开启的地方，即第11行。程序报错，“滚”到第11行，然后再提交，这时候可以认为第13-16行之间的代码都没执行过。

　　如果把commit放在第18行，那么finally的代码就可以不用写了。这时候的情况是：第14行代码报错，程序就进入catch代码块，接着进行回滚操作，”滚“到第11行，这时第18行的commit是没有执行的，事务还没有结束，但是回滚完成之后，catch的代码已经执行完毕，即方法结束了，方法结束后，连接池会自动帮你关闭connection，这时候事务就结束了。而且别人再拿到connection的时候，就重新开启了一个新的事务了。

　　

　　修改完service层后，再次执行转账功能（tom给lucy转100），这是发现，虽然我们已经加入事务的处理了，但是转账失败的时候，tom少了100元，lucy仍然不变，跟之前的情况一样。

　　问题的原因是：开启事务的时候，是从连接池中拿的一个connection，而在操作TransferDao的时候，又从池子中拿了一个connection，这两个connection并不是同一个！！而dao中转入、转出两个方法中的connection也不是同一个。以上的操作，就有了3个不同的connection，这是不允许的。注意：控制事务、开启事务、以及操作每条sql的connection必须是同一个！下面对原始版进行改进。

4.2 改进版

　　思路：我们在service中拿到了connection，为保证后面的操作是同一个connection，我们可以将service中的connection以参数的形式传递给dao层，这样就保证了connection是同一个。

【service层】

public class TransferService {
    public boolean transfer(String out, String in, double money) {
        TransferDao dao = new TransferDao();

        boolean isTransferSuccess = true;
        Connection conn = null;

        try {
            // 开启事务
            conn = JdbcUtils.getConnection();
            conn.setAutoCommit(false);
            // 转出钱的方法
            dao.out(conn,out, money);
            int i = 1 / 0;
            // 转入钱的方法
            dao.in(in,conn, money);
            // 事务的提交不建议放在这
            // conn.commit();
        } catch (Exception e) {
            isTransferSuccess = false;
            // 回滚事务
            try {
                conn.rollback();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
            e.printStackTrace();
        } finally{
            try {
                // 事务的提交建议放在finally里
                conn.commit();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return isTransferSuccess;
    }
}

【Dao层】

public class TransferDao {

    public void out(Connection conn, String out, double money) throws SQLException {
        QueryRunner qr = new QueryRunner();
        //Connection conn = JdbcUtils.getConnection();
        String sql = "update t_account set money=money-? where name=?";
        qr.update(conn, sql, money, out);
    }

    public void in(String in, Connection conn, double money) throws SQLException {
        QueryRunner qr = new QueryRunner();
        //Connection conn = JdbcUtils.getConnection();
        String sql = "update t_account set money=money+? where name=?";
        qr.update(conn, sql, money, in);
    }
}

4.3 最终版——使用ThreadLocal

　　在上面改进版的代码中，我们是在service中调用dao的方法，并把connection对象传递过去，这就保证了connection是同一个。但是这种方式不好， 我们在开发中使用分层的目的就是使每个层之间的逻辑更清楚。在改进版中， service层出现了connection，connection是数据库的连接资源，它应该是在dao层出现的 ，这就涉及到了层与层之间的”污染“了，所以并不好。

　　现在的矛盾在于：开启事务，需要用connection开，执行sql，也要用connection执行，而且这两个connection必须是同一个。但是事务的操作又必须在service层控制，而在service层还不想看到connection。接下来介绍ThreadLocal。

 　　首先我们需要的一点是：所有的方法调用，用的都是同一个线程（除非你开启一个新的线程）。在本案例的转账功能中，web层-service层-dao层之间的方法调用，都用的是同一个线程的。在操作事务时，我们可用尝试将connection放在一个Map中，map的key就是当前线程，value就是connection，这样就能保证service层和dao层用的是同一个connection。其实ThreadLocal就是利用这样的原理。

　　ThreadLocal内部其实是个Map来保存数据。虽然在使用ThreadLocal时只给出了值，没有给出键，其实它内部使用了当前线程做为键。

class MyThreadLocal<T> {
    private Map<Thread,T> map = new HashMap<Thread,T>();
    public void set(T value) {
        map.put(Thread.currentThread(), value);
    }
    
    public void remove() {
        map.remove(Thread.currentThread());
    }
    
    public T get() {
        return map.get(Thread.currentThread());
    }
}

　　ThreadLocal类只有三个方法：

• void set(T value)：保存值；
• T get()：获取值；
• void remove()：移除值。

【改进JdbcUtils】

public class JdbcUtils {

    // 获得Connection——从连接池中获取
    private static ComboPooledDataSource dataSource = new ComboPooledDataSource();

    // 创建ThreadLocal,<Connection>表示存放的值为Connection类
    private static ThreadLocal<Connection> tl = new ThreadLocal();

    // 获得当前线程上绑定的connection
    public static Connection getCurrentConnection() throws SQLException {
        // 从ThreadLocal寻找当前线程是否有对应的Connection
        Connection conn = tl.get();
        if (conn == null) {
            // 获得新的connection
            conn = getConnection();
            // 将conn资源绑定到ThreadLocal上
            tl.set(conn);
        }
        return conn;
    }

    // 开启事务
    public static void startTransaction() throws SQLException {
        Connection conn = getCurrentConnection();
        conn.setAutoCommit(false);
    }

    // 回滚事务
    public static void rollback() throws SQLException {
        getCurrentConnection().rollback();
    }

    // 提交事务
    public static void commit() throws SQLException {
        getCurrentConnection().commit();
    }

    public static DataSource getDataSource() {
        return dataSource;
    }

    // 获取连接
    public static Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }

    // 释放连接
    public static void release(Connection connection, PreparedStatement pstmt, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (pstmt != null) {
            try {
                pstmt.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

}

【service层】

public class TransferService {
    public boolean transfer(String out, String in, double money) {
        TransferDao dao = new TransferDao();

        boolean isTransferSuccess = true;

        try {
            // 开启事务
            //conn = JdbcUtils.getConnection();
            //conn.setAutoCommit(false);
            JdbcUtils.startTransaction();
            // 转出钱的方法
            dao.out(out, money);
            int i = 1 / 0;
            // 转入钱的方法
            dao.in(in, money);
            // 事务的提交不建议放在这
            // conn.commit();
        } catch (Exception e) {
            isTransferSuccess = false;
            // 回滚事务
            try {
                JdbcUtils.rollback();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
            e.printStackTrace();
        } finally{
            try {
                // 事务的提交建议放在finally里
                JdbcUtils.commit();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return isTransferSuccess;
    }
}

【Dao层】——数据库连接对象不再需要service层传递过来，而是直接从JdbcUtils提供的getCurrentConnection方法去获取

public class TransferDao {

    public void out(String out, double money) throws SQLException {
        QueryRunner qr = new QueryRunner();
        Connection conn = JdbcUtils.getCurrentConnection();
        String sql = "update t_account set money=money-? where name=?";
        qr.update(conn, sql, money, out);
    }

    public void in(String in, double money) throws SQLException {
        QueryRunner qr = new QueryRunner();
        Connection conn = JdbcUtils.getCurrentConnection();
        String sql = "update t_account set money=money+? where name=?";
        qr.update(conn, sql, money, in);
    }
}

　　这样在service层对事务的处理看起来就更加优雅了。ThreadLocal类在开发中使用得是比较多的，程序运行中产生的数据要想在一个线程范围内共享，只需要把数据使用ThreadLocal进行存储即可。

参考：https://www.cnblogs.com/xdp-gacl/p/3984001.html