ORACLE存储过程调用JAVA CLASS类
如何在Oracle中使用Java存储过程(详解)
如何在Oracle中使用Java存储过程(详解)如何在Oracle中使用Java存储过程(详解)一、如何缔造java存储过程?通常有三种步骤来缔造java存储过程。
1. 使用oracle的sql语句来缔造:e.g. 使用create or replace and compile java source named "" as后边跟上java源程序。
要求类的步骤必须是public static的,威力用于存储过程。
1.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. /12.13.Java 已14.15.缔造。
16.17.SQL> show errors java source "javademo1"18.没有19.20.舛误。
21.22.SQL> create or replace procedure javademo123. 2 as24.3 language java name JavaDemo1.main(/doc/58c87bea102de2bd970 58806.html ng.String[]);25. 4 /26.27.过程已28.30.31.SQL> set serveroutput on32.SQL> call javademo1();33.34.调用35.实现。
36.37.SQL> call dbms_java.set_output(5000);38.39.调用40.实现。
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);}}感谢阅读,希望能帮助到⼤家,谢谢⼤家对本站的⽀持!。
oracle调用JAVA类的方法
oracle调⽤JAVA类的⽅法导⼊jar包在oracle中导⼊需要的jar包,我们把编辑好的java类打成jar包,直接在oarcle⾥⾯写简单的调⽤就可以了, 1、操作系统需要拥有⽀持loadjava命令的jdk。
2、加载jlha.jar包,到oracle数据库中。
操作过程:在dos环境下,输⼊命令: loadjava -r -f -o -user usscares/usscares@usscares jlha.jar注意:jar包要在1.4的环境下编译,项⽬右键 properties java compiler compoler compliance level 1.4 即可否则报version 49 类似的错误调⽤JAVA类oracle调⽤JAVA类的⽅法主要有以下三种:1. ⽤loadjava⽅法装载;可能是调试⽅便,据说这种⽅法⽐较通⽤。
c:\test\hello.javaJava Code1 2 3 4 5 6 7 8 9 10 11 12 13 14 15public class hello{public static void main(String[] args){System.out.println("Hello");hello h = new hello();h.insertM(9);}public static void insertM(int pid){System.out.println("This is the method insertM."); }}C:\test>loadjava -u -v -resolve hello.javaSQL> create procedure prc_hehe as language java name 'hello.main(ng.String[])过程已创建。
SQL> call prc_hehe();调⽤完成。
存储过程调用java代码的方法
存储过程调用java代码的方法存储过程是一组SQL语句的集合,可以被视为一种预编译的SQL 语句,可以通过存储过程调用来实现对数据库的操作。
在Java中,我们可以通过以下方法来调用存储过程:1. 使用JDBC调用存储过程使用JDBC调用存储过程需要以下步骤:1)获取数据库连接。
2)创建CallableStatement对象,使用存储过程名称作为参数创建对象。
3)设置输入参数和输出参数。
输入参数可以通过setXXX()方法设置,输出参数可以使用registerOutParameter()方法注册。
4)执行存储过程。
可以使用execute()或executeUpdate()方法执行。
5)获取输出参数。
以下是一个简单的示例:```try(Connection conn = DriverManager.getConnection(url, user, password)) {CallableStatement cs = conn.prepareCall('{call procedure_name(?, ?)}');cs.setInt(1, 1); // 设置输入参数cs.registerOutParameter(2, Types.VARCHAR); // 注册输出参数cs.execute(); // 执行存储过程String result = cs.getString(2); // 获取输出参数System.out.println(result);} catch (SQLException e) {e.printStackTrace();}```2. 使用ORM框架调用存储过程使用ORM框架调用存储过程需要根据不同的框架进行配置。
以下是使用MyBatis调用存储过程的示例:1)在Mapper XML文件中定义存储过程调用语句。
```<select id='callProcedure' statementType='CALLABLE'>{call procedure_name(#{param1, mode=IN,jdbcType=INTEGER}, #{param2, mode=OUT, jdbcType=VARCHAR})}</select>```2)在Java代码中调用Mapper方法。
用java调用oracle存储过程总结3-返回列表-偶爱老婆-搜狐博客
用java调用oracle存储过程总结3-返回列表-偶爱老婆-搜狐博客三:返回列表由于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.T est_CURSOR) ISBEGINOPEN 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.CURS OR);proc.execute();rs = (ResultSet)proc.getObject(1);while(rs.next()){System.out.println("<tr><td>" + rs.getString(1) + "</td><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集合类型输出参数的PLSQL存储过程及其Java调用
Oracle集合类型输出参数的PL/SQL存储过程及其Java调用- -有段时间为了用存储过程做统计报表,写了这文章。
现在的java的数据库-关系映射技术似乎不提倡用存储过程,其实存储过程更能发挥数据库的效率。
1 引言存储过程因其执行效率高、与事务处理的结合、运行更安全等优点,在数据库应用程序中被广泛采用。
PL/SQL是用于从各种环境中访问Oracle数据库的一种编程语言,它与数据库服务器集成在一起,PL/SQL编写的存储过程编译效率高,网络系统开销小,同时PL/SQL直观性好,是大多数人的选择。
以Number、Varchar等基本标量类型为输出参数的PL/SQL存储过程,每个输出参数只能返回一个对应值。
而在实际数据库应用程序中,尤其是在进行系统综合查询统计时,往往需要返回二维数组或结果集,这时应考虑在存储过程中使用集合这种数据结构。
对于集合,我们可以一次把许多元素作为一个整体进行操作,也可以对集合中的单个元素进行操作,使用方便、灵活。
2 PL/SQL存储过程及Java程序的编写2.1 索引表作为输出参数索引表是无约束的,其大小的唯一限制(除可用内存外)就是它的关键字BINARY_INTEGER类型所能表示数值的约束(-2147483647...+2147483647),其元素不需要按任何特定顺序排列。
在声明时,我们不需要指定其大小,而且对索引表的元素可以直接赋值,不用初始化,可见使用索引表极其方便。
2.1.1存储过程的编写我们可以在PL/SQL语句块中定义索引表,但作为输出参数的索引表,必须要在包(package)里定义,方法如下:create or replace package out_param is---- 定义了元素是varchar2类型的一个索引表类型type out_index_table_typ is table of varchar2(50) index by binary_integer;end out_param;接下来就可以在pl/sql存储过程里引用在包里定义的索引表类型:create or replace procedure testPro1(in_param in varchar2,o_table out out_param. out_index_table_typ ) isbegin-------这里略去程序体end testPro1;其中,返回的索引表类型前必须用包名加上句点来引用out_param. out_index_table_typ 2.1.2 J ava程序的编写索引表与数据库表很形似,有key和value两列,但它不是真正的数据库表,不可以存储到数据库中。
论在Oracle中调用Java类
论在Oracle中调用Java类一、写作目的在生产系统中,往往会有一种情况是通过Oracle存储过程来调用Java程序,已达到更优的处理结果。
现就在生产过程中遇到的问题来简介在Oracle中如何调用Java类。
二、Oracle调用Java类简介Oracle数据库的Instance是由SGA和process组成的,在SGA中有6个不同的池,分别为Large pool,Java pool, Shared pool,Redo buffer,Block buffers 和Fixed SGA 。
Java 池(Java pool)是Oracle 8.1.5版本中增加的,目的是支持在数据库中运行Java。
存储过程(stored procedure)允许将运行于数据库层中的持久性逻辑与运行于中间层中的商务逻辑有效地分离开来。
这种分离可以降低整个应用程序的复杂性,并提供其重用性、安全性、性能和可伸缩性。
但是,妨碍存储过程广泛采用的一个主要障碍是不同数据库厂商使用各种专有的、且依赖于数据库的实现语言。
使用基于Java的存储过程可以解决这一问题。
Oracle已经实现了ANSI 标准,这些标准规定了从SQL中将静态Java方法作为过程或函数进行调用的能力。
这种实现被简单地称作"Java存储过程"。
三、生产中遇到的问题在EBS生产环境中,银行给员工发工资时,在进行账户校验以及付款时,是以并发请求的形式调用Java程序,表现出运行效率极低,付一笔款需要2-3分钟,分析原因有:1、并发程序运行时,会多次调用并发管理器,会有耗时。
2、如果此时有多个并发程序在运行,也会降低程序运行效率。
3、生产环境数据量巨大,也会对付款程序运行效率有影响。
解决方案:通过以上分析,原因2和3在生产上是在所难免的,可优化的余地并不是很大,因此,我们决定直接通过oracle调用java类,越过并发程序这一步骤,减少调用并发管理器的时间,从而缩短付款流程的时间,提升付款效率。
Oracle8i中使用Java语言来开发存储过程
Oracle8i中使用Java语言来开发存储过程在Oracle8i之前,开发人员只能使用PL/SQL来开发存储过程。
而在Oracle8i之中,不仅可以使用原有的PL/SQL开发存储过程,而且也可以使用Java语言来开发存储过程。
本篇文章将简单介绍关于这方面的知识,包括以下内容:∙存储过程简介;∙Java存储过程∙Java存储过程的开发步骤∙使用Java开发过程;∙使用Java开发函数;∙使用Java开发包;∙使用Java开发触发器;∙使用Java开发对象方法;∙使用JDeveloper开发JSP。
存储过程简介存储过程是存储在数据库中的一段存储程序。
当创建存储过程时,系统会对其进行编译,并将执行代码存储到数据库中。
设计存储过程的方针∙在定义存储过程时,要使用其完成单一、相对集中的任务。
∙在定义存储过程时,不要定义已经由其它特征所提供功能的过程。
例如,不要定义强制数据完整性的过程(使用完整性约束)。
2. 存储过程的优点1) 安全性当创建了存储过程之后,可以将执行该过程的权限授予其它用户,从而使得他可以执行特定的数据库操作,而不能访问其它模式对象(例如表)。
例如,你可以将执行过程(更新表)的权限授予其它用户,但不授予它们直接访问该表的权限。
2) 性能∙存储过程只被发送到数据库一次,相对于SQL语句或PL/SQL块而言,其网络通信量更小。
∙当调用存储过程时,数据库会直接运行该存储过程,无需进行编译。
相对于SQL语句或PL/SQL块而言,其执行速度更快。
3) 内存分配存储过程充分利用了Oracle共享内存的能力。
在将存储过程装载到内存中后,多个用户可以同时调用该存储过程,从而降低了应用对Oracle的实际内存需求。
4) 生产力存储过程提高了开发生产力。
通过将公共集合编写为存储过程,避免了冗余代码,从而提高了开发生产力。
例如,我们可以编写用于插入、更新、删除AUTHS表的过程,此后应用可以直接调用这些过程,而无需重写SQL语句。
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存储过程和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 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);需要将存储过程名称替换为实际的存储过程名称。
TN_ORA_0001_oracle存储过程调用java程序或外部bat文件
oracle存储过程调用java程序或外部bat文件by 胡珏1.调用bat文件1.1.创建java sourcecreate or replace and compile java source named exesyscommand as import java.io.*;publicclass ExeSysCommand{publicstatic String ExeCmd(String cmd) {Process proc=null;int exitValue;try {System.out.println(cmd);proc = Runtime.getRuntime().exec(cmd);exitValue = proc.waitFor();if (exitValue == 0) {return"PASS";} else {return"FAIL";}} catch (Exception e) {return e.getMessage();}}publicstaticvoid P_ExeCmd(String cmd) {Process proc = null;int exitValue;try {System.out.println(cmd);proc = Runtime.getRuntime().exec(cmd);exitValue = proc.waitFor();} catch (Exception e) {System.out.println(e.getMessage());}//proc.destroy();//proc=null;}publicstaticvoid main(String[] args)1.2.创建函数或存储引用该java source1.3.授权1.4.定义bat文件1.5.执行2.调用java程序2.1.创建java sourcecreate or replace and compile java source named httprequest asimport java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.io.OutputStreamWriter;import .URL;import .URLConnection;import .URLEncoder;import java.util.List;import java.util.Map;publicclass HttpRequest {finalstatic String username = "cluster";finalstatic String password = "cluster";finalstatic String url_encode = "UTF-8";publicstaticvoid main(String[] args) {//发送 GET 请求Strings=HttpRequest.sendGet("http://192.168.117.2:8081/kettle/executeTrans/ ", "trans=D:/KETTLE/sms.ktr&content=22");System.out.println(s);//发送 POST 请求Stringsr=HttpRequest.sendPost("http://192.168.117.2:8081/kettle/executeTran s/", "trans=D:/KETTLE/sms.ktr&content=22");System.out.println(sr);}* 向指定URL发送GET方法的请求** @param url* 发送请求的URL* @param param* 请求参数,请求参数应该是 name1=value1&name2=value2 的形式。
oracle调用java方法
oracle调用java方法在Oracle数据库中,可以通过Java调用存储过程、函数和触发器。
以下是在Oracle数据库中调用Java方法的步骤:1. 在Oracle数据库中创建一个Java类,并将其编译为字节码文件(.class文件)。
2. 在Oracle数据库中创建一个Java源对象,将编译后的字节码文件导入到该源对象中。
例如:CREATE OR REPLACE AND COMPILE JAVA SOURCE NAMED java_class AS <Java源代码>;3. 创建Java类的包装器(wrapper):CREATE OR REPLACE FUNCTION java_method(arg1 <参数类型>, arg2 <参数类型>, ...)RETURN <返回值类型>AS LANGUAGE JAVANAME'fully_qualified_java_class_name.method_name(java_parameter_data_typ es)';其中,fully_qualified_java_class_name是完全限定的Java类名,method_name是要调用的Java方法名。
4. 调用Java方法:SELECT java_method(arg1, arg2, ...) FROM dual;其中arg1, arg2等是Java方法的参数。
注意:调用Java方法需要在Oracle数据库中创建Java虚拟机,并启用相关权限。
以上是在Oracle数据库中调用Java方法的一般步骤。
具体的步骤和语法可能会有所不同,取决于您的具体数据库版本和配置。
请参考Oracle官方文档或使用特定版本的Oracle数据库的文档进行详细了解和操作。
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端(Sqlplus或Pl-Sql Developer)以存储过程(函数)的方式调用Java class类。
二、实现方式有两个步骤:创建Java class和创建存储过程,其中创建存储过程(函数)必须在Oracle 端进行,而创建java class则有两种方式,第一种是直接在Oracle端进行,第二种是Java IDE 中生成class后再导入到Oracle。
经实验测试,两种方式的效果相同。
为方便调试,本实验先按第一种方式进行,成功后将class和函数删除,再按第二种方式重新创建。
三、具体过程3.1 在Oracle端创建Java class在Sqlplus或Pl-Sql Developer的sql窗口中进行,示例代码如下:create or replace and compile java source named javatest aspublic class JavaTest{public static String encrypt(String data,String key){return data + " || " + key;}}执行后,会分别生成一个名为javatest的Java Source对象和Java class对象。
3.2 在Oracle端创建存储过程同样在Oracle端中进行,示例代码如下:create or replace function f_javatest_encrypt(p_data in varchar2, p_key in varchar2) return varchar2 aslanguage java name 'JavaTest.encrypt(ng.String, ng.String) return ng.String';执行后,会生成一个名为f_javatest_encrypt的函数。
oracle存储过程调用javasource的方法(一)
oracle存储过程调用javasource的方法(一)Oracle存储过程调用JavaSource的方法引言在Oracle数据库中,我们可以使用存储过程来进行复杂的数据处理和业务逻辑实现。
有时候,我们需要在存储过程中调用Java代码,以实现更复杂的功能。
本文将介绍一些在Oracle存储过程中调用JavaSource的方法。
方法一:使用CREATE JAVA语句创建Java类首先,我们可以使用CREATE JAVA语句在Oracle数据库中创建一个Java类,然后在存储过程中调用这个Java类的方法。
具体步骤如下: 1. 使用CREATE JAVA语句在Oracle数据库中创建一个Java类。
例如:CREATE OR REPLACE AND COMPILE JAVA SOURCE NAMED "He lloWorld" ASpublic class HelloWorld {public static String sayHello(String name) {return "Hello, " + name + "!";}};2.创建一个存储过程,其中调用了刚刚创建的Java类的方法。
例如:CREATE OR REPLACE PROCEDURE callJavaMethod ISlanguage Java name '() return ';resultStr ;BEGINresultStr := ('World');DBMS__line(resultStr);END;3.执行存储过程,测试Java类的调用是否成功。
例如:BEGINcallJavaMethod;END;方法二:使用CREATE LIBRARY语句创建Java库另一种方式是使用CREATE LIBRARY语句在Oracle数据库中创建一个Java库,然后在存储过程中调用这个Java库。
用java调用oracle存储过程总结
用java调用oracle存储过程总结分类:PL/SQL系列2009-09-24 15:08 253人阅读评论(0) 收藏举报声明:以下的例子不一定正确,只是为了演示大概的流程。
一:无返回值的存储过程存储过程为:CREATE OR REPLAC E PROCED URE TESTA(PARA1IN VARCHA R2,PARA2IN VARCHA R2) ASBEGININSERT INTO HYQ.B_ID (I_ID,I_NAME) VALUES (PARA1, PARA2);END TESTA;然后呢,在java里调用时就用下面的代码:packag e com.hyq.src;import java.sql.*;import java.sql.Result Set;public classTestPr ocedu reOne {public TestPr ocedu reOne() {}public static void main(String[] args ){String driver = "oracle.jdbc.driver.Oracle Drive r";String strUrl = "jdbc:oracle:thin:@127.0.0.1:1521: hyq ";Statem ent stmt = null;Result Set rs = null;Connec tionconn = null;Callab leSta temen t cstmt= null;try {Class.forNam e(driver);conn = Driver Manag er.getCon necti on(strUrl, " hyq ", " hyq ");Callab leSta temen t proc = null;proc = conn.prepar eCall("{ call HYQ.TESTA(?,?) }");proc.setStr ing(1, "100");proc.setStr ing(2, "TestOn e");proc.execut e();}catch(SQLExc eptio n ex2) {ex2.printS tackT race();}catch(Except ion ex2) {ex2.printS tackT race();}finall y{try {if(rs != null){rs.close();if(stmt!=null){stmt.close();}if(conn!=null){conn.close();}}}catch(SQLExc eptio n ex1) {}}}}二:有返回值的存储过程(非列表)当然了,这就先要求要建张表TESTTB,里面两个字段(I_ID,I_NAME)。
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调⽤存储过程的例⼦⼀样。
在ORACLE中调用JAVA
Oracle中的Java体系结构目前,使用Java来扩展存储程序是一种很流行的方法。
在使用Java类库处理数据的过程中,PL/SQL是必不可少的一环,这是因为PL/SQL封装了Java类库的数据访问,即任何Java存储对象访问的数据都必须经过PL/SQL。
由于本章的所有内容只被最新的数据库版本所支持,因此它独立于本书的其他章节,以下是本章要介绍的内容:●Oracle中的Java体系结构●Oracle JDBC的连接类型●客户端驱动器(Client-side driver),即JDBC瘦驱动(thin driver)●Oracle调用接口驱动器,即中间层胖驱动(middle-tier thick driver)●Oracle服务器端内部驱动器(Oracle Server-Side Internal Driver),即服务器级的胖驱动●在Oracle中创建Java类库●创建内部服务器的Java函数●创建内部服务器的Java过程●创建内部服务器的Java对象●创建、装载、删除、使用Java类库时的故障诊断●映射Oracle类型本章将向您展示一张Oracle中巨大的Java组织结构图,在解释了Java的体系结构之后,您还会看到开发和扩展Java组件的方法。
使用Java扩展的原因:我们将使用PL/SQL作为存储Java类库和其他PL/SQL存储程序或匿名块程序之间的接口。
我们还会映射Oracle和Java之间的本地数据类型和用户自定义数据类型,以便能定义有效接口和支持JSP(Java Server Page,Java服务器页面)。
1Oracle中的Java体系结构Oracle9i和10g版本的数据库为开发服务器端或内部Java程序组件提供了一个健壮的体系结构。
Java组件采用OO(Object-Oriented,面向对象)的结构,这样的结构非常适合Oracle的对象-关系模型(Object-Relational model)。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
SQL> create or replace procedure testjavaproc as language java name ''OracleJavaProc.main(ng.String[])'';
2/
过程已创建。
SQL> call testjavaproc();
过程已创建。
SQL> set serveroutput on SQL> call javademo1();
调用完成。
SQL> call dbms_java.set_output(5000);
调用完成。
SQL> call javademo1(); hello, java demo1
调用完成。
SQL> call javademo1(); hello, java demo1 调用完成。 2. 使用外部 class 文件来装载创建 e.g. 这里既然用到了外部文件,必然要将 class 文件放到 oracle Server 的某一目录 下边。
e.g.修改 OracleJavaProc 类内容如下:
import java.sql.*; import oracle.jdbc.*;
public class OracleJavaProc ...{
// Add a salgrade to the database. public static void addSalGrade(int grade, int losal, int hisal) ...{
+ e.getMessage()); } } } 使用 loadjava 命令将其装载到服务器端并编译:
D:eclipse3.1workspacedbtest>loadjava -u scott/tiger@iihero.oracledb -v -resolve Or acleJavaProc.java arguments: ''-u'' ''scott/tiger@iihero.oracledb ''-v'' ''-resolve'' ''OracleJavaProc.java'' creating : source OracleJavaProc loading : source OracleJavaProc resolving: source OracleJavaProc 查询一下状态:
OBJECT_TYPE US ------------------------------------ -------------OracleJavaProc JAVA CLASS
STAT VALID
OracleJavaProc JAVA SOURCE 测试一下存储过程:
VALID
SQL> create or replace procedure add_salgrade(id number, losal number, hisal num ber) as language java name ''OracleJavaProc.addSalGrade(int, int, int)'';
+ e.getMessage()); } }
public static int getHiSal(int grade) ...{
try ...{ Connection conn = DriverManager.getConnection("jdbc:default:connection:"); String sql = "SELECT hisal FROM salgrade WHERE grade = ?"; PreparedStatement pstmt = conn.prepareStatement(sql);pstmt.setInt(1,
D:/tiger@iihero.oracledbeclipse3.1workspacedbtest>loadjava -u scott -v -resolve Or acleJavaProc/tiger@iihero.oracledb.java arguments: ''-u'' ''scott/tiger@iihero.oracledb'' ''-v'' ''-resolve'' ''OracleJavaProc.java'' creating : source OracleJavaProc loading : source OracleJavaProc resolving: source OracleJavaProc 后边的应用示例:
SQL> SELECT object_name, object_type, status FROM user_objects WHERE object_type LIKE ''JAVA%'';
OBJECT_NAME --------------------------------------------------------------------------------
oracle 存储过程调用 java class
文章分类:Java 编程 /Phoenix_99/archive/2009/11/27/4886907.aspx 一、如何创建 java 存储过程? 通常有三种方法来创建 java 存储过程。
1. 使用 oracle 的 sql 语句来创建:
10 } 11 /
Java 已创建。
SQL> show errors java source "javademo1" 没有错误。
SQL> create or replace procedure javademo1 2 as 3 language java name ''JavaDemo1.main(ng.String[])''; 4/
public class OracleJavaProc {
public static void main(String[] argv) {
System.out.println procedure."); } }
SQL> grant create any directory to scott;
授权成功。
SQL> conn scott/tiger@iihero.oracledb 已连接。 SQL> create or replace directory
目录已创建。
test_dir
as ''d:\oracle'';
SQL> create or replace java class using bfile(test_dir, 'OracleJavaProc.class') 2/
System.out.println("Creating new salgrade for EMPLOYEE...");
try ...{ Connection conn = DriverManager.getConnection("jdbc:default:connection:");
String sql = "INSERT INTO salgrade " + "(GRADE,LOSAL,HISAL) " + "VALUES(?,?,?)";
先创建一个类, e.g.
import java.sql.*; import oracle.jdbc.*;
public class OracleJavaProc ...{
//Add a salgrade to the database. public static void addSalGrade(int grade, int losal, int hisal) ...{
2/
过程已创建。
SQL> set serveroutput on size 2000 SQL> call dbms_java.set_output(2000);
调用完成。
SQL> execute add_salgrade(6, 10000, 15000); Creating new salgrade for EMPLOYEE...
连接到: Oracle9i Enterprise Edition Release 9.2.0.1.0 - Production
With the Partitioning, OLAP and Oracle Data Mining options JServer Release 9.2.0.1.0 - Production
PreparedStatement pstmt = conn.prepareStatement(sql); pstmt.setInt(1,grade); pstmt.setInt(2,losal); pstmt.setInt(3,hisal); pstmt.executeUpdate(); pstmt.close(); } catch(SQLException e) ...{ System.err.println("ERROR! Adding Salgrade: "
PreparedStatement pstmt = conn.prepareStatement(sql); pstmt.setInt(1,grade); pstmt.setInt(2,losal); pstmt.setInt(3,hisal); pstmt.executeUpdate();