数据库事务

---

layout: post
title: 数据库事务
subtitle: 用法
date: 2018-04-24
author: ZL
header-img: img/20180424.jpg
catalog: true
tags:
- 数据库事务

---

事务

某些数据库的操作是一系列的，只要其中某一条出现了问题，执行失败，那么前面已经执行的语句在逻辑上就不应该生效。
一件事情有n个组成单元 要不这n个组成单元同时成功 要不n个单元就同时失败
就是将n个组成单元放到一个事务中。

其实，每一条sql语句都是自动事务的，就是说为每一条语句开一个事务。
同时，也可以收到那个开启事务，让多条语句在一个事务中执行。

MySQL的事务

命令：

• 开启：start transaction
• 事务提交：commit

  只有commit以后，开启事务之后执行的sql语句才会真正的执行，没有commit之前只是一种假的执行。

• 事务回滚：rollback

  从开启事务到事务回滚 中间的所有的 sql操作都认为无效数据库没有被更新

JDBC的事务

数据库的命令支持事务这种操作，那么JDBC作为封装的api肯定也是支持的。

在JDBC上面主要就是一些api罢了。
开启事务：conn.setAutoCommit(false);
提交事务：conn.commit();
回滚事务：conn.rollback();

封装的c3p0连接池

• 不包含事务的：

  package com.itheima.utils;
  
  import java.sql.Connection;
  import java.sql.ResultSet;
  import java.sql.SQLException;
  import java.sql.Statement;
  
  import javax.sql.DataSource;
  
  import com.mchange.v2.c3p0.ComboPooledDataSource;
  
  public class DataSourceUtils {
  
    private static DataSource dataSource = new ComboPooledDataSource();
  
    private static ThreadLocal tl = new ThreadLocal();
  
    // 直接可以获取一个连接池
    public static DataSource getDataSource() {
        return dataSource;
    }
    
    public static Connection getConnection() throws SQLException{
        return dataSource.getConnection();
    }
  
    // 获取连接对象
    public static Connection getCurrentConnection() throws SQLException {
  
        Connection con = tl.get();
        if (con == null) {
            con = dataSource.getConnection();
            tl.set(con);
        }
        return con;
    }
  
    // 开启事务
    public static void startTransaction() throws SQLException {
        Connection con = getCurrentConnection();
        if (con != null) {
            con.setAutoCommit(false);
        }
    }
  
    // 事务回滚
    public static void rollback() throws SQLException {
        Connection con = getCurrentConnection();
        if (con != null) {
            con.rollback();
        }
    }
  
    // 提交并且 关闭资源及从ThreadLocall中释放
    public static void commitAndRelease() throws SQLException {
        Connection con = getCurrentConnection();
        if (con != null) {
            con.commit(); // 事务提交
            con.close();// 关闭资源
            tl.remove();// 从线程绑定中移除
        }
    }
  
    // 关闭资源方法
    public static void closeConnection() throws SQLException {
        Connection con = getCurrentConnection();
        if (con != null) {
            con.close();
        }
    }
  
    public static void closeStatement(Statement st) throws SQLException {
        if (st != null) {
            st.close();
        }
    }
  
    public static void closeResultSet(ResultSet rs) throws SQLException {
        if (rs != null) {
            rs.close();
        }
    }
  
  }
  
  =======================================================
  
  //使用
  @Test
    public void testQueryAll() {
        try {
            // 1.获取核心类queryRunner
            QueryRunner qr = new QueryRunner(C3P0Utils.getDataSource());
            // 2.编写sql语句
            String sql = "select * from tbl_user";
            // 3.执行查询操作
            List users = qr.query(sql, new BeanListHandler(User.class));
            // 4.对结果集集合进行遍历
            for (User user : users) {
                System.out.println(user.getUname() + " : " + user.getUpassword());
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
  

• 包含事务的

  package com.itheima.utils;
  
  import java.sql.Connection;
  import java.sql.SQLException;
  
  import com.mchange.v2.c3p0.ComboPooledDataSource;
  
  public class MyDataSourceUtils {
  
    //获得Connection ----- 从连接池中获取
    private static ComboPooledDataSource dataSource = new ComboPooledDataSource();
    
    //创建ThreadLocal
    private static ThreadLocal tl = new ThreadLocal();
    
    //开启事务
    public static void startTransaction() throws SQLException{
        Connection conn = getCurrentConnection();
        conn.setAutoCommit(false);
    }
    
    //获得当前线程上绑定的conn
    public static Connection getCurrentConnection() throws SQLException{
        //从ThreadLocal寻找 当前线程是否有对应Connection
        Connection conn = tl.get();
        if(conn==null){
            //获得新的connection
            conn = getConnection();
            //将conn资源绑定到ThreadLocal（map）上
            tl.set(conn);
        }
        return conn;
    }
    
    public static Connection getConnection() throws SQLException{
        return dataSource.getConnection();
    }
  
    //回滚事务
    public static void rollback() throws SQLException {
        getCurrentConnection().rollback();
    }
  
    //提交事务
    public static void commit() throws SQLException {
        Connection conn = getCurrentConnection();
        conn.commit();
        //将Connection从ThreadLocal中移除
        tl.remove();
        conn.close();
        
    }
  
  }
  
  
  =====================================================
  //使用
  Connection conn = null;
  try {
    QueryRunner runner = new QueryRunner();
    
    //runner.update("update account set money=15000 where name='tom'");
    //获得一个Connection
    conn = DataSourceUtils.getConnection();
    
    //开启事务
    conn.setAutoCommit(false);
    
    runner.update(conn, "update account set money=15000 where name='tom'");
    //提交或回滚事务
    conn.commit();
    
  } catch (SQLException e) {
    try {
      conn.rollback();
    } catch (SQLException e1) {
      e1.printStackTrace();
    }
    e.printStackTrace();
  }
  
  
  

事务的特性和隔离级别

• 事务的特性ACID
  • 原子性（Atomicity）：在事务中的操作要么全部发生，要么全部不发生。
  • 一致性（Consistency）：事务前后的数据的完整性必须保持一致。举例子：转账时，转账的账户-100，转到的账户应该+100，如果+10000，数据的完整性就不一致了。
  • 隔离性（Isolation）：多个并发事务之间的数据必须相互隔离，事务的隔离性是指多个用户并发访问数据库时， 一个用户的 事务不能被其它用户的事务所干扰。
  • 持久性（Durability）：持久性是指一个事务一旦被提交，它对数据库中数据的改变 就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响。

• 事务所带来的问题
  • 脏读：B事务读取到了A事务尚未提交的数据
  • 不可重复读：一个事务中 两次读取的数据的内容不一致
  • 幻读&虚读：一个事务中 两次读取的数据的数量不一致

• 解决事务所带来的问题--隔离级别

  • 查看mysql的数据库的隔离级别
    select @@tx_isolation
    

    image

  • 设置mysql的隔离级别
    set session transaction isolation level 事务隔离级别
    

    image

  • 隔离级别

    • read uncommitted : 读取尚未提交的数据 ：哪个问题都不能解决
    • read committed：读取已经提交的数据 ：可以解决脏读 ---- oracle默认的
    • repeatable read：重读读取：可以解决脏读 和 不可重复读 ---mysql默认的
    • serializable：串行化：可以解决 脏读 不可重复读 和 虚读---相当于锁表

隔离级别的性能：
read uncommitted>read committed>repeatable read>serialazable
安全性：
read uncommitted