PreparedStatement批处理

什么是批处理?
当我们有多条sql语句需要发送到数据库执行的时候，有两种发送方式，一种是执行一条发送一条sql语句给数据库,另一个种是发送一个sql集合给数据库，也就是发送一个批sql到数据库。普通的执行过程是：每处理一条数据，就访问一次数据库；而批处理是：累积到一定数量，再一次性提交到数据库，减少了与数据库的交互次数，所以效率会大大提高,很显然两者的数据库执行效率是不同的，我们发送批处理sql的时候数据库执行效率要高

statement语句对象实现批处理有如下问题
缺点：采用硬编码效率低，安全性较差。
原理：硬编码，每次执行时相似SQL都会进行编译

PreparedStatement+批处理
优点：语句只编译一次，减少编译次数。提高了安全性（阻止了SQL注入）
原理：相似SQL只编译一次，减少编译次数
注意: 需要设置批处理开启&rewriteBatchedStatements=true

  1. package com.msb.test4;
  2. import java.sql.*;
  3. /**
  4.  * @Author: Ma HaiYang
  5.  * @Description: MircoMessage:Mark_7001
  6.  */
  7. public class TestBatch {
  8.     private static String driver ="com.mysql.cj.jdbc.Driver";
  9.     private static String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true&useServerPrepStmts=true&cachePrepStmts=true&&rewriteBatchedStatements=true";
  10.     private static String user="root";
  11.     private static String password="root";
  12.     public static void main(String[] args) {
  13.         testAddBatch();
  14.     }
  15.     // 定义一个方法,向部门表增加1000条数据
  16.     public static void testAddBatch(){
  17.         Connection connection = null;
  18.         PreparedStatement preparedStatement=null;
  19.         try{
  20.             Class.forName(driver);
  21.             connection = DriverManager.getConnection(url, user,password);
  22.             String sql="insert into dept values (DEFAULT ,?,?)";
  23.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
  24.             //设置参数
  25.             for (int i = 1; i <= 10663; i++) {
  26.                 preparedStatement.setString(1, "name");
  27.                 preparedStatement.setString(2, "loc");
  28.                 preparedStatement.addBatch();// 将修改放入一个批次中
  29.                 if(i%1000==0){
  30.                     preparedStatement.executeBatch();
  31.                     preparedStatement.clearBatch();// 清除批处理中的数据
  32.                 }
  33.             }
  34.             /*
  35.             * 整数数组中的元素代表执行的结果代号
  36.             * SUCCESS_NO_INFO -2
  37.             * EXECUTE_FAILED  -3
  38.             * */
  39.             /*int[] ints = */
  40.             preparedStatement.executeBatch();
  41.             preparedStatement.clearBatch();
  42.         }catch (Exception e){
  43.             e.printStackTrace();
  44.         }finally {
  45.             if(null != preparedStatement){
  46.                 try {
  47.                     preparedStatement.close();
  48.                 } catch (SQLException e) {
  49.                     e.printStackTrace();
  50.                 }
  51.             }
  52.             if(null != connection){
  53.                 try {
  54.                     connection.close();
  55.                 } catch (SQLException e) {
  56.                     e.printStackTrace();
  57.                 }
  58.             }
  59.         }
  60.     }
  61. }

JDBC中使用事务

事务概念:在逻辑上一组不可分割的操作,由多个sql语句组成,多个sql语句要么全都执行成功,要么都不执行. 原子性 一致性 隔离性 持久性
JDBC控制事物主要就是在学习如何让多个数据库操作成为一个整体,实现要么全都执行成功,要么全都不执行
在JDBC中，事务操作是自动提交。一条对数据库的DML(insert、update、delete)代表一项事务操作,操作成功后，系统将自动调用commit()提交，否则自动调用rollback()回滚,在JDBC中，事务操作方法都位于接口java.sql.Connection中,可以通过调用setAutoCommit(false)来禁止自动提交。之后就可以把多个数据库操作的表达式作为一个事务，在操作完成后调用commit()来进行整体提交，倘若其中一个表达式操作失败，都不会执行到commit()，并且将产生响应的异常；此时就可以在异常捕获时调用rollback()进行回滚,回复至数据初始状态.事务开始的边界则不是那么明显了，它会开始于组成当前事务的所有statement中的第一个被执行的时候。事务结束的边界是commit或者rollback方法的调用
preparedStatement.executeBatch(); 方法会直接修改数据数据库中的数据，无法起到事务的作用。

  1. 使用事务保证转账安全性
  2. package com.msb.test5;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.PreparedStatement;
  6. import java.sql.SQLException;
  7. /**
  8.  * @Author: Ma HaiYang
  9.  * @Description: MircoMessage:Mark_7001
  10.  */
  11. public class TestTransaction {
  12.     private static String driver ="com.mysql.cj.jdbc.Driver";
  13.     private static String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true&useServerPrepStmts=true&cachePrepStmts=true&&rewriteBatchedStatements=true";
  14.     private static String user="root";
  15.     private static String password="root";
  16.     public static void main(String[] args) {
  17.         testTransaction();
  18.     }
  19.     // 定义一个方法,向部门表增加1000条数据
  20.     public static void testTransaction(){
  21.         Connection connection = null;
  22.         PreparedStatement preparedStatement=null;
  23.         /*
  24.         * JDBC 默认是自动提交事务
  25.         * 每条DML都是默认提交事务的,多个preparedStatement.executeUpdate();都会提交一次事务
  26.         * 如果想手动控制事务,那么就不能让事务自动提交
  27.         * 通过Connection对象控制connection.setAutoCommit(false);
  28.         * 如果不设置 默认值为true,自动提交,设置为false之后就是手动提交了
  29.         * 无论是否发生回滚,事务最终会一定要提交的 提交我们建议放在finally之中进行提交
  30.         * 如果是转账的过程中出现异常了,那么我们就要执行回滚,回滚操作应该方法catch语句块中
  31.         *
  32.         * */
  33.         try{
  34.             Class.forName(driver);
  35.             connection = DriverManager.getConnection(url, user,password);
  36.             // 设置事务手动提交
  37.             connection.setAutoCommit(false);
  38.             String sql="update account set money =money- ? where aid = ?";
  39.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
  40.             // 转出
  41.             preparedStatement.setDouble(1, 100);
  42.             preparedStatement.setInt(2, 1);
  43.             preparedStatement.executeUpdate();
  44.             // 产生异常
  45.             //int i =1/0;
  46.             // 转入
  47.             preparedStatement.setDouble(1, -100);
  48.             preparedStatement.setInt(2, 2);
  49.             preparedStatement.executeUpdate();
  50.         }catch (Exception e){
  51.             if(null != connection){
  52.                 try {
  53.                     connection.rollback();// 回滚事务
  54.                 } catch (SQLException ex) {
  55.                     ex.printStackTrace();
  56.                 }
  57.             }
  58.             e.printStackTrace();
  59.         }finally {
  60.             // 提交事务
  61.             if(null != connection){
  62.                 try {
  63.                     connection.commit();
  64.                 } catch (SQLException e) {
  65.                     e.printStackTrace();
  66.                 }
  67.             }
  68.             if(null != preparedStatement){
  69.                 try {
  70.                     preparedStatement.close();
  71.                 } catch (SQLException e) {
  72.                     e.printStackTrace();
  73.                 }
  74.             }
  75.             if(null != connection){
  76.                 try {
  77.                     connection.close();
  78.                 } catch (SQLException e) {
  79.                     e.printStackTrace();
  80.                 }
  81.             }
  82.         }
  83.     }
  84. }
  1. 设置回滚点
  2. package com.msb.test5;
  3. import java.sql.*;
  4. import java.util.LinkedList;
  5. /**
  6.  * @Author: Ma HaiYang
  7.  * @Description: MircoMessage:Mark_7001
  8.  */
  9. public class TestTransaction2 {
  10.     private static String driver ="com.mysql.cj.jdbc.Driver";
  11.     private static String url="jdbc:mysql://127.0.0.1:3306/mydb?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&allowPublicKeyRetrieval=true&useServerPrepStmts=true&cachePrepStmts=true&&rewriteBatchedStatements=true";
  12.     private static String user="root";
  13.     private static String password="root";
  14.     public static void main(String[] args) {
  15.         testAddBatch();
  16.     }
  17.     // 定义一个方法,向部门表增加1000条数据
  18.     public static void testAddBatch(){
  19.         Connection connection = null;
  20.         PreparedStatement preparedStatement=null;
  21.         LinkedList<Savepoint> savepoints =new LinkedList<Savepoint>();
  22.         try{
  23.             Class.forName(driver);
  24.             connection = DriverManager.getConnection(url, user,password);
  25.             connection.setAutoCommit(false);
  26.             String sql="insert into dept values (DEFAULT ,?,?)";
  27.             preparedStatement = connection.prepareStatement(sql);//这里已经传入SQL语句
  28.             //设置参数
  29.             for (int i = 1; i <= 10663; i++) {
  30.                 preparedStatement.setString(1, "name");
  31.                 preparedStatement.setString(2, "loc");
  32.                 preparedStatement.addBatch();// 将修改放入一个批次中
  33.                 if(i%1000==0){
  34.                     preparedStatement.executeBatch();
  35.                     preparedStatement.clearBatch();// 清除批处理中的数据
  36.                     // 设置回滚点
  37.                     Savepoint savepoint = connection.setSavepoint();
  38.                     savepoints.addLast(savepoint);
  39.                 }
  40.                 // 数据在 100001条插入的时候出现异常
  41.                 if(i ==10001){
  42.                     int x =1/0;
  43.                 }
  44.             }
  45.             /*
  46.             * 整数数组中的元素代表执行的结果代号
  47.             * SUCCESS_NO_INFO -2
  48.             * EXECUTE_FAILED  -3
  49.             * */
  50.             /*int[] ints = */
  51.             preparedStatement.executeBatch();
  52.             preparedStatement.clearBatch();
  53.         }catch (Exception e){
  54.             if(null != connection){
  55.                 try {
  56.                     //Savepoint sp = savepoints.getLast();
  57.                     Savepoint sp = savepoints.get(4);
  58.                     if(null != sp){
  59.                         // 选择回滚点
  60.                         connection.rollback(sp);// 回滚
  61.                     }
  62.                 } catch (SQLException e2) {
  63.                     e2.printStackTrace();
  64.                 }
  65.             }
  66.             e.printStackTrace();
  67.         }finally {
  68.             if(null != connection){
  69.                 try {
  70.                     connection.commit();// 提交
  71.                 } catch (SQLException e) {
  72.                     e.printStackTrace();
  73.                 }
  74.             }
  75.             if(null != preparedStatement){
  76.                 try {
  77.                     preparedStatement.close();
  78.                 } catch (SQLException e) {
  79.                     e.printStackTrace();
  80.                 }
  81.             }
  82.             if(null != connection){
  83.                 try {
  84.                     connection.close();
  85.                 } catch (SQLException e) {
  86.                     e.printStackTrace();
  87.                 }
  88.             }
  89.         }
  90.     }
  91. }