用JDBC操作Oracle的存储过程返回值.
跟我学Oracle数据库系统管理和实现——应用Java JDBC 调用Oracle数据库存储过程的应用实例
（3）在PLSQL Developer中创建出 相关的存储过程及代 码代码
（4）在MyEclipse开发工具中创建类名称为 JdbcOracleProcedureWithOutResult，程序包名称为 com.px1987.javaoracle.dao.imple的Java程序类
（5）相关的Java程序的核心代码示例
7、Java JDBC调用Oracle存储过程相关函数的代码示例
使用JDBC调用函数的过程与JDBC调用存储过程非常类似， 但由于函数是由返回值的，因此要注册返回参数类型和获得返回 值。如下为调用的代码示例：
注意：使用JDBC调用函数或者过程获取多行查询结果，则需要使 用游标定义返回的数据集。
8、应用JDBC调用带输入参数值的Oracle存储过程的应用示 例
（1）创建数据库表someOneTable
Create table someOneTable (someOneField number(3,0), someTwoField varchar2 (20));
（2）在PLSQL Developer中创建出相关的存储过程及代码代码 1）在PLSQL Developer中应用过程模板创建过程，只需要选 择“文件”菜单中的“新建”——“程序窗口”——“过程”子 菜单 2）将出现存储过程的创建 模板窗口的对话框，在该对话 框的名称栏中输入存储过程的 名称，而在参数栏中输入存储 过程所需要的参数（本示例不 需要参数）。
3）点击对话框中的“确定”按钮，在存储过程的面板中输入 存储过程的代码，最终结果如下图所示。
4）编译该存储过程（产生出存储过程的机器码）
（3）在MyEclipse开发工具中创建类名称为 JdbcOracleProcedureWithOutResult，程序包名称为 com.px1987.javaoracle.dao.imple的Java程序类
Java调用Oracle存储过程返回结果集
Java调⽤Oracle存储过程返回结果集CREATE OR REPLACE PACKAGE typesASTYPE ref_cursor IS REF CURSOR;END;/CREATE TABLE STOCK_PRICES(RIC VARCHAR(6) PRIMARY KEY,PRICE NUMBER(7,2),UPDATED DATE );/CREATE OR REPLACE FUNCTION sp_get_stocks(v_price IN NUMBER)RETURN types.ref_cursorASstock_cursor types.ref_cursor;BEGINOPEN stock_cursor FORSELECT ric,price,updated FROM stock_prices WHERE price < v_price;RETURN stock_cursor;END;2. ⽤ sqlplus 测试过程SQL> var results refcursorSQL> exec :results := sp_get_stocks(20.0)SQL> print results3. 从 Java 调⽤import java.sql.*;import java.io.*;import oracle.jdbc.driver.*;public class JDBCDemo {/*** Compile-time flag for deciding which query to use*/private boolean useOracleQuery = true;/*** Class name of Oracle JDBC driver*/private String driver = "oracle.jdbc.driver.OracleDriver";/*** Initial url fragment*/private String url = "jdbc:oracle:thin:@";/*** Standard Oracle listener port*/private String port = "1521";/*** Oracle style of calling a stored procedure*/private String oracleQuery = "begin ? := sp_get_stocks(?); end;";/*** JDBC style of calling a stored procedure*/private String genericQuery = "{ call ? := sp_get_stocks(?) }";/*** Connection to database*/private Connection conn = null;/*** Constructor. Loads the JDBC driver and establishes a connection** @param host the host the db is on* @param db the database name* @param user user's name* @param password user's password*/public JDBCDemo(String host, String db, String user, String password) throws ClassNotFoundException, SQLException {// construct the urlurl = url + host + ":" + port + ":" + db;// load the Oracle driver and establish a connectiontry {Class.forName(driver);conn = DriverManager.getConnection(url, user, password);}catch (ClassNotFoundException ex) {System.out.println("Failed to find driver class: " + driver);throw ex;}catch (SQLException ex) {System.out.println("Failed to establish a connection to: " + url);throw ex;}}/*** Execute the stored procedure** @param price price parameter for stored procedure*/private void execute(float price)throws SQLException {String query = useOracleQuery ? oracleQuery : genericQuery;System.out.println("Query: " + query + "n");CallableStatement stmt = conn.prepareCall(query);// register the type of the out param - an Oracle specific typestmt.registerOutParameter(1, OracleTypes.CURSOR);// set the in paramstmt.setFloat(2, price);// execute and retrieve the result setstmt.execute();ResultSet rs = (ResultSet)stmt.getObject(1);// print the resultswhile (rs.next()) {System.out.println(rs.getString(1) + "t" +rs.getFloat(2) + "t" +rs.getDate(3).toString());}rs.close();stmt.close();}/*** Cleanup the connection*/private void cleanup() throws SQLException {if (conn != null)conn.close();}/*** Prints usage statement on stdout*/static private void usage() {System.out.println("java com.enterprisedt.demo.oracle.JDBCDemo " + " host db user password price");}/*** Runs the class*/public static void main(String[] args) throws Exception {if (args.length != 5) {age();System.exit(1);}else {try {// assign the args to sensible variables for clarityString host = args[0];String db = args[1];String user = args[2];String password = args[3];float price = Float.valueOf(args[4]).floatValue();// and execute the stored procJDBCDemo jdbc = new JDBCDemo(host, db, user, password); jdbc.execute(price);jdbc.cleanup();}catch (ClassNotFoundException ex) {System.out.println("Demo failed");}catch (SQLException ex) {System.out.println("Demo failed: " + ex.getMessage());}}}}。
JDBC操作Oracle存储过程
1. 关于oracle和结果集其实在大多数情况下,我们并不需要从oracle存储过程里返回一个或多个结果集,除非迫不得已。
如果大家用过MS SQL Server或Sybase SQL Server,那么从存储过程返回一个动态的结果集是一件非常容易的事情,只要在存储过程结束时写上“select colum n1,colum n2,.... from table_list where condition“就可以了。
但在Oracle中不能这样做. 我们必须使用Oracle Cursor.在Oracle PL/SQL中,Cursor用来返回一行或多行记录,借助Cursor,我们可以从结果集中取得所有记录.Cursor并不难,但是要从Oracle存储过程中返回结果集, 就需要用到Cursor变量,Cursor变量Oracle PL/SQL的类型是REF CURSOR, 我们只要定义了REF CURSOR 类型就可以使用Cursor变量. 比如我们可以这样定义:TYPE ref_cursor IS REF CURSOR;了解了Cursor以及Cursor变量,下面就介绍如何使用Cursor变量给JDBC返回结果集.2. 定义表结构在以下例子里，我们要用到一张表Hotline.Create table hotline(country varchar2(50),pno varchar2(50));3. 定义存储过程create or replace package PKG_HOTLINE istype HotlineCursorType is REF CURSOR;function getHotline return HotlineCursorType;end;create or replace package body PKG_HOTLINE isfunction getHotline return HotlineCursorType ishotlineCursor HotlineCursorType;beginopen hotlineCursor for select * from hotline;return hotlineCursor;end;end;在这个存储过程里,我们定义了HotlineCursorType 类型,并且在存储过程中简单地查找所有的记录并返回HotlineCursorType.4. 测试存储过程在Oracle SQL/Plus里登陆到数据库. 按以下输入就看到返回的结果集.SQL> var rs refcursor;SQL> exec :rs := PKG_HOTLINE.getHotline;SQL> print rs;5. Java调用简单地写一个Java Class.....public void openCursor(){Connection conn = null;ResultSet rs = null;CallableStatement stmt = null;String sql = “{? = call PKG_HOTLINE.getHotline()}“;try{conn = getConnection();stmt = conn.prepareCall(sql);stmt.registerOutParameter(1,OracleTypes.CURSOR);stmt.execute();rs = ((OracleCallableStatement)stmt).getCursor(1);while(rs.next()){String country = rs.getString(1);String pno = rs.getString(2);System.out.println(“country:“+country+“|pno:”+pno); }}catch(Exception ex){ex.printStackTrace();}finally{closeConnection(conn,rs,stmt);}}.....好了，大功告成.。
jdbctemplate调用存储过程返回 map对象
要使用JdbcTemplate调用存储过程并返回Map对象，可以按照以下步骤操作：1. 创建一个存储过程。
例如，创建一个名为`get_employee_info`的存储过程，该过程接收一个参数`emp_id`，并返回一个包含员工信息的Map对象。
```sqlCREATE PROCEDURE get_employee_info(IN emp_id INT, OUT result MAP<VARCHAR, VARCHAR>)BEGINSELECT * INTO result FROM employee WHERE id = emp_id;END;```2. 在Java代码中，使用JdbcTemplate调用存储过程。
首先，注入JdbcTemplate实例，然后使用`callProcedure`方法调用存储过程。
将结果存储在一个`Map`对象中。
```javaimport org.springframework.jdbc.core.JdbcTemplate;import org.springframework.jdbc.core.RowMapper;import java.util.HashMap;import java.util.List;import java.util.Map;public class EmployeeService {private JdbcTemplate jdbcTemplate;public EmployeeService(JdbcTemplate jdbcTemplate) {this.jdbcTemplate = jdbcTemplate;}public Map<String, Object> getEmployeeInfo(int empId) {Map<String, Object> result = new HashMap<>();jdbcTemplate.callProcedure("{call get_employee_info(?, ?)}", empId, result);return result;}}```3. 在上述示例中，我们使用了`callProcedure`方法的第一个参数来传递存储过程的名称，第二个参数用于传递输入参数（在本例中为`emp_id`），第三个参数用于传递输出参数（在本例中为`result`）。
Spring jdbcTemplate调用Oracle存储过程返回List集合
jdbcTemplate调用Oracle存储过程返回List集合作者:xyzc(cr10210206@)1.编写存储过程-- 模糊查询返回多条数据CREATE OR REPLACE PROCEDURE P_EMP_SELECT(RESULTLIST OUT SYS_REFCURSOR,V_ID IN NUMBER,V_NAME IN VARCHAR2)ISSQL_STR VARCHAR2(500);BEGINSQL_STR:='SELECT * FROM EMP WHERE 1=1 ';DBMS_OUTPUT.put_line('V_ID='||V_ID ||' V_NAME='||V_NAME);IF(V_ID<>0)THENBEGINSQL_STR:=SQL_STR ||' AND EMPNO>= '|| V_ID;END;END IF;IF(V_NAME IS NOT NULL)THEN-- 判断字符串是否为空BEGINSQL_STR:=SQL_STR ||' AND ENAME LIKE '''||V_NAME ||'%'' ';-- 字符串是四个单引号 ''A%'' END;END IF;DBMS_OUTPUT.put_line(' SQL_STR:'||SQL_STR);-- 输出SQL语句OPEN RESULTLIST FOR SQL_STR;END;-- 测试DECLAREMYCRS SYS_REFCURSOR;-- 注意这里用分号；V_EMP EMP%ROWTYPE;BEGIN-- 调用过程，返回的是已经打开的CURSORP_EMP_SELECT(MYCRS,7900,'');LOOPFETCH MYCRS INTO V_EMP;EXIT WHEN MYCRS%NOTFOUND;DBMS_OUTPUT.put_line(V_EMP.EMPNO||' '||V_EMP.ENAME);END LOOP;CLOSE MYCRS;END;2.编写Java代码package com.zc.test;import java.sql.CallableStatement;import java.sql.ResultSet;import java.sql.ResultSetMetaData;import java.sql.SQLException;import java.util.ArrayList;import java.util.HashMap;import java.util.List;import oracle.jdbc.driver.OracleTypes;import org.springframework.dao.DataAccessException;import org.springframework.jdbc.core.CallableStatementCallback; import org.springframework.jdbc.core.JdbcTemplate;/*** 测试Oracle存储过程* */public class TestOraclePro {private static JdbcTemplate jdbcTemplate= TestDao.getJdbcTemplateOracle();/*** 测试* */public static void main(String[] args) {TestOraclePro test = new TestOraclePro();List<HashMap<String, Object>> result = test.testPro();System.out.println("\nresult:\n" + result);/*** 返回的结果：** [{DEPTNO=20, COMM=null, HIREDATE=1980-12-17 00:00:00.0, MGR=7902, SAL=800, JOB=CLERK, ENAME=SMITH, EMPNO=7369},* {DEPTNO=30, COMM=300, HIREDATE=1981-02-20 00:00:00.0, MGR=7698, SAL=1600, JOB=SALESMAN, ENAME=ALLEN, EMPNO=7499}, * {DEPTNO=30, COMM=500, HIREDATE=1981-02-22 00:00:00.0, MGR=7698, SAL=1250, JOB=SALESMAN, ENAME=WARD, EMPNO=7521},* {DEPTNO=20, COMM=null, HIREDATE=1981-04-02 00:00:00.0,MGR=7839, SAL=2975, JOB=MANAGER, ENAME=JONES, EMPNO=7566},* {DEPTNO=30, COMM=1400, HIREDATE=1981-09-28 00:00:00.0, MGR=7698, SAL=1250, JOB=SALESMAN, ENAME=MARTIN, EMPNO=7654}, * {DEPTNO=30, COMM=null, HIREDATE=1981-05-01 00:00:00.0, MGR=7839, SAL=2850, JOB=MANAGER, ENAME=BLAKE, EMPNO=7698},* {DEPTNO=10, COMM=null, HIREDATE=1981-06-09 00:00:00.0, MGR=7839, SAL=2450, JOB=MANAGER, ENAME=CLARK, EMPNO=7782},* {DEPTNO=20, COMM=null, HIREDATE=1987-04-19 00:00:00.0, MGR=7566, SAL=3000, JOB=ANALYST, ENAME=SCOTT, EMPNO=7788},* {DEPTNO=10, COMM=null, HIREDATE=1981-11-17 00:00:00.0, MGR=null, SAL=5000, JOB=PRESIDENT, ENAME=KING, EMPNO=7839}, * {DEPTNO=30, COMM=0, HIREDATE=1981-09-08 00:00:00.0, MGR=7698, SAL=1500, JOB=SALESMAN, ENAME=TURNER, EMPNO=7844}, * {DEPTNO=20, COMM=null, HIREDATE=1987-05-23 00:00:00.0, MGR=7788, SAL=1100, JOB=CLERK, ENAME=ADAMS, EMPNO=7876},* {DEPTNO=30, COMM=null, HIREDATE=1981-12-03 00:00:00.0, MGR=7698, SAL=950, JOB=CLERK, ENAME=JAMES, EMPNO=7900},* {DEPTNO=20, COMM=null, HIREDATE=1981-12-03 00:00:00.0, MGR=7566, SAL=3000, JOB=ANALYST, ENAME=FORD, EMPNO=7902},* {DEPTNO=10, COMM=null, HIREDATE=1982-01-23 00:00:00.0, MGR=7782, SAL=1300, JOB=CLERK, ENAME=MILLER, EMPNO=7934}]* */}/*** 调用存储过程返回 List<HashMap<String, Object>>* */@SuppressWarnings({ "unchecked", "rawtypes" })public List<HashMap<String, Object>> testPro(){final String sql = "{call P_EMP_SELECT(?,?,?)}";List<HashMap<String, Object>> result = (List<HashMap<String, Object>>) jdbcTemplate.execute(sql,new CallableStatementCallback(){ public Object doInCallableStatement(CallableStatement cs) throws SQLException,DataAccessException {List<HashMap<String, Object>> list = new ArrayList<HashMap<String, Object>>();cs.registerOutParameter(1, OracleTypes.CURSOR); //输出参数：游标cs.setInt(2, 2000);//输入参数cs.setString(3, "");//输入参数cs.execute();//执行ResultSet rs = null;try {rs = (ResultSet) cs.getObject(1);//获取结果集while (rs.next()) {HashMap<String, Object> dataMap = new HashMap<String, Object>();ResultSetMetaData rsMataData = rs.getMetaData();for(int i = 1; i <= rsMataData.getColumnCount(); i++) {dataMap.put(rsMataData.getColumnName(i),rs.getString(rsMataData.getColumnName(i)));}list.add(dataMap);}} catch (Exception e) {e.printStackTrace();}finally{if(rs != null){rs.close();}}return list;}});return result;}}。
jdbctemplate调用返游标的存储过程
JdbcTemplate是Spring框架中用于简化数据库操作的一个工具类，通过JdbcTemplate可以方便地进行数据库操作，包括执行SQL语句、调用存储过程等。
在实际应用中，经常需要调用返回游标的存储过程，本文将详细介绍如何使用JdbcTemplate来调用返回游标的存储过程。
存储过程是在数据库中预先编译好的一组SQL语句，通过存储过程可以方便地实现复杂的业务逻辑。
有些存储过程会返回游标，用于返回查询结果集。
在使用JdbcTemplate调用返回游标的存储过程时，需要注意以下几点：1. 编写存储过程需要在数据库中编写一个返回游标的存储过程。
存储过程的语法和数据库的类型有关，这里以Oracle数据库为例，假设有一个名为“get_users”的存储过程，用于返回用户表中的所有用户信息。
```CREATE OR REPLACE PROCEDURE get_users (p_cursor OUTSYS_REFCURSOR) ASBEGINOPEN p_cursor FORSELECT * FROM users;END;```在这个存储过程中，定义了一个输出参数p_cursor，用于返回游标。
游标的类型为SYS_REFCURSOR，可以用于返回查询结果集。
2. 定义JdbcTemplate bean在Spring的配置文件中，需要定义一个JdbcTemplate的bean，并配置数据源等信息。
```<bean id="jdbcTemplate"class="org.springframework.jdbc.core.JdbcTemplate"><property name="dataSource" ref="dataSource"/></bean>```这里假设数据源的名称为dataSource，需要在配置文件中定义数据源的相关信息。
Delphi调用Oracle存储过程并返回数据集的例子
Delphi调用 Oracle存储过程并返回数据集的例子
Delphi 调用 Oracle 存储过程并返回数据集的例子. 一、先在 Oracle 建好
CREATE OR REPLACE PACKAGE pkg_test AS
try with ADOStoredProc1 do begin
Connection := ADOConnection1; Parameters.Clear; ProcedureName:= 'pkg_test.get'; Parameters.CreateParameter('p1',ftInteger,pdInput,10,1); Open; end; except showMessage('无法执行过程.'); end; end;
IF i_test = 0 THEN OPEN p_rc FOR SELECT SYSDATE FROM dual;
ELSE OPEN p_rc FOR SELECT * FROM tab;
END IF; END get; END pkg_test;
二、用 Delphi 调用 建一个窗体,拖动控件 AdoConnection1 , ADOStoredProc1 和 Button1. procedure TForm1.Button1Click(Sender: TObject); begin try with ADOConnection1 do begin ConnectionString:= 'Provider=OraOLEDB.Oracle.1;' + 'Password=密码;' + 'Persist Security Info=True;' + 'User ID=用户名;' + 'Data Source=数据库名;' + 'Extended Properties="PLSQLRSet=1;"'; Open; end; except showMessage('连接不成功'); exit; end;
mysql jdbctemplate调用带返回值存储过程
mysql jdbctemplate调用带返回值存储过程如何使用MySQL JdbcTemplate调用带返回值的存储过程MySQL是一款常用的关系型数据库管理系统，而JdbcTemplate则是Spring框架中用于简化数据库操作的强大工具。
在一些需要大量数据计算或处理的场景中，使用存储过程可以有效地提高数据库的性能和效率。
然而，有时候我们需要从存储过程中获取返回值，那么如何使用MySQL JdbcTemplate来调用带返回值的存储过程呢？本文将一步一步回答这个问题。
在MySQL中，存储过程是一组预先编译并存储在数据库服务器中的SQL 语句集合，可以在需要的时候调用执行。
存储过程可以带有输入参数、输出参数和返回值。
在本文中，我们将重点关注带有返回值的存储过程的调用。
首先，我们需要创建一个带有返回值的存储过程。
假设我们有一个数据库中的表格“employees”，并且我们希望创建一个存储过程来获取员工的数量。
以下是创建存储过程的SQL语句：CREATE PROCEDURE get_employee_count(OUT employee_count INT)BEGINSELECT COUNT(*) INTO employee_count FROM employees; END上述存储过程声明了一个输出参数employee_count，然后在存储过程中使用SELECT COUNT(*)语句查询员工数量，并将结果存储到输出参数中。
接下来，我们需要在Java代码中使用JdbcTemplate来调用这个存储过程，并获取返回值。
首先，我们需要在Spring配置文件中配置JdbcTemplate的实例：<bean id="jdbcTemplate"class="org.springframework.jdbc.core.JdbcTemplate"><property name="dataSource" ref="dataSource"/></bean>上述配置文件中的dataSource指的是数据源，这里省略了具体的配置细节。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
用JDBC操作Oracle的存储过程返回值 Oracle的存储过程可以返回任何类型，包括一个ResultSet，JDBC自带的CallableStatement可以提供操作这些返回值得借口，其中我们可以通过registerOutParameter来注册需要返回的类型。
CallableStatement是PrepareStatement的一个子类，但提供了返回和注册Out类型参数的功能。
我们看一下例子，在Oracle里面我们定义了一个包如下： create or replace package GP_TESTP is type my_dCursor is ref cursor; procedureGP_Test(m_cursor2 OUT my_dCursor; end GP_TESTP; create or replace package body GP_TESTP is procedure GP_Test(m_cursor2 OUT my_dCursor is begin open m_cursor2 for select bom.material_no,bom.product_no from gp2_bom bom where bom.year=2006 ; end GP_Test; end GP_TESTP; 在JDBC里面我们可以通过如下的接口来得到返回的动态游标的内容 Global.start(; //初始化连接池 ConnectionWrapperwrapper=ConnectionPoolFactory.getPoolInstance(.borrowConnection(;//从连接池里面返回连接 Connection conn=wrapper.getConnection(; try { String callSql="{callGP_TESTP.GP_Test(?}"; CallableStatement cs = null; ResultSet rs=null; cs =conn.prepareCall(callSql; cs.registerOutParameter(2,oracle.jdbc.OracleTypes.CURSOR; cs.execute(; rs = (ResultSetcs.getObject(2; while(rs.next({ //String s=rs.get(""; String component=rs.getString(2; String productNo=rs.getString(4;System.out.println("component="+component+"-------productNo="+productNo; } } catch (SQLException e { // TODO Auto-generated catch block e.printStackTrace(; } 注意兰颜色的代码是注册动态游标和返回结果集的关键代码。
======================================= 2008年07月06日星期日07:41 P.M.一：无返回值的存储过程存储过程为： CREATE OR REPLACE PROCEDURE TESTA(PARA1 IN VARCHAR2,PARA2 IN VARCHAR2 AS BEGIN INSERT INTO HYQ.B_ID (I_ID,I_NAME VALUES (PARA1, PARA2; END TESTA; 然后呢，在java里调用时就用下面的代码： package com.hyq.src; import java.sql.*; import java.sql.ResultSet; public class TestProcedureOne { public TestProcedureOne( { } public static void main(String[] args { String driver = "oracle.jdbc.driver.OracleDriver"; String strUrl = "jdbc:oracle:thin:@127.0.0.1:1521: hyq "; Statement stmt = null;ResultSet rs = null; Connection conn = null; CallableStatement cstmt = null; try{ Class.forName(driver; conn = DriverManager.getConnection(strUrl, " hyq ", " hyq "; CallableStatement proc = null; proc = conn.prepareCall("{ call HYQ.TESTA(?,? }"; proc.setString(1, "100"; proc.setString(2, "TestOne";proc.execute(; } catch (SQLException ex2 { ex2.printStackTrace(; } catch (Exception ex2 { ex2.printStackTrace(; } finally{ try { if(rs != null{ rs.close(;if(stmt!=null{ stmt.close(; } if(conn!=null{ conn.close(; } } } catch (SQLException ex1 { } } } } 当然了，这就先要求要建张表TESTTB,里面两个字段（I_ID，I_NAME）。
二：有返回值的存储过程（非列表）存储过程为： CREATE OR REPLACE PROCEDURE TESTB(PARA1 IN VARCHAR2,PARA2 OUT VARCHAR2 AS BEGIN SELECT INTO PARA2 FROM TESTTB WHERE I_ID= PARA1; END TESTB; 在java里调用时就用下面的代码： package com.hyq.src; public class TestProcedureTWO { public TestProcedureTWO( { } public static void main(String[] args { String driver = "oracle.jdbc.driver.OracleDriver"; String strUrl ="jdbc:oracle:thin:@127.0.0.1:1521:hyq"; Statement stmt = null; ResultSet rs = null; Connection conn = null; try { Class.forName(driver; conn =DriverManager.getConnection(strUrl, " hyq ", " hyq "; CallableStatement proc = null; proc = conn.prepareCall("{ call HYQ.TESTB(?,? }"; proc.setString(1, "100";proc.registerOutParameter(2, Types.VARCHAR; proc.execute(; String testPrint = proc.getString(2; System.out.println("=testPrint=is="+testPrint; } catch (SQLException ex2 { ex2.printStackTrace(; } catch (Exception ex2 { ex2.printStackTrace(; } finally{ try { if(rs != null{ rs.close(; if(stmt!=null{ stmt.close(; } if(conn!=null{ conn.close(; } } } catch (SQLException ex1 { } } } } } 注意，这里的proc.getString(2中的数值2并非任意的，而是和存储过程中的out列对应的，如果out是在第一个位置，那就是proc.getString(1，如果是第三个位置，就是proc.getString(3，当然也可以同时有多个返回值，那就是再多加几个out参数了。
2008年07月06日星期日 07:42 P.M.由于oracle存储过程没有返回值，它的所有返回值都是通过out参数来替代的，列表同样也不例外，但由于是集合，所以不能用一般的参数，必须要用pagkage了.所以要分两部分， 1，建一个程序包。
如下： CREATE OR REPLACE PACKAGE TESTPACKAGE AS TYPE Test_CURSOR IS REF CURSOR; end TESTPACKAGE; 2，建立存储过程，存储过程为： CREATE OR REPLACE PROCEDURETESTC(p_CURSOR out TESTPACKAGE.Test_CURSOR IS BEGIN OPENp_CURSOR FOR SELECT * FROM HYQ.TESTTB; END TESTC; 可以看到，它是把游标（可以理解为一个指针），作为一个out 参数来返回值的。
在java里调用时就用下面的代码： package com.hyq.src; import java.sql.*; importjava.io.OutputStream; import java.io.Writer; import java.sql.PreparedStatement; import java.sql.ResultSet; import oracle.jdbc.driver.*; public class TestProcedureTHREE{ public TestProcedureTHREE( { } public static void main(String[] args { String driver = "oracle.jdbc.driver.OracleDriver"; String strUrl ="jdbc:oracle:thin:@127.0.0.1:1521:hyq"; Statement stmt = null; ResultSet rs = null; Connection conn = null; try { Class.forName(driver; conn =DriverManager.getConnection(strUrl, "hyq", "hyq"; CallableStatement proc = null; proc = conn.prepareCall("{ call hyq.testc(? }";proc.registerOutParameter(1,oracle.jdbc.OracleTypes.CURSOR; proc.execute(; rs = (ResultSetproc.getObject(1; while(rs.next( { System.out.println("" + rs.getString(1 + "</td>"+rs.getString(2+"</td></tr>"; } } catch (SQLException ex2{ ex2.printStackTrace(; } catch (Exception ex2 { ex2.printStackTrace(; } finally{ try { if(rs != null{ rs.close(; if(stmt!=null{ stmt.close(; } if(conn!=null{ conn.close(; } } } catch (SQLException ex1 { } } }。