1、批量操作优势
在对数据库进行批量操作时,应分析操作的前后相关性,如果属于大批量的操作,而且前续操作的结果不依赖与后继操作,则完全可以使用批处理来操作DB。
使用批处理的优点:
1. 多个SQL语句的执行,共用一个Connection资源。在对数据库操作时,connection资源是很宝贵的,数据库的维护从某种角度来说,就是减少数据库的连接数,减轻对DB的压力。创建一个数据连接要远远比使用数据库连接消耗资源。这也正是数据库连接池存在的意义。
2. 批处理在效率上总是比逐条处理有优势,要处理的数据的记录条数越大,批处理的优势越明显。在处理大批量相同业务逻辑的DB操作可以使用批处理达到简化、高效处理。
3. 在单一时间段,提高应用与DB间的吞吐量,缩短DB响应时间。大部分应用都有DB操作,如果SQL语句操作不当会导致DB长时间处于不可用状态,或是使DB资源占用率升高,从而影响了应用,最终被DB拖垮。缩短DB的响应时间,一来可以提供应用性能,二来减轻DB压力,对维持高系能的应用有极大的帮助。
2、批量操作的实现(Statement 和 PreparedStatement )
JDBC使用Statement和PreparedStatement实现批处理功能。
PreparedStatement:
1) addBatch()将一组参数添加到PreparedStatement对象内部。
2) executeBatch()将一批参数提交给数据库来执行,如果全部命令执行成功,则返回更新计数组成的数组。
Statement:
1) addBatch(String sql)方法会在批处理缓存中加入一条sql语句。
2) executeBatch()执行批处理缓存中的所有sql语句。
注意:PreparedStatement中使用批量更新时,要先设置好参数后再使用addBatch()方法加入缓存。批量更新中只能使用更改、删除或插入语句。
Statement批量处理和事务代码:
package com.ambow.day20.jdbc.JDBCTestCommitAndRollback;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import com.ambow.day19.jdbc.util.JDBCConAndClo;
/*
*1,首先把Auto commit设置为false,不让它自动提交
*2,进行手动提交(commit)
*3,提交完成后回复现场将Auto commit,还原为true,
*4,当异常发生执行catch中SQLException时,记得要rollback(回滚);
**/
public class StatementCommitAndRollbackTest {
public static void main(String args[]) {
Connection con = null;
Statement stm = null;
try {
con = JDBCConAndClo.getConnectionBao();
stm = con.createStatement();
con.setAutoCommit(false);
// 若不出现异常,则继续执行到try语句完,否则跳转到catch语句中
stm.addBatch("insert into student values(23,'tangbao','高数',100)");
stm.addBatch("insert into student values(24,'王定','c#',98)");
stm.addBatch("insert into student values(25,'王国云','java',90)");
stm.addBatch("insert into student values(26,'溜出','英语',89)");
stm.addBatch("insert into student values(27,'wqde','java',63)");
/*
* int[] executeBatch() throws
* SQLException将一批命令提交给数据库来执行,如果全部命令执行成功,则返回更新计数组成的数组。
*/
stm.executeBatch();
System.out.println("插入成功!");
// commit:若成功执行完所有的插入操作,则正常结束
con.commit();
System.out.println("提交成功!");
con.setAutoCommit(true);
} catch (SQLException e) {
e.printStackTrace();
try {
//rollback: 若出现异常,对数据库中所有已完成的操作全部撤销,则回滚到事务开始状态
if (!con.isClosed()) {
con.rollback();
System.out.println("提交失败,回滚!");
con.setAutoCommit(true);
}
} catch (SQLException e1) {
e1.printStackTrace();
} finally {
JDBCConAndClo.closeStatement(stm);
JDBCConAndClo.closeConnection(con);
}
}
}
}
PreparedStatement批量处理和事务代码:
package com.ambow.day20.jdbc.JDBCTestCommitAndRollback;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import com.ambow.day19.jdbc.util.JDBCConAndClo;
/*
* PreparedStatement:
*1.addBatch() 将一组参数添加到 PreparedStatement对象内部
*2.executeBatch() 将一批参数提交给数据库来执行,如果全部命令执行成功,则返回更新计数组成的数组。
**/
public class PreparedStatementCommitAndRollbackTest {
public static void main(String args[]) {
Connection con = null;
PreparedStatement pstm = null;
try {
// 1. 建立与数据库的连接
con = JDBCConAndClo.getConnectionBao();
// 2. 执行sql语句
// 1).先创建PreparedStatement语句(发送slq请求):
pstm = con.prepareStatement("insert into student values(?,?,?,?)");
con.setAutoCommit(false);//1,首先把Auto commit设置为false,不让它自动提交
// 2) 设置sql语句1
pstm.setInt(1, 33);
pstm.setString(2,"wangqin");
pstm.setString(3, "c++");
pstm.setDouble(4, 78.5);
// 3) 将一组参数添加到此 PreparedStatement 对象的批处理命令中。
pstm.addBatch();
// 2) 设置sql语句2
pstm.setInt(1, 34);
pstm.setString(2,"wuytun");
pstm.setString(3, "c");
pstm.setDouble(4, 77);
// 3) 将一组参数添加到此 PreparedStatement 对象的批处理命令中。
pstm.addBatch();
// 2) 设置sql语句3
pstm.setInt(1, 31);
pstm.setString(2,"tetet");
pstm.setString(3, "c++");
pstm.setDouble(4, 90);
// 3) 将一组参数添加到此 PreparedStatement 对象的批处理命令中。
pstm.addBatch();
// 2) 设置sql语句4
pstm.setInt(1, 32);
pstm.setString(2,"liug");
pstm.setString(3, "c");
pstm.setDouble(4, 50);
// 3) 将一组参数添加到此 PreparedStatement 对象的批处理命令中。
pstm.addBatch();
// 4) 将一批参数提交给数据库来执行,如果全部命令执行成功,则返回更新计数组成的数组。
pstm.executeBatch();
System.out.println("插入成功!");
// 若成功执行完所有的插入操作,则正常结束
con.commit();//2,进行手动提交(commit)
System.out.println("提交成功!");
con.setAutoCommit(true);//3,提交完成后回复现场将Auto commit,还原为true,
} catch (SQLException e) {
e.printStackTrace();
try {
// 若出现异常,对数据库中所有已完成的操作全部撤销,则回滚到事务开始状态
if(!con.isClosed()){
con.rollback();//4,当异常发生执行catch中SQLException时,记得要rollback(回滚);
System.out.println("插入失败,回滚!");
con.setAutoCommit(true);
}
} catch (SQLException e1) {
e1.printStackTrace();
}
}finally{
JDBCConAndClo.closePreparedStatement(pstm);
JDBCConAndClo.closeConnection(con);
}
}
}
使用批处理是有绝对的好处,可是凡事都利必有弊。在使用批处理应用注意以下几点,这些小的细节常常被我们忽略,但是这些细节都对你应用的性能有着至关重要的影响。
1. 使用批出量没有进行分批分量处理。
在使用批处理首先应该注意一点,批处理也不是万能的,批处理都存在一次执行的最大吞吐量限制。正如上面所提到的,批处理在单一时间段提高了与DB间的吞吐量,但是任何DB都是有吞吐量最大限制。当达到或是超过,最大吞吐量的峰值时,容易导致DB过载,更严重会导致DB宕机。例如上面的示例代码,如果入参list长度很大,几万甚至几十万,想想会导致上面结果呢。当然是背道而驰使应用的系能急剧下降,而且给DB带来风险。正确的做法应该是分批分量进行提交。处理执行SQL的时候,批处理的分批的大小与数据库的吞吐量以及硬件配置有很大关系,需要通过测试找到最佳的分批大小,一般在200-2000之间。如下代码:
try {
ps = conn.prepareStatement(sql);
for(int i = 0; i < elms.size(); i++) {
Element elm = (Element) elms.get(i);
if(null == elm || null == elm.getUserId() || null == elm.getState()) {
continue;
}
ps.setInt(1, elm.getStatus());
ps.setString(2, elm.getProcID());
ps.addBatch();
if ((i != 0 && i % 2000 == 0) || i == elms.size() - 1) {
ps.executeBatch();
ps.clearBatch();
ps.close();
ps = conn.prepareStatement(sql);
}
}
} catch (SQLException sqlEx) {
log.warn("[update][state][error][SQLException]");
log.warn(sqlEx);
} catch (Exception e) {
log.warn("[update][state][error][SQLException]");
log.warn(e);
} finally {
DBTools.close(conn, ps, null);
}
2. 使用批处理时,没有关注DB测异常情况,导致批处理失败。
这里涉及到一些异常处理最基本的点。上述例程还有个小小的问题需要注意,当ps.executeBatch()执行时,如果该批次的SQL语句中有一条SQL抛出异常,那么后续的批处理将不会有执行的机会,导致漏执行。所以经过优化后:
try {
ps = conn.prepareStatement(sql);
for(int i = 0; i < elms.size(); i++) {
try {
Element elm = (Element) elms.get(i);
if(null == elm || null == elm.getUserId() || null == elm.getState()) {
continue;
}
ps.setInt(1, elm.getStatus());
ps.setString(2, elm.getProcID());
ps.addBatch();
if ((i != 0 && i % 2000 == 0) || i == elms.size() - 1) {
ps.executeBatch();
ps.clearBatch();
ps.close();
ps = conn.prepareStatement(sql);
}
} catch (SQLException e) {
log.warn("[update][state][error][SQLException]");
log.warn(e);
ps.clearBatch();
ps.close();
ps = conn.prepareStatement(sql);
} catch (Exception e) {
log.warn("[update][state][error][SQLException]");
log.warn(e);
ps.executeBatch();
ps.clearBatch();
ps.close();
ps = conn.prepareStatement(sql);
} finally {
DBTools.close(conn, ps, null);
}
3. 使用批处理时,当批处理中有一条SQL语句优化SQL异常而导致整个批处理失败。
在打印日志时应该注意,以上的打印方式对问题定位没有任何帮助。如上如果其中的一条SQL语句执行失败,那么你不知道究竟是什么异常,因为没有打印异常列,而只打印了最顶层异常。例如:如上程序在DB2数据库中执行失败后,只返回了如下信息com.ibm.db2.jcc.c.vd: Non-atomic batch failure. The batch was submitted, but at least one exception occurred on an individual member of the batch. Use getNextException() to retrieve the exceptions for specific batched elements.大概意思是批处理执行失败,批处理已经提交,但是其中至少有一条或者多条执行失败。使用getNextException来查看执行白失败的SQL语句异常信息,便于定位!可是这样还是有问题,你知道了SQL语句的异常了,但是你不知道究竟是那条SQL语句导致的异常,其实,可以更具批处理执行的返回值来检查执行结果,如下代码:
Int[] results = ps.executeBatch();