Oracle8i中使用Java语言来开发存储过程
本篇文章来源与时代朝阳数据库(原晓通数据库)培训部Oracle资料库。
在Oracle8i之前，开发人员只能使用PL/SQL来开发存储过程。而在Oracle8i之中，不仅可以使用原有的PL/SQL开发存储过程，而且也可以使用Java语言来开发存储过程。本篇文章将简单介绍关于这方面的知识，包括以下内容：
l存储过程简介；
lJava存储过程
lJava存储过程的开发步骤
l使用Java开发过程；
l使用Java开发函数；
l使用Java开发包；
l使用Java开发触发器；
l使用Java开发对象方法；
l使用JDeveloper开发JSP。
存储过程简介
存储过程是存储在数据库中的一段存储程序。当创建存储过程时，系统会对其进行编译，并将执行代码存储到数据库中。
1.设计存储过程的方针
l在定义存储过程时，要使用其完成单一、相对集中的任务。
l在定义存储过程时，不要定义已经由其它特征所提供功能的过程。例如，不要定义强制数据完整性的过程(使用完整性约束)。
2.存储过程的优点
1)安全性
当创建了存储过程之后，可以将执行该过程的权限授予其它用户，从而使得他可以执行特定的数据库操作，而不能访问其它模式对象(例如表)。例如，你可以将执行过程(更新表)的权限授予其它用户，但不授予它们直接访问该表的权限。
2)性能
l存储过程只被发送到数据库一次，相对于SQL语句或PL/SQL块而言，其网络通信量更小。
l当调用存储过程时，数据库会直接运行该存储过程，无需进行编译。相对于SQL语句或PL/SQL块而言，其执行速度更快。
3)内存分配
存储过程充分利用了Oracle共享内存的能力。在将存储过程装载到内存中后，多个用户可以同时调用该存储过程，从而降低了应用对Oracle的实际内存需求。
4)生产力
存储过程提高了开发生产力。通过将公共集合编写为存储过程，避免了冗余代码，从而提高了开发生产力。例如，我们可以编写用于插入、更新、删除AUTHS表的过程，此后应用可以直接调用这些过程，而无需重写SQL语句。当管理数据的方法发生变化时，只需要修改过程，而不需要对应用进行任何修改。
Java存储过程
在以前的Oracle版本中，开发存储过程是通过PL/SQL来完成的。而在Oracle8i版本中，我们不仅可以使用PL/SQL开发存储过程，而且还可以使用Java语言来开发存储过程。
1.PL/SQL与Java存储过程比较
与PL/SQL相比，使用Java语言开发存储过程有以下优点：
lJava语言具有更强大的运算能力，提供了更多的运算方法。当要完成进行复杂运算的存储过程时，使用JSP将是你最好的选择。
lPL/SQL只能用于Oracle数据库，而Java语言可以应用于更多的数据库系统(如Sybase、DB2、Informix等等)，所以Java存储过程将具有更好的兼容性、可移植性。
2.JSP分类
Java存储过程包括过程、函数、触发器以及对象方法四种类型。
3.调用JSP的四种方法
lCALL语法；
lDML语句；
lPL/SQL块、子程序、包；
l由触发器隐含调用。
Java存储过程的开发步骤
1.编写Java源代码
当开发Java存储过程时，首先应该编写Java源代码。如下图所示：
注意事项：
l当以public方式声明类时，类名必须与其文件名完全一致。
l只有public static方法可以作为Java存储过程。
2.装载Java代码及类到Oracle8i数据库中
在编写了Java源代码之后，接下来应该将Java代码及相应的Java类装载到Oracle8i数据库中。如下图所示：
装载Java代码及类到RDBMS有以下两种方法：
l使用loadjava工具，通过该工具可以快速装载Java源代码(.java)、Java二进制代码(.class)以及Java打包文件(.jar)。
l使用CREATE Java、ALTER Java装载Java代码。
其中，前一种方法相对简单，并且我们推荐你使用这种方法。
3.生成调用说明
在装载了Java类之后，接下来应该生成对public static方法的调用说明，最终完成Java存储过程的开发工作。如下图所示：
完成上述步骤之后，就完成了Java存储过程的开发工作，然后就可以调用并执行该Java存储过程了。
使用Java开发过程
过程用于执行某种操作。需要注意的是，过程所对应的Java方法返回值必须为空(void)。本节以创建用于插入、修改和删除AUTHS表的JSP为例，说明使用Java开发过程的方法。如下图所示：
下面讲述完成上述任务的方法及过程：
1.编写Java源代码
程序清单如下(manipulate_auths.java)：
/*导入Java类*/
import java.sql.*;
import java.io.*;
import oracle.jdbc.driver.*;
/*主类*/
public class manipulate_auths {
public static void insert_auths
(String code,String name,int sex,String birthdate,String entry_date_time)
throws SQLException {
/*建立到数据库的缺省连接*/
Connection conn = new OracleDriver().defaultConnection();
/*构造动态SQL语句*/
String sql = "INSERT INTO auths
(author_code,name,sex,birthdate,entry_date_time) " +
"VALUES (?,?,?,?,?)";
/*使用try ... catch语句抓取并抛出例外*/
try {
/*准备动态SQL语句*/
PreparedStatement pstmt = conn.prepareStatement(sql);
/*设置动态SQL参数值*/
pstmt.setString(1, code);
pstmt.setString(2, name);
pstmt.setInt(3, sex);
pstmt.setString(4, birthdate);
pstmt.setString(5, entry_date_time);
/*执行动态SQL语句*/
pstmt.executeUpdate();
/*关闭动态SQL语句*/
pstmt.close();
} catch (SQLException e) { }
}
public static void delete_auths (String code)
throws SQLException {
/*建立到数据库的缺省连接*/
Connection conn = new OracleDriver().defaultConnection();
/*构造动态SQL语句*/
String sql = "DELETE FROM authsWHERE author_code = ?";
/*使用try ... catch语句抓取并抛出例外*/
try {
/*准备动态SQL语句*/
PreparedStatement pstmt = conn.prepareStatement(sql);
/*设置动态SQL参数值*/
pstmt.setString(1, code);
/*执行动态SQL语句*/
pstmt.executeUpdate();
/*关闭动态SQL语句*/
pstmt.close();
} catch (SQLException e) { }
}
public static void modify_salary (String code,float salary)
throws SQLException {
/*建立到数据库的缺省连接*/
Connection conn = new OracleDriver().defaultConnection();
/*构造动态SQL语句*/
String sql = "UPDATE auths SET salary = ? WHERE author_code = ?";
/*使用try ... catch语句抓取并抛出例外*/
try {
/*准备动态SQL语句*/
PreparedStatement pstmt = conn.prepareStatement(sql);
/*设置动态SQL参数值*/
pstmt.setFloat(1, salary);
pstmt.setString(2, code);
/*执行动态SQL语句*/
pstmt.executeUpdate();
/*关闭动态SQL语句*/
pstmt.close();
} catch (SQLException e) { }
}
}
2.装载Java代码及类到Oracle8i数据库中
在编写了Java源代码之后，就可以将Java对象装载到Oracle8i数据库中了。下面是完成这项任务的方法：
3.发行Java，生成调用说明
在装载了Java类后，就可以发行该Java类，并生成调用其方法的过程说明了。下面是完成该项任务的方法：
4.调用JSP
在生成了调用Java方法的过程说明之后，我们就可以调用JSP了。例如：
使用Java开发函数
函数用于返回特定数据。本节将通过创建用于返回作者的文章标题，以及某种类型的文章个数为例，说明使用Java开发函数的方法。如下图所示：
下面讲述完成上述任务的方法和过程。
1.编写Java源代码
程序清单如下(query_article.java)：
/*导入Java类*/
import java.sql.*;
import java.io.*;
import oracle.jdbc.driver.*;
/*主类*/
public class query_article {
public static String auths_article(String code)
throws SQLException {
/*建立到数据库的缺省连接*/
Connection conn = new OracleDriver().defaultConnection();
/*构造动态SQL语句*/
String sql1 = "SELECT name FROM auths WHERE author_code=?";
String sql2 = "SELECT title FROM article WHERE author_code=?";
/*声明并初始化auths_article变量*/
String auths_article = new String();
/*使用try ... catch语句抓取并抛出例外*/
try {
/*准备动态SQL语句*/
PreparedStatement pstmt = conn.prepareStatement(sql1);
/*设置动态SQL参数值*/
pstmt.setString(1, code);
/*执行查询，并将结果保存到结果集中*/
ResultSet rset = pstmt.executeQuery();
/*循环获取并处理结果集数据*/
while(rset.next())
auths_article =auths_article + rset.getString(1);
/*关闭结果集*/
rset.close();
/*关闭动态SQL语句*/
pstmt.close();
} catch (SQLException e) {}
auths_article = auths_article + "所编写文章的标题如下：\n";
try {
/*准备动态SQL语句*/
PreparedStatement pstmt = conn.prepareStatement(sql2);
/*设置动态SQL参数值*/
pstmt.setString(1, code);
/*执行查询，并将结果保存到结果集中*/
ResultSet rset = pstmt.executeQuery();
/*循环获取并处理结果集数据*/
while(rset.next()) {
auths_article =auths_article + "" + rset.getString(1) + "\n";
}
/*关闭结果集*/
rset.close();
/*关闭动态SQL语句*/
pstmt.close();
} catch (SQLException e) {}
return auths_article;
}
public static String query_type_article_number(String code)
throws SQLException {
/*建立到数据库的缺省连接*/
Connection conn = new OracleDriver().defaultConnection();
/*构造动态SQL语句*/
String sql = "SELECT count(*) FROM article WHERE article_code IN "
+ "(SELECT article_code FROM article_type WHERE type_code=?)";
String article_number = new String("类型为" + code + "的文章共有");
/*使用try ... catch语句抓取并抛出例外*/
try {
/*准备动态SQL语句*/
PreparedStatement pstmt = conn.prepareStatement(sql);
/*设置动态SQL参数值*/
pstmt.setString(1, code);
/*执行查询，并将结果保存到结果集中*/
ResultSet rset = pstmt.executeQuery();
/*循环获取并处理结果集数据*/
while(rset.next())
article_number = article_number + rset.getString(1) + "篇";
/*关闭结果集*/
rset.close();
/*关闭动态SQL语句*/
pstmt.close();
} catch (SQLException e) {}
return article_number;
}
}
2.装载Java代码及类到Oracle8i数据库中
在编写了Java源代码之后，就可以将Java对象装载到Oracle8i数据库中了。下面是完成这项任务的方法：
3.发行Java，生成调用说明
在装载了Java类后，就可以发行该Java类，并生成调用其方法的函数说明了。下面是完成该项任务的方法：
4.调用JSP
在生成了调用Java方法的函数说明之后，就可以调用这些函数了。例如：
使用Java开发包
Java类用于封装Java方法，与此类似，包用于封装过程和函数等。本节将通过创建用于管理表subject的包为例，说明使用Java开发包的方法。如下图所示：
下面讲述完成上述任务的方法和过程。
1.编写Java源代码
程序清单如下(manage_subject.java)：
/*导入Java类*/
import java.sql.*;
import java.io.*;
import oracle.jdbc.driver.*;
/*主类*/
public class manage_subject {
public static String query_subject()
throws SQLException {
/*建立到数据库的缺省连接*/
Connection conn = new OracleDriver().defaultConnection();
/*构造SQL语句*/
String sql = "SELECT * FROM subject";
/*声明并初始化subject变量*/
String subject = new String();
/*使用try ... catch语句抓取并抛出例外*/
try {
/*创建Statement对象*/
Statement stmt = conn.createStatement();
/*执行SQL语句，并将查询结果赋给结果集*/
ResultSet rset = stmt.executeQuery(sql);
/*循环获取并处理结果集变量*/
while(rset.next())
subject = subject + rset.getString(1) + "\n";
/*关闭结果集*/
rset.close();
} catch (SQLException e) {}
return subject;
}
public static void insert_subject(String subject)
throws SQLException {
/*建立到数据库的缺省连接*/
Connection conn = new OracleDriver().defaultConnection();
/*构造动态SQL语句*/
String sql = "INSERT INTO subject VALUES(?)";
/*使用try ... catch语句抓取并抛出例外*/
try {
/*准备动态SQL语句*/
PreparedStatement pstmt = conn.prepareStatement(sql);
/*设置动态SQL参数值*/
pstmt.setString(1, subject);
/*执行动态SQL语句*/
pstmt.executeUpdate();
/*关闭动态SQL语句*/
pstmt.close();
} catch (SQLException e) {}
}
public static void delete_subject(String subject)
throws SQLException {
/*建立到数据库的缺省连接*/
Connection conn = new OracleDriver().defaultConnection();
/*构造动态SQL语句*/
String sql = "DELETE FROM subject WHERE subject=?";
/*使用try ... catch语句抓取并抛出例外*/
try {
/*准备动态SQL语句*/
PreparedStatement pstmt = conn.prepareStatement(sql);
/*设置动态SQL参数值*/
pstmt.setString(1, subject);
/*执行动态SQL语句*/
pstmt.executeUpdate();
/*关闭动态SQL语句*/
pstmt.close();
} catch (SQLException e) {}
}
public static void update_subject(String old_subject,String new_subject)
throws SQLException {
/*建立到数据库的缺省连接*/
Connection conn = new OracleDriver().defaultConnection();
/*构造动态SQL语句*/
String sql = "UPDATE subject SET subject=? WHERE subject=?";
/*使用try ... catch语句抓取并抛出例外*/
try {
/*准备动态SQL语句*/
PreparedStatement pstmt = conn.prepareStatement(sql);
/*设置动态SQL参数值*/
pstmt.setString(1, new_subject);
pstmt.setString(2, old_subject);
/*执行动态SQL语句*/
pstmt.executeUpdate();
/*关闭动态SQL语句*/
pstmt.close();
} catch (SQLException e) {}
}
}
2.装载Java代码及类到Oracle8i数据库中
在编写了Java源代码之后，就可以将Java对象装载到Oracle8i数据库中了。下面是完成这项任务的方法：
3.发行Java，生成调用说明
在装载了Java类后，就可以发行该Java类，并生成调用其方法的包了。下面是完成该项任务的方法：
4.调用JSP
在生成了调用Java方法的包后，就可以调用这些方法所对应的函数和过程了。例如：
使用Java开发触发器
触发器是一段存储程序，当执行特定修改操作时，会触发它，并执行其中的存储程序。下面以记载表AUTHS作者工资更新情况的触发器为例，说明使用Java开发触发器的方法。如下图所示：
下面讲述完成上述任务的方法和过程。
1.编写Java源代码
程序清单如下(trigger.java)：
/*导入Java类*/
import java.sql.*;
import java.io.*;
import oracle.jdbc.driver.*;
/*主类*/
public class trigger {
public static void log_salary(String name,float old_sal,float new_sal)
throws SQLException {
/*建立到数据库的缺省连接*/
Connection conn = new OracleDriver().defaultConnection();
String sql = "INSERT INTO salary_audit VALUES(?,?,?)";
/*使用try ... catch语句抓取并抛出例外*/
try {
PreparedStatement pstmt = conn.prepareStatement(sql);
pstmt.setString(1, name);
pstmt.setFloat(2, old_sal);
pstmt.setFloat(3, new_sal);
pstmt.executeUpdate();
pstmt.close();
} catch (SQLException e) {}
}
}
2.装载Java代码及类到Oracle8i数据库中
在编写了Java源代码之后，就可以将Java对象装载到Oracle8i数据库中了。下面是完成这项任务的方法：
3.发行Java，生成调用说明
在装载了Java类后，就可以发行该Java类，并生成调用其方法的过程说明及触发器了。下面是完成该项任务的方法：
4.调用JSP
在创建了触发器之后，当修改作者工资时会自动调用其中的存储程序。例如：
使用Java开发对象方法
对象类型是一种用户自定义的数据结构，它可以将数据类型、函数以及过程封装到该数据结构中。对象方法是指对象类型中的函数和过程，本节将以获取和增加对象工资信息为例，说明使用Java开发对象方法的方法。如下图所示：
下面讲述完成上述任务的方法及过程：
1.编写Java源代码
程序清单如下(object_type.java)：
/*导入Java类*/
import java.sql.*;
import java.io.*;
import oracle.sql.*;
import oracle.jdbc.driver.*;
import oracle.oracore.*;
import oracle.jdbc2.*;
import java.math.*;
/*主类，实现了SQLData接口*/
public class object_type implements SQLData {
/*声明private变量，它们对应于对象类型的属性*/
private String code;
private String name;
private BigDecimal sex;
private BigDecimal salary;
/*方法get_name()：对象类型的方法，用于获取对象姓名*/
public String get_name() {
return name;
}
/*方法get_salary()：对象类型的方法，用于获取对象工资*/
public BigDecimal get_salary() {
BigDecimal sal = salary;
return sal;
}
/*方法raise_salary()：对象类型的方法，用于增加对象工资*/
public void raise_salary(BigDecimal raise) {
salary = salary.add(raise);
}
/*以下程序段实现了接口SQLData */
String sql_type;
public String getSQLTypeName() throws SQLException {
return sql_type;
}
public void readSQL(SQLInput stream, String typeName) throws SQLException {
sql_type = typeName;
code = stream.readString();
name = stream.readString();
sex = stream.readBigDecimal();
salary = stream.readBigDecimal();
}
public void writeSQL(SQLOutput stream) throws SQLException {
stream.writeString(code);
stream.writeString(name);
stream.writeBigDecimal(sex);
stream.writeBigDecimal(salary);
}
}
2.装载Java代码及类到Oracle8i数据库中
在编写了Java源代码之后，就可以将Java对象装载到Oracle8i数据库中了。下面是完成这项任务的方法：
3.发行Java，生成调用说明
在装载了Java类后，就可以发行该Java类，并生成调用其方法的相应对象方法了。下面是完成该项任务的方法：
4.调用JSP
在创建了对象类型及对象方法之后，就可以调用这些对象方法了。例如：
使用JDeveloper开发JSP
本节以创建用于操纵ARTICLE表的JSP为例，说明使用JDeveloper 2.0开发JSP的方法。如下图所示：
这里只简单介绍使用JDeveloper开发JSP的过程和步骤，而关于如何使用JDeveloper请读者参见相关手册。
1.准备工作
1)选择“File—> New Workspace”，创建名称为jsp.jws的工作组。如下图所示：
2)选择“File—>New Project”，此时会启动新项目创建向导，并显示如下对话框：
3)选中“Create an”，然后单击“Next”，此时会显示如下对话框：
4)如上图所示，在“Project Name”框中键入“article”，项目路径框中键入“d:\jsp”，然后单击“Next”，此时会显示如下对话框：
5)在上图的对话框中键入你所需要的信息，然后单击“Next”，此时会显示如下对话框：
6)单击“Finish”，完成项目的创建过程，此时的图形界面如下：
2.编写Java源代码
在完成了准备工作之后，我们就可以编写Java源代码了。步骤如下：
1)选择“File—>New”，此时会弹出如下对话框：
2)如上图所示，选中“Class”，然后单击“OK”，此时会弹出如下对话框：
3)如上图所示，在“Class Name”框中键入“article”，选中“Style”中的“Public”，然后单击“OK”，此时会增加名称为“article.java”的节点。如下图所示：
4)双击“article.java”节点，会显示编辑工作区。如下图所示：
5)然后，在编辑工作区中编写如下的Java源代码(article.java)：
/*导入Java类*/
import java.sql.*;
import java.io.*;
import oracle.jdbc.driver.*;
/*主类*/
public class article {
public static String query_article(String code)
throws SQLException {
/*建立到数据库的缺省连接*/
Connection conn = new OracleDriver().defaultConnection();
/*构造动态SQL语句 */
String sql = "SELECT author_code,title FROM article " +
"WHERE article_code = ?";
/*声明String变量article_info，该变量将用于存储文章信息*/
String article_info = new String();
/*使用try ... catch语句抓取并抛出例外*/
try {
/*准备动态SQL语句*/
PreparedStatement pstmt = conn.prepareStatement(sql);
/*设置动态SQL参数值*/
pstmt.setString(1, code);
ResultSet rset = pstmt.executeQuery();
/*循环获取并处理结果*/
while(rset.next()) {
article_info = "作者代码：" + rset.getString(1) + "\n";
article_info = article_info + "文章标题：" +
rset.getString(2);
}
/*关闭结果集*/
rset.close();
/*关闭动态SQL语句*/
pstmt.close();
} catch (SQLException e) {}
return article_info;
}
public static void insert_article(String article_code,
String author_code,String secrate_level,String pub_date)
throws SQLException {
/*建立到数据库的缺省连接*/
Connection conn = new OracleDriver().defaultConnection();
/*构造动态SQL语句*/
String sql = "INSERT INTO article (article_code,author_code," +
"secrate_level,pub_date) VALUES (?,?,?,?)";
/*使用try ... catch语句抓取并抛出例外*/
try {
/*准备动态SQL语句*/
PreparedStatement pstmt = conn.prepareStatement(sql);
/*设置动态SQL参数值*/
pstmt.setString(1, article_code);
pstmt.setString(2, author_code);
pstmt.setString(3, secrate_level);
pstmt.setString(4, pub_date);
pstmt.executeUpdate();
/*关闭动态SQL语句*/
pstmt.close();
} catch (SQLException e) {}
}
public static void delete_article (String code)
throws SQLException {
/*建立到数据库的缺省连接*/
Connection conn = new OracleDriver().defaultConnection();
/*构造SQL语句*/
String sql = "DELETE FROM articleWHERE article_code = ?";
/*使用try ... catch语句抓取并抛出例外*/
try {
/*准备动态SQL语句*/
PreparedStatement pstmt = conn.prepareStatement(sql);
/*设置动态SQL参数值*/
pstmt.setString(1, code);
pstmt.executeUpdate();
/*关闭动态SQL语句*/
pstmt.close();
} catch (SQLException e) {}
}
public static void update_article (String code,String secrate_level)
throws SQLException {
/*建立到数据库的缺省连接*/
Connection conn = new OracleDriver().defaultConnection();
/*构造动态SQL语句*/
String sql = "UPDATE article SET secrate_level = ?" +
" WHERE article_code = ?";
/*使用try ... catch语句抓取并抛出例外*/
try {
/*准备动态SQL语句*/
PreparedStatement pstmt = conn.prepareStatement(sql);
/*设置动态SQL参数值*/
pstmt.setString(1, secrate_level);
pstmt.setString(2, code);
pstmt.executeUpdate();
/*关闭动态SQL语句*/
pstmt.close();
} catch (SQLException e) {}
}
}
3.配置并发行JSP
步骤如下：
1)选择“Project—>Deploy—>New Profile”，此时会弹出如下对话框：
2)如上图所示，选中“Deploy Java Classes and Stored Procedure to Oracle8i”，然后单击“Next”，此时会弹出如下对话框：
3)单击“Next”，此时会弹出如下对话框：
4)单击“Next”，此时会显示如下对话框：
5)单击“Next”，此时会显示如下对话框：
6)清除“Default Database Package”框，然后单击“Next”，此时会显示如下对话框：
7)单击“New”创建数据库连接，此时会弹出如下对话框：
该对话框用于配置数据库连接信息，按照你的数据库设置来配置相应参数。完成数据库连接的配置后，单击“Test Connection”测试配置是否正确。如果配置不正确，则修改配置参数。
8)单击“OK”，此时会弹出如下对话框：
在该对话框中显示了相应的数据库连接信息。
9)单击“Next”，此时会弹出如下对话框：
10)单击“Finish”，此时会弹出如下对话框：
11)单击“No”退出配置，然后在主窗口中选中配置文件“Profile1.prf”，单击鼠标右键，此时会显示如下弹出菜单：
12)从弹出菜单中选择“Properties”，此时会显示如下对话框：
13)选择“Methods”页，此时的对话框如下所示：
14)如上图所示，选中Publish下的所有单选框，然后单击“Done”，此时会显示如下对话框：
15)单击“Yes”，会开始配置和发行JSP，并最终显示如下界面：
16)单击“Done”，此时会显示如下信息框：
17)单击“OK”，这样我们就完成了配置和发行JSP的全部过程了。然后，我们就可以调用JSP完成相应任务了。
4.调用JSP
在创建了基于Java的函数和过程之后，就可以调用这些函数和过程了。方法如下：
扫一扫
161
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
