java创建存储过程
可以在PL/sql Devlelop环境中写
用Java编写Oracle存储过程和函数
Oracle里可以使用多种语言来编写存储过程，比如Pro*C/C++,PL/SQL,COBOL,在Oracle8i开始支持用Java编写存储过程。
如果非要写存储过程的话，做为以Java谋生的我，首选用Java编写，用PL/SQL需要记忆很多的语法(Pascal类的语法)和函数，远不如使用Java/JDBC这么轻车熟路。而且，DB2等数据库都支持Java存储过程，所以不比为每一种数据学习一种编写存储过程的方法了。
Java存储过程与一般的JDBC程序有所不同的是：
1.有安全限制，毕竟是在oracle内部运行的，不允许访问操作系统的资源，如文件。
2.获取数据库联接方式，connection = new OracleDriver().defaultConnection();
3.System.out,System.err,System.in等输入输出有所不同。可以利用某些命令重定向。
下面是用Java source写一个存储过程和函数的例子。
1．在plsqldeveloper里，java source里增加一个MyTest类，
代码：
create or replace and compile java source named test as
public class MyTest
{// 创建存储过程的java源代码
（执行时请将注释删除，这里本人试过所有的注释了，都不行，还没弄明白为什么不能用注释）
public static void myProc(int a,int b,int[] ret){
ret[0]=a+b;
}
// 创建函数的java源代码（执行时请将注释删除）
public static int myFunc(int a,int b){
return a+b;
}
}
/
F8执行它，以保存并编译。
2)增加一个procere和函数，执行如下命令:
代码:
'创建存储过程
CREATE OR REPLACE PROCEDURE myProc(a in number, b in number, ret out number) AS
LANGUAGE java NAME 'MyTest.myProc(int,int,int[])'; '注意MyTest.myProc是我们编写的java source的类名和方法名
/
'创建函数
CREATE OR REPLACE FUNCTION myFunc(a in number, b in number) RETURN NUMBER IS
LANGUAGE java NAME 'MyTest.myFunc(int,int) return int';
/
F8执行它，以保存并编译。
3)使用测试
‘测试存储过程用到的测试代码
set serveroutput on
DECLARE a INTEGER;
BEGIN
myProc(1, 2, a);
DBMS_OUTPUT.PUT_LINE(a);
END;
/
‘测试函数用到的测试代码
select myFunc(1,2) from al;
存储过程执行结果：
3
PL/SQL procere successfully completed
--------------------------------------------
函数执行结果
MYFUNC(1,2)
-----------
3
可以适当找些参考例子，从简单的开始，希望我的回答对你有所帮助。
2. java中怎么用存储过程啊
对已储存过程的调用是CallableStatement对象所含的内容。这种调用是用一种换码语法来写的，有两种形式：一种形式带结果参，另一种形式不带结果参数。结果参数是一种输出(OUT)参数，是已储存过程的返回值。两种形式都可带有数量可变的输入（IN参数）、输出（OUT参数）或输入和输出（INOUT参数）的参数。问号将用作参数的占位符。在JDBC中调用已储存过程的语法如下所示。注意，方括号表示其间的内容是可选项；方括号本身并非语法的组成部份。 {call过程名[(?,?,...)]} 返回结果参数的过程的语法为： {?=call过程名[(?,?,...)]} 不带参数的已储存过程的语法类似： {call过程名} 通常，创建CallableStatement对象的人应当知道所用的DBMS是支持已储存过程的，并且知道这些过程都是些什么。然而，如果需要检查，多种DatabaseMetaData方法都可以提供这样的信息。例如，如果DBMS支持已储存过程的调用，则supportsStoredProceres方法将返回true，而getProceres方法将返回对已储存过程的描述。 CallableStatement继承Statement的方法（它们用于处理一般的SQL语句），还继承了PreparedStatement的方法（它们用于处理IN参）。 CallableStatement中定义的所有方法都用于处理OUT参数或INOUT参数的输出部分：注册OUT参数的JDBC类型（一般SQL类型）、从这些参数中检索结果，或者检查所返回的值是否为JDBCNULL。 JDBC存储过程1、创建CallableStatement对象 CallableStatement对象是用Connection方法prepareCall创建的。下例创建CallableStatement的实例，其中含有对已储存过程getTestData调用。该过程有两个变量，但不含结果参数：CallableStatementc stmt=con.prepareCall("{callgetTestData(?,?)}");其中?占位符为IN、OUT还是INOUT参数，取决于已储存过程getTestData。 JDBC存储过程2、IN和OUT参数 将IN参数传给CallableStatement对象是通过setXXX方法完成的。该方法继承自PreparedStatement。所传入参数的类型决定了所用的setXXX方法（例如，用setFloat来传入float值等）。如果已储存过程返回OUT参数，则在执行CallableStatement对象以前必须先注册每个OUT参数的JDBC类型（这是必需的，因为某些DBMS要求JDBC类型）。注册JDBC类型是用registerOutParameter方法来完成的。语句执行完后，CallableStatement的getXXX方法将取回参数值。正确的getXXX方法是为各参数所注册的JDBC类型所对应的Java类型。换言之，registerOutParameter使用的是JDBC类型（因此它与数据库返回的JDBC类型匹配），而getXXX将之转换为Java类型。 作为示例，下述代码先注册OUT参数，执行由cstmt所调用的已储存过程，然后检索在OUT参数中返回的值。方法getByte从第一个OUT参数中取出一个Java字节，而getBigDecimal从第二个OUT参数中取出一个BigDecimal对象（小数点后面带三位数）： CallableStatementc stmt=con.prepareCall("{callgetTestData(?,?)}"); cstmt.registerOutParameter(1,java.sql.Types.TINYINT); cstmt.registerOutParameter(2,java.sql.Types.DECIMAL,3); cstmt.executeQuery(); byte x=cstmt.getByte(1); java.math.BigDecimaln=cstmt.getBigDecimal(2,3); CallableStatement与ResultSet不同，它不提供用增量方式检索大OUT值的特殊机制。JDBC存储过程3、INOUT参数 既支持输入又接受输出的参数（INOUT参数）除了调用registerOutParameter方法外，还要求调用适当的setXXX方法（该方法是从PreparedStatement继承来的）。setXXX方法将参数值设置为输入参数，而registerOutParameter方法将它的JDBC类型注册为输出参数。setXXX方法提供一个Java值，而驱动程序先把这个值转换为JDBC值，然后将它送到数据库中。这种IN值的JDBC类型和提供给registerOutParameter方法的JDBC类型应该相同。然后，要检索输出值，就要用对应的getXXX方法。例如，Java类型为byte的参数应该使用方法setByte来赋输入值。应该给registerOutParameter提供类型为TINYINT的JDBC类型，同时应使用getByte来检索输出值。 下例假设有一个已储存过程reviseTotal，其唯一参数是INOUT参数。方法setByte把此参数设为25，驱动程序将把它作为JDBCTINYINT类型送到数据库中。接着，registerOutParameter将该参数注册为JDBCTINYINT。执行完该已储存过程后，将返回一个新的JDBCTINYINT值。方法getByte将把这个新值作为Javabyte类型检索。 CallableStatementc stmt=con.prepareCall("{callreviseTotal(?)}"); cstmt.setByte(1,25); cstmt.registerOutParameter(1,java.sql.Types.TINYINT); cstmt.executeUpdate(); byte x=cstmt.getByte(1); 1）返回一个结果集（ResultSet）。2）返回一个特定的值。下面来详细的说明。1）返回一个结果集（ResultSet）,这种类似通常的处理结果集如果事先就有一个类似如下的procere CREATE PROCEDURE getShipQuantity @jsid int ASSELECT jf_js_id,SUM(jf_ship_quantity) AS shipqty FROM tjobsheet_finish f WHERE (jf_js_id=@jsid)GROUP BY jf_js_id 那么我们将通过如下的代码来调用 String sql = "{ call getShipQuantity(?) }";Connection con = conn.connection();ResultSet rs = null;BigDecimal shipQuantity = new BigDecimal(0);try{ CallableStatement cs = con.prepareCall(sql); cs.setInt(1,jsoId);//设置输入参数 rs = cs.executeQuery();//返回结果集 if(rs.next()){ shipQuantity = new BigDecimal(rs.getDouble(2)); } logger.debug("shipQuantity --------------------- "+shipQuantity);}catch(Exception e){ logger.debug(e);}2）返回一个特定的值。也就是说，在procere的定义中已经用output输出参数了。请看下面的proceercreate procere getSingleWgt @@singleWgt numeric(8,3) output,@jsnum varchar(11) = '0000-0480'asdeclare @stwgt numeric(8,3)select @stwgt = sum(b.stwgt)from js as ainner join jsactdtl as b on a.jsnum = b.jsnumwhere a.completion = 1 and b.stflag = 22and a.jsnum = @jsnumselect @@singleWgt = (@stwgt/orderedqty) from js where jsnum = @jsnum那么我们将通过如下的代码来调用String sql = "{ call getSingleWgt(?,?) }";Connection con = getSession().connection();//得到connectiontry{ CallableStatement cs = con.prepareCall(sql);//通过它来执行sql cs.registerOutParameter(1,java.sql.Types.FLOAT);//注册输出参数 cs.setString(2,shipment.getJsnum());//指出输入参数 if(cs.execute()){//执行 float output = cs.getFloat(1);//返回值 }}catch(Exception e){logger.debug(e);｝
3. 怎样用JavaDB创建存储过程
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class UseSQLDataBase3 {
Connection con;
Statement state;
ResultSet rs;
CallableStatement cs;//调用存储过程使用的接口
String url = "jdbc:microsoft:sqlserver://localhost:1433; DatabaseName=test";
String user = "sa";
String password = "";
public void connectSQL(){
try {
Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");
} catch (ClassNotFoundException e) {
// TODO 自动生成 catch 块
e.printStackTrace();
}
try {
con = DriverManager.getConnection(url, user, password);
state = con.createStatement();
//创建存储过程SQL语句
String createProcere = " create procere SHOW_SUPPLIERS " +
"as "+
" select SUPPLIERS.SUP_NAME,COFFEES.COF_NAME "+
"from suppliers,coffees"+
"where suppliers.sup_id = coffees.sup_id "+
"order by sup_name";
//创建存储过程
state.executeUpdate("USE TEST");
state.executeUpdate(createProcere);
//调用存储过程
cs = con.prepareCall("{call SHOW_SUPPLIERS}");//创建一个 CallableStatement 对象来调用数据库存储过程
//返回调用的结果集
rs = cs.executeQuery();
//输出结果
System.out.println("SUPPLIERS.SUP_NAME COFFEES.COF_NAME");
while(rs.next()){
String sup_name = rs.getString(1);
String coffees_name = rs.getString(2);
System.out.println(sup_name + " " + coffees_name);
}
con.close();
state.close();
} catch (SQLException e) {
// TODO 自动生成 catch 块
e.printStackTrace();
}
}
public static void main(String[] args){
new UseSQLDataBase3().connectSQL();
}
}
4. 如何创建Java存储过程
1、操作系统：windows 2000 Server
2、数 据 库：Oracle 8i R2 (8.1.7) for NT 企业版
3、安装路径：C:\ORACLE
实现方法：
1、 创建一个文件为TEST.java
public class TEST
{
public static void main (String args[])
{
System.out.PRintln("HELLO THIS iS A JAVA PROCEDURE");
}
}
2、 javac TEST.java
3、 java TEST
4、 SQL> conn system/manager
SQL> grant create any Directory to scott;
SQL> conn scott/tiger
SQL> create or replace directory test_dir as 'd:\'
目录已创建。
SQL> create or replace java class using bfile(test_dir,'TEST.CLASS')
2/
Java 已创建。
SQL> select object_name,object_type,STATUS from user_objects;
SQL> create or replace procere test_java
as language java
name 'TEST.main(java.lang.String[])';
/
过程已创建。
SQL> set serveroutput on size 5000
SQL> call dbms_java.set_output(5000);
调用完成。
SQL> execute test_java;
HELLO THIS iS A JAVA PROCEDURE
PL/SQL 过程已成功完成。
SQL> call test_java();
HELLO THIS iS A JAVA PROCEDURE
调用完成。
5. 用java调用已有的存储过程创建一个数据库怎么写
就是调用存储过程，存储过程创建数据吧；传入参数，直接调用即可，与调用普通存储过程相同；只是需要注意你连接数据库的用户需要有创建DBA权限。
6. 执行存储过程有多少种方法java
Java执行存储过程的方法：
简单的老的JDBC通过CallableStatement类支持存储过程的调用。该类实际上是PreparedStatement的一个子类。假设有一个poets数据库。数据库中有一个设置诗人逝世年龄的存储过程。下面是对老酒鬼Dylan Thomas（old soak Dylan Thomas，不指定是否有关典故、文化，请批评指正。译注）进行调用的详细代码：
try{
intage=39;
StringpoetName="dylanthomas";
CallableStatementproc=connection.prepareCall("{callset_death_age(?,?)}");
proc.setString(1,poetName);
proc.setInt(2,age);
cs.execute();
}catch(SQLExceptione){//....}传给prepareCall方法的字串是存储过程调用的书写规范。它指定了存储过程的名称，？代表了需要指定的参数。
和JDBC集成是存储过程的一个很大的便利：为了从应用中调用存储过程，不需要存根（stub）类或者配置文件，除了你的DBMS的JDBC驱动程序外什么也不需要。
当这段代码执行时，数据库的存储过程就被调用。我们没有去获取结果，因为该存储过程并不返回结果。执行成功或失败将通过例外得知。失败可能意味着调用存储过程时的失败（比如提供的一个参数的类型不正确），或者一个应用程序的失败（比如抛出一个例外指示在poets数据库中并不存在“Dylan Thomas”）
结合SQL操作与存储过程
映射Java对象到SQL表中的行相当简单，但是通常需要执行几个SQL语句；可能是一个SELECT查找ID，然后一个INSERT插入指定ID的数据。在高度规格化（符合更高的范式，译注）的数据库模式中，可能需要多个表的更新，因此需要更多的语句。Java代码会很快地膨胀，每一个语句的网络开销也迅速增加。
将这些SQL语句转移到一个存储过程中将大大简化代码，仅涉及一次网络调用。所有关联的SQL操作都可以在数据库内部发生。并且，存储过程语言，例如PL/SQL，允许使用SQL语法，这比Java代码更加自然。早期的存储过程，使用Oracle的PL/SQL语言编写：
createprocereset_death_age(poetVARCHAR2,poet_ageNUMBER)
poet_idNUMBER;
beginSELECTidINTOpoet_idFROMpoetsWHEREname=poet;
INSERTINTOdeaths(mort_id,age)VALUES(poet_id,poet_age);
endset_death_age;
set_death_age几乎可以肯定是一个很烂的实现。应该在poets表中添加一列来存储逝世年龄。Java代码中并不关心数据库模式是怎么实现的，因为它仅调用存储过程。以后可以改变数据库模式以提高性能，但是不必修改代码。
下面是调用上面存储过程的Java代码：
publicstaticvoidsetDeathAge(PoetdyingBard,intage)throwsSQLException{
Connectioncon=null;
CallableStatementproc=null;
try{
con=connectionPool.getConnection();
proc=con.prepareCall("{callset_death_age(?,?)}");
proc.setString(1,dyingBard.getName());
proc.setInt(2,age);
proc.execute();
}
finally{
try{proc.close();}
catch(SQLExceptione){}
con.close();
}
}为了确保可维护性，建议使用像这儿这样的static方法。这也使得调用存储过程的代码集中在一个简单的模版代码中。如果用到许多存储过程，就会发现仅需要拷贝、粘贴就可以创建新的方法。因为代码的模版化，甚至也可以通过脚本自动生产调用存储过程的代码。
Functions
存储过程可以有返回值，所以CallableStatement类有类似getResultSet这样的方法来获取返回值。当存储过程返回一个值时，必须使用registerOutParameter方法告诉JDBC驱动器该值的SQL类型是什么。也必须调整存储过程调用来指示该过程返回一个值。
下面接着上面的例子。这次查询Dylan Thomas逝世时的年龄。这次的存储过程使用PostgreSQL的pl/pgsql：
createfunctionsnuffed_it_when(VARCHAR)returnsinteger'declare
poet_idNUMBER;
poet_ageNUMBER;
begin
--.
SELECTidINTOpoet_idFROMpoetsWHEREname=$1;
--getandreturntheage.
SELECTageINTOpoet_ageFROMdeathsWHEREmort_id=poet_id;
returnage;
end;'language'pl/pgsql';
另外，注意pl/pgsql参数名通过Unix和DOS脚本的$n语法引用。同时，也注意嵌入的注释，这是和Java代码相比的另一个优越性。在Java中写这样的注释当然是可以的，但是看起来很凌乱，并且和SQL语句脱节，必须嵌入到Java String中。
下面是调用这个存储过程的Java代码：
connection.setAutoCommit(false);
CallableStatementproc=connection.prepareCall("{?=callsnuffed_it_when(?)}");
proc.registerOutParameter(1,Types.INTEGER);
proc.setString(2,poetName);
cs.execute();
intage=proc.getInt(2);
如果指定了错误的返回值类型会怎样？那么，当调用存储过程时将抛出一个RuntimeException，正如你在ResultSet操作中使用了一个错误的类型所碰到的一样。
复杂的返回值
如果这是存储过程的全部功能，那么存储过程就不是其它远程执行机制的替换方案了。存储过程的功能比这强大得多。
当执行一个SQL查询时，DBMS创建一个叫做cursor（游标）的数据库对象，用于在返回结果中迭代每一行。ResultSet是当前时间点的游标的一个表示。这就是为什么没有缓存或者特定数据库的支持，只能在ResultSet中向前移动。
某些DBMS允许从存储过程中返回游标的一个引用。JDBC并不支持这个功能，但是Oracle、PostgreSQL和DB2的JDBC驱动器都支持在ResultSet上打开到游标的指针（pointer）。
设想列出所有没有活到退休年龄的诗人，下面是完成这个功能的存储过程，返回一个打开的游标，同样也使用PostgreSQL的pl/pgsql语言：
createprocerelist_early_deaths()returnrefcursoras'declare
toesuprefcursor;
begin
opentoesupforSELECTpoets.name,deaths.ageFROMpoets,deaths--allentriesindeathsareforpoets.--butthetablemightbecomegeneric.
WHEREpoets.id=deaths.mort_idANDdeaths.age<60;
returntoesup;
end;'language'plpgsql';
下面是调用该存储过程的Java方法，将结果输出到PrintWriter：
PrintWriter:
staticvoidsendEarlyDeaths(PrintWriterout){
Connectioncon=null;
CallableStatementtoesUp=null;
try{
con=ConnectionPool.getConnection();
//...con.
setAutoCommit(false);//Setupthecall.
CallableStatementtoesUp=connection.prepareCall("{?=calllist_early_deaths()}");
toesUp.registerOutParameter(1,Types.OTHER);
toesUp.execute();
ResultSetrs=(ResultSet)toesUp.getObject(1);
while(rs.next()){
Stringname=rs.getString(1);
intage=rs.getInt(2);
out.println(name+"was"+age+"yearsold.");
}
rs.close();
}
catch(SQLExceptione){//Weshouldprotectthesecalls.toesUp.close();con.close();
}
}因为JDBC并不直接支持从存储过程中返回游标，使用Types.OTHER来指示存储过程的返回类型，然后调用getObject()方法并对返回值进行强制类型转换。
这个调用存储过程的Java方法是mapping的一个好例子。Mapping是对一个集上的操作进行抽象的方法。不是在这个过程上返回一个集，可以把操作传送进去执行。本例中，操作就是把ResultSet打印到一个输出流。这是一个值得举例的很常用的例子，下面是调用同一个存储过程的另外一个方法实现：
publicclassProcessPoetDeaths{
publicabstractvoidsendDeath(Stringname,intage);
}
staticvoidmapEarlyDeaths(ProcessPoetDeathsmapper){
Connectioncon=null;
CallableStatementtoesUp=null;
try{
con=ConnectionPool.getConnection();
con.setAutoCommit(false);
CallableStatementtoesUp=connection.prepareCall("{?=calllist_early_deaths()}");
toesUp.registerOutParameter(1,Types.OTHER);
toesUp.execute();
ResultSetrs=(ResultSet)toesUp.getObject(1);
while(rs.next()){
Stringname=rs.getString(1);
intage=rs.getInt(2);
mapper.sendDeath(name,age);
}
rs.close();
}catch(SQLExceptione){//Weshouldprotectthesecalls.toesUp.close();
con.close();
}
}这允许在ResultSet数据上执行任意的处理，而不需要改变或者复制获取ResultSet的方法：
staticvoidsendEarlyDeaths(finalPrintWriterout){
ProcessPoetDeathsmyMapper=newProcessPoetDeaths(){
publicvoidsendDeath(Stringname,intage){
out.println(name+"was"+age+"yearsold.");
}
};
mapEarlyDeaths(myMapper);
}这个方法使用ProcessPoetDeaths的一个匿名实例调用mapEarlyDeaths。该实例拥有sendDeath方法的一个实现，和我们上面的例子一样的方式把结果写入到输出流。当然，这个技巧并不是存储过程特有的，但是和存储过程中返回的ResultSet结合使用，是一个非常强大的工具。
7. 如何在Oracle中使用Java存储过程
通常有三种方法来创建java存储过程。
1. 使用oracle的sql语句来创建：
e.g. 使用create or replace and compile java source named "<name>" as
后边跟上java源程序。要求类的方法必须是public static的，才能用于存储过程。
SQL>"javademo1"
as
importjava.sql.*;
publicclassJavaDemo1
{
publicstaticvoidmain(String[]argv)
{
System.out.println("hello,javademo1");
}
}
/
Java已创建。
SQL>showerrorsjavasource"javademo1"
没有错误。
SQL>
as
languagejavaname'JavaDemo1.main(java.lang.String[])';
/
过程已创建。
SQL>setserveroutputon
SQL>calljavademo1();
调用完成。
SQL>calldbms_java.set_output(5000);
调用完成。
SQL>calljavademo1();
hello,javademo1
调用完成。
SQL>calljavademo1();
hello,javademo1
调用完成。
2. 使用外部class文件来装载创建
e.g. 这里既然用到了外部文件，必然要将class文件放到oracle Server的某一目录下边。
publicclassOracleJavaProc
{
publicstaticvoidmain(String[]argv)
{
System.out.println("It'saJavaOracleprocere.");
}
}
SQL>;
授权成功。
SQL>connscott/[email protected]
已连接。
SQL>createorreplacedirectorytest_diras'd:/oracle';
目录已创建。
SQL>(test_dir,'OracleJavaProc.CLASS')
2/
Java已创建。
SQL>'OracleJavaProc.main(java.lang.String[])';
2/
过程已创建。
SQL>calltestjavaproc();
调用完成。
SQL>executetestjavaproc;
PL/SQL过程已成功完成。
SQL>setserveroutputonsize5000
SQL>calldbms_java.set_output(5000);
调用完成。
SQL>executetestjavaproc;
It'saJavaOracleprocere.
3. 我推荐的一种方法，直接使用loadjava命令远程装载并创建。
先创建一个类, e.g.
importjava.sql.*;
importoracle.jdbc.*;
publicclassOracleJavaProc{
//Addasalgradetothedatabase.
publicstaticvoidaddSalGrade(intgrade,intlosal,inthisal){
System.out.println("...");
try{
Connectionconn=
DriverManager.getConnection("jdbc:default:connection:");
Stringsql=
"INSERTINTOsalgrade"+
"(GRADE,LOSAL,HISAL)"+
"VALUES(?,?,?)";
PreparedStatementpstmt=conn.prepareStatement(sql);
pstmt.setInt(1,grade);
pstmt.setInt(2,losal);
pstmt.setInt(3,hisal);
pstmt.executeUpdate();
pstmt.close();
}
catch(SQLExceptione){
System.err.println("ERROR!AddingSalgrade:"
+e.getMessage());
}
}
}
使用loadjava命令将其装载到服务器端并编译：
D:eclipse3.1workspacedbtest>loadjava-uscott/[email protected]
acleJavaProc.java
arguments:'-u''scott/[email protected]'-v''-resolve''OracleJavaProc.java'
creating:sourceOracleJavaProc
loading:sourceOracleJavaProc
resolving:sourceOracleJavaProc
查询一下状态：
连接到:
.2.0.1.0-Proction
WiththePartitioning,
JServerRelease9.2.0.1.0-Proction
SQL>SELECTobject_name,object_type,statusFROMuser_objectsWHEREobject_typeLIKE'JAVA%';
OBJECT_NAME
--------------------------------------------------------------------------------
OBJECT_TYPESTATUS
--------------------------------------------------
OracleJavaProc
JAVACLASSVALID
OracleJavaProc
JAVASOURCEVALID
测试一下存储过程：
SQL>createorreplaceprocereadd_salgrade(idnumber,losalnumber,hisalnum
ber)aslanguagejavaname'OracleJavaProc.addSalGrade(int,int,int)';
2/
过程已创建。
SQL>setserveroutputonsize2000
SQL>calldbms_java.set_output(2000);
调用完成。
SQL>executeadd_salgrade(6,10000,15000);
...
PL/SQL过程已成功完成。
SQL>select*fromsalgradewheregrade=6;
GRADELOSALHISAL
------------------------------
61000015000
8. JAVA用代码操作数据库创建表，视图，触发器，存储过程等。
create
or
replace
trigger
trg_delete_count
before
delete
on
student
for
each
row
begin
delete
from
成绩表
where
成绩表.学号=：old.学号;
commit;
end;
想要实现类似的功能，不一定要用触发器的，可以设置两个表的主键和外键，设置级联删除关系，删除主键时，外键表中的记录也会自动删除。
9. 什么是java中的存储过程请教高手帮忙
java本身是没储存过程的，
存储过程是由流控制和SQL语句书写的过程，这个过程经编译和优化后存储在数据库服务器中，使用时只要调用即可。
比如说，在java调用oracle存储过程。