java调用oracle存储过程精彩总结_百度文库.

合集下载

Java调用Oracle存储过程详解

Java调⽤Oracle存储过程详解Java调⽤Oracle存储过程详解步骤：1、编写Oracle存储过程2、编写数据库获取连接⼯具类3、编写简单应⽤调⽤存储过程实现：1、Oracle存储过程：/*测试表*/create table test(id varchar2(32),name varchar2(32));/*存储过程插⼊数据*/CREATE OR REPLACE PROCEDURE insert_procedure(PARA1 IN VARCHAR2,PARA2 IN VARCHAR2) ASBEGININSERT INTO test (id, name) VALUES (PARA1, PARA2);END insert_procedure;/*存储过程返回结果集*/CREATE OR REPLACE PROCEDURE select_procedure(para_id IN VARCHAR2,name OUT sys_refcursor /* 这个sys_refcursor类型在SYS.STANDARD包中 */) ASBEGINOPEN name FORSELECT * FROM test WHERE id = para_id;END;2、JDBC⼯具类import java.sql.Connection;import java.sql.DriverManager;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;public class DBUtil {public static final String DRIVER = "oracle.jdbc.driver.OracleDriver";public static final String URL = "jdbc:oracle:thin:@localhost:1521/orcl";public static final String USERNAME = "pfm";public static final String PASSWORD = "pfm";/*** 通过静态代码块注册数据库驱动*/static {try {Class.forName(DRIVER);} catch (ClassNotFoundException e) {e.printStackTrace();}}/*** 获得Connection** @returnConnection conn = null;try {conn = DriverManager.getConnection(URL, USERNAME, PASSWORD); } catch (SQLException e) {e.printStackTrace();}return conn;}/*** 获得Statement** @return*/public static Statement getStatement() {Statement st = null;try {st = getConnection().createStatement();} catch (SQLException e) {e.printStackTrace();}return st;}/*** 关闭ResultSet** @param rs*/public static void closeResultSet(ResultSet rs) {if (rs != null) {try {rs.close();} catch (SQLException e) {e.printStackTrace();}}}/*** 关闭Statement** @param st*/public static void closeStatement(Statement st) {if (st != null) {try {st.close();} catch (SQLException e) {e.printStackTrace();}}}/*** 关闭Connection** @param conn*/public static void closeConnection(Connection conn) {if (conn != null) {try {conn.close();} catch (SQLException e) {e.printStackTrace();}}}/*** 关闭全部** @param rs* @param sta* @param connpublic static void closeAll(ResultSet rs, Statement sta, Connection conn) {closeResultSet(rs);closeStatement(sta);closeConnection(conn);}}3、调⽤存储过程：import java.sql.CallableStatement;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import oracle.jdbc.driver.OracleTypes;/*** 测试调⽤存储过程**/public class StoredTest {public static void main(String[] args) {insert_call();//select_call();}/*** 执⾏存储过程插⼊数据*/public static void insert_call() {Connection conn = DBUtil.getConnection();PreparedStatement pst = null;CallableStatement proc = null; // 创建执⾏存储过程的对象try {proc = conn.prepareCall("{ call insert_procedure(?,?) }");proc.setString(1, "1"); // 设置第⼀个输⼊参数proc.setString(2, "hello call"); // 设置第⼀个输⼊参数proc.execute();// 执⾏} catch (SQLException e) {e.printStackTrace();} finally {try {// 关闭IO流proc.close();DBUtil.closeAll(null, pst, conn);} catch (Exception e) {e.printStackTrace();}}}/*** 执⾏存储过程查询数据*/public static void select_call() {Connection conn = DBUtil.getConnection();CallableStatement stmt;try {stmt = conn.prepareCall("{ call select_procedure(?, ?) }"); // ⽤此调⽤⽅法不能实现多⾏语法 stmt.setString(1, "1");stmt.registerOutParameter(2, OracleTypes.CURSOR);stmt.execute();ResultSet rs = (ResultSet) stmt.getObject(2);while (rs.next()) {System.out.println(rs.getString("name"));}} catch (SQLException e) {e.printStackTrace();} finally {DBUtil.closeConnection(conn);}}感谢阅读，希望能帮助到⼤家，谢谢⼤家对本站的⽀持！。

JAVA调用ORACLE存储过程小结

JAVA调用ORACLE存储过程小结在Java中调用Oracle存储过程可以使用JDBC（Java Database Connectivity）技术。

JDBC是一种用于执行SQL语句和数据库操作的API。

在本文中，我们将讨论如何在Java中调用Oracle存储过程。

在调用Oracle存储过程之前，我们需要创建一个连接到数据库的JDBC连接。

这可以通过以下步骤完成：2. 创建数据库连接：使用JDBC驱动程序创建一个Connection对象来与数据库建立连接。

需要提供数据库的URL，用户名和密码。

例如：```String username = "your_username";String password = "your_password";Connection connection = DriverManager.getConnection(url, username, password);```这里的URL是连接到Oracle数据库的URL。

localhost表示连接的是本地主机，1521是Oracle数据库的默认端口，xe是Oracle Express Edition的默认数据库实例。

3. 调用存储过程：通过创建一个CallableStatement对象来调用存储过程。

首先，我们需要构造一个SQL语句，其中包含对存储过程的调用。

假设我们要调用一个名为`get_employee`的存储过程，它接受一个员工ID作为参数，并返回该员工的姓名和薪水。

在Java代码中，可以这样调用存储过程：```String sql = "{call get_employee(?,?,?)}";CallableStatement statement = connection.prepareCall(sql);```这里的`?`是占位符，表示存储过程的参数。

通过调用`connection.prepareCall(`方法，可以创建一个CallableStatement对象，并将SQL语句作为参数传递给它。

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

Oracle存储过程总结

存储过程基本概念（1）过程过程就是高级程序设计语言中的模块的概念,将一些内部联系的命令组成一个个过程,通过参数在过程之间传递数据是模块化设计思想的重要内容（2）存储过程特点.●1）存储过程是预编译过的，并且经优化后存储于SQL内存中，使用时无需再次编译，提高了工作效率；●2）存储过程的代码直接存放于数据库中，一般由客户端直接通过存储过程的名字进行调用，减少了网络流量，加快了系统执行速度，例如在进行百万以上的大批量数据查询时，使用存储过程分页要比其他方式分页快得多；●3）使用存储过程可以减少SQL注入式攻击，提高了系统的安全性，执行存储过程的用户要具有一定的权限才能使用存储过程，没有数据操作权限的用户只能在其控制下间接地存取数据;●4）在同时进行主、从表及多表间的数据维护及有效性验证时，使用存储过程比较方便，而且可以有效利用SQL中的事务处理的机制；●5）使用存储过程，可以实现存储过程设计和编码工作分开进行，只要将存储过程名、参数、及返回信息告诉编码人员即可；●6）但使用存储过程封装业务逻辑将限制应用程序的可移植性；另外，如果更改存储过程的参数或者其返回的数据及类型的话，需要修改应用程序的相关代码，比较繁琐。

（3）过程的语法结构（4）创建过程实例●创建名为stu_proc的过程,create是创建过程的标识符,replace表示若同名过程存在将覆盖原过程.例子：该过程定义了一个变量,其类型和student数据表中的sname字段类型相同,都是字符型,将数据表中的sno字段为1的sname字段内容送入变量中,然后输出结果.结果（5）存储过程例子set serverout on或者例子：BEGINdbms_output.put_line('Hello World'); END;/或begindbms_output.enable(1000);dbms_output.put_line('hello, world');end;（6）测试存储过程方式1、选择需要测试的存储过程，右键“测试”2、使用语句call XXX() （7）参数。

调用oracle存储

存储过程在小公司用的不多，但是如果业务比较复杂或者性能要求比较苛刻的时候存储过程就派上用场了，我选择了mybatis来做实验。

1.无输入和输出参数的存储过程我写了一个比较简单的，需要注意的是Oracle无参存储过程不能写括号返回游标可以直接用下面的方法上面原作者的写法太麻烦了?1 2 3 4 5 6 Map map = new HashMap();map.put("jid", jid);userInfoMapper.getFriendList(map);//result 为在mybatis xml文件时写的返回结果名List<UserInfo> list = (List<UserInfo>)map.get("result"); return list;1、xml文件<select id="getGroupNum" statementType="CALLABLE" parameterType="com.guorui.model.ParamSPC">{call GYL_COMMON.GETGROUPNUM(#{IN_PARAMETERID,jdbcType=VARCHAR,mode=IN},#{IN_STEELID,jdbcType=VARCHAR,mode=IN},null,null,null,#{OUT_GN,jdbcType=INTEGER,mode=OUT},#{RST,jdbcType=CURSOR,mode=OUT,resultMap=BaseResultMap2,javaType=java.sql.ResultSet} )}</select><resultMap id="BaseResultMap2" type="com.guorui.dao.TbSysUser"><result column="USERID" jdbcType="DECIMAL" property="userid" /><result column="NUSERID" jdbcType="VARCHAR" property="nuserid" /><result column="STRUSERNAME" jdbcType="VARCHAR" property="strusername" /><result column="STRDEP" jdbcType="VARCHAR" property="strdep" /><result column="STRDUTY" jdbcType="VARCHAR" property="strduty" /><result column="STRUSERPWD" jdbcType="VARCHAR" property="struserpwd" /><result column="DTINSDATE" jdbcType="TIMESTAMP" property="dtinsdate" /><result column="STRINSBY" jdbcType="VARCHAR" property="strinsby" /><result column="DTUPTDATE" jdbcType="TIMESTAMP" property="dtuptdate" /><result column="STRUPTBY" jdbcType="VARCHAR" property="struptby" /><result column="LOGIN_COUNT" jdbcType="DECIMAL" property="loginCount" /><result column="LOGIN_LAST_TIME" jdbcType="TIMESTAMP" property="loginLastTime" /><result column="STATUS" jdbcType="VARCHAR" property="status" /><result column="STRDEPNO" jdbcType="VARCHAR" property="strdepno" /></resultMap>2、parameter beanpublic class ParamSPC {String IN_PARAMETERID;String IN_STEELID;Integer OUT_GN;List<TbSysUser> RST;public String getIN_PARAMETERID() {return IN_PARAMETERID;}public void setIN_PARAMETERID(String iN_PARAMETERID) {IN_PARAMETERID = iN_PARAMETERID;}public String getIN_STEELID() {return IN_STEELID;}public void setIN_STEELID(String iN_STEELID) {IN_STEELID = iN_STEELID;}public Integer getOUT_GN() {return OUT_GN;}public void setOUT_GN(Integer oUT_GN) {OUT_GN = oUT_GN;}public List<TbSysUser> getRST() {return RST;}public void setRST(List<TbSysUser> rST) {RST = rST;}}3、xxxMaper.java 中的方法Object getGroupNum(ParamSPC param);4、使用demoSqlSession session = AllSqlMap.getInstance().openSession();try {TbSysUserMapper mapper = session.getMapper(TbSysUserMapper.class); ParamSPC param = new ParamSPC();param.setIN_PARAMETERID("010401"); // 填充in 参数，out 参数不用任何处理param.setIN_STEELID("65Mn棒带");mapper.getGroupNum(param);System.out.println(param.getOUT_GN()); // 获取计算结果System.out.println(param.getRST().size());mit(true);} catch(Exception e){e.printStackTrace();session.rollback(true);} finally {session.close();}。

oracle存储过程调用javasource的方法

oracle存储过程调用javasource的方法Oracle存储过程调用Java方法介绍在Oracle数据库中，我们可以使用存储过程来执行一系列的数据库操作。

有时候，我们希望在存储过程中调用Java方法，以实现一些比较复杂的逻辑。

本文将详细介绍在Oracle存储过程中调用Java方法的几种方法。

方法一：使用Java Stored ProcedureJava Stored Procedure是Oracle数据库提供的一种特殊的存储过程类型，在该类型的存储过程中可以直接调用Java方法。

步骤：1.创建Java类，并将其编译成字节码文件（.class文件）。

2.将字节码文件导入到数据库中，可以使用loadjava工具或通过SQL语句执行导入。

3.创建Java Stored Procedure，将其指定为刚导入的字节码文件，并编写实际的存储过程逻辑。

4.在需要的地方调用Java Stored Procedure。

优点：•简单易用，只需创建Java类和Java Stored Procedure即可。

•可以直接访问数据库，无需通过其他方式。

缺点：•必须将Java类编译成字节码文件并导入到数据库中，稍显麻烦。

•Java Stored Procedure在数据库中运行，可能会造成数据库性能的损耗。

方法二：使用外部过程调用Java方法Oracle数据库通过提供外部过程功能，允许我们在存储过程中调用外部的Java方法。

步骤：1.将Java方法包装成Java函数或Java过程，并将其编译成动态加载库文件（.so或.dll文件）。

2.使用CREATE LIBRARY语句在数据库中创建对应的外部库。

3.创建存储过程，将其指定为调用外部库中的函数或过程，并编写实际的存储过程逻辑。

4.在需要的地方调用存储过程。

优点：•可以方便地调用已存在的Java方法，无需修改原有代码。

•外部过程在数据库外部运行，不会对数据库性能造成影响。

调用oracle存储过程(详解)

PL/SQL 块的结构和实例
• • • • • • • • • • • • • • • • • • • • • • •
1.使用各种if 语句 2.使用循环语句 3.使用控制语句——goto 和null；条件分支语句 pl/sql 中提供了三种条件分支语句if—then，if – then – else，if – then – elsif – then 这里我们可以和java 语句进行一个比较简单的条件判断 if – thenn 问题：编写一个过程，可以输入一个雇员名，如果该雇员的工资低于2000，就给该员工工资增加10%。 Sql 代码 1. create or replace procedure sp_pro6(spName varchar2) is 2. --定义 3. v_sal emp.sal%type; 4. begin 5. --执行 6. select sal into v_sal from emp where ename=spName; 7. --判断 8. if v_sal<2000 then 9. update emp set sal=sal+sal*10% where ename=spName; 10. end if; 11.end; 12./
PL/SQL 块的结构和实例
• • • • • •
pl/sql分类 -- 过程，函数，包，触发器过程过程用于执行特定的操作，当建立过程时，既可以指定输入参数(in)，也可以指定输出参数(out)，通过在过程中使用输入参数，可以将数据传递到执行部分；通过使用输出参数，可以将执行部分的数据传递到应用环境。在sqlplus 中可以使用create procedure 命令来建立过程。
PL/SQL 块的结构和实例

Oracle存储过程和java调用

1 存储过程介绍存储过程是指用于特定操作的pl/sql块，是由流控制和sql语句书写的过程。

存储过程经编译和sql优化后存储在数据库服务器中，使用时候只需要调用即可。

2 存储过程的优点1 使用存储过程，可以实现存储过程设计和编码工作分开进行，只要将存储过程名，参数，以及返回信息告诉编码人员即可。

2 使用存储过程可以减少sql注入式攻击，提供系统的安全性。

3 执行存储过程的用户要具有一定的权限才能使用存储过程。

没有数据操作权限的用户只能在系统控制下间接的存取数据。

4 存储过程的代码直接放在了数据库中，一般由客户端直接通过存储过程的名称来进行调用，简化客户端的操作逻辑。

3 存储过程的语法存储过程包含三部分声明，执行部分，异常。

可以有无参数的或带参数的存储过程。

存储过程的定义：Create [or replace] procedure procedure_name[(parameter1[mode] datatype1,parameter2 [model] datatype2…)]IS[As]BeginPl/sql block;End [procedure_name]其中： procedure_name是存储过程的名字，parameter用于指定参数，model用于指定参数模式，datatype用于指定参数类型， IS [AS]用于开始PL/SQL代码块。

注：1，当定义存储过程的参数时，只能指定数据类型，不能指定数据长度。

2，建立存储过程时，既可以指定存储过程的参数，也可以不提供任何参数。

3，存储过程的参数主要有三种类型：输入参数(IN)、输出参数(OUT)、输入输出参数(IN OUT)，其中IN用于接收调用环境的输入参数，OUT用于将输出数据传递到调用环境，IN OUT不仅要接收数据，而且要输出数据到调用环境。

4 一个简单的存储过程+调试写一个存储过程--修改其中的数据select count(*) from table1 where name='weiguo' 的查询结果是 count(*)=0如果涉及到两个或以上的输入参数，如下图：5 存储过程和java程序的接口操作5.1 无返回值的存储过程查询数据库-显示5.2 有返回值的存储过程（非列表-单个出参）注意，这里的proc.getString(2)中的数值2并非任意的，而是和存储过程中的out列对应的，如果out是在第一个位置，那就是proc.getString(1)，如果是第三个位置，就是proc.getString(3)，当然也可以同时有多个返回值，那就是再多加几个out参数了。

java调用oracle存储过程

Java 调用存储过程为了同学们方便请使用system用户登录操作（一）创建表T_DEMO1CREATE TABLE system.T_DEMO1( "ID" number,"NAME" varchar)（二）注意，如果scott没有创建存储过程的权限，可以用sys用户登录创建权限创建存储过程create or replace procedure p_demo1(para1 in number,para2 in varchar2) isbeginINSERT INTO scott.t_demo1(id,name) VALUES (PARA1, PARA2);commit ;end p_demo1;（3）创建存储过程和创建表一样都可以在navicate或pl/sql或sql/plus 里执行。

看存储过程是否可用可以在sql/plus 活在pl/sql或navicat工具里面执行call p_demo1(1,'rrr') ;看看存储过程是否成功（4）java调用无返回值的存储过程请查看CallProdures1代码以下是调用有返回值的存储过程（1）创建存储过程CREATE OR REPLACE PROCEDURE p_demo2(PARA1 in number,PARA2 OUT VARCHAR2) ASBEGINSELECT name INTO PARA2 FROM scott.t_demo1 WHERE id= PARA1;END p_demo2;（2）请查看CallDemo2例子以下是调用返回是列表的存储过程（1）由于oracle存储过程没有返回值，它的所有返回值都是通过out参数来替代的，列表同样也不例外，但由于是集合，所以不能用一般的参数，必须要用package了.所以要分两部分（2）创建包（package）CREATE OR REPLACE PACKAGE p_package ASTYPE Test_CURSOR IS REF CURSOR;end p_package;（3）创建存储过程CREATE OR REPLACE PROCEDURE p_demo3(p_CURSOR out p_package.Test_CURSOR) ISBEGINOPEN p_CURSOR FOR SELECT * FROM scott.t_demo1;END p_demo3;（4）具体代码参考CallDemo3。

java oracle存储过程写法及调用

java oracle存储过程写法及调用Java中调用和编写Oracle存储过程是非常常见的操作，可以利用存储过程来执行数据库操作，提高数据库的性能和安全性。

本文将为您详细介绍Java中调用和编写Oracle存储过程的方法和步骤。

一、什么是Oracle存储过程？Oracle存储过程是一段预定义在数据库中的PL/SQL代码，可以像函数一样接收参数和返回值，用于完成特定的数据库操作。

存储过程可以包含SQL语句、逻辑控制语句、流程控制语句等，可以完成复杂的业务逻辑和数据库操作。

二、Java中调用Oracle存储过程的步骤1. 导入相关的JDBC驱动在Java中调用Oracle存储过程之前，首先需要导入相关的JDBC驱动。

可以从Oracle官网下载相应版本的JDBC驱动，将其添加到Java项目的classpath中。

2. 建立数据库连接使用JDBC的Connection对象与数据库建立连接。

可以使用如下代码建立连接：String url = "jdbc:oracle:thin:localhost:1521:orcl";String username = "username";String password = "password";Connection conn = DriverManager.getConnection(url, username, password);需要将url、username和password替换为实际的数据库连接信息。

3. 创建CallableStatement对象使用Connection对象的prepareCall方法创建CallableStatement对象，该对象用于执行存储过程的调用。

String sql = "{call 存储过程名称(?, ?)}";CallableStatement cstmt = conn.prepareCall(sql);需要将存储过程名称替换为实际的存储过程名称。

java调用存储过程

Java 调用存储过程PL/SQL子程序，很多情况下是给应用程序来调用的，所有我们要掌握使用其他编程语言来调用我们写好的存储过程。

下面我们介绍下使用java调用Oracle的存储过程。

1.配置调用类package com.mscncn.plsql.util;import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;public class DBUtil {static{try {Class.forName("oracle.jdbc.OracleDriver");} catch (ClassNotFoundException e) {e.printStackTrace();}}public static Connection getConntection(){Connection ct=null;try {ct = DriverManager.getConnection("jdbc:oracle:thin:@192.168.0.25:1521:oracle","scott","scott");} catch (SQLException e) {e.printStackTrace();}return ct;}}2.编写存储过程create or replace package pro_pk istype pager_cursor is ref cursor;procedure add_dept(dept_no in number,dept_name in varchar2,location in varchar2);procedure delete_dept(dept_no in number,num out number);end pro_pk;create or replace package body pro_pk isprocedure add_dept(dept_no in number,dept_name in varchar2,location in varchar2)isexp_remaining exception;pragma exception_init(exp_remaining,-1);/*非预定义错误，-1是违反唯一约束*/ begininsert into dept values(dept_no,dept_name,location);if sql%found then /*隐式游标，sql*/return 1;elsereturn 0;end if;exceptionwhen exp_remaining thendbms_output.put_line('违反唯一约束.');end add_dept;procedure delete_dept(dept_no in number,num out number)isbegindelete from dept where deptno=dept_no;if sql%found thennum:=1;elsenum:=1;end if;end delete_dept;end pro_pk;create or replace package pageUtil istype page_cursor is ref cursor;--定义一个游标类型procedure pager(tName in varchar2, --表名pageNum in number, --页数pageSize in number,--每页记录数totalRecord out number,--总记录数totalPage out number,--总页数p_cursor out page_cursor);end pageUtil;create or replace package body pageUtil isprocedure pager(tName in varchar2, --表名pageNum in number, --页数pageSize in number,--每页记录数totalRecord out number,--总记录数totalPage out number,--总页数p_cursor out page_cursor) is--定义sql语句字符串v_sql varchar2(1000);--分页开始位置，与结束位置v_begin number:=(pageNum-1)*pageSize+1;v_end number:=pageNum*pageSize;beginv_sql:='select * from ( select t.*,rownum rn from '||tName||' t where rownum<='||v_end||') where rn>='||v_begin;--把游标和sql关联dbms_output.put_line(v_sql);open p_cursor for v_sql;--计算totalRecord与totalPagev_sql:='select count(*) from '||tName;--execute immediate v_sql into totalRecord;if mod(totalRecord,pageSize)=0 thentotalPage:=totalRecord/pageSize;elsetotalPage:=totalRecord/pageSize+1;end if;--关闭游标,这儿需要注意，如果我们在java程序中使用cursor,那么就一定不能关闭cursor--否则关闭cursor后，java程序中返回的结果集就是null--close p_cursor;end pager;end pageUtil;3.调用存储过程1）调用没有返回值的存储过程/*** java调用没有返回值的存储过程*/@Testpublic void proNoReulstTest(){Connection ct=DBUtil.getConntection();try {CallableStatement cs=ct.prepareCall("{call pro_pk.add_dept(?,?,?)}");cs.setInt(1, 13);cs.setString(2, "java开发部");cs.setString(3, "中国信阳");cs.execute();} catch (SQLException e) {e.printStackTrace();}finally{try {ct.close();} catch (SQLException e) {e.printStackTrace();}}}2）调用有返回值的存储过程/*** java调用有返回值的存储过程(返回值类型为number)*/@Testpublic void proHasReulstTest(){Connection ct=DBUtil.getConntection();try {CallableStatement cs=ct.prepareCall("{call pro_pk.delete_dept(?,?)}");cs.setInt(1, 13);//注册第二个参数为存储过程的返回值cs.registerOutParameter(2, OracleType.STYLE_INT);cs.execute();//通过参数的索引，来获取存储过程的返回值，索引从1开始int num=cs.getInt(2);System.out.println(num==1?"删除成功":"删除失败");} catch (SQLException e) {e.printStackTrace();}finally{try {ct.close();} catch (SQLException e) {e.printStackTrace();}}}3）java程序调用存储过程返回值为游标/*** 存储过程返回一个游标*/@Testpublic void proReturnCursorTest(){Connection ct=DBUtil.getConntection();try {CallableStatement cs=ct.prepareCall("{call pageUtil.pager(?,?,?,?,?,?)}");cs.setString(1, "emp");cs.setInt(2, 2);cs.setInt(3, 5);cs.registerOutParameter(4, OracleTypes.NUMBER);cs.registerOutParameter(5, OracleTypes.NUMBER);cs.registerOutParameter(6, OracleTypes.CURSOR);cs.execute();//通过参数的索引，来获取存储过程的返回值，索引从1开始int totalRecord=cs.getInt(4);int totalPage=cs.getInt(5);ResultSet rs=(ResultSet)cs.getObject(6);System.out.println("总记录数为:"+totalRecord+",总页数为:"+totalPage);while(rs.next()){System.out.println("雇员编号："+rs.getInt("empno")+",雇员姓名:"+rs.getString("ename"));}} catch (SQLException e) {e.printStackTrace();}finally{try {ct.close();} catch (SQLException e) {e.printStackTrace();}} }。

oracle 存储过程调用java

oracle 存储过程调用java一收藏一、如何创建java存储过程？通常有三种方法来创建java存储过程。

1. 使用oracle的sql语句来创建：e.g. 使用create or replace and compile java source named "<name>" as后边跟上java源程序。

要求类的方法必须是public static的，才能用于存储过程。

SQL> create or replace and compile java source named "javademo1"2 as3 import java.sql.*;4 public class JavaDemo15 {6 public static void main(String[] argv)7 {8 System.out.println("hello, java demo1");9 }10 }11 /Java 已创建。

SQL> show errors java source "javademo1"没有错误。

SQL> create or replace procedure javademo12 as3 language java name ''JavaDemo1.main(ng.String[])'';4 /过程已创建。

SQL> set serveroutput onSQL> call javademo1();调用完成。

SQL> call dbms_java.set_output(5000);调用完成。

SQL> call javademo1();hello, java demo1调用完成。

如何实现Java对0racle存储过程的调用

的作用
ｓｍｔｓｔｔｉｇ１ｖｉｄｐｎ）ｔ．ｅＳｒ（，ｎｅｔｏ；ｎ
ｓｍｔｘｃｔＵｄｔ（ｔ．ｅｕｅｐａｅ）ｅ：
／的结果集：／取
Ｒｓｌｅ＝（ａｌａｔｂＳａｅｎ）ｍｔｇｔｕｓ）ｅｕＳｔｓ（ｃｅｌｌｔｔｍｅｔｔ）ｅＣｒｏ：ｔｒＯｒＣａｅｓ．
Ｐ／Ｑ中创建ＪｖＯＲＥ对象．然后再把ＪｖＯＲＥＬＳＬａａＳＵＣａａＳＵＣ对象转换成Ｐ／ＱＬＳＬ存储过程。因为Ｊｖａａ访问操作系统资源
的接口相当丰富．基本都能满足各种业务场景的需求，比如访问文件、调用动态链接库等，现在实现一个具体应用，就是访问操作系统的目录树及其下的文件，主要起个抛砖引玉 ‘ ｒｃｅｔｉ＠１４．０４９１２：ｒｌｃｔ＂ｔｇｒ），＂
或用动态的ＳＬ语句来对数据库对象的控制操作，如创建或Ｑ
删除数据库表、数据库视图等数据库对象。但是在有些业务场景中，需要在Ｐ／Ｑ中直接访问或控制操作系统的一些ＬＳＬ资源，操作系统的资源有很多，比如文件、设备、操作系统的ＡＩ等，以实现一些特定的功能需求，实现这种功能的Ｐ等

JAVA调用ORACLE存储过程小结

JAVA调用ORACLE存储过程小结在Java中调用Oracle存储过程是一个常见的需求，本文将给出一个关于如何在Java中调用Oracle存储过程的小结。

主要包括以下方面内容：1. 连接到Oracle数据库：首先需要使用Java的JDBC API来连接到Oracle数据库。

可以使用Oracle提供的JDBC驱动程序，通过加载驱动程序的方式来建立与数据库的连接。

在连接数据库时，需要提供数据库的URL、用户名和密码。

2. 构造存储过程的调用语句：在Java中调用Oracle存储过程时，需要构造一个适当的SQL语句来调用存储过程。

调用语句的格式为“{call 存储过程名(参数1, 参数2, ...)}”。

3. 设置存储过程的输入参数：在构造存储过程的调用语句后，需要通过PreparedStatement对象设置存储过程的输入参数。

这可以通过调用PreparedStatement对象的setXXX(方法来实现，其中XXX是参数的数据类型。

例如，如果输入参数是整数类型，则可以调用setInt(方法设置参数的值。

4. 执行存储过程：设置好存储过程的输入参数后，可以通过调用PreparedStatement对象的executeUpdate(或execute(方法来执行存储过程。

executeUpdate(方法适用于执行插入、更新或删除操作的存储过程，而execute(方法适用于执行查询操作的存储过程。

5. 获取存储过程的输出参数：执行存储过程后，可以通过PreparedStatement对象的getXXX(方法来获取存储过程的输出参数的值。

需要注意的是，存储过程的输出参数必须在执行存储过程之前通过调用registerOutParameter(方法来注册。

6. 关闭连接和释放资源：执行完存储过程后，需要关闭与数据库的连接，并释放相关的资源。

可以通过调用Connection对象的close(方法来关闭连接。

下面是一个示例代码，展示了如何在Java中调用Oracle存储过程：```javaimport java.sql.*;public class CallOracleProcedurepublic static void main(String[] args)Connection conn = null;CallableStatement stmt = null;try// 连接到Oracle数据库Class.forName("oracle.jdbc.driver.OracleDriver");//构造存储过程的调用语句String sql = "{call PROCEDURE_NAME(?, ?, ?)}";stmt = conn.prepareCall(sql);//设置存储过程的输入参数stmt.setString(1, "input1");stmt.setInt(2, 10);//注册存储过程的输出参数stmt.registerOutParameter(3, Types.VARCHAR);//执行存储过程stmt.executeUpdate(;//获取存储过程的输出参数String output = stmt.getString(3);System.out.println("Output: " + output);} catch (SQLException ， ClassNotFoundException e) e.printStackTrace(;} finally//关闭连接和释放资源tryif (stmt != null) stmt.close(;if (conn != null) conn.close(;} catch (SQLException e)e.printStackTrace(;}}}```上述示例代码展示了如何通过Java程序调用Oracle存储过程。

java下实现调用oracle的存储过程和函数

java下实现调用oracle的存储过程和函数在oracle下创建一个test的账户，然后1.创建表：STOCK_PRICES[cpp]view plaincopyprint?1.--创建表格2.CREATE TABLE STOCK_PRICES(3.RIC VARCHAR(6) PRIMARY KEY,4.PRICE NUMBER(7,2),5.UPDATED DATE );2.插入测试数据：[sql]view plaincopyprint?1.--插入数据2.INSERT INTO stock_prices values('1111',1.0,SYSDATE);3.INSERT INTO stock_prices values('1112',2.0,SYSDATE);4.INSERT INTO stock_prices values('1113',3.0,SYSDATE);5.INSERT INTO stock_prices values('1114',4.0,SYSDATE);3.建立一个返回游标：PKG_PUB_UTILS[cpp]view plaincopyprint?1.--建立一个返回游标2.CREATE OR REPLACE PACKAGE PKG_PUB_UTILS IS3.--动态游标4.TYPE REFCURSOR IS REF CURSOR;5.END PKG_PUB_UTILS;4.创建和存储过程：P_GET_PRICE[sql]view plaincopyprint?1.--创建存储过程2.CREATE OR REPLACE PROCEDURE P_GET_PRICE3.(4.AN_O_RET_CODE OUT NUMBER,5.AC_O_RET_MSG OUT VARCHAR2,6.CUR_RET OUT PKG_PUB_UTILS.REFCURSOR,7.AN_I_PRICE IN NUMBER8.)9.IS10.BEGIN11.AN_O_RET_CODE := 0;12.AC_O_RET_MSG := '操作成功';13.14.OPEN CUR_RET FOR15.SELECT * FROM STOCK_PRICES WHERE PRICE<AN_I_PRICE;16.EXCEPTION17.WHEN OTHERS THEN18.AN_O_RET_CODE := -1;19.AC_O_RET_MSG := '错误代码:' || SQLCODE || CHR(13) || '错误信息:' || SQLERRM;20.END P_GET_PRICE;5.创建函数：[cpp]view plaincopyprint?1.--创建函数：F_GET_PRICE2.CREATE OR REPLACE FUNCTION F_GET_PRICE(v_price IN NUMBER)3.RETURN PKG_PUB_UTILS.REFCURSOR4.AS5.stock_cursor PKG_PUB_UTILS.REFCURSOR;6.BEGIN7.OPEN stock_cursor FOR8.SELECT * FROM stock_prices WHERE price < v_price;9.RETURN stock_cursor;10.END;6.JAVA调用存储过程返回结果集JDBCoracle10G_INVOKEPROCEDURE.java[java]view plaincopyprint?1.import java.sql.*;2.import oracle.jdbc.OracleCallableStatement;3.import oracle.jdbc.OracleTypes;4.5./* 本例是通过调用oracle的存储过程来返回结果集:6.* oracle 9i、10G 的jdbc由1个jar包组成：classes12.zip7.*/8.public class JDBCoracle10G_INVOKEPROCEDURE {9.Connection conn = null;10.Statement statement = null;11.ResultSet rs = null;12.CallableStatement stmt = null;13.14.String driver;15.String url;16.String user;17.String pwd;18.String sql;19.String in_price;20.21.public JDBCoracle10G_INVOKEPROCEDURE()22.{23.driver = "oracle.jdbc.driver.OracleDriver";24.url = "jdbc:oracle:thin:@localhost:1521:ORCL";25.// oracle 用户er = "test";27.// oracle 密码28.pwd = "test";29.init();30.// mysid：必须为要连接机器的sid名称，否则会包以下错：31.// java.sql.SQLException: Io 异常: Connection32.//refused(DESCRIPTION=(TMP=)(VSNNUM=169870080)(ERR=12505)(ERROR_STACK=(ERRO R=(CODE=12505)(EMFI=4))))33.// 参考连接方式:34.// Class.forName( "oracle.jdbc.driver.OracleDriver" );35.// cn = DriverManager.getConnection(36.// "jdbc:oracle:thin:@MyDbComputerNameOrIP:1521:ORCL", sUsr, sPwd );37.38.}39.40.public void init() {41.System.out.println("oracle jdbc test");42.try {43.Class.forName(driver);44.System.out.println("driver is ok");45.conn = DriverManager.getConnection(url, user, pwd);46.System.out.println("conection is ok");47.statement = conn.createStatement();48.// conn.setAutoCommit(false);49.// 输入参数50.in_price = "3.0";51.// 调用函数52.stmt = conn.prepareCall("call P_GET_PRICE(?,?,?,?)");53.stmt.registerOutParameter(1, java.sql.Types.FLOAT);54.stmt.registerOutParameter(2, java.sql.Types.CHAR);55.stmt.registerOutParameter(3, oracle.jdbc.OracleTypes.CURSOR);56.stmt.setString(4, in_price);57.stmt.executeUpdate();58.int retCode = stmt.getInt(1);59.String retMsg = stmt.getString(2);60.if (retCode == -1) { // 如果出错时，返回错误信息61.System.out.println("报错！");62.} else {63.// 取的结果集的方式一：64.rs = ((OracleCallableStatement) stmt).getCursor(3);65.// 取的结果集的方式二：66.// rs = (ResultSet) stmt.getObject(3);67.String ric;68.String price;69.String updated;70.// 对结果进行输出71.while (rs.next()) {72.ric = rs.getString(1);73.price = rs.getString(2);74.updated = rs.getString(3);75.System.out.println("ric:" + ric + ";-- price:" + price76.+ "; --" + updated + "; ");77.}78.}79.80.} catch (Exception e) {81.e.printStackTrace();82.} finally {83.System.out.println("close ");84.}85.}86.87.public static void main(String args[])// 自己替换［］88.{89.new JDBCoracle10G_INVOKEPROCEDURE();90.}91.}7.开发JAVA调用函数返回结果集JDBCoracle10G_INVOKEFUNCTION.java[java]view plaincopyprint?1.import java.sql.*;2.import oracle.jdbc.OracleCallableStatement;3.import oracle.jdbc.OracleTypes;4.5./*6./* 本例是通过调用oracle的函数来返回结果集:7.* oracle 9i、10G 的jdbc由1个jar包组成：classes12.zip8.*/9.public class JDBCoracle10G_INVOKEFUNCTION {10.Connection conn = null;11.Statement statement = null;12.ResultSet rs = null;13.CallableStatement stmt = null;14.15.String driver;16.String url;17.String user;18.String pwd;19.String sql;20.String in_price;21.22.public JDBCoracle10G_INVOKEFUNCTION()23.{24.driver = "oracle.jdbc.driver.OracleDriver";25.url = "jdbc:oracle:thin:@localhost:1521:ORCL";26.// oracle 用户er = "test";28.// oracle 密码29.pwd = "test";30.init();31.// mysid：必须为要连接机器的sid名称，否则会包以下错：32.// java.sql.SQLException: Io 异常: Connection33.//refused(DESCRIPTION=(TMP=)(VSNNUM=169870080)(ERR=12505)(ERROR_STACK=(ERRO R=(CODE=12505)(EMFI=4))))34.// 参考连接方式:35.// Class.forName( "oracle.jdbc.driver.OracleDriver" );36.// cn = DriverManager.getConnection(37.// "jdbc:oracle:thin:@MyDbComputerNameOrIP:1521:ORCL", sUsr, sPwd );38.}39.40.public void init() {41.System.out.println("oracle jdbc test");42.try {43.Class.forName(driver);44.System.out.println("driver is ok");45.conn = DriverManager.getConnection(url, user, pwd);46.System.out.println("conection is ok");47.statement = conn.createStatement();48.// conn.setAutoCommit(false);49.// 输入参数50.in_price = "5.0";51.// 调用函数52.stmt = conn.prepareCall("{? = call F_GET_PRICE(?)}");53.// stmt.registerOutParameter(1, java.sql.Types.FLOAT);54.// stmt.registerOutParameter(2, java.sql.Types.CHAR);55.stmt.registerOutParameter(1, oracle.jdbc.OracleTypes.CURSOR);56.stmt.setString(2, in_price);57.stmt.executeUpdate();58.// 取的结果集的方式一：59.rs = ((OracleCallableStatement) stmt).getCursor(1);60.// 取的结果集的方式二：61.// rs = (ResultSet) stmt.getObject(1);62.String ric;63.String price;64.String updated;65.66.while (rs.next()) {67.ric = rs.getString(1);68.price = rs.getString(2);69.updated = rs.getString(3);70.System.out.println("ric:" + ric + ";-- price:" + price + "; --"71.+ updated + "; ");72.}73.74.} catch (Exception e) {75.e.printStackTrace();76.} finally {77.System.out.println("close ");78.}79.}80.81.public static void main(String args[])// 自己替换［］82.{83.new JDBCoracle10G_INVOKEFUNCTION();84.}85.}。

用java调用oracle存储过程总结

用java‎调用ora‎cle存储‎过程总结分类：PL/SQL系列‎2009-09-24 15:08 253人阅‎读评论(0) 收藏举报声明：以下的例子‎不一定正确‎，只是为了演‎示大概的流‎程。

一：无返回值的‎存储过程存储过程为‎：CREAT‎E OR REPLA‎C E PROCE‎D URE TESTA‎(PARA1‎IN VARCH‎A R2,PARA2‎IN VARCH‎A R2) ASBEGIN‎INSER‎T INTO HYQ.B_ID (I_ID,I_NAM‎E) VALUE‎S (PARA1‎, PARA2‎);END TESTA‎;然后呢，在java‎里调用时就‎用下面的代‎码：packa‎g e com.hyq.src;impor‎t java.sql.*;impor‎t java.sql.Resul‎t Set;publi‎c class‎TestP‎r oced‎u reOn‎e {publi‎c TestP‎r oced‎u reOn‎e() {}publi‎c stati‎c void main(Strin‎g[] args ){Strin‎g drive‎r = "oracl‎e.jdbc.drive‎r.Oracl‎e Driv‎e r";Strin‎g strUr‎l = "jdbc:oracl‎e:thin:@127.0.0.1:1521: hyq ";State‎m ent stmt = null;Resul‎t Set rs = null;Conne‎c tion‎conn = null;Calla‎b leSt‎a teme‎n t cstmt‎= null;try {Class‎.forNa‎m e(drive‎r);conn = Drive‎r Mana‎g er.getCo‎n nect‎i on(strUr‎l, " hyq ", " hyq ");Calla‎b leSt‎a teme‎n t proc = null;proc = conn.prepa‎r eCal‎l("{ call HYQ.TESTA‎(?,?) }");proc.setSt‎r ing(1, "100");proc.setSt‎r ing(2, "TestO‎n e");proc.execu‎t e();}catch‎(SQLEx‎c epti‎o n ex2) {ex2.print‎S tack‎T race‎();}catch‎(Excep‎t ion ex2) {ex2.print‎S tack‎T race‎();}final‎l y{try {if(rs != null){rs.close‎();if(stmt!=null){stmt.close‎();}if(conn!=null){conn.close‎();}}}catch‎(SQLEx‎c epti‎o n ex1) {}}}}二：有返回值的‎存储过程（非列表）当然了，这就先要求‎要建张表T‎ESTTB‎,里面两个字‎段（I_ID，I_NAM‎E）。

Oracle存储过程及调用

Oracle存储过程及调⽤Oracle存储过程语法Oracle的存储过程语法如下：create procedure 存储过程名称（随便取）is在这⾥可以定义常量、变量、游标、复杂数据类型这⾥可以定义变量、常量begin执⾏部分end;（2）带参数的存储过程语法：create procedure 存储过程名称（随便取） (变量1 数据类型,变量2 数据类型,...,变量n 数据类型)is在这⾥可以定义常量、变量、游标、复杂数据类型这⾥可以定义变量、常量begin执⾏部分end;（3）带输⼊、输出参数的存储过程语法：create procedure 存储过程名称（随便取） (变量1 in(或out) 数据类型,变量2 in(或out) 数据类型,...,变量n in(或out) 数据类型)is在这⾥可以定义常量、变量、游标、复杂数据类型这⾥可以定义变量、常量begin执⾏部分end;注意：⽤上⾯的语法创建存储过程时可能会碰到数据库中已经有了同名的存储过程，这样Oracle就会弹框报错，说名字已被现有对象使⽤。

解决⽅法有两种：⽅法⼀：换个存储过程名⽅法⼆：在最开头的create procedure 之间加上 or replace 关键字，例如：create or replace procedure 存储过程名称。

但是这种⽅法不建议使⽤，因为这种⽅法会把之前同名的存储过程替换为你当前写的这个存储过程案例⼀：没参数的存储过程create replace procedure procedure_1isbegindbms_output.put_line('procedure_1.......');end;存储过程案例⼆：带参数的的存储过程create procedure procedure_2(v_i number,v_j number)isv_m number(5);begindbms_output.put_line('procedure_2.......');v_m := v_i + v_j;dbms_output.put_line(v_i||' + '||v_j||' = '||v_m);end;存储过程案例三：带输⼊、输出参数的存储过程存储过程的参数分为输⼊参数和输出参数，输⼊参数：输⼊参数⼀般会在变量名和数据类型之间加in来表⽰该参数是输⼊参数输出参数：输出参数⼀般会在变量名和数据类型之间加out来表⽰该变量是输出参数不写in和out的话，默认为输⼊参数create procedure procedure_3(v_i in number,v_j in number ,v_m out number)isbegindbms_output.put_line('procedure_3.......');v_m:=v_i - v_j;dbms_output.put_line(v_i||' - '||v_j||' = '||v_m);end;PL/SQL块中调⽤存储过程下⾯以调⽤上⾯三个存储过程为例declarev_param1 number(5):=2;v_param2 number(5):=8;v_result number(5);begin--调⽤上⾯案例⼀的存储过程procedure_1();--调⽤上⾯案例⼆的存储过程procedure_2(v_param1,v_param2);--调⽤上⾯案例三的存储过程procedure_3(v_param1,v_param2,v_result);dbms_output.put_line(v_result);end;/*执⾏结果：*/procedure_1.......procedure_2.......2 + 8 = 10procedure_3.......2 - 8 = -610java调⽤存储过程案例⼀：java调⽤没有返回值的存储过程要求：编写⼀个像数据库emp表插⼊⼀条编号为6666，姓名为张三，职位为MANAGER的记录/*存储过程*/create procedure procedure_4(v_empno emp.empno%type,v_ename emp.ename%type,v_job emp.job%type )isbegininsert into emp (empno,ename,job) values (v_empno,v_ename,v_job);end;//java调⽤存储过程public static void main(String[] args) {Connection conn=null;CallableStatement cs=null;ResultSet rs=null;//java调⽤存储过程try {Class.forName("oracle.jdbc.OracleDriver");conn=DriverManager.getConnection("jdbc:oracle:thin:@127.0.01:1521:orcl", "scott", "tiger");cs=conn.prepareCall("{call procedure_4(?,?,?)}");//给输⼊参数赋值cs.setInt(1, 6666);cs.setString(2, "张三");cs.setString(3, "MANAGER");cs.execute();//执⾏} catch (Exception e) {e.printStackTrace();}finally{closeResource(conn,cs,rs);//关闭资源}}//执⾏后就会向数据库的emp表中插⼊⼀条编号为6666，姓名为张三，职位为MANAGER的记录案例⼆：java调⽤返回单列单⾏的存储过程要求：编写⼀个根据员⼯编号查找员⼯姓名的存储过程，并⽤java调⽤该存储过程/*存储过程*/create procedure procedure_5(v_empno in emp.empno%type,v_ename out emp.ename%type)isbeginselect ename into v_ename from emp where empno=v_empno;end;//java调⽤存储过程public static void main(String[] args) {Connection conn=null;CallableStatement cs=null;ResultSet rs=null;try {Class.forName("oracle.jdbc.OracleDriver");conn=DriverManager.getConnection("jdbc:oracle:thin:@127.0.01:1521:orcl", "scott","tiger");cs=conn.prepareCall("{call procedure_5(?,?)}");cs.setInt(1, 6666);//给输⼊参数赋值/*指定输出参数的数据类型语法：oracle.jdbc.OracleTypes.输出参数的数据类型此例输出参数的数据类型是varchar，所以是oracle.jdbc.OracleTypes.VARCHAR*/cs.registerOutParameter(2, oracle.jdbc.OracleTypes.VARCHAR);cs.execute();//执⾏//获取输出参数的值，位置要和输出参数对应？的位置对应起来，该例输出参数对应第2个问号，⽽且输出参数的数据类型为字符型，所以是cs.getString(2) String a=cs.getString(2);System.out.println("员⼯姓名："+a);} catch (Exception e) {e.printStackTrace();}finally{closeResource(conn,cs,rs);//关闭资源}}/*执⾏结果,控制台打印：*/结果：员⼯姓名：张三案例三：java调⽤返回单⾏多列的存储过程要求：编写⼀个根据员⼯编号查找员⼯姓名、职位和⼯资的存储过程，并⽤java调⽤该存储过程/*存储过程*/create procedure procedure_6(v_empno in emp.empno%type,v_ename out emp.ename%type,v_job out emp.job%type,v_sal out emp.sal%type)isbeginselect ename,job,sal into v_ename,v_job,v_sal from emp where empno=v_empno;end;//java调⽤存储过程public static void main(String[] args) {Connection conn=null;CallableStatement cs=null;ResultSet rs=null;try {Class.forName("oracle.jdbc.OracleDriver");conn=DriverManager.getConnection("jdbc:oracle:thin:@127.0.01:1521:orcl", "scott","tiger");cs=conn.prepareCall("{call procedure_6(?,?,?,?)}");cs.setInt(1, 7788);//指定输出参数的数据类型，注意：顺序要对应起来cs.registerOutParameter(2, oracle.jdbc.OracleTypes.VARCHAR);cs.registerOutParameter(3, oracle.jdbc.OracleTypes.VARCHAR);cs.registerOutParameter(4, oracle.jdbc.OracleTypes.DOUBLE);cs.execute();//执⾏//获取返回值String ename=cs.getString(2);//获取姓名String job=cs.getString(3);//获取职位double sal=cs.getDouble(4);//获取薪⽔System.out.println("员⼯编号为7788的姓名为："+ename+" 职位是："+job+" 薪⽔是："+sal);} catch (Exception e) {e.printStackTrace();}finally{closeResource(conn,cs,rs);//关闭资源}}/*执⾏结果，控制台打印：*/员⼯编号为7788的姓名为：SCOTT 职位是：ANALYST 薪⽔是：3000.0案例四：java调⽤返回多⾏多列（返回列表）的存储过程要求：编写⼀个根据部门编号查找部门所有员⼯信息的存储过程，并⽤java调⽤该存储过程/*定义游标*/create package my_package astype emp_cursor is ref cursor;end my_package;/*存储过程*/create procedure procedure_7(v_deptno in emp.deptno%type,emp_cursor out my_package.emp_cursor)isbeginopen emp_cursor for select * from emp where deptno=v_deptno;end;//java调⽤存储过程public static void main(String[] args) {Connection conn=null;CallableStatement cs=null;ResultSet rs=null;try {Class.forName("oracle.jdbc.OracleDriver");conn=DriverManager.getConnection("jdbc:oracle:thin:@127.0.01:1521:orcl", "scott","tiger");cs=conn.prepareCall("{call procedure_7(?,?)}");cs.setInt(1, 20);//给输⼊参数赋值cs.registerOutParameter(2, oracle.jdbc.OracleTypes.CURSOR );//指定输出参数的数据类型cs.execute();rs=(ResultSet) cs.getObject(2);//获取输出参数的值while(rs.next()){//顺序为数据库中字段前后顺序，例如数据库emp表中第5列为hiredate，数据类型为Date，所以获取第5列值时就应该⽤rs.getDate(5) System.out.println(rs.getInt(1)+" "+rs.getString(2)+" "+rs.getDate(5));}} catch (Exception e) {e.printStackTrace();}finally{closeResource(conn,cs,rs);//关闭资源}}/*以下就是20号部门所有员⼯的信息，这⾥为⽅便我们只打印了编号、姓名和⼊职时间运⾏结果，控制台打印：*/7369 SMITH 1980-12-177566 JONES 1981-04-027788 SCOTT 1987-04-197876 ADAMS 1987-05-237902 FORD 1981-12-03这是上⾯java调⽤存储过程代码中关闭资源⽅法的代码public static void closeResource(Connection conn,CallableStatement cs,ResultSet rs){if(rs!=null){try {rs.close();} catch (SQLException e) {e.printStackTrace();}}if(cs!=null){try {cs.close();} catch (SQLException e) {e.printStackTrace();}}if(conn!=null){try {conn.close();} catch (SQLException e) {e.printStackTrace();}}}最后给个应⽤，分页的存储过程分页存储过程：/*定义游标*/create package page_package astype page_cursor is ref cursor;end page_package;/*存储过程*/create procedure pro_paging (v_page_size in number,--每页显⽰多少条v_page_count out number,--总页数v_current_page in number,--当前页v_total_count out number,--记录总条数emp_cursor out page_package.page_cursor--返回查询结果集的游标)isv_begin number(5):=v_page_size*(v_current_page-1)+1;--查询起始位置v_end number(5):=v_page_size*v_current_page;--查询结束位置v_sql varchar2(1000):='select empno,ename from(select a.empno,a.ename,rownum rn from(select empno,ename from emp) awhere rownum<='|| v_end ||') bwhere b.rn>='||v_begin;/*不能像下⾯这么写，不然调⽤该存储过程时会报类型不⼀致的错，因为最⾥⾯查的只有empno,ename，因此外⾯也要和⾥⾯保持⼀致 v_sql varchar2(1000):=\'select * from(select a.*,rownum rn from(select empno,ename from emp) awhere rownum<=\'|| v_end ||\') bwhere b.rn>='||v_begin;*/v_ename varchar2(10);v_empno number(4);beginopen emp_cursor for v_sql;loopfetch emp_cursor into v_empno,v_ename;exit when emp_cursor%notfound;dbms_output.put_line(v_empno||' '||v_ename);end loop;v_sql:='select count(empno) from emp';execute immediate v_sql into v_total_count;if(mod(v_total_count,v_page_size)=0) thenv_page_count:=v_total_count/v_page_size;elsev_page_count:=trunc(v_total_count/v_page_size)+1;end if;dbms_output.put_line('共 '||v_total_count||' 条记录');dbms_output.put_line('共 '||v_page_count||' 页');dbms_output.put_line('当前页： '||v_current_page);dbms_output.put_line('每页显⽰ '||v_page_size||' 条');end;Java调⽤的话和上⾯java调⽤存储过程的例⼦⼀样。

java调用Oracle存储过程方式汇总

spring调用Oracle存储过程，并用cursor返回结果集1. 创建表：Java代码1.create table TEST_USERS2.(3. USER_ID VARCHAR2(10) not null,4. NAME VARCHAR2(10) not null,5. PASSWORD VARCHAR2(20) not null6.)2. 创建存储过程：Java代码1.create or replace package display_users_package is2. type search_results is ref cursor;3. procedure display_users_proc(results_out out search_results, userId in test_er_id%type);4.end display_users_package;5.6.create or replace package body display_users_package is7. procedure display_users_proc(results_out out search_results, userId in test_er_id%type)8. is9. begin10. if userId is not null then11. open results_out for select * from test_users where user_id like userId || '%';12. else13. open results_out for select * from test_users;14. end if;15. end display_users_proc;16.end display_users_package;这个results_out是一个游标类型，用来返回查找的结果集。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

1.基本结构CREATE OR REPLACEPROCEDURE 存储过程名字(参数1 IN NUMBER,参数2 IN NUMBERIS变量1 INTEGER :=0;变量2 DATE;BEGINEND 存储过程名字2.SELECT INTO STATEMENT将select查询的结果存入到变量中,可以同时将多个列存储多个变量中,必须有一条记录,否则抛出异常(如果没有记录抛出NO_DATA_FOUND例子:BEGINSELECT col1,col2 into 变量1,变量2 FROM typestruct where xxx;EXCEPTIONWHEN NO_DATA_FOUND THENxxxx;END;一:无返回值的存储过程存储过程为:CREATE OR REPLACE PROCEDURE TESTA(PARA1 IN VARCHAR2,PARA2 IN VARCHAR2 AS BEGININSERT INTO HYQ.B_ID (I_ID,I_NAME S (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 BEGINSELECT 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参数了。

三:返回列表由于oracle存储过程没有返回值,它的所有返回值都是通过out参数来替代的,列表同样也不例外,但由于是集合,所以不能用一般的参数,必须要用pagkage了.所以要分两部分,1,建一个程序包。

如下:CREATE OR REPLACE PACKAGE TESTPACKAGE ASTYPE Test_CURSOR IS REF CURSOR;end TESTPACKAGE;2,建立存储过程,存储过程为:CREATE OR REPLACE PROCEDURE TESTC(p_CURSOR out TESTPACKAGE.Test_CURSOR IS BEGINOPEN p_CURSOR FOR SELECT * FROM HYQ.TESTTB;END TESTC;可以看到，它是把游标（可以理解为一个指针），作为一个 out 参数来返回值的。

在 java 里调用时就用下面的代码： package com.hyq.src; import java.sql.*; import java.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 { } } } }在这里要注意，在执行前一定要先把 oracle 的驱动包放到 class 路径里，否则会报错。