精华内容
下载资源
问答
  • jdbc调用存储过程
    2021-12-10 11:50:39

    jdbc调用存储过程

    使用mysql数据库

    1. 在mysql中选择好数据库(我的mysql版本是8.0.25)

    2. 创建一个存储过程

      # 在MySQL中每行命令都是用“;”结尾,回车后自动执行,在存储过程中“;”往往不代表指令结束,马上运行,而DELIMITER原本就是“;”的意思,因此用这个命令转换一下“;”为“$$”,这样只有收到“$$”才认为指令结束可以执行
      DELIMITER $$
      # IN 输入参数,OUT 输出参数
      CREATE PROCEDURE register(IN username varchar(20),IN userpass varchar(20),OUT userid int)
      BEGIN 
      	insert into userinfo(userName,userPass)values(username,userpass);
      	select LAST_INSERT_ID() INTO userid;
      END $$
      
    3. mysql中调用存储过程

      # 设置一个变量接收输出参数
      set @userid=0;
      # 调用
      CALL register('存储过程','ccgc',@userid);
      # 查询输出参数结果
      select @userid;
      

    使用jdbc调用存储过程

    1. 引入mysql8的驱动jar包

      使用maven或手工引入都可以

    2. jdbc调用程序

      package com.kfm.config;
      
      import java.sql.*;
      
      public class DBHelper {
          public static void callProcedure() throws SQLException, ClassNotFoundException {
              // 加载sql驱动
              Class.forName("com.mysql.cj.jdbc.Driver");
              // 建立数据库连接
              Connection conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1/eshop?serverTimezone=UTC", "root", "password");
              // 装载存储过程
              CallableStatement callableStatement = conn.prepareCall("{CALL register(?,?,?)}");
              //设置sql语句的参数
              callableStatement.setObject(1, "jdbc");
              callableStatement.setObject(2, "jdbc");
              callableStatement.registerOutParameter(3, Types.INTEGER);
              // 执行存储过程
              callableStatement.executeUpdate();
              //获取输出参数的值
              int userid=callableStatement.getInt(3);
              System.out.println(userid);
              //关闭连接
              callableStatement.close();
              conn.close();
          }
      	// 测试
          public static void main(String[] args) {
      
              try {
                  callProcedure();
              } catch (ClassNotFoundException | SQLException e) {
                  e.printStackTrace();
              }
      
          }
      }
      
    更多相关内容
  • jdbc 存储过程 java 程序 JDBC 调用存储过程方法
  • NULL 博文链接:https://sxpujs.iteye.com/blog/376972
  • JDBC调用存储过程与存储函数

    万次阅读 多人点赞 2019-01-26 11:28:33
    JDBC API中提供了调用存储过程的方法,通过CallableStatement对象进行操作。CallableStatement对象位于java.sql包中,它继承于PreparedStatement对象,PreparedStatement对象又继承于Statement对象。...

    在JDBC API中提供了调用存储过程的方法,通过CallableStatement对象进行操作。CallableStatement对象位于java.sql包中,它继承于PreparedStatement对象,PreparedStatement对象又继承于Statement对象。CallableStatement对象主要用于执行数据库中定义的存储过程和存储函数,其调用方法如下:

    调用存储过程:{call <procedure-name>[(<arg1>,<arg2>, ...)]}

    调用存储函数:{?= call <procedure-name>[(<arg1>,<arg2>, ...)]} 

    CallableStatement对象的常用方法:

    下面将以调用MySQL数据的存储过程和存储函数为示例。

    1、创建数据库连接与关闭

    1.1 获取MySQL数据库的连接

    import java.sql.*; //导入java.sql包
    // 数据库驱动
    public static final String DRIVER_CLASS = "com.mysql.cj.jdbc.Driver";
    
    // 数据库连接地址
    public static final String DB_URL = "jdbc:mysql://localhost:3306/db_admin?serverTimezone=Hongkong&useUnicode=true&characterEncoding=utf8&useSSL=false";
    
    // 数据库用户名称
    public static final String DB_USER = "root";
    
    // 数据库用户密码
    public static final String DB_PASSWORD = "123456";
    
    /**
     * 获取数据库连接
     * 
     * @author pan_junbiao
     * @return 数据库连接对象
     */
    public static Connection getConnection()
    {
    	Connection conn = null;
    
    	try
    	{
    		// 加载数据库驱动类
    		Class.forName(DRIVER_CLASS);
    		System.out.println("数据库驱动加载成功");
    
    		// 获取数据库连接对象
    		conn = DriverManager.getConnection(DB_URL, DB_USER, DB_PASSWORD);
    		System.out.println("数据库连接成功");
    
    	} catch (ClassNotFoundException cnfe)
    	{
    		cnfe.printStackTrace();
    	} catch (SQLException sqle)
    	{
    		sqle.printStackTrace();
    	} catch (Exception ex)
    	{
    		ex.printStackTrace();
    	}
    
    	return conn;
    }

    1.2 关闭相关数据操作对象

    /**
     * 关闭数据库操作对象
     * 
     * @author pan_junbiao
     * @param res  ResultSet对象
     * @param stmt Statement对象
     * @param conn Connection对象
     */
    public static void closeOperate(ResultSet res, Statement stmt, Connection conn)
    {
    	try
    	{
    		// 关闭ResultSet对象
    		if (res != null)
    		{
    			res.close();
    		}
    
    		// 关闭Statement对象
    		if (stmt != null)
    		{
    			stmt.close();
    		}
    
    		// 关闭Connection对象
    		if (conn != null)
    		{
    			conn.close();
    		}
    
    		System.out.println("关闭数据库操作对象完成");
    
    	} catch (SQLException sqle)
    	{
    		sqle.printStackTrace();
    	}
    }

     

    2、调用存储过程

    示例:通过调用存储过程,获取用户分页列表,数据总数和总页数。

    2.1 创建存储过程

    /*
      -- 存储过程:分页查询用户列表
      -- 输入参数:page_index:当前页码
      -- 输入参数:page_size:分页大小
      -- 输出参数:total_count:数据总数
      -- 输出参数:total_page:总页数
    */
    DROP PROCEDURE IF EXISTS proc_search_user;
    CREATE PROCEDURE proc_search_user(IN page_index INT,IN page_size INT, OUT total_count INT, OUT total_page INT)
    BEGIN
    		DECLARE begin_no INT;
    		SET begin_no = (page_index-1)*page_size;
     
    		-- 分页查询列表
    		SELECT * FROM tb_user
    		WHERE id >= (
    			SELECT id FROM tb_user
    			ORDER BY id ASC
    			LIMIT begin_no,1
    		)
    		ORDER BY id ASC
    		LIMIT page_size;
    
    		-- 计算数据总数
    		SELECT COUNT(1) INTO total_count FROM tb_user;
    
    		-- 计算总页数
    		SET total_page = FLOOR((total_count + page_size - 1) / page_size);
    
    END;

    2.2 调用存储过程

    /**
     * 调用存储过程
     * 
     * @author pan_junbiao
     */
    public static void execProcedure()
    {
    	Connection conn = null; // 数据库连接对象
    	CallableStatement clbStmt = null; // CallableStatement对象
    	ResultSet res = null; // 结果集对象
    	try
    	{
    		// 获取数据库连接
    		conn = getConnection();
    
    		// 创建CallableStatement对象
    		clbStmt = conn.prepareCall("{CALL proc_search_user(?,?,?,?)}");
    
    		// 设置输入参数
    		clbStmt.setInt(1, 3); // 查询第3页数据
    		clbStmt.setInt(2, 10); // 每页10条数据
    
    		// 注册输出参数
    		clbStmt.registerOutParameter(3, Types.INTEGER);
    		clbStmt.registerOutParameter(4, Types.INTEGER);
    
    		// 执行调用存储过程,并获取结果集
    		res = clbStmt.executeQuery();
    
    		// 循环遍历结果集
    		while (res.next())
    		{
    			// 获取列值
    			int id = res.getInt("id");
    			String name = res.getString("name");
    			Timestamp createTime = res.getTimestamp("create_time");
    
    			// 输出列值
    			System.out.println("编号:" + id + "  姓名:" + name + "  创建时间:" + createTime);
    		}
    
    		// 获取输出参数值
    		int totalCount = clbStmt.getInt(3);
    		int totalPage = clbStmt.getInt(4);
    		System.out.println("数据总数:" + totalCount + " 总页数:" + totalPage);
    
    	} catch (SQLException sqle)
    	{
    		sqle.printStackTrace();
    	} finally
    	{
    		// 关闭数据库操作对象
    		closeOperate(res, clbStmt, conn);
    	}
    }

    执行结果:

     

    3、调用存储函数

    示例:通过调用存储函数,根据用户编号,获取用户姓名。

    3.1 创建存储函数

    /*
        -- 存储函数:根据用户编号,获取用户姓名
        -- 输入参数:用户编号
        -- 返回结果:用户姓名
    */
    DROP FUNCTION IF EXISTS func_get_user_name;
    CREATE FUNCTION func_get_user_name(in_id INT)
    RETURNS VARCHAR(30)
    BEGIN
    	DECLARE out_name VARCHAR(30);
     
    	SELECT name INTO out_name FROM tb_user
    	WHERE id = in_id;
     
    	RETURN out_name;
    END;

    3.2 调用存储函数

    /**
     * 调用存储函数
     * 
     * @author pan_junbiao
     */
    public static void execFunction()
    {
    	Connection conn = null; // 数据库连接对象
    	CallableStatement clbStmt = null; // CallableStatement对象
    	try
    	{
    		// 获取数据库连接
    		conn = getConnection();
    
    		// 创建CallableStatement对象
    		clbStmt = conn.prepareCall("{?=CALL func_get_user_name(?)}");
    
    		// 注册输出结果参数
    		clbStmt.registerOutParameter(1, Types.VARCHAR);
    
    		// 设置输入参数
    		clbStmt.setInt(2, 5);
    
    		// 执行调用存储函数
    		clbStmt.execute();
    
    		// 获取输出参数值
    		String userName = clbStmt.getString(1);
    		System.out.println("用户名称:" + userName);
    
    	} catch (SQLException sqle)
    	{
    		sqle.printStackTrace();
    	} finally
    	{
    		// 关闭数据库操作对象
    		closeOperate(null, clbStmt, conn);
    	}
    }

    执行结果:

     

    展开全文
  • 1. 创建存储过程 建立一个MySQL的存储过程 add_pro 代码如下: ... 调用存储过程 代码如下: package com.zhanggaosong; import java.sql.CallableStatement; import java.sql.Connection; import java.sql.DriverManage
  • JDBC调用存储过程和函数 在数据库中我们可以写一些存储过程和函数,来封装一些常用的SQL语句,存储过程和函数目的是为了可重复地执行操作数据库的sql语句的集合 返回值上: 存储过程的返回值,可以有多个值 函数...

     

    JDBC调用存储过程和函数

    在数据库中我们可以写一些存储过程和函数,来封装一些常用的SQL语句,存储过程和函数目的是为了可重复地执行操作数据库的sql语句的集合

    返回值上:

    • 存储过程的返回值,可以有多个值
    • 函数的返回值,只有一个值

    函数是可以嵌入在SQL中使用的,可以在SELECT等SQL语句中调用,而存储过程则不行。我们可以在数据库中创建一些常用的存储过程和函数,这样我们在数据访问层直接调用即可。这里记录一下使用JDBC调用存储过程和函数的方法

    调用没有返回值的存储过程

    首先我们在数据库中创建一个没有返回值的存储过程:

    create or replace procedure proc_Ins_Dept(vid in varchar2 ,vname  in varchar2,vloc in varchar2) is
    begin insert into Dept values(vid,vname,vloc);
    end proc_Ins_Dept;

    我是在Oracle中创建的,其他的数据库大同小异

    在Dao中调用:

    复制代码

    // 无返回值的存储过程
        public void proc1() {
            try {
    
                Connection conn = super.getConn();    //调用了BaseDao创建连接
    
                CallableStatement cs = conn.prepareCall("{call proc_Ins_Dept(?,?,?)}");  //调用格式 {call 存储过程名(参数)}
                cs.setObject(1, 76);
                cs.setObject(2, "技术部");
                cs.setObject(3, "zhengzhou");
                cs.execute();            //执行
                cs.close();
                conn.close();
    
            } catch (Exception ex) {
                ex.printStackTrace();
            }
    
        }

    复制代码

    调用有返回值的存储过程

    创建有返回值的存储过程:

    复制代码

    create or replace procedure pro_Ins_Dept (vid in varchar2,vname in varchar2,vloc in varchar2,vresult out varchar2) is 
    begin insert into Dept values(vid,vname,vloc);
      vresult:='success';
    Exception
      when others then
       vresult:='fail';
    end pro_Ins_Dept;

    复制代码

    输入值使用in,返回值使用out表示

    在Dao中调用:

    复制代码

    // 带返回值的存储过程
        public void proc2() {
            try {
                Connection conn = super.getConn();
                CallableStatement cs = conn.prepareCall("{call proc_Ins_Dept2(?,?,?,?)}");
                cs.setObject(1, 76);
                cs.setObject(2, "市场部");
                cs.setObject(3, "luoyang");
                cs.registerOutParameter(4, java.sql.Types.VARCHAR);           //注册返回类型(sql类型)
                cs.execute();
    
                Object objRtn = cs.getObject(4);      //得到返回值
    
                System.out.println(objRtn);
    
                cs.close();
                conn.close();
    
            } catch (Exception ex) {
                ex.printStackTrace();
            }
    
        }

    复制代码

    唯一不同的是我们需要给返回值注册类型,可以在java.sql.Types类中找到对应的Sql类型,Oracle中的varchar2对应的也是varchar。最后使用CallableStatement的get方法得到返回结果

    调用自定义函数

    SQL语句:

    create or replace function fun_avg_dept(vdeptno in number)
        return number is 
           r number;
    begin select avg(sal) into r from emp where deptno=vdeptno;
           return(r);
    end fun_avg_dept;

    Dao中调用:

    复制代码

        // 带返回值的自定义函数
        public void fun1() {
            try {
                Connection conn = super.getConn();
                               
                //函数可以嵌入到Sql中
                String sql = "select fun_avg_dept(?) from dual";
    
                //调用方式还是和使用ps调用普通SQL一样
                PreparedStatement ps = conn.prepareStatement(sql);
    
                ps.setObject(1, 10);
    
                ResultSet rs = ps.executeQuery();
    
                if (rs.next()) {
                    System.out.println(rs.getObject(1));
                }
    
                rs.close();
                ps.close();
                conn.close();
    
            } catch (Exception ex) {
                ex.printStackTrace();
            }
    
        }

    复制代码

     

    标签: JavaEE笔记

    https://www.cnblogs.com/lz2017/p/7500411.html

     

     

     

     

    随笔- 51  文章- 1  评论- 0 

    如何使用 JDBC 调用存储在数据库中的函数或存储过程

    JDBC调用存储过程
    步骤:
    1 通过Connection对象的prepareCall()方法创建一个CallableStatement对象的实例。在使用Connection对象的prepareCall()方法时,需要传入一个String类型的字符串,该字符串用于指明如何调用存储过程
    {?= call <procedure-name>[(<arg1>,<arg2>, ...)]}
    {call <procedure-name>[(<arg1>,<arg2>, ...)]}

    2 通过CallableStatement对象的registerOutParameter()方法注册OUT参数
    3 通过CallableStatement对象的setXxx()方法设定IN或IN OUT参数
    若想将参数默认值设为Null,可以使用setNull()方法
    4 通过CallableStatement对象的execute()方法执行存储过程
    5 如果所调用的是带返回参数的存储过程,还需要通过CallableStatement对象的getXxx()方法获取其返回值
    注:通过数据字典查看存储过程或函数的定义

    select text from user_source where lower(name)='add_fun';
    调用函数:

     

    package com.atguigu.jdbc;

    import static org.junit.Assert.*;

    import java.sql.CallableStatement;
    import java.sql.Connection;
    import java.sql.SQLException;
    import java.sql.Types;

    import javax.sql.DataSource;

    import org.junit.Test;

    import com.mchange.v2.c3p0.ComboPooledDataSource;

    public class JDBCTest {

    /**
    * 如何使用 JDBC 调用存储在数据库中的函数或存储过程
    */
    @Test
    public void testCallableStatment() {

    Connection connection = null;
    CallableStatement callableStatement = null;

    try {
    connection = JDBCTools.getConnection();

    // 1. 通过 Connection 对象的 prepareCall()
    // 方法创建一个 CallableStatement 对象的实例.
    // 在使用 Connection 对象的 preparedCall() 方法时,
    // 需要传入一个 String 类型的字符串, 该字符串用于指明如何调用存储过程.
    String sql = "{?= call sum_salary(?, ?)}";
    callableStatement = connection.prepareCall(sql);

    // 2. 通过 CallableStatement 对象的 
    //reisterOutParameter() 方法注册 OUT 参数.
    callableStatement.registerOutParameter(1, Types.NUMERIC);
    callableStatement.registerOutParameter(3, Types.NUMERIC);

    // 3. 通过 CallableStatement 对象的 setXxx() 方法设定 IN 或 IN OUT 参数. 若想将参数默认值设为
    // null, 可以使用 setNull() 方法.
    callableStatement.setInt(2, 80);

    // 4. 通过 CallableStatement 对象的 execute() 方法执行存储过程
    callableStatement.execute();

    // 5. 如果所调用的是带返回参数的存储过程, 
    //还需要通过 CallableStatement 对象的 getXxx() 方法获取其返回值.
    double sumSalary = callableStatement.getDouble(1);
    long empCount = callableStatement.getLong(3);

    System.out.println(sumSalary);
    System.out.println(empCount);

    } catch (Exception e) {
    e.printStackTrace();
    } finally {
    JDBCTools.releaseDB(null, callableStatement, connection);
    }


    }

    @Test
    public void testC3P0() throws SQLException {
    DataSource dataSource = new ComboPooledDataSource("c3p0");

    System.out.println(dataSource.getConnection());
    }

    }

    标签: JDBC

    好文要顶 关注我 收藏该文  

    苍狼哂啡
    关注 - 3
    粉丝 - 1

    +加关注

    « 上一篇:c3p0数据库连接池使用--创建JDBCTools 公共类
    » 下一篇:如何使用JDBC调用存储在数据库中的函数或存储过程 */

    https://www.cnblogs.com/xiaona19841010/p/5223779.html

     

     

     

     

    JDBC学习笔记(10)——调用函数&存储过程

    如何使用JDBC调用存储在数据库中的函数或存储过程:

    * 1.通过COnnection对象的prepareCall()方法创建一个CallableStatement
    *    对象的实例,在使用Connection对象的prepareCall() 方法时,需要传入一个String类型的字符串,
    *    该字符串用于指明如何调用存储过程

    * 2.通过CallableStatement对象的registerOutParameter() 方法注册Out参数

    * 3.通过CallableStatement对象的setXxx()方法设定IN或In out
    *    参数,若想将参数设为null,可以使用setNUll()

    * 4.通过CallableStatement对象的execute()方法执行存储过程

    * 5.如果所调用的是带返回参数的存储过程没还需要通过CallableStatement对象的getXxx()函数进行获取

    具体的代码实现:

    复制代码

     1     @Test
     2     public void testCallableStatement() {
     3         Connection connection = null;
     4         /**
     5          * 调用存储函数 1.{?= call <procedure-name>[(<arg1>,<arg2>, ...)]} 
     6          * 调用存储过程 2.{call <procedure-name>[(<arg1>,<arg2>, ...)]}
     7          */
     8         // 调用存储函数和调用存储过程,一个sql语句的区别
     9         String sql = "{?= call <procedure-name>[(<arg1>,<arg2>, ...)]}";
    10         CallableStatement callableStatement = null;
    11         try {
    12 
    13             connection = JDBCTools.getConnection();
    14             /*
    15              * 1.通过COnnection对象的prepareCall()方法创建一个CallableStatement
    16              * 对象的实例,在使用Connection对象的prepareCall() 方法时,需要传入一个String类型的字符串,
    17              * 该字符串用于指明如何调用存储过程
    18              */
    19             callableStatement = connection.prepareCall(sql);
    20 
    21             /*
    22              * 2.通过CallableStatement对象的registerOutParameter() 方法注册Out参数
    23              */
    24             callableStatement.registerOutParameter(1, Types.NUMERIC);
    25             callableStatement.registerOutParameter(3, Types.NUMERIC);
    26 
    27             /*
    28              * 3.通过CallableStatement对象的setXxx()方法设定IN或In out
    29              * 参数,若想将参数设为null,可以使用setNUll()
    30              */
    31             callableStatement.setInt(2, 80);
    32 
    33             /* 4.通过CallableStatement对象的execute()方法执行存储过程 */
    34             callableStatement.execute();
    35 
    36             /*
    37              * 5.如果所调用的是带返回参数的存储过程没还需要通过CallableStatement对象的getXxx()
    38              */
    39             double sumSalary = callableStatement.getDouble(1);
    40             long empCount = callableStatement.getLong(3);
    41         } catch (Exception e) {
    42             e.printStackTrace();
    43         } finally {
    44             JDBCTools.release(null, callableStatement, connection);
    45         }
    46     }

    复制代码

    调用函数和存储过程的sql语句的区别:

    * 调用存储函数 1.{?= call <procedure-name>[(<arg1>,<arg2>, ...)]} 
    * 调用存储过程 2.{call <procedure-name>[(<arg1>,<arg2>, ...)]}

    这个知识点暂时没用到,先做下笔记,待以后用到以后再深入研究,JDBC的学习暂时告一段落,开启新的学习征程!

     


    个人感悟:把简单的事情做到极致,打扎实的基础,写优秀的代码

    本文为博主原创文章,转载请注明出处:http://www.cnblogs.com/ysw-go/
    1、本博客的原创原创文章,都是本人平时学习所做的笔记,如有错误,欢迎指正。
    2、如有侵犯您的知识产权和版权问题,请通知本人,本人会即时做出处理文章。
    3、本博客的目的是知识交流所用,转载自其它博客或网站,作为自己的参考资料的,感谢这些文章的原创人员

    分类: JDBC

    好文要顶 关注我 收藏该文  

    菜鸟奋斗史
    关注 - 23
    粉丝 - 131

    +加关注

    « 上一篇:JDBC学习笔记(9)——DBUtils的使用
    » 下一篇:HTML+CSS+JS学习总结

    https://www.cnblogs.com/ysw-go/p/5480675.html

     

     

     

     

    java实现存储过程并同时得到out与return的值

    置顶 2017年07月09日 15:12:40 风雪夜归人提示已存在 阅读数:637 标签: java存储过程数据库

    @Test
    public final void test() {
    SessionFactory sf = baseDao4.getSessionFactory();//任意穿件一个session
    Session session = sf.openSession();
    try{
           //session.beginTransaction(); //如果有spring来管理事务,记得注销这句
            session.doWork(
            new Work() {
    @Override
    public void execute(Connection connection) throws SQLException {
    CallableStatement cs = connection.prepareCall("{?=CALL GSP_GR_DISTRIBUTOR(?,?,?,?,?,?)}"); //第一个?是return的值  //最后一个是out的值. jdbc下标从1开始.hibernate是从0开始.坑爹了.
    cs.registerOutParameter(1,java.sql.Types.INTEGER);
                       cs.setInt(2, 999999);
                       cs.setInt(3, 1);    
                       cs.setInt(4, 1);    
                       cs.setInt(5, 1);    
                       cs.setInt(6, 1);  
                       cs.registerOutParameter(7,java.sql.Types.NVARCHAR);
                       cs.execute();
                       int a = cs.getInt(1);
                       System.out.println(a);
                       String result = cs.getString(7);
            System.out.println(result);
    /*
    * 可用
    Statement s = connection.createStatement();
    String sql = "select * from RechargeRecord";
        ResultSet rs = s.executeQuery(sql);
        
        while(rs.next()){
        System.out.println(rs.getInt(1));
        }*/
    }

            );
         //    session.getTransaction().commit();
           
       }catch(Exception e){
          e.printStackTrace();
       }
       finally{
          session.close();  //如果用spring管理,也需要这就关闭连接.
       }

    }

    https://blog.csdn.net/qq_38024577/article/details/74887053

     

     

     


     

     

    狐小仙

    JDBC操作存储过程、存储函数、out参数使用游标

    JDBC工具类

    复制代码

    public class JDBCUtils {
        private static String driver = "oracle.jdbc.OracleDriver";
        private static String url = "jdbc:oracle:thin:@192.168.79.128:1521/orcl";
        private static String user = "scott";
        private static String password = "tiger";
        
        
        static{
            //注册驱动
            //DriverManager.registerDriver(driver)
            try {
                Class.forName(driver);
            } catch (ClassNotFoundException e) {
                throw new ExceptionInInitializerError(e);
            }
        }
        
        public static Connection getConnection(){
            try {
                return DriverManager.getConnection(url, user, password);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            return null;
        }
        
        public static void release(Connection conn,Statement st,ResultSet rs){
            if(rs != null){
                try {
                    rs.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }finally{
                    rs = null; ///-----> 原因:Java GC: Java的GC不受代码的控制
                }
            }
            if(st != null){
                try {
                    st.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }finally{
                    st = null;
                }
            }
            if(conn != null){
                try {
                    conn.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }finally{
                    conn = null;
                }
            }
        }
    }

    复制代码

    存储过程

    复制代码

    --存储过程
    create or replace procedure queryEmpInformation(eno in number,
                                                    pename out varchar2,
                                                    psal out number,
                                                    pjob out varchar2)
    is
    begin
      select ename,sal,job into pename,psal,pjob from emp where empno = eno;
    end queryEmpInformation;

    复制代码

    java代码

    复制代码

    @Test
        public void testProcedure(){
            //jdbc调用存储过程sql语句:
            //{call <procedure-name>[(<arg1>,<arg2>, ...)]}
            String sql = "{call queryEmpInformation(?,?,?,?)}";
            
            Connection conn = null;
            CallableStatement call = null;
            
            try{
                conn = JDBCUtils.getConnection();
                call = conn.prepareCall(sql);
                
                //输入参数赋值
                call.setInt(1, 7839);
                
                //输出参数,声明为输出参数
                call.registerOutParameter(2, OracleTypes.VARCHAR);
                call.registerOutParameter(3, OracleTypes.NUMBER);
                call.registerOutParameter(4, OracleTypes.VARCHAR);
                
                //执行
                call.execute();
                
                //获取值
                String name = call.getString(2);
                double sal = call.getDouble(3);
                String job = call.getString(4);
                System.out.println(name+"\t"+sal+"\t"+job);
            }catch (Exception e){
                e.printStackTrace();
            }finally{
                JDBCUtils.release(conn, call, null);
            }
        }

    复制代码

    存储函数

    复制代码

    --存储函数
    create or replace function queryEmpIncome(eno in number)
    return number
    is
    psal emp.sal%type;
    pcomm emp.comm%type;
    begin
      select sal,comm into psal,pcomm from emp where empno = eno;
      return psal*12+nvl(pcomm,0);
    end queryEmpIncome;

    复制代码

    java代码

    复制代码

    @Test
        public void testFuntion(){
            //jdbc调用存储函数sql语句:
            //{?= call <procedure-name>[(<arg1>,<arg2>, ...)]}
            String sql = "{? = call queryEmpIncome(?)}";
            
            Connection conn = null;
            CallableStatement call = null;
            
            try{
                conn = JDBCUtils.getConnection();
                call = conn.prepareCall(sql);
                
                //注册输出参数
                call.registerOutParameter(1, OracleTypes.NUMBER);
                //输入参数
                call.setInt(2, 7839);
                
                //执行
                call.execute();
                
                //取出返回值
                double income = call.getDouble(1);
                System.out.println("年薪:"+income);
            }catch (Exception e){
                e.printStackTrace();
            }finally{
                JDBCUtils.release(conn, call, null);
            }
        }

    复制代码

    out参数游标

    复制代码

    --创建包头
    create or replace package mypackage 
    is
    --定义一个cursor类型变量
    type empcursor is ref cursor;
    procedure queryEmpList(dno in number,empList out empcursor);
    end mypackage;
    
    
    --创建包体
    create or replace package body mypackage is
      procedure queryEmpList(dno in number,empList out empcursor)
        as
        begin
          open empList for select * from emp where deptno = dno;
          end;
    end mypackage;

    复制代码

    java代码

    复制代码

    @Test
        public void testCursor(){
            String sql = "call mypackage.queryEmpList(?,?)";
            
            Connection conn = null;
            CallableStatement call = null;
            ResultSet rs = null;
            
            try{
                conn = JDBCUtils.getConnection();
                call = conn.prepareCall(sql);
                
                call.setInt(1, 20);
                call.registerOutParameter(2, OracleTypes.CURSOR);
                
                call.execute();
                
                rs = ((OracleCallableStatement)call).getCursor(2);
                while(rs.next()){
                    String name = rs.getString("ename");
                    double sal = rs.getDouble("sal");
                    System.out.println(name+"\t"+sal);
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally{
                JDBCUtils.release(conn, call, null);
            }
        }

    复制代码

     

    分类: Java

    好文要顶 关注我 收藏该文  

    狐小仙
    关注 - 0
    粉丝 - 0

    +加关注

    0

    0

    « 上一篇:存储过程函数
    » 下一篇:触发器

    posted on 2018-08-01 17:22 狐小仙 阅读(184) 评论(0) 编辑 收藏

    https://www.cnblogs.com/zsh-wj/p/9402486.html

    展开全文
  • CallableStatement接口用于调用存储过程和函数。 通过使用存储过程和函数,我们可以在数据库上编写业务逻辑,这将使性能更好,因为它们是预编译的。 2 存储过程和函数的区别? 3 获取CallableStatement对象...

    原文链接:http://www.yiidian.com/jdbc/jdbc-callablestatement.html

    1 CallableStatement接口

    CallableStatement接口用于调用存储过程和函数。

    通过使用存储过程和函数,我们可以在数据库上编写业务逻辑,这将使性能更好,因为它们是预编译的。

    2 存储过程和函数的区别?

    file

    3 获取CallableStatement对象

    Connection接口的prepareCall() 方法返回CallableStatement对象。语法如下:

    public CallableStatement prepareCall("{ call procedurename(?,?...?)}");

    下面给出了获取CallableStatement对象代码示例:

    CallableStatement stmt=con.prepareCall("{call myprocedure(?,?)}");

    上面代码调用了接收2个参数(可能是输入参数或输出参数)的存储过程:myprocedure。

    4 调用存储过程的示例

    4.1 创建存储过程

    在MySQL的test数据库中,执行以下SQL创建pro_insert_user存储过程:

    DELIMITER $$
    CREATE PROCEDURE pro_insert_user(username VARCHAR(50),PASSWORD VARCHAR(50))
    BEGIN
    
    INSERT INTO t_user(username,PASSWORD) VALUES(username,PASSWORD); 
    
    END $$

    存储过程中涉及的t_user表的表结构如下:

    CREATE TABLE `t_user` (
       `id` int(11) NOT NULL AUTO_INCREMENT,
       `username` varchar(50) DEFAULT NULL,
       `password` varchar(50) DEFAULT NULL,
       PRIMARY KEY (`id`)
     ) ENGINE=InnoDB AUTO_INCREMENT=10 DEFAULT CHARSET=utf8

    4.2 编写示例代码

    CallProDemo:

    package com.yiidian;
    
    import java.io.*;
    import java.sql.*;
    
    /**
     * 一点教程网 - http://www.yiidian.com
     */
    public class CallProDemo {
        public static void main(String args[])throws Exception {
            try {
                Class.forName("com.mysql.jdbc.Driver");
    
                Connection con = DriverManager.getConnection(
                        "jdbc:mysql://localhost:3306/test", "root", "root");
    
                CallableStatement stmt=con.prepareCall("{call pro_insert_user(?,?)}");
                stmt.setString(1,"mark");
                stmt.setString(2,"123");
                stmt.execute();
    
                System.out.println("存储过程调用成功!");
    
                con.close();
            }catch(Exception e){
                System.out.println(e);
            }
        }
    }

    4.3 运行测试

    执行完毕程序后,查看t_user表是否多了一条记录:

    file

    5 调用函数的示例

    在下面的示例中,我们调用pro_sum函数,该函数接收两个输入参数并返回给定数字的总和。在这里,我们使用到了CallableStatement接口的registerOutParameter() 方法,该方法将输出参数注册为其相应的类型。它向CallableStatement提供有关所显示结果类型的信息。

    Types类定义了许多常量如INTEGER,VARCHAR,FLOAT,DOUBLE,BLOB,CLOB等。

    5.1 创建存储过程

    在MySQL的test数据库中,执行以下SQL创建fun_sum函数:

    DELIMITER $$
    CREATE FUNCTION fun_sum(n1 INT,n2 INT)
    RETURNS INT
    BEGIN
    
    DECLARE total INT;  
    SET total = n1+n2;  
    RETURN total;
    
    END $$

    file

    5.2 编写示例代码

    CallFunDemo:

    package com.yiidian;
    
    import java.io.*;
    import java.sql.*;
    
    /**
     * 一点教程网 - http://www.yiidian.com
     */
    public class CallFunDemo {
        public static void main(String args[])throws Exception {
            try {
                Class.forName("com.mysql.jdbc.Driver");
    
                Connection con = DriverManager.getConnection(
                        "jdbc:mysql://localhost:3306/test", "root", "root");
    
                CallableStatement stmt=con.prepareCall("{?= call fun_sum(?,?)}");
                stmt.setInt(2,10);
                stmt.setInt(3,43);
                stmt.registerOutParameter(1,Types.INTEGER);
                stmt.execute();
    
                System.out.println(stmt.getInt(1));
    
                con.close();
            }catch(Exception e){
                System.out.println(e);
            }
        }
    }

    5.3 运行测试

    file

    file

    欢迎关注我的公众号::一点教程。获得独家整理的学习资源和日常干货推送。 如果您对我的系列教程感兴趣,也可以关注我的网站:yiidian.com

    展开全文
  • JDBC调用存储过程(以MySQL为例)

    千次阅读 2018-10-30 16:07:17
    String url = "jdbc:mysql://127.0.0.1:3306/ump?useUnicode=true&characterEncoding=utf8&autoReconnect=true&rewriteBatchedStatements=TRUE"; String user = "root"; String password = "123456"; ...
  • 存储过程(Stored Procedure)是在大型数据库系统中,一组为了完成特定功能的SQL 语句集,存储在数据库中,经过第一次编译后调用不需要再次编译,用户通过指定存储过程的名字并给出参数(如果该存储过程带有参数)来...
  • JDBC调用存储过程

    2008-03-18 13:15:10
    这是用JBuilder做的一个简单的例子, 用java代码调用存储过程,实现增删改查。
  • 今天去面试 问答这问题 , 没有打上来 ,特来请教一下各位 , 原因分析一下 ,谢谢大家
  • jdbc调用存储过程 函数例子
  • JDBC如何调用存储过程

    千次阅读 2022-01-27 15:54:06
    JDBC如何调用存储过程
  • JDBC调用存储过程 返回多结果集

    千次阅读 2016-10-28 11:12:36
    package com.demo1; import java.sql.CallableStatement; import java.sql.Connection; import java.sql.ResultSet;...//调用无参存储过程 包括查询和删除 public class Demo6 { //1.存储
  • PLSQL jdbc调用存储过程(入门)
  • * @param storageName 接受存储过程的名称 * @param args 存储过程的参数 * @return 返回op_auction_buy_information的结果集 */ public static Map, Object> getRui(String storageName, String[] args...
  • JAVA JDBC 调用存储过程 传参数

    千次阅读 2015-10-09 09:49:42
    程序存储1000~2000条数据,我们现在是循环将每一条save进去,现想优化下用存储过程来实现。
  • 使用JDBC调用存储过程

    2015-04-14 23:21:04
    今天我们来分享下如何在java中使用JDBC调用数据库中的存储过程
  • JDBC调用Oracle存储过程详解

    千次阅读 2019-04-19 22:16:25
    一、为什么要调用存储过程 1、概述 存储过程说白了就是一堆 SQL 的合并,中间加了点逻辑控制,但是存储过程处理比较复杂的业务时比较实用。比如说:一个复杂的数据操作,如果你在前台处理的话,可能会涉及到多次...
  • 使用Oracle数据库实现了jdbc调用存储过程进行增加数据、删除数据、修改数据、查询全部数据、查询单个数据
  • 目的在于找到java+pg数据库存储过程的最佳开发模式及调用方式。 必要数据及代码交代 数据表: 地区区域表一张,数据量大约30000条,不过不是重点,表结构如下: &amp;amp;amp;quot;id&amp;amp;amp;quot; int...
  • 如何通过GBase8s jdbc调用存储过程 本文通过实例介绍如何通过jdbc连接GBase8s,实现存储过程调用返回。 1、首先,工程中引入GBase8s驱动包文件。 2、创建GBase8s存储过程: 3、编写jdbc访问GBase8s存储过程用例: ...
  • spring jdbc 调用存储过程封装

    千次阅读 2015-05-20 16:05:35
    1、调用存储过程--返回list以及无结果返回以及只返回一个参数 /** * 获取数据库内的存储过程--返回一个List * @param procedureName 存储过程名 * @param inParameter 输入的参数 * @param ...
  • 使用jdbc调用存储过程

    千次阅读 2015-02-28 11:19:05
    你可以使用特殊的语法在Java类中通过JDBC调用存储过程。在调用时,存储过程的名称及指定的参数通过JDBC连接发送给DBMS,执行存储过程并通过连接(如果有)返回结果。 使用存储过程拥有和使用基于EJB或CORBA这样的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 128,700
精华内容 51,480
关键字:

jdbc调用存储过程

友情链接: sqlite3.rar