Statement和PreparedStatement批量更新

优势：1.节省传递时间。 2.并发处理。

PreparedStatement：

1） addBatch()将一组参数添加到PreparedStatement对象内部。

2） executeBatch()将一批参数提交给数据库来执行，如果全部命令执行成功，则返回更新计数组成的数组。

Statement：

1） addBatch(String sql)方法会在批处理缓存中加入一条sql语句。

2） executeBatch()执行批处理缓存中的所有sql语句。

注意：PreparedStatement中使用批量更新时，要先设置好参数后再使用addBatch()方法加入缓存。批量更新中只能使用更改、删除或插入语句。

Java代码  

1. Statement批量处理和事务代码如下：
2. package com.ambow.day20.jdbc.JDBCTestCommitAndRollback;
3. import java.sql.Connection;
4. import java.sql.SQLException;
5. import java.sql.Statement;
6. import com.ambow.day19.jdbc.util.JDBCConAndClo;
7. /*
8. *1,首先把Auto commit设置为false,不让它自动提交
9. *2,进行手动提交（commit）
10. *3,提交完成后回复现场将Auto commit,还原为true,
11. *4,当异常发生执行catch中SQLException时，记得要rollback(回滚)；
12. * */
13. public class StatementCommitAndRollbackTest {
14. public static void main(String args[]) {
15. Connection con = null;
16. Statement stm = null;
17. try {
18. con = JDBCConAndClo.getConnectionBao();
19. stm = con.createStatement();
20. con.setAutoCommit(false);
21. // 若不出现异常，则继续执行到try语句完，否则跳转到catch语句中
22. stm.addBatch("insert into student values(23,‘tangbao‘,‘高数‘,100)");
23. stm.addBatch("insert into student values(24,‘王定‘,‘c#‘,98)");
24. stm.addBatch("insert into student values(25,‘王国云‘,‘java‘,90)");
25. stm.addBatch("insert into student values(26,‘溜出‘,‘英语‘,89)");
26. stm.addBatch("insert into student values(27,‘wqde‘,‘java‘,63)");
27. /*
28. * int[] executeBatch() throws
29. * SQLException将一批命令提交给数据库来执行，如果全部命令执行成功，则返回更新计数组成的数组。
30. */
31. stm.executeBatch();
32. System.out.println("插入成功!");
33. // commit:若成功执行完所有的插入操作，则正常结束
34. con.commit();
35. System.out.println("提交成功!");
36. con.setAutoCommit(true);
37. } catch (SQLException e) {
38. e.printStackTrace();
39. try {
40. //rollback: 若出现异常，对数据库中所有已完成的操作全部撤销，则回滚到事务开始状态
41. if (!con.isClosed()) {
42. con.rollback();
43. System.out.println("提交失败，回滚！");
44. con.setAutoCommit(true);
45. }
46. } catch (SQLException e1) {
47. e1.printStackTrace();
48. } finally {
49. JDBCConAndClo.closeStatement(stm);
50. JDBCConAndClo.closeConnection(con);
51. }
52. }
53. }
54. }
55. PreparedStatement批量处理和事务代码如下：
56. package com.ambow.day20.jdbc.JDBCTestCommitAndRollback;
57. import java.sql.Connection;
58. import java.sql.PreparedStatement;
59. import java.sql.SQLException;
60. import com.ambow.day19.jdbc.util.JDBCConAndClo;
61. /*
62. * PreparedStatement:
63. 1.addBatch() 将一组参数添加到 PreparedStatement对象内部
64. 2.executeBatch() 将一批参数提交给数据库来执行，如果全部命令执行成功，则返回更新计数组成的数组。
65. *
66. */
67. public class PreparedStatementCommitAndRollbackTest {
68. public static void main(String args[]) {
69. Connection con = null;
70. PreparedStatement pstm = null;
71. try {
72. // 1. 建立与数据库的连接
73. con = JDBCConAndClo.getConnectionBao();
74. // 2. 执行sql语句
75. // 1).先创建PreparedStatement语句(发送slq请求）：
76. pstm = con.prepareStatement("insert into student values(?,?,?,?)");
77. con.setAutoCommit(false);//1,首先把Auto commit设置为false,不让它自动提交
78. // 2) 设置sql语句1
79. pstm.setInt(1, 33);
80. pstm.setString(2,"wangqin");
81. pstm.setString(3, "c++");
82. pstm.setDouble(4, 78.5);
83. // 3) 将一组参数添加到此 PreparedStatement 对象的批处理命令中。
84. pstm.addBatch();
85. // 2) 设置sql语句2
86. pstm.setInt(1, 34);
87. pstm.setString(2,"wuytun");
88. pstm.setString(3, "c");
89. pstm.setDouble(4, 77);
90. // 3) 将一组参数添加到此 PreparedStatement 对象的批处理命令中。
91. pstm.addBatch();
92. // 2) 设置sql语句3
93. pstm.setInt(1, 31);
94. pstm.setString(2,"tetet");
95. pstm.setString(3, "c++");
96. pstm.setDouble(4, 90);
97. // 3) 将一组参数添加到此 PreparedStatement 对象的批处理命令中。
98. pstm.addBatch();
99. // 2) 设置sql语句4
100. pstm.setInt(1, 32);
101. pstm.setString(2,"liug");
102. pstm.setString(3, "c");
103. pstm.setDouble(4, 50);
104. // 3) 将一组参数添加到此 PreparedStatement 对象的批处理命令中。
105. pstm.addBatch();
106. // 4) 将一批参数提交给数据库来执行，如果全部命令执行成功，则返回更新计数组成的数组。
107. pstm.executeBatch();
108. System.out.println("插入成功！");
109. // 若成功执行完所有的插入操作，则正常结束
110. con.commit();//2,进行手动提交（commit）
111. System.out.println("提交成功!");
112. con.setAutoCommit(true);//3,提交完成后回复现场将Auto commit,还原为true,
113. } catch (SQLException e) {
114. e.printStackTrace();
115. try {
116. // 若出现异常，对数据库中所有已完成的操作全部撤销，则回滚到事务开始状态
117. if(!con.isClosed()){
118. con.rollback();//4,当异常发生执行catch中SQLException时，记得要rollback(回滚)；
119. System.out.println("插入失败，回滚！");
120. con.setAutoCommit(true);
121. }
122. } catch (SQLException e1) {
123. e1.printStackTrace();
124. }
125. }finally{
126. JDBCConAndClo.closePreparedStatement(pstm);
127. JDBCConAndClo.closeConnection(con);
128. }
129. }
130. }

<!--EndFragment-->