jdbc调用存储过程

2021-12-10 11:50:39

jdbc调用存储过程

使用mysql数据库

在mysql中选择好数据库（我的mysql版本是8.0.25）

创建一个存储过程

# 在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 $$

mysql中调用存储过程

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

使用jdbc调用存储过程

引入mysql8的驱动jar包

使用maven或手工引入都可以

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();
        }

    }
}

mysql 数据库 sql

更多相关内容

JDBC 调用存储过程方法
2017-07-03 10:26:23

jdbc 存储过程 java 程序 JDBC 调用存储过程方法

收起
jdbc调用存储过程，函数，游标
2019-03-16 01:08:11

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);
	}
}

执行结果：

收起

展开全文

Java

jdbc调用mysql存储过程实现代码
2020-12-15 14:39:54

1. 创建存储过程建立一个MySQL的存储过程 add_pro 代码如下: ... 调用存储过程 代码如下: package com.zhanggaosong; import java.sql.CallableStatement; import java.sql.Connection; import java.sql.DriverManage

收起

JDBC调用存储过程和函数

2018-12-25 16:49:53

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

+加关注

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

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

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

收起

展开全文

使用JDBC调用存储过程和函数

2020-03-18 10:06:29

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

欢迎关注我的公众号：：一点教程。获得独家整理的学习资源和日常干货推送。如果您对我的系列教程感兴趣，也可以关注我的网站：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"; ...

收起

Java procedure
后端开发 - 使用JDBC调用存储过程
2018-12-20 21:12:52

存储过程（Stored Procedure）是在大型数据库系统中，一组为了完成特定功能的SQL 语句集，存储在数据库中，经过第一次编译后调用不需要再次编译，用户通过指定存储过程的名字并给出参数（如果该存储过程带有参数）来...

收起

java
JDBC调用存储过程
2008-03-18 13:15:10

这是用JBuilder做的一个简单的例子，用java代码调用存储过程，实现增删改查。

收起
jdbc调用存储过程，存储过程里写了提交还要不要调jdbc的提交
2018-04-19 00:48:02

今天去面试问答这问题 , 没有打上来 ,特来请教一下各位 , 原因分析一下 ,谢谢大家

收起
jdbc调用存储过程 函数例子
2012-01-08 16:06:58

jdbc调用存储过程 函数例子

收起
用JDBC如何调用存储过程
千次阅读 2022-01-27 15:54:06

用JDBC如何调用存储过程

收起

数据库 mysql java
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调用存储过程(入门)
2012-02-10 09:28:04

PLSQL jdbc调用存储过程(入门)

收起
jdbc调用存储过程，遍历两个结果集（获取存储过程返回的多个结果集），珍藏版
千次阅读 2017-09-08 11:28:00

* @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 的合并，中间加了点逻辑控制，但是存储过程处理比较复杂的业务时比较实用。比如说：一个复杂的数据操作，如果你在前台处理的话，可能会涉及到多次...

收起
jdbc调用存储过程实现增删改查
2016-08-31 10:49:32

使用Oracle数据库实现了jdbc调用存储过程进行增加数据、删除数据、修改数据、查询全部数据、查询单个数据

收起

procedure
[jdbctemplate+POSTGRESQL+存储过程]jdbc调用存储过程顺便勘误同时给出几个较好的配合方式
千次阅读 2018-11-01 22:51:49

目的在于找到java+pg数据库存储过程的最佳开发模式及调用方式。必要数据及代码交代数据表：地区区域表一张，数据量大约30000条，不过不是重点，表结构如下： &amp;amp;quot;id&amp;amp;quot; int...

收起

返回json格式
如何通过GBase8s jdbc调用存储过程
2022-01-24 13:49:55

如何通过GBase8s jdbc调用存储过程 本文通过实例介绍如何通过jdbc连接GBase8s，实现存储过程调用返回。 1、首先，工程中引入GBase8s驱动包文件。 2、创建GBase8s存储过程： 3、编写jdbc访问GBase8s存储过程用例： ...

收起

java
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这样的...

收起

jdbc调用存储过程

使用mysql数据库

使用jdbc调用存储过程

JDBC 调用存储过程方法

jdbc调用存储过程，函数，游标

JDBC调用存储过程与存储函数

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

1.1 获取MySQL数据库的连接

1.2 关闭相关数据操作对象

2、调用存储过程

2.1 创建存储过程

2.2 调用存储过程

3、调用存储函数

3.1 创建存储函数

3.2 调用存储函数

jdbc调用mysql存储过程实现代码

JDBC调用存储过程和函数

JDBC调用存储过程和函数

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

调用有返回值的存储过程

调用自定义函数

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

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

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

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

JDBC工具类

存储过程

java代码

存储函数

java代码

out参数游标

java代码

使用JDBC调用存储过程和函数

1 CallableStatement接口

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

3 获取CallableStatement对象

4 调用存储过程的示例

4.1 创建存储过程

4.2 编写示例代码

4.3 运行测试

5 调用函数的示例

5.1 创建存储过程

5.2 编写示例代码

5.3 运行测试

JDBC调用存储过程（以MySQL为例）

后端开发 - 使用JDBC调用存储过程

JDBC调用存储过程

jdbc调用存储过程，存储过程里写了提交还要不要调jdbc的提交

jdbc调用存储过程 函数例子

用JDBC如何调用存储过程

JDBC调用存储过程 返回多结果集

PLSQL jdbc调用存储过程(入门)

jdbc调用存储过程，遍历两个结果集（获取存储过程返回的多个结果集），珍藏版

JAVA JDBC 调用存储过程 传参数

使用JDBC调用存储过程

JDBC调用Oracle存储过程详解

jdbc调用存储过程实现增删改查

[jdbctemplate+POSTGRESQL+存储过程]jdbc调用存储过程顺便勘误同时给出几个较好的配合方式

如何通过GBase8s jdbc调用存储过程

spring jdbc 调用存储过程封装

使用jdbc调用存储过程

jdbc调用存储过程

jdbc调用存储过程函数例子

JDBC调用存储过程返回多结果集

JAVA JDBC 调用存储过程传参数