Oracle JDBC编程指南

需积分: 9 66 浏览量更新于2024-08-02 收藏 1.38MB PDF 举报

"Oracle-JDBC" Oracle JDBC 是Oracle公司提供的用于Java应用程序与Oracle数据库之间进行交互的Java Database Connectivity (JDBC)驱动程序。这个资源，"Oracle与JDBC的书籍"，由Donald Bales撰写，详细介绍了如何在Oracle环境中利用JDBC技术进行Java编程。本书的作者首先讲解了建立数据库连接的基础知识，这是使用JDBC的首要步骤。读者将学习如何通过JDBC API创建和管理这些连接，以便能够与Oracle数据库进行通信。这包括理解JDBC驱动程序的类型和它们在Java应用程序中的作用。接下来，书中深入探讨了如何发送SQL查询并处理返回的结果。SQL是数据库操作的核心，掌握如何在JDBC中正确使用SQL是关键。作者还会展示如何执行复杂的操作，如更新、插入和删除记录，以及如何处理查询结果集。在进阶部分，Bales引导读者了解如何处理Oracle数据库中的大型对象（LOBs），这是处理大容量数据时的关键。此外，他还讲解了如何调用PL/SQL存储过程，这是Oracle数据库特有的功能，允许在数据库级别执行复杂的业务逻辑。书中的另一亮点是关于Oracle 9i的面向对象特性的介绍，这包括如何创建和操作对象类型的表，以及利用这些特性来设计更复杂的数据模型。最后，书中涵盖了事务管理和并发控制，这是多用户环境下的数据库操作中不可或缺的部分。这部分内容将帮助开发者理解如何确保数据的一致性和完整性。此外，还讨论了性能优化策略，这对于任何处理大量数据的应用程序来说都是至关重要的。在预读章节中，作者解释了编写此书的初衷，目标读者群体，以及书的结构。他还指出了书中遵循的约定，软件版本信息，以及如何提供反馈和问题。总而言之，"Java Programming with Oracle JDBC" 是一本全面的指南，适合那些希望在Java应用程序中充分利用Oracle数据库功能的开发者阅读。通过这本书，读者将能够深入理解Oracle JDBC的工作原理，并获得在实际项目中使用它的必要技能。

For a middle-tier program such as EJB that resides in an Oracle8i database but requires

access to resources outside of the Oracle8i database in which it resides, use the server-

side Thin driver.

2.1.4 Versions

Table 2-1 lists the Oracle JDBC driver versions along with the database versions and JDK

versions supported by each and the driver types that are available for each.

Table 2-1. Oracle drivers and the JDKs they support

Driver

release

Database

version

7.3.4

Database

version

8.0.4

Database

version

8.0.5

Database

version

8.0.6

Database

version

8.1.5

Database

version

8.1.6

JDK

1.0.x

JDK

1.1.x

JDK

1.2.x

Client

side

OCI

Client

side

Thin

Server

side

Thin

Server

side

Internal

7.3.4

8.0.4

8.0.5

8.0.6

8.1.5

8.1.6

There are a few important issues to consider about the information in Table 2-1:

• The server-side internal driver only supports JDK 1.2.x.

• Beginning with driver Version 8.1.6, JDK 1.0.x is no longer supported.

• Also beginning with Version 8.1.6, the OCI driver uses the standard Java Native Interface

(JNI). This means you can now use the OCI drivers with JVMs other than Sun's. Prior to

8.1.6, the OCI driver used an earlier native call specification named Native Method

Interface (NMI). This prevented the use of OCI drivers with non-Sun JVMs.

As you can see by examining Table 2-1, Oracle supports JDBC for database versions 7.3.4

through 8.1.6. Each new release of the driver software maintains backward compatibility with

earlier versions of the database. In addition, as long as you don't try to use newer functionality

with an older driver release, you can use an older driver release with a newer version of the

database. For example, you can use the 7.3.4 driver to access an 8.1.6 database, as long as you

don't try to use features that did not exist in the 7.3.4 version of the database. This can be a

handy workaround when planning the migration of a large application. Let's say you had an

application that you migrated from database Version 7.3.4 to 8.1.6. You could continue to use the

7.3.4 driver in the client until you start utilizing features, such as object views, that are specific to

database Version 8.1.6. However, I still recommend you use the newest drivers whenever

possible.

2.1.5 Oracle Class Files

Each Oracle client software release has its own set of class files stored in a zip format:

classes102.zip for use with JDK1.0.x, classes111.zip and nls_charset11.zip for use with JDK

1.1.x, and classes12.zip and nls_charset12.zip for use with JDK 1.2.x. From here on I'll refer to

these sets of class files as classesXXX.zip.

2.2 Installation

Installing the JDBC drivers varies depending on whether you use the OCI driver or the Thin

driver. Let's start with the OCI driver installation.

2.2.1 Installing the OCI Driver

To install the OCI driver software, follow these steps:

1. Install the Oracle client software from its distribution CD.

2. Add the appropriate classesXXX.zip file to your CLASSPATH environment variable.

3. If you are using Java 2 Enterprise Edition (J2EE), add the appropriate classesXXX.zip file

to your J2EE_CLASSPATH environment variable.

4. Add the client binaries to your PATH environment variable.

5. On Unix or Linux, add the client binaries to the LD_LIBRARY_PATH environment

variable.

2.2.1.1 Install the Oracle Client

If you are going to use the OCI driver, you'll need the Oracle8i Oracle Client distribution media or

the Oracle Enterprise Edition distribution media (typically, these are on CD-ROM) to install the

client software. Follow your operating-system-specific instructions to execute the Oracle

Universal Installer. Then simply follow the installation instructions from the Oracle Universal

Installer's screen.

The Oracle Universal Installer creates several directories during the installation of the client

software on your computer. The directories of interest to you are all under ORACLE_HOME\jdbc.

ORACLE_HOME refers to the directory where the Oracle client software was installed. Typically,

these directories are:

demo/samples

Contains Oracle's sample programs, demonstrating the use of SQL92 and Oracle SQL

syntax, PL/SQL blocks, streams, objects (user-defined types and extensions), and

performance extensions.

doc

Contains the API documentation for the JDBC drivers.

lib

Contains the following classesXXX.zip files:

classes111.zip

For JDK 1.1.x support

classes12.zip

For JDB 1.2.x support

nls_charset11.zip and nls_charset12.zip

For National Language support

jta.zip

For the Java Transaction API

jndi.zip

For the Java Naming and Directory Interface API

The files jta.zip and jndi.zip are part of the standard JDK, but Oracle recommends you use those

included in the lib directory (and those that Oracle distributes) for compatibility with Oracle

classes in the classesXXX.zip file.

The content in these directories varies with the version of JDBC drivers installed. The preceding

directories and files are from Version 8.1.6.

2.2.1.2 Setting environment variables

After the client software installation, add the name of the appropriate classesXXX.zip file to your

CLASSPATH environment variable setting. If you are using J2EE, also add the appropriate

classesXXX.zip file to your J2EE_CLASSPATH setting. Be sure to specify only one

classesXXX.zip file; otherwise, you will encounter unexpected behavior and errors. For example,

if your Oracle Client software is installed on Microsoft Windows NT in the C:\Oracle\Ora81\

directory, then you need to add the following file to your CLASSPATH and J2EE_CLASSPATH

environment variables:

c:\oracle\ora81\jdbc\lib\classes12.zip;

In addition, you also need to add the Oracle Client binaries to your PATH. For example, if your

Oracle Client software is installed on Windows NT in C:\Oracle\Ora81\, then you need to add the

following to your PATH statement:

c:\oracle\ora81\bin;

For Unix, you need to add the Oracle Client binaries to your LD_LIBRARY_PATH setting. For

example, if your Oracle Client software is installed in /u01/app/oracle/product/8.1.6, then you

need to add the following to your LD_LIBRARY_PATH setting:

/u01/app/oracle/product/8.1.6/lib:

2.2.2 Installing the Thin Driver

To install the Thin driver software, follow these steps:

1. Install the Oracle Thin driver from the Oracle client distribution CD.

2. Add the appropriate classesXXX.zip file to your CLASSPATH environment variable.

3. If you are using Java 2 Enterprise Edition (J2EE), add the appropriate classesXXX.zip file

to your J2EE_CLASSPATH environment variable.

2.2.2.1 Install the Thin driver class files

If you are going to use the Thin driver, you can use the Oracle Universal Installer as I specified for

the OCI driver, but this time select only the appropriate Thin driver for installation. Alternatively,

you can simply locate the appropriate classesXXX.zip file on the distribution media and copy it to

an appropriate location on your computer. Then add the desired classesXXX.zip file to your

CLASSPATH and J2EE_CLASSPATH settings. Once again, be sure to specify only one

classesXXX.zip file; otherwise, you will encounter unexpected behavior and errors.

You can also obtain the Thin driver, and an updated version of the OCI driver, via the Oracle

Technology Network (OTN) at:

http://technet.oracle.com/software/tech/java/sqlj_jdbc/software_index.htm. To get

access to the drivers you must be an OTN member. Membership is free, and there is a wealth of

valuable information available, such as documentation, discussion forums, and technology tracks

that allow you as a developer to get a developer copy of all the software for a particular operating

system for about $200/year. I encourage you to take advantage of this resource.

Be aware, however, that while the OCI driver updates are available at OTN, the rest of the OCI

client software is not. You must get this by installing the client software from your distribution

media. Further, if you get a newer classesXXX.zip file, say for 8.1.6, you can use it only with

Version 8.1.6 client software. The Java class files must match the version of the client software.

Many problems flood the JDBC forum about this issue. Of course, you can avoid this problem by

using the Thin driver, which does not use any client software.

2.2.2.2 Setting environment variables

After you've installed the Thin driver, or copied its classesXXX.zip file to an appropriate directory,

you'll need to set several environment variables. Add the desired classesXXX.zip file to your

CLASSPATH and J2EE_CLASSPATH settings. For example, if you copied the classes12.zip file

to /u01/app/oracle/product/8.1.6/jdbc/lib on Unix, then you need to add the following to your

CLASSPATH and J2EE_CLASSPATH environment variables:

/u01/app/oracle/product/8.1.6/jdbc/lib/classes12.zip;

2.2.3 Using Sun's JDBC-ODBC Bridge

This discussion on installation would not be complete if I did not at least acknowledge Sun's

JDBC-ODBC Bridge. If you are going to use the Bridge, then you'll have to install the Oracle

Client and ODBC software, because the Oracle ODBC drivers use the OCI software.

2.3 Connecting to a Database

After you've installed the appropriate driver, it's time to get down to some programming and learn

how to establish a database connection using JDBC. The programming involved to establish a

JDBC connection is fairly simple. Here are the steps to follow:

1. Add import statements to your Java program so the compiler will know where to find the

classes you'll be using in your Java code.

2. Register your JDBC driver. This step causes the JVM to load the desired driver

implementation into memory so it can fulfill your JDBC requests.

3. Formulate a database URL. That is, create a properly formatted address that points to

the database to which you wish to connect.

4. Code a call to the DriverManager object's getConnection( ) method to establish a

database connection.

2.3.1 Package Imports

Import statements tell the Java compiler where to find the classes you reference in your code

and are placed at the very beginning of your source code. To use the standard JDBC package,

which allows you to select, insert, update, and delete data in SQL tables, add the following

imports to your source code:

import java.sql.* ; // for standard JDBC programs

import java.math.* ; // for BigDecimal and BigInteger support

If you need to use JDK 1.1.x, you can still get most of Oracle's JDBC 2.0 features by including the

following import statement in your program:

import oracle.jdbc2.* // for Oracle interfaces equivalent to

// JDBC 2.0 standard package for JDK 1.1.x

Keep in mind, however, that when you do start using JDK 1.2.x or higher you'll have to modify

your code and remove this import statement.

Without the imports shown here you'll have to explicitly identify each class file with its full

package path and name. For example, with imports, you'll normally write the following code to

create a connection object:

Connection conn = DriverManager.getConnection(

"jdbc:oracle:thin:@esales:1521:orcl", "scott", "tiger");

Without imports, however, you'll have to type the following longer statement instead:

java.sql.Connection conn = java.sql.DriverManager.getConnection(

"jdbc:oracle:thin:@esales:1521:orcl", "scott", "tiger");

As you might expect, Oracle provides a number of extensions to the JDBC standard. These

extensions support the use of Oracle-specific database features such as the methods to write

database object types. To use Oracle's extended functionality, add the following imports to your

source code:

import oracle.sql.* ; // for Oracle type extensions

import oracle.jdbc.driver.*; // for Oracle database access and updates

// in Oracle type formats

Now that you have your last bit of housekeeping done, you can move on to registering the

appropriate driver in order to establish a JDBC connection.

2.3.2 Registering a JDBC Driver

You must register the Oracle driver, oracle.jdbc.driver.OracleDriver, in your program

before you use it. At this point, you may be confused because we've been talking about the OCI

and Thin drivers, but now we refer only to one class when registering. That's because the same

class file implements both drivers.

Registering the driver is the process by which the Oracle driver's class file is loaded into memory

so it can be utilized as an implementation of the JDBC interfaces. You need to do this only once

in your program. You can register a driver in one of three ways. The most common approach is to

use Java's Class.forName( ) method to dynamically load the driver's class file into memory,

which automatically registers it. This method is preferable because it allows you to make the

driver registration configurable and portable. The following example uses Class.forName( ) to

try {

Class.forName("oracle.jdbc.driver.OracleDriver");

}

catch(ClassNotFoundException e) {

System.out.println("Oops! Can't find class

oracle.jdbc.driver.OracleDriver");

System.exit(1);

}

The second approach you can use to register a driver is to use the static

DriverManager.registerDriver( ) method. Use the registerDriver( ) method if you

are using a non-JDK compliant JVM, such as the one provided by Microsoft. For example:

try {

DriverManager.registerDriver(new oracle.jdbc.driver.OracleDriver( ));

}

catch(SQLException e) {

System.out.println("Oops! Got a SQL error: " + e.getMessage( ));

System.exit(1);

剩余388页未读，继续阅读

togato

粉丝: 0
资源: 3

Oracle JDBC编程指南

dm8-oracle-jdbc16-wrapper.jar

Oracle-jdbc-12.2.0.1.zip

oracle-jdbc6

oracle-jdbc

ORACLE-JDBC

Oracle-JDBC-Driver

Oracle-jdbc-jar包

mssqlserve-mysql-oracle-jdbcconnector

oracle-jdbc-7.jar

oracle-jdbc.zip

最新资源