2

我使用 JDBC，自动提交 = true。在其中一项操作中，我正在使用准备好的语句进行批量插入。

public void executeBatchInsert(String query, List<Object[]> entityList)  {
        try {
            pstmt = conn.prepareStatement(query);
            for(int i=0; i<entityList.size(); i++) {
                int j=1;
                for(Object o: entityList.get(i)) {
                    pstmt.setObject(j++, formatColumnValue(o));
                }

                pstmt.addBatch();
                if((i+1)%1000 == 0) {
                    pstmt.executeBatch();
                }
            }
            pstmt.executeBatch();
        } catch (SQLException e) {
        }
    }

如果我在执行它时遇到异常，当我关闭这个连接时，所有的锁都会被释放并发生回滚吗？

——B. Teja。

4

3 回答 3

5

你的问题的直接答案是：不。如果发生异常，您必须手动调用该rollback方法。在这样做之前，您setAutoCommit必须false. 默认情况下，自动提交设置为true. 将自动提交设置为true你不能做 a rollback，exception会发生告诉你这一点。

稍后不要忘记autoCommit返回，true否则您可能会使用其他方法获得不可预期的结果。

这是有关如何实现此功能的示例。这只是草图，您可能应该更多地注意如何处理connection,prepared statment等exception。

public void insertAndRollback(Connection connection) {
    try {
        final ArrayList parameters = new ArrayList();

        // Add your parameters to the arraylist
        parameters.add("John");
        parameters.add("Lee");
        parameters.add("Mary");
        parameters.add("Peter");
        parameters.add("Lewis");
        parameters.add("Patrick");

        final String parameterizedQuery = "insert into person (name) values (?)";

        final int batchSize = 5; // Set your batch size here
        int count = 0;
        int aux = 0;

        // Get the total number of '?' in the query
        int totalQueryParameters = Utils.countCharOccurrences(parameterizedQuery, '?');
        final int auxTotalQueryParameters = totalQueryParameters;

        final PreparedStatement preparedStatement = connection.prepareStatement(parameterizedQuery);

        // Auto Commit must be set to false
        connection.setAutoCommit(false);

        for(int i = 0; i < parameters.size(); i++)
        {
            Object obj = parameters.get(i);

            aux++;
            preparedStatement.setObject(aux, obj);

            if(totalQueryParameters == i + 1) { // Because the ArrayList starts from zero.
                // First query "parsed" - > Add to batch
                preparedStatement.addBatch();
                // One query has been added to the batch. Re-adapt the cycle.
                totalQueryParameters = totalQueryParameters + auxTotalQueryParameters;
                aux = 0;
            }

            if(++count % batchSize == 0) {
                preparedStatement.executeBatch();
            }
        }

        preparedStatement.executeBatch(); // insert remaining queries
        preparedStatement.close();
        connection.setAutoCommit(true); // Make it back to default.
    } catch (SQLException ex) {
        // Do the rollback
        doRollback(connection);

        try {
            // Make it back to default.
            connection.setAutoCommit(true);
        } catch (SQLException ex1) {
            ex1.printStackTrace();
        }

        // Dont forget to close the preparedStatement and the connection
        // if you don't need the connection open any more.

        ex.printStackTrace();
    }
}


private void doRollback(Connection c) {
    try {
        c.rollback();
    } catch (SQLException ex) {
        ex.printStackTrace();
    }
}
于 2014-10-11T01:48:42.723 回答
3

事实上 PreparedStatement.executeBatch 并没有澄清这个问题，也许在其他地方，但我确信它不是原子操作，因为 SQL 没有批处理操作，所以 executeBatch 在数据库级别分别执行每个语句。我在 MySQL 上进行了测试：

t1 是具有 n1 INT(11) Not Null 列的空表，autocommit = true

    ResultSet rs1 = conn.createStatement().executeQuery("select count(*) from t1");
    rs1.next();
    System.out.println(rs1.getInt(1));

    String query = "insert into t1 (n1) values(?)";
    PreparedStatement ps = conn.prepareStatement(query);
    ps.setObject(1, 1);
    ps.addBatch();
    ps.setObject(1, null);
    ps.addBatch();
    try {
        ps.executeBatch();
    } catch (Exception e) {
        System.out.println(e);
    }

    ResultSet rs2 = conn.createStatement().executeQuery("select count(*) from t1");
    rs2.next();
    System.out.println(rs2.getInt(1));

它打印

0
java.sql.BatchUpdateException: Column 'n1' cannot be null
1

也就是说，批次中有 2 个插入；第一次成功，第二次失败，仍然 t1 得到 1 行

于 2013-01-31T13:45:11.620 回答
1

棘手的一个， autocommit=true强烈不推荐，执行批处理时。

话虽如此，我建议使用getUpdateCount()和构建逻辑来执行剩余的。

最后commit

于 2013-01-31T12:11:56.260 回答