JDBC提供了数据库batch处理的能力，在数据大批量操作（新增、删除等）的情况下可以大幅度提升系统的性能。我以前接触的一个项目，在没有采用batch处理时，删除5万条数据大概要半个小时左右，后来对系统进行改造，采用了batch处理的方式，删除5万条数据基本上不会超过1分钟。看一段JDBC代码：

// 关闭自动执行
con.setAutoCommit(false);
Statement stmt = con.createStatement();

stmt.addBatch("INSERT INTO employees VALUES (1000, 'Joe Jones')");
stmt.addBatch("INSERT INTO departments VALUES (260, 'Shoe')");
stmt.addBatch("INSERT INTO emp_dept VALUES (1000, 260)");

// 提交一批要执行的更新命令
int[] updateCounts = stmt.executeBatch();

    本例中禁用了自动执行模式，从而在调用 Statement.executeBatch() 时可以防止 JDBC 执行事务处理。禁用自动执行使得应用程序能够在发生错误及批处理中的某些命令不能执行时决定是否执行事务处理。因此，当进行批处理更新时，通常应该关闭自动执行。

    在JDBC 2.0 中，Statement 对象能够记住可以一起提交执行的命令列表。创建语句时，与它关联的命令列表为空。Statement.addBatch() 方法为调用语句的命令列表添加一个元素。如果批处理中包含有试图返回结果集的命令，则当调用 Statement. executeBatch() 时，将抛出 SQLException。只有 DDL 和 DML 命令（它们只返回简单的更新计数）才能作为批处理的一部分来执行。如果应用程序决定不提交已经为某语句构
造的命令批处理，则可以调用方法 Statement.clearBatch()（以上没有显示）来重新设置批处理。

    Statement.executeBatch() 方法将把命令批处理提交给基本 DBMS 来执行。命令的执行将依照在批处理中的添加顺序来进行。ExecuteBatch() 为执行的命令返回更新计数数组。数组中对应于批处理中的每个命令都包含了一项，而数组中各元素依据命令的执行顺序（这还是和命令的最初添加顺序相同）来排序。调用executeBatch() 将关闭发出调用的 Statement 对象的当前结果集（如果有一个结果集是打开的）。executeBatch() 返回后，将重新将语句的内部批处理命令列表设置为空。

    如果批处理中的某个命令无法正确执行，则 ExecuteBatch() 将抛出BatchUpdateException。可以调用BatchUpdateException.getUpdateCounts() 方法来为批处理中成功执行的命令返回更新计数的整型数组。因为当有第一个命令返回错误时，Statement.executeBatch() 就中止，而且这些命令是依据它们在批处理中的添加顺序而执行的。所以如果 BatchUpdateException.getUpdateCounts() 所返回的数组包含 N 个元素，这就意味着在调用 executeBatch() 时批处理中的前 N 个命令被成功执行。用PreparedStatement 可以象下面这样写代码：


// 关闭自动执行
con.setAutoCommit(false);
PreparedStatement stmt = con.prepareStatement("INSERT INTO employees VALUES (?, ?)");

stmt.setInt(1, 2000);
stmt.setString(2, "Kelly Kaufmann");
stmt.addBatch();

// 提交要执行的批处理
int[] updateCounts = stmt.executeBatch();

========================================

PrepareStatement 也是接口
PrepareStatement extends Statement
PrepareStatement 本身没有 int[] executeBatch() throws SQLException 方法
而是继承了Statement的方法，且它们都是接口没有实际实现方法，但Statement
接口对executeBatch()方法做了规范
/**
     * Submits a batch of commands to the database for execution and
     * if all commands execute successfully, returns an array of update counts.
       每次提交一批命令到数据库中执行，如果所有的命令都成功执行了，那么返回一个
       数组，这个数组是说明每条命令所影响的行数
     * The <code>int</code> elements of the array that is returned are ordered
     * to correspond to the commands in the batch, which are ordered
     * according to the order in which they were added to the batch.
       返回的数组中每个整型值都是排过序的，它们的顺序和批量处理中的命令们是一致的，
       命令的顺序是按照它们被加到批处理中的顺序一致。
     * The elements in the array returned by the method <code>executeBatch</code>
     * may be one of the following:
       executeBatch方法返回的数组中的元素可能是下面几种情形之一：
     * <OL>
     * <LI>A number greater than or equal to zero -- indicates that the
     * command was processed successfully and is an update count giving the
     * number of rows in the database that were affected by the command's
     * execution
       一个大于或等于零的数字，简单说来命令成功执行后就返回它所影响到的行的数目
     * <LI>A value of <code>SUCCESS_NO_INFO</code> -- indicates that the command was
     * processed successfully but that the number of rows affected is
     * unknown
       
      * The constant indicating that a batch statement executed successfully
      * but that no count of the number of rows it affected is available.
      int SUCCESS_NO_INFO = -2;
      常量SUCCESS_NO_INFO代表的值＝-2,也就是说命令执行成功了但命令影响到的行数
      无法统计，是未知的，只能返回SUCCESS_NO_INFO来说明命令执行情况。
     * <P> * If one of the commands in a batch update fails to execute properly,
     * this method throws a <code>BatchUpdateException</code>, and a JDBC
     * driver may or may not continue to process the remaining commands in
     * the batch.
       如果批量处理时其中一个命令执行失败，则会抛出一个异常BatchUpdateException
       JDBC驱动可能会停止剩余的命令，也可能继续执行剩余的命令。
     * However, the driver's behavior must be consistent with a
     * particular DBMS, either always continuing to process commands or never
     * continuing to process commands.
       不管怎样，驱动要怎么做取决于数据库管理系统的细节，总是执行或总是不执行两者其一。
     * If the driver continues processing
     * after a failure, the array returned by the method
     * <code>BatchUpdateException.getUpdateCounts</code>
     * will contain as many elements as there are commands in the batch, and
     * at least one of the elements will be the following:
       发生失败后如果驱动继续执行，通过BatchUpdateException.getUpdateCounts()方法返回
       的数组应该包括批处理中有的那些命令的结果，并且至少有一个元素的值是下面的情况：
     * <P>
     * <LI>A value of <code>EXECUTE_FAILED</code> -- indicates that the command failed
     * to execute successfully and occurs only if a driver continues to
     * process commands after a command fails
           int EXECUTE_FAILED = -3;
           指示命令没有成功执行的常量值EXECUTE_FAILED，并且只有在命令出错后驱动继续执行的情况下才会出现，
           如果出错后不再执行，则返回的结果中没有错误信息只有那些被成功执行后的结果。
     * </OL>
     * <P> * A driver is not required to implement this method.
     * The possible implementations and return values have been modified in
     * the Java 2 SDK, Standard Edition, version 1.3 to
     * accommodate the option of continuing to proccess commands in a batch
     * update after a <code>BatchUpdateException</code> obejct has been thrown.
       驱动不实现此方法，可能会出现的实现和返回值在Java 2 SDK，Standard Edition,
       version 1.3 ，以适应批处理时抛出BatchUpdateException 异常后是继续执行还是
       终止执行的选项。
      
     * @return an array of update counts containing one element for each
     * command in the batch. The elements of the array are ordered according
     * to the order in which commands were added to the batch.
       返回一个和添加命令时的顺序一样的数组结果
     * @exception SQLException if a database access error occurs or the
     * driver does not support batch statements. Throws {@link BatchUpdateException}
     * (a subclass of <code>SQLException</code>) if one of the commands sent to the
     * database fails to execute properly or attempts to return a result set.
     * @since 1.3
     */
       如果数据库访问异常或驱动不支持批处理命令，或者如果一个命令发送到数据库时失败或尝试取得结果集
       时失败，都会抛一个异常BatchUpdateException 它是SQLException的子类。

executeBatch()方法：用于成批地执行SQL语句，但不能执行返回值是ResultSet结果集的SQL语句，而是直接执行stmt.executeBatch(); 
addBatch()：向批处理中加入一个更新语句。 
clearBatch()：清空批处理中的更新语句

 public void executeBatch() throws SQLException {
            Connection con = Toolkit. getMySqlConnection();
            String sql = "xxx";
            String sql_2 = "xxx";

            Statement st = null;
           // Statement、PreparedStatement（它从 Statement 继承而来）和CallableStatement（它从 PreparedStatement 继承而来）。它们都专用于发送特定类型的 SQL 语句：Statement 对象用于执行不带参数的简单 SQL 语句；PreparedStatement 对象用于执行带或不带 IN参数的预编译 SQL 语句；CallableStatement 对象用于执行对数据库已存储过程的调用。
             try {
                   st = con.createStatement();

                   //conn.setAutoCommit()的功能是每执行一条SQL语句，就作为一次事务提交。但一般在项目中很有可能需要执行多条SQL语句作为一个事务。若有一个执行不成功,就会rollback（）；当true的时候可启用自动提交模式，false可禁用该模式
                   con.setAutoCommit(false);
                   //使用addBatch()添加SQL语句
                   st.addBatch(sql);
                   st.addBatch(sql_2);
                   st.addBatch(....);
                //使用executeBatch()执行批量sql语句
                   st.executeBatch();
                   con.commit();
            } catch (SQLException e) {
                   loger.info(e.getMessage());
            } finally {
                  Toolkit. close(con);
                  st.close();
            }
      }

实现批处理addBatch，executeBatch

l业务场景：当需要向数据库发送一批SQL语句执行时，应避免向数据库一条条的发送执行，而应采用JDBC的批处理机制，以提升执行效率。
l实现批处理有两种方式，第一种方式：
•Statement.addBatch(sql)
l执行批处理SQL语句
•executeBatch()方法：执行批处理命令
•clearBatch()方法：清除批处理命令


Connection conn = null;
Statement st = null;
ResultSet rs = null;
try {
conn = JdbcUtil.getConnection();
String sql1 = "insert into user(name,password,email,birthday)
  values('kkk','123','abc@sina.com','1978-08-08')";
String sql2 = "update user set password='123456' where id=3";
st = conn.createStatement();
st.addBatch(sql1);  //把SQL语句加入到批命令中
st.addBatch(sql2);  //把SQL语句加入到批命令中
st.executeBatch();
} finally{
  JdbcUtil.free(conn, st, rs);
}


l采用Statement.addBatch(sql)方式实现批处理：
•优点：可以向数据库发送多条不同的ＳＱＬ语句。
•缺点：
•SQL语句没有预编译。
•当向数据库发送多条语句相同，但仅参数不同的SQL语句时，需重复写上很多条SQL语句。例如：
  Insert into user(name,password) values(‘aa’,’111’);
  Insert into user(name,password) values(‘bb’,’222’);
  Insert into user(name,password) values(‘cc’,’333’);
  Insert into user(name,password) values(‘dd’,’444’);


l实现批处理的第二种方式：
•PreparedStatement.addBatch()
conn = JdbcUtil.getConnection();
String sql = "insert into user(name,password,email,birthday) values(?,?,?,?)";
st = conn.prepareStatement(sql);
for(int i=0;i<50000;i++){
st.setString(1, "aaa" + i);
st.setString(2, "123" + i);
st.setString(3, "aaa" + i + "@sina.com");
st.setDate(4,new Date(1980, 10, 10));
st.addBatch();
if(i%1000==0){
st.executeBatch();
st.clearBatch();
}
}
st.executeBatch();
l采用PreparedStatement.addBatch()实现批处理
•优点：发送的是预编译后的SQL语句，执行效率高。
•缺点：只能应用在SQL语句相同，但参数不同的批处理中。因此此种形式的批处理经常用于在同一个表中批量插入数据，或批量更新表的数据。

• sql