优化Oracle JDBC编程：性能与扩展实战

需积分: 9 9 浏览量更新于2024-07-18 收藏 3.29MB PDF 举报

《专家Oracle JDBC编程》是一本由R.M. Menon编著的专业技术书籍，针对Java语言的广泛应用背景下，讲解如何通过JDBC（Java Database Connectivity）API有效地访问和操作Oracle数据库。Oracle是全球顶级数据库之一，本书的焦点在于提升性能和可扩展性。在JDBC编程方面，本书深入探讨了如何利用Java与Oracle数据库进行高效交互，包括连接管理、数据操作（如查询、更新、插入和删除）、事务处理、结果集处理、错误处理以及优化查询策略等核心主题。作者强调了在大规模系统中保持良好的性能和稳定性的重要性，这在现代企业级应用中尤其关键。书中可能会介绍Oracle JDBC驱动程序的使用方法，如何配置连接池以提高并发性能，以及如何通过PreparedStatement避免SQL注入攻击，确保数据安全。此外，还会涉及连接池管理、连接复用、缓存优化、网络通信效率等方面的最佳实践。技术评审者们如Rob Harrop、Thomas Kyte、Torben Holm和Julian Dyke的专业知识，确保了内容的准确性和实用性。他们可能对特定的技术细节进行了验证和补充，帮助读者避免常见问题，提升代码质量。版权和使用限制方面，本书受到严格保护，未经版权所有者和出版商事先书面许可，禁止任何形式的复制或传输，无论是电子还是机械方式，包括复印、录音，或者通过任何信息存储和检索系统。对于商标使用，书中仅以编辑方式提及，尊重并无意侵犯商标权。本书的编辑团队包括Lead Editor Tony Davis、多位技术编辑和项目经理，他们共同确保了内容的组织结构清晰，排版专业，并在项目管理和质量控制上提供了支持。《Expert Oracle JDBC Programming》是为Java开发者提供深入理解Oracle数据库和高效JDBC编程实践的宝贵资源，无论你是初学者还是经验丰富的开发人员，都能从中受益匪浅，提升在实际工作中的数据库操作能力。

Introduction

With the popularity of Java language, JDBC is now perhaps the most commonly used API

to access databases. Oracle is one of the premium databases of the world. This book is about

accessing and manipulating data in Oracle using JDBC, with a focus on performance and scal-

ability.

Why another book on JDBC and Oracle, you may ask? I wrote this book because I realized

that most of the other JDBC books available today more or less regurgitate the JDBC specifica-

tion and the Oracle JDBC documentation that is freely available on the Internet. This book is

different. The central aim of this book is to complement the available documentation on JDBC

and Oracle, and to teach you how to use JDBC with Oracle effectively. This book is also different

from other JDBC books because of its focus on performance and scalability of applications.

Using this book, you will discover the following, among other things:

• How to use all the major features of standard JDBC and its Oracle extensions (Oracle 10g

and 9i)

• The most important architectural features of Oracle, an understanding of which will

enable you to write solid Oracle applications

• How to write and run your own benchmarks to validate (or invalidate) various perform-

ance claims, using invaluable Oracle performance tools such as tkprof, SQL trace, etc.

• The importance of understanding how to effectively exploit SQL and PL/SQL in your

applications

Please note that this book does not cover related technologies such as OC4J, JSP, Spring

Framework, and so on. Instead, it maintains focus on the JDBC API and the database tier.

Within the JDBC API, I have skipped some of the less commonly used JDBC features such as

distributed transactions, some of the RAC-related topics, and rowsets. The section “Overview

of JDBC API” in Chapter 3 explains in detail the different interfaces of the JDBC API and the

chapters that cover them (and it provides appropriate references if a topic is not covered).

Who This Book Is For

This book is for those who want to learn how to write effective JDBC code when developing

an Oracle application. The book assumes that you are familiar with Java and have some basic

knowledge of SQL and PL/SQL. The book does not assume any prior knowledge of JDBC. All

concepts are illustrated with detailed examples accompanied by interspersed comments

explaining the examples. Your best bet to make the most out of this book is to run the exam-

ples while you are reading along.

xxiii

What This Book Covers

The book consists of 17 chapters covering a wide range of topics. The following sections pres-

ent chapter-by-chapter breakdowns.

Chapter 1: Performance Toolkit

The very first chapter introduces you to the various performance tools you’ll use throughout

the book. These include tools such as tkprof that come bundled with Oracle, as well as tools

I wrote in Java for your convenience. This is a reference chapter that I recommend you revisit

whenever you need to refresh your memory about a tool used elsewhere in the book.

Chapter 2: Oracle Fundamentals

This chapter explores some of the fundamental architectural features of Oracle that you as a

developer should know. You’ll be introduced to topics such as multiversioning read consis-

tency, the locking mechanism used by Oracle, shared pool, latches, undo, redo, and so on,

with illustrative examples. I also provide performance guidelines applicable in general when

developing an application. I recommend that you read this chapter before you read any other

remaining chapters in this book.

Chapter 3: Introduction to JDBC

In this chapter, you’ll learn the software you need to install to develop and run JDBC programs

on either UNIX or the Windows platform. You’ll examine the various types of JDBC drivers, and

which ones to use when. You’ll also get a good overview of the JDBC API and learn how to con-

nect to a database. You’ll then go on to write your first JDBC program.

Chapter 4: Transactions

Transactions form the basis of any database. In this chapter, you’ll take a brief look at transac-

tions in the context of JDBC. You’ll see how to commit and roll back a transaction in JDBC. You’ll

learn what transaction isolation levels are and which ones are supported by Oracle. You’ll learn

about some important principles you need to follow when writing transactions for an Oracle

application. You’ll also examine transaction savepoints, a feature exposed to Java programs in

JDBC 3.0.

Chapter 5: Statement and PreparedStatement

In this chapter, you’ll first be introduced to the mechanics of how Oracle processes SQL state-

ments. You’ll then examine two of the fundamental statement interfaces of JDBC: Statement

and PreparedStatement. You’ll look at why you should almost always prefer PreparedStatement

over Statement. You’ll learn about how using PreparedStatement can help avoid SQL injection

(a security hacking technique) attacks. You’ll also learn about standard and Oracle update

batching, and compare the two in terms of performance and other features.

■INTRODUCTIONxxiv

Chapter 6: CallableStatement

In this chapter, you’ll explore in detail how to invoke stored SQL procedures from JDBC using

the CallableStatement interface. You’ll learn how to use SQL92 syntax or Oracle syntax when

invoking a stored procedure using the CallableStatement interface.

Chapter 7: Result Sets Explored

This chapter describes the advanced features of the ResultSet interface, including prefetch-

ing, scrollability, positioning, sensitivity, and updatability. You’ll learn the various strengths

and weaknesses of these features, and you’ll examine how to paginate through the results of a

query efficiently. You’ll learn how you can dynamically build query statements with unknown

number of bind variables using either the PreparedStatement or CallableStatement interface.

The ResultSetMetaData and DatabaseMetaData interfaces are also covered.

Chapter 8: Oracle Objects: An Objective Analysis

This chapter introduces Oracle objects and collections. You’ll critically examine how these fea-

tures should be used in Oracle applications in general. Note that this chapter doesn’t discuss

how to access objects and collections from JDBC; those topics are covered in the next three

chapters. I strongly recommend you read this chapter, though, since it forms the basis of the

following three chapters that discuss Oracle objects and collections.

Chapter 9: Using Weakly Typed Struct Objects

In this chapter, you’ll learn how to materialize Oracle objects as weakly typed objects in Java. A

weakly typed object refers to a Java object that represents objects using an array of attributes.

Chapter 10: Using Strongly Typed Interfaces with JPublisher

Here, you’ll learn how to materialize objects as strongly typed objects in Java. A strongly typed

object refers to an object belonging to a custom Java class specifically created to represent a

given database object type in Java. Along the way, you’ll learn how to use the JPublisher utility

to generate custom classes representing Oracle objects.

Chapter 11: Using Oracle Collections and References

This chapter explains how to retrieve the collections in Oracle as either a weakly typed or

strongly typed array of custom class objects (generated using the JPublisher utility). You’ll crit-

ically examine some of the performance extensions Oracle provides you with, and you’ll also

study suitable benchmarks evaluating the effectiveness of these extensions. You’ll then move

on to learn about references, and how to access and manipulate them using JDBC.

Chapter 12: Using LOBs and BFILEs

In this chapter, you’ll learn what LOBs (large objects) are and how they’re stored in Oracle.

You’ll then examine how to retrieve and manipulate them. You’ll also compare various alter-

natives when manipulating LOBs through the JDBC API.

■INTRODUCTION

xxv

Chapter 13: Statement Caching

In this chapter, you’ll learn about statement caching, its different flavors in JDBC, and how it

improves the performance of JDBC programs. As a background to the statement-caching con-

cept, you’ll also examine cursors and ref cursors in detail. In addition, you’ll look at two other

related caches Oracle provides you with: the PL/SQL cursor cache (which is the PL/SQL equiv-

alent of the JDBC statement cache) and session cached cursors.

Chapter 14: Connection Pooling and Caching

In this chapter, you’ll learn about connection pooling and caching, and how they can improve

the performance of your application. You’ll look at the 9i and 10g implementations separately.

Finally, you’ll examine Oracle’s OCI driver connection pooling feature.

Chapter 15: Security-Related Issues

This chapter examines some of the security issues involved in a three-tier architecture that uses

connection pooling. In particular, it delves into various alternatives of mapping an application

end user to a database end user, and different ways in which an application can authenticate to

the database on behalf of an end user. You’ll also learn about the proxy authentication feature.

Chapter 16: Locking-Related Issues

In this chapter, you’ll look at some of the issues related to locking in Oracle. In particular, you’ll

learn about the infamous lost update problem and various ways to address it. Along the way,

you’ll examine different strategies to implement two solutions to the lost update problem,

namely optimistic locking and pessimistic locking. You’ll also compare these two solutions

and determine when to use each strategy.

Chapter 17: Selected PL/SQL Techniques

In the final chapter, you’ll learn why it is critical for a JDBC programmer working with Oracle

databases to learn and master PL/SQL. You’ll also examine a few selected PL/SQL techniques

that will help you in writing high-performance and maintainable PL/SQL code.

Appendix

The Appendix includes two reference tables that list mappings between SQL object types and

Java types.

优化Oracle JDBC编程：性能与扩展实战

Expert.Oracle.JDBC.Programming.May.2005

jdbc_on_oracle

Menon_Labs:植物干扰器团队1

menon-labs-challenge

ANJALI.MENON-PROJECT-86

menonlabs-challenge:Menon Labs的后端挑战

menon-log-trace:日志跟踪客户端:dizzy:

Parallel Programming in OpenMP

RDE07-Lucas_Sobutka_Menon:RDE07类的摘要

matlab中ode15s函数代码-LocalizationMeetsNetworks:用于G.Menon和J.Krishnan,Spatia

最新资源