数据库事务


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

你可能感兴趣的:(数据库事务)