04 批量处理

批量处理

标签（空格分隔）： jdbc

---

最慢：Statement

使用Statement是最慢的方法。因为在循环中，我们每次循环都要创建一个SQL语句，然后再进行executeUpdate()

/**
     * 向  MySQL 的 customers 数据表中插入 10 万条记录
     * 测试如何插入, 用时最短. 
     * 1. 使用 Statement.
     */
    @Test
    public void testBatchWithStatement(){
        Connection connection = null;
        Statement statement = null;
        String sql = null;

        try {
            connection = JDBCTools.getConnection();
            JDBCTools.beginTx(connection);

            statement = connection.createStatement();

            long begin = System.currentTimeMillis();
            for(int i = 0; i < 100000; i++){
                sql = "INSERT INTO customers VALUES(" + (i + 1) 
                        + ", 'name_" + i + "', '29-6月 -13')";
                preparedStatement.executeUpdate();
            }
            long end = System.currentTimeMillis();

            System.out.println("Time: " + (end - begin)); //39567

            JDBCTools.commit(connection);
        } catch (Exception e) {
            e.printStackTrace();
            JDBCTools.rollback(connection);
        } finally{
            JDBCTools.releaseDB(null, statement, connection);
        }
    }

执行时间是39567毫秒

次慢PreparedStatement

使用PreparedStatement，我们在循环外面写一个包含占位符的SQL语句，然后我们在循环中只写executeUpdate()，这样省去了很多次的创建SQL的操作，要快了好几倍。

public void testBatchWithPreparedStatement(){
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        String sql = null;

        try {
            connection = JDBCTools.getConnection();
            JDBCTools.beginTx(connection);
            sql = "INSERT INTO customers VALUES(?,?,?)";
            preparedStatement = connection.prepareStatement(sql);
            Date date = new Date(new java.util.Date().getTime());

            long begin = System.currentTimeMillis();
            for(int i = 0; i < 100000; i++){
                preparedStatement.setInt(1, i + 1);
                preparedStatement.setString(2, "name_" + i);
                preparedStatement.setDate(3, date);

                preparedStatement.executeUpdate();
            }
            long end = System.currentTimeMillis();

            System.out.println("Time: " + (end - begin)); //9819

            JDBCTools.commit(connection);
        } catch (Exception e) {
            e.printStackTrace();
            JDBCTools.rollback(connection);
        } finally{
            JDBCTools.releaseDB(null, preparedStatement, connection);
        }
    }

执行耗时9819毫秒

最快Batch

类比我们在IO流中的缓冲流。

在搬砖的时候，我们将砖搬到板车上然后一次性的运走一板车的砖，这样很有效率。

在JDBC批量处理中，我们使用addBatch()方法“积攒”SQL，当“积攒”到一定程度，就统一的执行一次. 并且清空先前 “积攒” 的 SQL。

不要忘记：若总条数不是批量数值的整数倍, 则还需要再额外的执行一次

@Test
    public void testBatch(){
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        String sql = null;

        try {
            connection = JDBCTools.getConnection();
            JDBCTools.beginTx(connection);
            sql = "INSERT INTO customers VALUES(?,?,?)";
            preparedStatement = connection.prepareStatement(sql);
            Date date = new Date(new java.util.Date().getTime());

            long begin = System.currentTimeMillis();
            for(int i = 0; i < 100000; i++){
                preparedStatement.setInt(1, i + 1);
                preparedStatement.setString(2, "name_" + i);
                preparedStatement.setDate(3, date);

                //"积攒" SQL 
                preparedStatement.addBatch();

                //当 "积攒" 到一定程度, 就统一的执行一次. 并且清空先前 "积攒" 的 SQL
                if((i + 1) % 300 == 0){
                    preparedStatement.executeBatch();
                    preparedStatement.clearBatch();
                }
            }

            //若总条数不是批量数值的整数倍, 则还需要再额外的执行一次. 
            if(100000 % 300 != 0){
                preparedStatement.executeBatch();
                preparedStatement.clearBatch();
            }

            long end = System.currentTimeMillis();

            System.out.println("Time: " + (end - begin)); //569

            JDBCTools.commit(connection);
        } catch (Exception e) {
            e.printStackTrace();
            JDBCTools.rollback(connection);
        } finally{
            JDBCTools.releaseDB(null, preparedStatement, connection);
        }
    }

执行时间569毫秒。

比Statement的速度快了五六十倍。