Java与Oracle JDBC编程入门指南

4星 · 超过85%的资源需积分: 10 107 浏览量更新于2024-07-31 收藏 1.34MB PDF 举报

《Java编程与Oracle JDBC》是一本由Donald Bales编著的专业教程，由O'Reilly出版社于2002年1月首次发行，ISBN号码为0-596-00088-x，共496页。本书专为那些希望在Java程序中利用Oracle JDBC技术访问关系型数据的开发者精心设计，旨在帮助读者掌握这一关键技术。本书的核心内容围绕Oracle JDBC展开，从基础入门到高级应用，涵盖了广泛的议题。首先，作者引导读者探索如何建立数据库连接，并教授如何执行SQL查询并获取结果。接着，书中深入探讨了更复杂的话题，如处理大对象流、调用PL/SQL过程，以及利用Oracle 9i的面向对象特性。最后，作者对事务管理、并发控制和性能优化进行了全面讲解，确保读者在实际项目中能有效运用所学知识。《Java Programming with Oracle JDBC》的目标读者是Java开发人员，特别是那些希望在Oracle数据库环境中扩展其技能的工程师。书中采用清晰易懂的语言和实践案例，使得理论与实践相结合，便于读者快速上手。全书结构严谨，分为两个主要部分：概述介绍JDBC技术和深入的应用数据库连接。第一部分（1.1至1.3章）介绍了JDBC API的基础概念，包括客户端使用以及SQL的基本操作。第二部分（2.1至2.3章）聚焦于实际应用，讲解JDBC驱动的安装、数据库连接的设置，以及如何在实际环境中构建和维护数据库连接。此外，书中还包含版权信息、目录索引、完整描述、作者简介、读者评论和勘误表，以提供完整的参考资源。如果你是正在学习Java与Oracle数据库交互的新手，或者希望提升在这一领域的能力，这本书无疑是值得深入研读的宝贵资料。如果你在阅读过程中遇到任何问题或建议，作者提供了联系方式以便读者反馈和交流。通过学习本书，你将能够充分利用Java与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页未读，继续阅读

xuweilirichard

粉丝: 0
资源: 1

Java与Oracle JDBC编程入门指南

Java Programming With Oracle Sqlj

java_database_programming_with_jdbc.rar_java programming

Java.Programming.with.Oracle

Java与Oracle JDBC编程全面指南

掌握Oracle JDBC的Java编程实战教程

Practical Database Programming with Java

Murach's Java Programming, 4th edition

JAVA_JDBC面向对象分页(初步设计二之oracle)

Practical.Database.Programming.with.Java.2011

JAVA数据库编程JDBC .rar

最新资源