数据库事务

数据库事务

在数据库中，所谓事务是指一组逻辑操作单元，使数据从一种状态变换到另一种状态。

事务的操作：先定义开始一个事务，然后对数据作修改操作，这时如果提交(commit),这些修改就永久的保存下来，如果回退(rollback),数据库管理系统将放弃所作的所有修改而回到开始事务时的状态。

事务的ACID属性

　　1.原子性(Actomicity)

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

　　2.一致性(Consistency)

　　事务必须使数据库从一个一致状态转换到另外一个一致性状态。

　　3.隔离性(lsolation)
　　事务的隔离性是指一个事务的执行不能被其他事务干扰，即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。

　　4.持久性(Durability)

　　持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来的其他操作和数据库故障不应该对其有任何影响

JDBC事务处理

事务：指构成单个逻辑工作单位的操作集合

——调用Connection对象的setAutoCommit(false);以取消自动提交事务

——在所有的SQL语句都成功执行后,调用Commit()；方法提交事务

——在出现异常时，调用rollback();方法回滚事务

——若此时connection没有被关闭，则需要恢复其自动提交的状态。

关于事务：

1.如果多个操作，每个操作使用的是自己单独的连接，则无法保证事务。

2.具体步骤：

1）事务操作开始，开始事务：取消Connection的默认提交行为。

　　connection.setAutoCommit(false);

2)如果事务的操作都成功，则提交事务：connection.commit();

3)回滚事务：若出现异常，则在catch块中回滚事务。

    @Test
    public void test6(){
        Connection conn = null;
            Dao dao = new Dao();
        try {
            conn = Methods.getConnection();
            //1.
            conn.setAutoCommit(false);

            String sql = "update account set balance=balance-500 where id =1";
            dao.updateSW(conn,sql);
            int i = 10/0;
            sql = "update account set balance=balance+500 where id =2";
            dao.updateSW(conn,sql);

            //2.
            conn.commit();
        } catch (Exception e) {
            e.printStackTrace();
            try {
                //3.
                conn.rollback();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
        } finally {
            Methods.release(null,conn,null);
        }
        
    }

　　

 //修改的事务
    public void updateSW(Connection conn,String sql,Object...args){
        PreparedStatement preparedStatement = null;

        try {

            preparedStatement = conn.prepareStatement(sql);

            for(int i = 0;i<args.length;i++){
                preparedStatement.setObject(i+1,args[i]);
            }
            preparedStatement.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            Methods.release(preparedStatement,null,null);
        }
    }

　　

数据库的隔离级别

　　脏读：对于两个事务T1、T2，T1读取了已经被T2更新但还没有被提交的字段。之后，若T2回滚，T1读取的内容就是临时且无效的。

　　不可重复读：对于两个事务T1，T2，T1读取了一个字段，然后T2更新了该字段。之后，T1再次读取同一个字段，值就不同了。

　　幻读：对于两个事务T1、T2，T1从一个表中读取一个字段，然后T2在该表中插入一些新的行。之后，如果T1再次读取同一个表，就会多出几行。

数据库事务的隔离性：数据库系统必须具有隔离并发运行各个事务的能力，使它们不会相互影响，避免各种并发问题。

一个事务与其他事务隔离的程度称为隔离级别。数据库规定了多种事务隔离级别，不同隔离级别对应不同的干扰程度，隔离级别越高，数据一致性就越好，但并发行越弱。

隔离级别	描述
READ UNCOMMITED(读未提交数据)	其他事务提交的变更、脏读、不可重复读和幻读
READ COMMITED(读已提交的数据)	只允许事务已经被其他事务提交的变更，避免脏读，但不可重复读和幻读依然出现。
REPEATABLE READ(可重复读)	确保事务可以多次从一个字段中读取相同的值，访问期间，禁止其他事务访问，可以避免脏读，但不可重复读和幻读问题仍然可能出现
SERIALIZABLE(串行化)	不让并发访问，性能低，隔离级别最高

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Oracle支持的2种事务隔离级别：

　　READ COMMITED（默认的),SERIALIZABLE

Mysql支持的4种事务隔离级别：

　　默认：REPEATABLE READ

 

在JDBC程序中可以通过Connection的setTransactionIsolation来设置事务的隔离级别。

 

~查看当前的隔离级别：

——SELECT@@tx_isolation

~设置当前mysql连接的隔离级别：

——set transaction isolation level read committed;

~设置数据库系统的全局的隔离级别：

——set global transaction isolation level read committed;

 

    @Test
    public void testUpdate(){
        Connection conn = null;
        Dao dao = new Dao();
        try {
            conn = Methods.getConnection();
            conn.setAutoCommit(false);

            String sql = "update account set balance=balance-500 where id =1";
            dao.updateSW(conn,sql);

   在此设置断点       conn.commit();//未提交
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            Methods.release(null,conn,null);
        }
    }
    @Test
    public void testRead(){
        Dao dao = new Dao();
        String sql = "select balance from account where id=1";
        Integer balance = dao.getForValue(sql);
        System.out.println(balance);//500
    }

 

　　

  //查询一条记录——》数量
    public <E> E getForValue(String sql, Object...args){
        Connection conn = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;

        try {
            conn = Methods.getConnection();
            conn.setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);

　　　　　　　//设置该事务的隔离级别是读未提交数据

            conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);

　　　　　　
　　　　　　　　

            preparedStatement = conn.prepareStatement(sql);
            for (int i = 0; i < args.length; i++) {
                preparedStatement.setObject(i+1,args[i]);
            }
            resultSet = preparedStatement.executeQuery();
            if(resultSet.next()){
                return (E) resultSet.getObject(1);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            Methods.release(preparedStatement,conn,resultSet);
        }
        return null;
    }