数据库事务

1.JDBC处理事务

数据库事务是一组逻辑操作单元，使数据从一种状态变换到另一种状态。为确保数据库中数据的一致性，数据的操纵应当是离散的成组的逻辑单元，当它全部完成时，数据的一致性可以保持，而当这个单元中的一部分操作失败，整个事务应全部视为失败，所有从起点以后的操作应全部退到开始操作。

例如：A——B转帐，对应于如下两条sql语句。

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

 有下面的数据表，存储了用户的ID号，用户名，密码以及账户余额：

现要用代码实现TOM给Jerry汇款500元的事务操作。

关于事务：

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

2.具体步骤：

1).事务操作开始前，开始事务：取消Connection的默认提交行为：connection.setAutoCommit(false);

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

3).若出现异常，则在catch块中回滚事务：connection.rollback();

示例代码：

package com.test.jdbc;

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

import org.junit.Test;

public class TransactionTest {
	
	@Test
	public void testTransaction() throws SQLException {
		Connection connection = null;
		try{
			//为sql获得数据库的同一个连接
			connection=JDBCTools.getConnection();
			//开始事务，取消默认提交
			connection.setAutoCommit(false);
			String sql="UPDATE USERS SET BALANCE ="+"BALANCE-500 WHERE ID=1";
			update(connection,sql);
			//异常
			int i=10/0;
			sql="UPDATE USERS SET BALANCE ="+"BALANCE+500 WHERE ID=2";
			update(connection,sql);
			//提交事务
			connection.commit();
		}catch(Exception e){
			e.printStackTrace();
			try{
				//若遭遇异常，事务回滚
				connection.rollback();
			}catch(Exception eq){
				eq.printStackTrace();
			}
		}finally{
			JDBCTools.release(null, null, connection);
		}
	}
	public void update(Connection connection,String sql,Object ... args){
		PreparedStatement prepareStatement=null;
		try{
			prepareStatement=connection.prepareStatement(sql);
			for(int i=0;i<args.length;i++){
				prepareStatement.setObject(i+1,args[i]);
			}
			prepareStatement.executeUpdate();
		}catch(Exception e){
			e.printStackTrace();
		}finally{
			JDBCTools.release(null, prepareStatement, connection);
		}
	}

}

2.数据库的隔离级别

多个线程开启各自事务操作数据库中数据时，数据库系统要负责隔离操作，以保证各个线程在获取数据时的准确性。

2.1 事务不考虑隔离性可能会引发的问题

如果事务不考虑隔离性，可能会引发如下问题：

①脏读：脏读指一个事务读取了另外一个事务未提交的数据。

这是非常危险的，假设Ａ向Ｂ转帐100元，对应sql语句如下所示：

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

当第1条sql执行完，第2条还没执行(A未提交时)，如果此时Ｂ查询自己的帐户，就会发现自己多了100元钱。如果A等B走后再回滚，B就会损失100元。　　

②不可重复读

不可重复读指在一个事务内读取表中的某一行数据，多次读取结果不同。
例如银行想查询A帐户余额，第一次查询A帐户为200元，此时A向帐户内存了100元并提交了，银行接着又进行了一次查询，此时A帐户为300元了。银行两次查询不一致，可能就会很困惑，不知道哪次查询是准的。
不可重复读和脏读的区别是，脏读是读取前一事务未提交的脏数据，不可重复读是重新读取了前一事务已提交的数据。
很多人认为这种情况就对了，无须困惑，当然是后面的为准。我们可以考虑这样一种情况，比如银行程序需要将查询结果分别输出到电脑屏幕和写到文件中，结果在一个事务中针对输出的目的地，进行的两次查询不一致，导致文件和屏幕中的结果不一致，银行工作人员就不知道以哪个为准了。

③幻读

幻读是指在一个事务内读取到了别的事务插入的数据，导致前后读取不一致。
如丙存款100元未提交，这时银行做报表统计account表中所有用户的总额为500元，然后丙提交了，这时银行再统计发现帐户为600元了，造成虚读同样会使银行不知所措，到底以哪个为准。

2.2 事务隔离性的设置语句

MySQL数据库共定义了四种隔离级别：

1. Serializable(串行化)：可避免脏读、不可重复读、虚读情况的发生。
2. Repeatable read(可重复读)：可避免脏读、不可重复读情况的发生。
3. Read committed(读已提交)：可避免脏读情况发生。
4. Read uncommitted(读未提交)：最低级别，以上情况均无法保证。

 3.批量处理

在实际的项目开发中，有时候需要向数据库发送一批SQL语句执行，这时应避免向数据库一条条的发送执行，而应采用JDBC的批处理机制，以提升执行效率。JDBC实现批处理有两种方式：statement和preparedstatement。

3.1 使用Statement完成批处理

①使用Statement对象添加要批量执行SQL语句，如下：

1.Statement.addBatch(sql1);
2 Statement.addBatch(sql2);
3 Statement.addBatch(sql3);

②执行批处理SQL语句：Statement.executeBatch();
③清除批处理命令：Statement.clearBatch();

示例代码：

package me.gacl.demo;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.Statement;
import me.gacl.utils.JdbcUtils;
import org.junit.Test;
 
public class JdbcBatchHandleByStatement {

    @Test
    public void testJdbcBatchHandleByStatement(){
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        try{
            conn = JdbcUtils.getConnection();
            String sql1 = "insert into testbatch(id,name) values(1,'aaa')";
            String sql2 = "insert into testbatch(id,name) values(2,'bbb')";
            String sql3 = "insert into testbatch(id,name) values(3,'CCC')";
            String sql4 = "insert into testbatch(id,name) values(4,'DDD')";
            String sql5 = "update testbatch set name='gacl' where id=1";
            String sql6 = "insert into testbatch(id,name) values(5,'FFF')";
            String sql7 = "delete from testbatch where id=2";
            st = conn.createStatement();
            //添加要批量执行的SQL
            st.addBatch(sql1);
            st.addBatch(sql2);
            st.addBatch(sql3);
            st.addBatch(sql4);
            st.addBatch(sql5);
            st.addBatch(sql6);
            st.addBatch(sql7);
            //执行批处理SQL语句
            st.executeBatch();
            //清除批处理命令
            st.clearBatch();
        }catch (Exception e) {
            e.printStackTrace();
        }finally{
            JdbcUtils.release(conn, st, rs);
        }
    }
}

3.2 使用PreparedStatement完成批量处理

示例代码：

package me.gacl.demo;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import me.gacl.utils.JdbcUtils;
import org.junit.Test;

public class JdbcBatchHandleByPrepareStatement {

    @Test
    public void testJdbcBatchHandleByPrepareStatement(){
        long starttime = System.currentTimeMillis();
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
        
        try{
            conn = JdbcUtils.getConnection();
            String sql = "insert into testbatch(id,name) values(?,?)";
            st = conn.prepareStatement(sql);
            for(int i=1;i<1000008;i++){  //i=1000  2000
                st.setInt(1, i);
                st.setString(2, "aa" + i);
                st.addBatch();
                if(i%1000==0){
                    st.executeBatch();
                    st.clearBatch();
                }
            }
            st.executeBatch();
        }catch (Exception e) {
            e.printStackTrace();
        }finally{
            JdbcUtils.release(conn, st, rs);
        }
        long endtime = System.currentTimeMillis();
        System.out.println("程序花费时间：" + (endtime-starttime)/1000 + "秒！！");
    }
}