事务 - 火鸟的怒放

事务

2018-05-13　　22:08:27

什么是事务

　　通俗的说，一件事有多个单元，为保证不出错，可以把这多个单元放入事务中，这多个单元要么同时成功，要么同时失败

JDBC事务

　　默认是自动事务，例如每执行一次executeUpdate()方法，事务自动提交

　　手动事务：

　　　　开启事务：start transaction

　　　　提交事务：commit　　从开启事务到提交事务中间的所有sql语句都是有效的更新数据库

　　　　回归事务：rollback　　从开启事务到回滚事务中间的所有sql语句都是无效的更新数据库,数据库未被改变

jdbc事务

　　开启事务：conn.setAutoComnmit(false);

　　提交事务：conn.commit();

　　回滚事务：conn.rollback();

　　sql语句中的Connection对象和conn必须是同一个，才能对事务进行控制

DBUtils事务

　　例如：下列代码简单的模仿转账业务（不考虑注入攻击）web层向service传递用户的转出账户out,转入账户in，和金额money,service层向web层传递一个布尔参数，告知成功与否

service层：

package com.itheima.transfer.service;

import java.sql.Connection;
import java.sql.SQLException;

import com.transfer.dao.TransferDao;
import com.utils.DataSourceUtils;
import com.utils.MyDataSourceUtils;

public class TransferService {
    public boolean transfer(String out,String in,Double money){
        TransferDao dao = new TransferDao();
        Boolean isAccess = false;
        Connection conn = null;
        try {
            conn = DataSourceUtils.getConnection();
            //开启事务
            conn.setAutoCommit(false);
            dao.out(conn,out,money);
            //int i = 1/0;
            dao.in(conn,in,money);
            isAccess = true;
        } catch (Exception e) {
            //回滚
            try {
                conn.rollback();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
        } finally{
            try {
                conn.commit();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return isAccess;
    }
}

dao层：

package com.itheima.transfer.dao;
import java.sql.Connection;
import java.sql.SQLException;
import org.apache.commons.dbutils.QueryRunner;
import com.utils.MyDataSourceUtils;

public class TransferDao {
    public void out(Connection conn,String out, Double money) throws SQLException {
        QueryRunner runner = new QueryRunner();
        String sql = "update account set money=money-? where name=?";
        runner.update(conn, sql, money,out);
    }
    public void in(Connection conn,String in, Double money) throws SQLException {
        QueryRunner runner = new QueryRunner();
        String sql = "update account set money=money+? where name=?";
        runner.update(conn, sql, money,in);
    }
}

　　这样可以实现一个转账的小demo了，但是conn属于dao层内容放在service层不太合适，这时可以借助ThreadLocal绑定资源的方法，将Connection对象绑定在线程里，让conn不再出现在service层中

service层：

package com.itheima.transfer.service;
import java.sql.Connection;
import java.sql.SQLException;
import com.transfer.dao.TransferDao;
import com.utils.DataSourceUtils;
import com.utils.MyDataSourceUtils;
public class TransferService {
    public boolean transfer(String out,String in,Double money){
        TransferDao dao = new TransferDao();
        Boolean isAccess = false;
        try {
            //开启事务
            MyDataSourceUtils.startTransaction();
            dao.out(out,money);
            //int i = 1/0;
            dao.in(in,money);
            isAccess = true;
        } catch (Exception e) {
            //回滚
            try {
                MyDataSourceUtils.rollback();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
        } finally{
            try {
                MyDataSourceUtils.commit();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return isAccess;
    }
}

dao层：

package com.itheima.transfer.dao;
import java.sql.Connection;
import java.sql.SQLException;
import org.apache.commons.dbutils.QueryRunner;
import com.utils.MyDataSourceUtils;
public class TransferDao {

    public void out(String out, Double money) throws SQLException {
        QueryRunner runner = new QueryRunner();
        Connection conn = MyDataSourceUtils.getCurrentConnection();
        String sql = "update account set money=money-? where name=?";
        runner.update(conn, sql, money,out);
    }

    public void in(String in, Double money) throws SQLException {
        QueryRunner runner = new QueryRunner();
        Connection conn = MyDataSourceUtils.getCurrentConnection();
        String sql = "update account set money=money+? where name=?";
        runner.update(conn, sql, money,in);
    }
    
}

MyDataSourceUtils：

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<Connection> tl = new ThreadLocal<Connection>();
    
    //获取当前线程绑定conn
    public static Connection getCurrentConnection() throws SQLException{
        //从ThreadLocal寻找 当前线程是否有对应Connection
        Connection conn = tl.get();
        if(conn==null){
            //获得新的connection
            conn = getConnection();
            //将conn绑定到线程
            tl.set(conn);
        }
        return conn;
    }
    
    //获取conn
    public static Connection getConnection() throws SQLException{
        return dataSource.getConnection();
    }
    
    //开启线程
    public static void startTransaction() throws SQLException{
        Connection conn = getCurrentConnection();
        if(conn!=null){
            conn.setAutoCommit(false);            
        }
    }
    
    //事务回滚
    public static void rollback() throws SQLException{
        Connection conn = getCurrentConnection();
        if(conn!=null){
            conn.rollback();
        }
    }
    
    //提交事务
    public static void commit() throws SQLException{
        Connection conn = getCurrentConnection();
        if(conn!=null){
            conn.commit();
            conn.close();
            tl.remove();
        }
    }
    
}

事务的特性（ACID）

　　1）原子性（Atomicity）原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。

　　2）一致性（Consistency）一个事务中，事务前后数据的完整性必须保持一致。

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

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

并发访问问题（隔离性引起）

　　不考虑隔离性，事务存在以下并发问题

　　1）脏读：B事务读取到了A事务尚未提交的数据 ------- 要求B事务要读取A事务提交的数据

　　　　　　　例如：B找A还钱，A开启事务，更新数据库，但没提交，告诉B还完了，B查询数据库确实还了，欠条销毁后，A回滚，B再查询数据库时发现钱没了！这就叫脏读，两次查询的数据不一样，其中也含有不可重复这个问题

　　2）不可重复读：一个事务中两次读取的数据的内容不一致 ------- 要求的是一个事务中多次读取时数据是一致的 --- unpdate

　　3）幻读/虚读：一个事务中两次读取的数据的数量不一致 ------- 要求在一个事务多次读取的数据的数量是一致的 --insert delete

事务隔离级别

　　1）read uncommitted : 读取尚未提交的数据：哪个问题都不能解决

　　2）read committed：读取已经提交的数据：可以解决脏读 ---- oracle默认的

　　3）repeatable read：重读读取：可以解决脏读和不可重复读 ---mysql默认的

　　4）serializable：序列化：可以解决，脏读，不可重复读和虚读---相当于锁表

　　从性能上考虑：read uncommitted>read committed>repeatable read>serializable

　　从安全上考虑：serializable<repeatable read<read committed<read uncommitted

posted on 2018-05-13 23:01 火鸟的怒放阅读(142) 评论(0) 收藏举报

刷新页面返回顶部