JDBC(4)：批处理、存储过程和事务

最新推荐文章于 2024-04-30 07:30:00 发布
最新推荐文章于 2024-04-30 07:30:00 发布
阅读量996 收藏
点赞数
分类专栏： jdbc 文章标签： 批处理 JDBC-+
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/NowUSeeMe/article/details/54917517
版权

批处理

需求

当需要向数据库发送一批SQL语句执行时，应避免向数据库一条条的发送执行，而应采用JDBC的批处理机制，以提升执行效率。

主要API

添加批处理

void  addBatch(String sql)

执行批处理

int[] executeBatch()

清空批处理

void  clearBatch()

案例

程序有100个UserInfo对象（list集合），需要插入数据库，使用JDBC的批处理解决
表user_info结构

CREATE TABLE `user_info` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(20) DEFAULT NULL,
  `password` varchar(20) DEFAULT NULL,
  PRIMARY KEY (`id`)
)

批处理实现方式1：Statement.addBatch(sql)

@Test
public void BatchTest1(){
    String driver = "com.mysql.jdbc.Driver";
    String url = "jdbc:mysql://127.0.0.1:3306/address";
    String user = "root";
    String pwd = "password";
    Connection conn = null;
    Statement statement = null;

    String sql1 = "insert into user_info(username,password) values('now','123')";
       String sql2 = "update user_info set password='2333' where id=3";
       try {
           //获取连接
        Class.forName(driver);
           conn = (Connection) DriverManager.getConnection(url,user, pwd);
        statement = (Statement) conn.createStatement();
        statement.addBatch(sql1);  //把SQL语句加入到批命令中
        statement.addBatch(sql2);  //把SQL语句加入到批命令中
        statement.executeBatch();
       } catch (Exception e) {
           e.printStackTrace();
       } finally {
           if (statement != null) {
               try {
                statement.close();
               } catch (SQLException e) {
                   e.printStackTrace();
                   throw new RuntimeException(e);
               }
           }
           if (conn != null) {
               try {
                   conn.close();
               } catch (SQLException e) {
                   e.printStackTrace();
                   throw new RuntimeException(e);
               }
           }
   }
}
采用Statement.addBatch(sql)方式实现批处理：

优点：
　　可以向数据库发送多条不同的ＳＱＬ语句。
缺点：
　　1.SQL语句没有预编译。
　　2.当向数据库发送多条语句相同，但仅参数不同的SQL语句时，需重复写上很多条SQL语句。如：

insert into user_info(username,password) values('user1','123');
insert into user_info(username,password) values('user2','123')；
insert into user_info(username,password) values('user3','123');
insert into user_info(username,password) values('user4','123')；

批处理实现方式2：PreparedStatement.addBatch()

@Test
public void BatchTest2(){
    String driver = "com.mysql.jdbc.Driver";
    String url = "jdbc:mysql://127.0.0.1:3306/address";
    String user = "root";
    String pwd = "password";
    Connection conn = null;
    PreparedStatement psmt = null;

    String sql = "insert into user_info(username,password) values(?,?)";
       try {
           //获取连接
        Class.forName(driver);
           conn = (Connection) DriverManager.getConnection(url,user, pwd);
           psmt =  (PreparedStatement) conn.prepareStatement(sql);
           for (int i = 0; i < 100; i++) {
            psmt.setString(1, "user"+i);
            psmt.setString(2, "pwd"+i);
            psmt.addBatch();
        }
        psmt.executeBatch();
       } catch (Exception e) {
           e.printStackTrace();
       } finally {
           if (psmt != null) {
               try {
                psmt.close();
               } catch (SQLException e) {
                   e.printStackTrace();
                   throw new RuntimeException(e);
               }
           }
           if (conn != null) {
               try {
                   conn.close();
               } catch (SQLException e) {
                   e.printStackTrace();
                   throw new RuntimeException(e);
               }
           }
   }

}
采用PreparedStatement.addBatch()实现批处理

优点：
　　发送的是预编译后的SQL语句，执行效率高。
缺点：
　　只能应用在SQL语句相同，但参数不同的批处理中。因此此种形式的批处理经常用于在同一个表中批量插入数据，或批量更新表的数据。

存储过程

创建存储过程

表user_info结构：

名类型长度小数点允许空值是否主键
idint110no是
usernamevarchar200yes否
passwordvarchar200yes否

新建一个存储过程

my_procedure1:

CREATE PROCEDURE my_procedure1(IN inputId INT)
BEGIN
    SELECT * FROM user_info WHERE id=inputId;
END

sql调用以及输出结果

SQL语句：CALL pro_findById(5);
输出结果：

idusernamepassword
1user1pwd1
2user2pwd2
3user3pwd3

java代码调用及输出结果

    @Test
    public void testCall() {
        String driver = "com.mysql.jdbc.Driver";
        String url = "jdbc:mysql://127.0.0.1:3306/address";
        String user = "root";
        String pwd = "password";
        Connection conn = null;
        PreparedStatement preparedStatement = null;
        ResultSet resultSet = null;
        String sql = "CALL my_procedure1(?)";
        try {
            Class.forName(driver);
            conn = (Connection) DriverManager.getConnection(url,user, pwd);
            preparedStatement =  (PreparedStatement) conn.prepareStatement(sql);
            preparedStatement.setInt(1, 3);
            resultSet = preparedStatement.executeQuery();
            while( resultSet.next() ){
                   String username = resultSet.getString("username");
                   String password =resultSet.getString("password");
                   System.out.println("username:"+username +" password:"+password);
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        } finally {
            if (preparedStatement != null) {
                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
            }
        }    
    }

输出结果：

username:user3 password:pwd3

创建带有输出参数的存储过程

有输出参数的存储过程，在使用java调用时没有ResultSet返回，是通过输出参数来获取执行结果的

新建一个有输出参数的存储过程

my_procedure2:

CREATE PROCEDURE my_procedure2(IN inputId INT, OUT  outputname VARCHAR(20))
BEGIN
    SELECT username into outputname FROM user_info WHERE id=inputId;
END

输入参数为inputId，输出参数为outputname

sql调用以及输出结果

SQL语句（@name=outputname）：CALL my_procedure2(3,@name);
获取输出参数结果：SELECT @name;
输出结果：

@name
user3

java代码调用及输出结果

    @Test
    public void testCall2() {
        String driver = "com.mysql.jdbc.Driver";
        String url = "jdbc:mysql://192.168.1.20:3306/address";
        String user = "root";
        String pwd = "zaqwsx123";
        Connection conn = null;
        CallableStatement  cstmt = null;  
        String sql = "CALL my_procedure2(?,?)";
        try {
            Class.forName(driver);
            conn = (Connection) DriverManager.getConnection(url,user, pwd);
            cstmt =   (CallableStatement) conn.prepareCall(sql); //这里调用方法不同与testCall那个方法里面的方法，返回的Statement子类也不一样
            cstmt.setInt(1, 3);
            //设置输出参数(注册输出参数)
            //参数一：参数位置
            //参数二：存储过程中的输出参数的jdbc类型  VARCHAR(20)
            cstmt.registerOutParameter(2, java.sql.Types.VARCHAR);
            cstmt.executeQuery();//结果不是返回到结果集中，而是返回到输参数中
            //得到输出参数的值
            // 索引值：预编译sql中的输出参数的位置
            String res = cstmt.getString(2);//专门获取存储过程中的输出参数
            System.out.println(res);
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        } finally {
            if (cstmt != null) {
                try {
                    cstmt.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
            }
        }    
    }

输出结果：

user3

事务

定义

事务是指作为单个逻辑工作单元执行的一系列操作，要么完全地执行，要么完全地不执行。
特性：原子性、一致性、隔离性、持久性（简称ACID）。

事务的三个方法

java.sql.Connection类中存在关于事务的三个方法：
- 关闭自动提交 Connection.setAutoCommit(false);
- 开启事务 Connection.rollback();
- 回滚事务 Connection.commit(); —提交事务

典型案例

前提

假设存在一张账户表（mysql表引擎必须为InnoDB，才支持事务）， 表建立如下SQL语句，有用户名和账号余额字段，存在用户zhangsan和lisi，余额分别为5000和3000。

CREATE TABLE `account` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(20) DEFAULT NULL,
  `balance` double DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE= InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
idusernamebalance
1zhangsan5000
2lisi3000

案例1

张三向李四转让了1000，此时张三和李四余额分别为4000和1000，映射到具体代码即为执行两条SQL语句：1，将用户zhangsan的余额改为4000 2.将lisi的余额改为4000。假如执行完1后突然系统异常，2没执行。这是不允许的，我们希望1也能回滚一下，即将用户zhangsan的余额重改为5000。这个时候就需要用到事务。
使用事务代码：

  @Test
  public void trans1(){
        String driver = "com.mysql.jdbc.Driver";
        String url = "jdbc:mysql://127.0.0.1:3306/address";
        String user = "root";
        String pwd = "password";
        Connection conn = null;
        PreparedStatement preparedStatement = null;

        String sql_zs = "update account set balance=balance-1000 where username='zhangsan'";
        String sql_ls = "update account set balance=balance+1000 where username='lisi' 2333"; //人为设置SQL语句错误
        try {
            //获取连接
            Class.forName(driver);
            conn = (Connection) DriverManager.getConnection(url,user, pwd);

            conn.setAutoCommit(false);  //开启事务，需手动进行提交
            //------------第一次  张三-1000-----------------------
            preparedStatement =  (PreparedStatement) conn.prepareStatement(sql_zs);
            preparedStatement.executeUpdate();

            //------------第二次  李四+1000-----------------------
            preparedStatement = (PreparedStatement) conn.prepareStatement(sql_ls);
            preparedStatement.executeUpdate();

        } catch (Exception e) {

            try {
                conn.rollback(); //发生异常时，进行事务回滚操作
            } catch (SQLException e1) {
                e1.printStackTrace();
            } 
            e.printStackTrace();
            throw new RuntimeException(e);
        } finally {
              try {
                conn.commit();  //最终提交事务
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
            if (preparedStatement != null) {
                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
            }
       }
   }

以上代码中，人为设置SQL语句String sql_lisi错误。不用事务提交回滚的话将会出现zhangsan的账户余额改为4000，而lisi的账户余额没变的情况。使用事务回滚zhangsan和lisi账户余额都没变。

案例2

张三第一次向李四转让了1000，此时转让成功，操作也都执行了，张三李四余额分别为都4000。第二次李四发现张三转多了，向张三转回500，这次出错了，错误跟案例1类似。也能回滚一下，但会滚到第一次转账结束后即可，这个时候需要用到SavePoint。

 @Test
  public void trans2(){
        String driver = "com.mysql.jdbc.Driver";
        String url = "jdbc:mysql://127.0.0.1:3306/address";
        String user = "root";
        String pwd = "password";
        Connection conn = null;
        PreparedStatement preparedStatement = null;

        String sql_zs1 = "update account set balance=balance-1000 where username='zhangsan'";
        String sql_ls1 = "update account set balance=balance+1000 where username='lisi'";

        Savepoint savepoint = null;

        String sql_zs2 = "update account set balance=balance+500 where username='zhangsan'";
        String sql_ls2 = "update account set balance=balance-500 where username='lisi' 23333";

        try {
            //获取连接
            Class.forName(driver);
            conn = (Connection) DriverManager.getConnection(url,user, pwd);

            conn.setAutoCommit(false);  //开启事务，需手动进行提交
            //------------第一次  张三-1000   李四+1000  假设执行成功-----------------------
            preparedStatement =  (PreparedStatement) conn.prepareStatement(sql_zs1);
            preparedStatement.executeUpdate();
            preparedStatement = (PreparedStatement) conn.prepareStatement(sql_ls1);
            preparedStatement.executeUpdate();
            //设置回滚点
            savepoint = conn.setSavepoint();
            //------------第二次   张三+500   李四-500 sql语句出错-----------------------
            preparedStatement =  (PreparedStatement) conn.prepareStatement(sql_zs2);
            preparedStatement.executeUpdate();
            preparedStatement = (PreparedStatement) conn.prepareStatement(sql_ls2);
            preparedStatement.executeUpdate();

        } catch (Exception e) {

            try {
                conn.rollback(savepoint);  //发生异常时，进行事务回滚到设置好的保存点
            } catch (SQLException e1) {
                e1.printStackTrace();
            } 
            e.printStackTrace();
            throw new RuntimeException(e);
        } finally {
              try {
                conn.commit();  //最终提交事务
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
            if (preparedStatement != null) {
                try {
                    preparedStatement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                    throw new RuntimeException(e);
                }
            }
       }
   }
nowseeme
关注
专栏目录
批处理和存储过程
IAIAI的博客
08-21 1036
批处理：一次执行多条sql语句 package com.heima.jdbc; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.Statement; import java.util.Date; import org.junit.Test; import com.heima.uti
JDBC：批处理+存储过程+事务
Holyn的博客
03-29 350
1.批处理 一次执行多条sql.sql语句的格式不同. 发送sql到数据库执行的对象:Statement/PreparedStatement. Statement:  void addBatch(sql); 添加批处理sql int[] executeBatch(); 执行批处理sql void clearBatch(); 清空批处理sql //可以处理多条不同格式的sql语句，如i...
JDBC之批处理、事务、存储过程
网站开发初中级代码参考-转载
09-10 164
当需要向数据库发送一批SQL语句执行时，应避免向数据库一条条的发送执行，而应采用JDBC的批处理机制，以提升执行效率。; 实现批处理有两种方式，第一种方式： Statement.addBatch(sql)list 执行批处理SQL语句 executeBatch()方法：执行批处理命令 clearBatch()方法：清除批处理命令 例： Connectio...
JDBC存储过程及事务处理
网站开发初中级代码参考-转载
09-10 113
存储过程是由SQL语句，及其数据库相关的增强指令和流程控制语句书写的过程程序，经过数据库编译和优化后储存在数据可服务器中。利用存储过程完成应用系统的逻辑操作处理，可以提高系统的运行性能和可维护性，但会影响程序的可移植性。 JDBC调用存储过程 l编写存储过程 l得到CallableStatement，并调用存储过程： l设置参数，注册返回值，输出： 事务处...
批处理文件和存储过程
weixin_30438813的博客
12-19 118
Statement 对象和PreparedStatement package jdbc; import java.io.FileNotFoundException; import java.sql.Connection; import java.sql.PreparedStatement; import java.sql.SQLException; import java...
JDBC批处理和事务
lalasonghhh的博客
08-23 529
JDBC批处理和事务 第一节 JDBC批处理 批量处理允许将相关的SQL语句分组到批处理中，并通过对数据库的一次调用提交它们。 当需要一次向数据库发送多个SQL语句时，可以减少连接数据库的开销，从而提高性能。 1.1 Statement批处理 以下是使用语句对象的批处理的典型步骤 1 注册驱动获取连接 2 使用*createStatement（）*方法创建Statement对象。 3 使用*se...
sqljdbc4-4.0.zip
04-07
`sqljdbc4-4.0.jar`的使用不仅限于基本的连接，它还支持预编译的SQL语句（PreparedStatement），事务处理，批处理操作，以及高级特性如存储过程、游标、大数据类型处理等。此外，这个驱动还提供了JDBC遵从性测试，以...
JDBC加强(批处理和事务)
最新发布
棉花糖老丫
04-30 493
所谓的事务，如果把多条sql语句看做一个事务，那么这个事务要么一起成功，要么一起失败！！
jconn4 jdbc连接sybase驱动
06-28
此外，`jconn4`驱动还优化了对Sybase特定功能的支持，如存储过程、触发器、事务处理等。 总之，`jconn4`是Java开发者与Sybase数据库进行通信的重要工具，通过标准的JDBC接口，它简化了Java应用程序与Sybase数据库的...
sqljdbc4-4.0.jar
10-09
sqljdbc4-4.0.jar驱动使得Java开发者能够利用这些特性，方便地执行SQL查询，执行存储过程，以及进行事务管理等操作。 在使用"sqljdbc4-4.0.jar"之前，开发者需要将其添加到项目的类路径中，这样Java程序才能找到并...
批处理，主键，存储过程和事务
Qiluluwawa的专栏
09-10 716
JDBC第三课 1、批处理（采用处理机制，提升效率） 1）实现批处理有两种方式， 2）第一种方式： Statement.addBatch(sql)  //list列表 执行批处理SQL语句 executeBatch()方法：执行批处理命令 clearBatch()方法：清除批处理命令 例子： Connection conn =null; Statement st = null;
JDBC 存储过程和事务管理
热心网友
07-27 449
一、存储过程 1.什么是存储过程 存储过程（Stored Procedure）是在大型数据库系统中，一组为了完成特定功能的SQL 语句集，存储在数据库中，经过第一次编译后再次调用不需要再次编译，用户通过指定存储过程的名字并给出参数（如果该存储过程带有参数）来执行它。存储过程是数据库中的一个重要对象。 2.存储过程的优点 （1）存储过程只在创造时进行编译，以后每次执行存储过程都不需再重新...
存储过程重新捡起
uwenKing
01-02 451
相隔半年多没有接触存储过程和触发器了，有点陌生，找点资料重新捡回起来http://hi.baidu.com/xmlf/blog/item/b247b251f80e908e8d5430ea.html1、SQL批处理语句:可以一次执行多个语句select au_lname from authorsselect au_fname from authors如果两个语句中有一个出错，则都不会执行。你可以
存储过程（批处理sql）
laodao1的专栏
09-18 944
ALTER PROCEDURE [dbo].[sqlcount]AS begin insert into score (course,studentid,score) values(dfs,3,23) end begin select top 1 * from score order by scoreid desc end begin selec
JDBC中执行存储过程和对事务的处理
开发中的点点滴滴
03-23 2176
详见例子和用法
jdbc批处理的事务控制
wungmc的专栏
12-18 2381
jdbc默认是事务自动提交，每条sql执行都是一个事务，批处理中也是如此，如果想将批处理作为一个事务处理，则要先关闭事务自动提交，改为手动提交，如下：String sql = "insert into person(name, age) values (?, ?)"; try { conn = getConn(); conn.setAutoCommit(false);//关闭自动提
存储过程（四）查询，使用的是jdbc
十八楼的三室二厅
04-04 715
IN `_fields` varchar(200),IN `_table` varchar(50)          //这里面要注意，每个地方的空格都很重要，要不拼接起来的sql语句是错误的，现在没问题，用的时候                                                                           要注意调试 BEGIN S
laravel项目中出现mysql嵌套事务的分析
beyond__devil的博客
11-05 3115
自己对于项目代码架构了解的真的是太少了，也没有时间去看、研究，整天忙于各种业务代码。今天想在项目中添加上事务处理！碰到了如下的一个问题： 1.定义了一个公共方法，里面进行了一系列的数据库操作，为了保证异常时，可以恢复到最初状态，采用了 '事务机制'。 // 增加用户积分 function add_point(){ DB::beginTransaction();
事务
Hisense的专栏
04-03 915
本文参考了下文的一些内容：http://www.bigwww.com/info/html/edu/database/20071226/22283.html 保存点(savepoint)是事务处理过程中的一个标志，和回滚命令(rollback)结合使用，主要的用途是允许用户将某一段处理回滚而不必回滚整个事务，这在pl/sql研发中还是非常有用处的。下面的例子中，把savepoint标记在
JDBC批处理：掌握基础操作与整合事务
批处理是JDBC编程中提升性能的重要工具，它结合了事务管理和SQL批量执行，使数据库操作更为高效和可靠。通过理解和熟练运用这些概念，开发者可以更有效地管理数据库操作，特别是在处理大量数据时。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值