批量更新操作

批量更新逻辑：

底层真正的批量更新(一次请求发送批量更新语句)

底层循环发送语句(假批量更新)—本质上就是一条一条更新

批量更新逻辑判断

JdbcTemplate

JdbcUtils.supportsBatchUpdates(ps.getConnection())—判断连接是否支持批量更新

publicint[] batchUpdate(Stringsql,finalBatchPreparedStatementSetterpss)throwsDataAccessException {

if(logger.isDebugEnabled()) {

logger.debug("Executing SQL batch update ["+sql+"]");

}

returnexecute(sql,newPreparedStatementCallback() {

publicint[] doInPreparedStatement(PreparedStatementps)throwsSQLException {

try{

intbatchSize=pss.getBatchSize();

InterruptibleBatchPreparedStatementSetteripss=

(pssinstanceofInterruptibleBatchPreparedStatementSetter ?

(InterruptibleBatchPreparedStatementSetter)pss:null);

if(JdbcUtils.supportsBatchUpdates(ps.getConnection())) {

for(inti= 0;i

pss.setValues(ps,i);

if(ipss!=null&&ipss.isBatchExhausted(i)) {

break;

}

ps.addBatch();

}

returnps.executeBatch();

}

else{

ListrowsAffected=newArrayList();

for(inti= 0;i

pss.setValues(ps,i);

if(ipss!=null&&ipss.isBatchExhausted(i)) {

break;

}

rowsAffected.add(ps.executeUpdate());

}

int[]rowsAffectedArray=newint[rowsAffected.size()];

for(inti= 0;i

rowsAffectedArray[i] =rowsAffected.get(i);

}

returnrowsAffectedArray;

}

}

finally{

if(pssinstanceofParameterDisposer) {

((ParameterDisposer)pss).cleanupParameters();

}

}

}

});

}

备注:

Mysql: DatabaseMetaData 直接返回true

publicbooleansupportsBatchUpdates()throwsSQLException {

returntrue;

}

Mysql最终走的原生jdbc Statement----所以

即便JdbcUtils.supportsBatchUpdates(ps.getConnection())为true了也不一定是真正的批处理

Oracle: OracleDatabaseMetaData 直接返回true

oracle最终走的原生jdbc Statement----所以

即便JdbcUtils.supportsBatchUpdates(ps.getConnection())为true了也不一定是真正的批处理

SqlSessionTemplate

第一步：配置一个SqlSessionTemplate, Batch模式

第二步：代码开启事务，必须要开启，只有开启同一个事务，循环insert底层才会只执行addBatch并且不执行executeBatch,最后统一

public void test(){

SqlSessionTemplate template=ApplicationContextUtils.getBean("batchSqlSession",SqlSessionTemplate.class);

for (int i = 0; i < 20000; i++) {

Map m=new HashMap();

m.put("id",i);

m.put("name","test"+i);

m.put("age", 1+i);

template.insert("inpspect.testBatch",m);

}

List list=template.flushStatements();

}

原生jdbc Statement

Mysql

PreparedStatement形式

com.mysql.jdbc .PreparedStatement类:

批量新增的条件:rewriteBatchedStatements为true就可以了

批量修改或者删除:rewriteBatchedStatements为true，并且批量的语句>3条

批量修改或者删除的数量>3(this.batchedArgs.size() > 3)

Statement形式

com.mysql.jdbc. StatementImpl.executeBatch

allowMultiQueries为true或者rewriteBatchedStatements为true并且批量语句大于4条

Oracle

PreparedStatement形式

依赖类:oracle.jdbc.driver. T4CPreparedStatement

Statement形式

依赖oracle.jdbc.driver.T4CStatement。 不支持批量更新操作,因为本质上还是一条sql一次请求，执行完一条再执行下一条。跟mysql不一样，mysql statement模式会分号拼接

数据库配置支持批量更新

Mysql

PreparedStatement形式

设置:rewriteBatchedStatements=true

例如：jdbc:mysql://xxxx:3306/cloud_nms?rewriteBatchedStatements=true&autoReconnect=true&useUnicode=true&noAccessToProcedureBodies=true&characterEncoding=utf8&allowMultiQueries=true

Statement形式

设置:allowMultiQueries=true

Mysql批量更新返回值问题

批量更新的逻辑

PreparedStatement形式

PreparedStatement st=conn.prepareStatement(" insert into test_batch(id,name,age) values(?,?,?)");

for (int i = 20000; i < 20003; i++) {

Map m=new HashMap();

m.put("id",i);

m.put("name","test"+i);

m.put("age", 1+i);

st.setInt(1, i);

st.setString(2, "test"+i);

st.setInt(3,  1+i);

st.addBatch();

}

int[] aa=st.executeBatch();

新增：多个值拼成一条sql语句,多个值逗号分隔

最终拼接成sql: insert into xxx values(1,1,1),(2,2,2),(3,3,3),…..

修改：最终多个语句分号分隔，一次执行

最终拼接成:update xxx set a=xxxx where id=1; update xxx set a=xxxx where id=2; update xxx set a=xxxx where id=3

删除:最终多个语句分号分隔，一次执行

最终拼接成:delete from xxx where id=1; delete from xxx where id=2; delete from xxx where id=3

Statement

新增、修改、删除最终都是以多个语句分号分隔，一次执行

insert into xxx values(1,1,1); insert into xxx values (2,2,2); insert into xxx values (3,3,3);…

oracle

PreparedStatement形式

无需设置，依赖的是oracle的动态sql，绑定参数

Statement形式

不支持，无论怎么设置都不支持

oracle批量更新返回值问题

批量更新的逻辑

PreparedStatement形式

Statement

还是单条执行sql

批量更新的返回值

PreparedStatement形式

String sql="delete test_batch where id=?";

PreparedStatement st= conn.prepareStatement(sql);

for (int i =0; i < 4; i++) {

st.setString(1, "idi"+i+"d");

st.addBatch();

}

Int[] result=st.executeBatch();--返回[-2,-2,-2,-2]

都返回-2

新增、删除、更新返回:[-2,-2,-2] 新增批量执行其实是封装成了一条语句，而这一条语句影响了多行，mysql底层为了返回标准化，就将每条对应更新的结果值人为的赋值-2。-2表示执行成功了

Statement形式

新增、修改、删除都会返回:[0,1,1]---0表示影响了0行，1表示影响了一行.

常见批量更新问题

Mysql环境,使用jdbctempate.batchUpdate方法，或者使用了 原生jdbc的executeBatch方法批量更新的时候，有的语句能成功有的不能成功，但是成功的语句会入库。

原因:没有设置rewriteBatchedStatements=true，导致最终mysql底层还是一条一条的更新，由于没有关闭自动提交，所以执行一条就提交一条。当其中一条报错的时候肯定就不会入库了，对应的该语句的执行结果是-3,然后继续执行后面的语句不会停止的。

最终的结果会是:异常语句失败忽略，正常语句执行成功入库

见下图: com.mysql.jdbc. PreparedStatement. executeBatchSerially方法

问题延伸

如果想要批量执行的语句要么成功要么失败解决办法：

通过设置rewriteBatchedStatements=true,让mysql驱动底层就一次把批量sql发送过去执行，这样只要有一条有问题，那么就都不会执行入库

通过事务控制，如果不设置rewriteBatchedStatements=true，底层是一条一条的发的，那么可以通过手动提交，执行完以后没异常再提交，有异常回滚。最好同时设置continueBatchOnError=false，这样的话，有异常不继续，性能更高