关于JDBC的批量操作executeBatch()所引发sql语句异常

java.sql.BatchUpdateException: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '('1512144017', 'quqiang01' at line 1
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
    at com.mysql.jdbc.Util.handleNewInstance(Util.java:425)
    at com.mysql.jdbc.Util.getInstance(Util.java:408)
    at com.mysql.jdbc.SQLError.createBatchUpdateException(SQLError.java:1162)
    at com.mysql.jdbc.PreparedStatement.executeBatchedInserts(PreparedStatement.java:1587)
    at com.mysql.jdbc.PreparedStatement.executeBatchInternal(PreparedStatement.java:1253)
    at com.mysql.jdbc.StatementImpl.executeBatch(StatementImpl.java:970)
Caused by: com.mysql.jdbc.exceptions.jdbc4.MySQLSyntaxErrorException: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near '('1512144017', 'quqiang01' at line 1
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
    at com.mysql.jdbc.Util.handleNewInstance(Util.java:425)
    at com.mysql.jdbc.Util.getInstance(Util.java:408)
    at com.mysql.jdbc.SQLError.createSQLException(SQLError.java:943)
    at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3973)
    at com.mysql.jdbc.MysqlIO.checkErrorPacket(MysqlIO.java:3909)
    at com.mysql.jdbc.MysqlIO.sendCommand(MysqlIO.java:2527)
    at com.mysql.jdbc.MysqlIO.sqlQueryDirect(MysqlIO.java:2680)
    at com.mysql.jdbc.ConnectionImpl.execSQL(ConnectionImpl.java:2487)
    at com.mysql.jdbc.PreparedStatement.executeInternal(PreparedStatement.java:1858)
    at com.mysql.jdbc.PreparedStatement.executeUpdateInternal(PreparedStatement.java:2079)
    at com.mysql.jdbc.PreparedStatement.executeUpdateInternal(PreparedStatement.java:2013)
    at com.mysql.jdbc.PreparedStatement.executeLargeUpdate(PreparedStatement.java:5104)
    at com.mysql.jdbc.PreparedStatement.executeBatchedInserts(PreparedStatement.java:1548)
    ... 5 more

最近在使用JDBC的时候,一个比较坑的细节,就是关于他里面使用PreparedStatement或者Statement 的 addBatch()/executeBatch()的具体实现问题;

不要手贱在你传入的sql语句没末尾加上分号;

具体是这样:

 //以一个批量提交的实现工具举例
 // List<List<Object>> lists: 所有数据的list
 // List<Object>:单条数据"值"的list

 public void batchExecutePstamt(String sql, List < List < Object >> lists) {
     try {
         connection.setAutoCommit(false);
         pstmt = connection.prepareStatement(sql);
         if (lists != null && !lists.isEmpty()) {
             for (List < Object > cList: lists) {
                 if (cList == null || cList.isEmpty())
                     continue;

                 for (int i = 0; i < cList.size(); i++) {
                     pstmt.setObject(i + 1, cList.get(i));
                 }
                 pstmt.addBatch();
             }
             log.info(pstmt.toString());
             pstmt.executeBatch();
             connection.commit();
         }
     } catch (SQLException e) {
         e.printStackTrace();
     }
 }

在这里,我们传入大量的需要插入的对象的List<List<Object>>,里面的 List<Object> 就是某一条具体的记录的值;

如果你调用的时候, 在传入sql的时候, 传入了类似于  insert into `tablename` (name,age) values (?,?); 的sql语句
那么他每次addBatch的时候就会在
com.mysql.jdbc.PreparedStatement.addBatch()的创建com.mysql.jdbc.PreparedStatement.BatchParams 然后放进batchedArgs 静态列表里面

  public void addBatch() throws SQLException {
         synchronized (checkClosed().getConnectionMutex()) {
             if (this.batchedArgs == null) {
                 this.batchedArgs = new ArrayList<Object>();
             }

             for (int i = 0; i < this.parameterValues.length; i++) {
                 checkAllParametersSet(this.parameterValues[i], this.parameterStreams[i], i);
             }

             this.batchedArgs.add(new BatchParams(this.parameterValues, this.parameterStreams, this.isStream, this.streamLengths, this.isNull));
         }
     }

addBatch()

  public class BatchParams {
         public boolean[] isNull = null;

         public boolean[] isStream = null;

         public InputStream[] parameterStreams = null;

         public byte[][] parameterStrings = null;

         public int[] streamLengths = null;

         BatchParams(byte[][] strings, InputStream[] streams, boolean[] isStreamFlags, int[] lengths, boolean[] isNullFlags) {
             //
             // Make copies
             //
             this.parameterStrings = new byte[strings.length][];
             this.parameterStreams = new InputStream[streams.length];
             this.isStream = new boolean[isStreamFlags.length];
             this.streamLengths = new int[lengths.length];
             this.isNull = new boolean[isNullFlags.length];
             System.arraycopy(strings, 0, this.parameterStrings, 0, strings.length);
             System.arraycopy(streams, 0, this.parameterStreams, 0, streams.length);
             System.arraycopy(isStreamFlags, 0, this.isStream, 0, isStreamFlags.length);
             System.arraycopy(lengths, 0, this.streamLengths, 0, lengths.length);
             System.arraycopy(isNullFlags, 0, this.isNull, 0, isNullFlags.length);
         }
     }

 PreparedStatement batchedStatement = null;

BatchParams

然后会在最后使用executeBatch()的时候处理 batchedArgs中的 数据

处理的步骤为:
>> com.mysql.jdbc.StatementImpl.executeBatch()
>> com.mysql.jdbc.PreparedStatement.executeBatchInternal()
这里回去判断你设置的一些参数, 比如connection.getRewriteBatchedStatements(), 这个有助于批量数据处理的参数, 需要在jdbc.url连接中设置 rewriteBatchedStatements = true, 不过好像只针对于某个版本(5.2 ?不确定 )以后的数据操作性能有帮助.
在这里会进入一个将多个PreparedStatement转化为 BLUK 模式的一条语句;(bluk模式不知道的请自行百度)

>> com.mysql.jdbc.PreparedStatement.executeBatchedInserts(int)

这里面有一段源码:

 PreparedStatement batchedStatement = null;

 int batchedParamIndex = 1;
 long updateCountRunningTotal = 0;
 int numberToExecuteAsMultiValue = 0;
 int batchCounter = 0;
 CancelTask timeoutTask = null;
 SQLException sqlEx = null;

 long[]updateCounts = new long[numBatchedArgs];
 //上面不多说

 try {
     //这句会把初始化我们传进来的sql
     //我们传进来的是类似于 insert into  tablename (columns…) values (?,?...)这种
     //到这里相当于初始化成 INSERT INTO tablename` (`name`, `age`) values (** NOT SPECIFIED **, ** NOT SPECIFIED **);
     //然后他会根据顺序传进我们上面所传进的多个已经赋值的PreparedStatement,
     batchedStatement = /* FIXME -if we ever care about folks proxying our MySQLConnection */
         prepareBatchedInsertSQL(locallyScopedConn, numValuesPerBatch);

     if (locallyScopedConn.getEnableQueryTimeouts() && batchTimeout != 0 && locallyScopedConn.versionMeetsMinimum(5, 0, 0)) {
         timeoutTask = new CancelTask(batchedStatement);
         locallyScopedConn.getCancelTimer().schedule(timeoutTask, batchTimeout);
     }

     if (numBatchedArgs < numValuesPerBatch) {
         numberToExecuteAsMultiValue = numBatchedArgs;
     } else {
         numberToExecuteAsMultiValue = numBatchedArgs / numValuesPerBatch;
     }

     int numberArgsToExecute = numberToExecuteAsMultiValue * numValuesPerBatch;

     for (int i = 0; i < numberArgsToExecute; i++) {
         if (i != 0 && i % numValuesPerBatch == 0) {
             try {
                 updateCountRunningTotal += batchedStatement.executeLargeUpdate();
             } catch (SQLException ex) {
                 sqlEx = handleExceptionForBatch(batchCounter - 1, numValuesPerBatch, updateCounts, ex);
             }

             getBatchedGeneratedKeys(batchedStatement);
             batchedStatement.clearParameters();
             batchedParamIndex = 1;

         }
         //@see 这里是关键
         //@see 如果还有后续的PreparedStatement,根据后面的一个参数,那么他就会将batchedStatement设置为:
         // INSERT INTO tablename` (`name`, `age`) values("名字1",'23'), (** NOT SPECIFIED **, ** NOT SPECIFIED **);

         //@see 问题就在这里
         //@see 如果你传入的sql :" insert into  tablename (columns…) values (?,?...);"是这样的,那么生成的单条语句以及单个PreparedStatement没有任何问题,你拿到数据库执行去也OK
         //@see 但是他现在要给你转为BLUK模式的,如果你结尾带了分号,语句就会变成:
         // INSERT INTO tablename` (`name`, `age`) values("名字1",'23');, (** NOT SPECIFIED **, ** NOT SPECIFIED **);然后等待下一次填充参数
         //@see 多的这个分号就是导致sql语句错误的原因

         //@see 有兴趣可以进源码的这个方法看看
         batchedParamIndex = setOneBatchedParameterSet(batchedStatement, batchedParamIndex, this.batchedArgs.get(batchCounter++));
     }

     try {
         updateCountRunningTotal += batchedStatement.executeLargeUpdate();
     } catch (SQLException ex) {
         sqlEx = handleExceptionForBatch(batchCounter - 1, numValuesPerBatch, updateCounts, ex);
     }

     getBatchedGeneratedKeys(batchedStatement);

     numValuesPerBatch = numBatchedArgs - batchCounter;
 }
 finally {
     if (batchedStatement != null) {
         batchedStatement.close();
         batchedStatement = null;
     }
 }