Java Data Objects

Customers who bought this, also bought: Beginning Transact-SQL with SQL Server 2000 and 2005 The Java Developer's Guide to Eclipse (2nd Edition) JBoss at Work: A Practical Guide Java in a Nutshell, 5th Edition Professional DotNetNuke ASP.NET Portals Java Threads, 3rd Edition Applying Enterprise JavaBeans: Component-Based Development for the J2EE Platform , Second Edition Teach Yourself Transact-SQL in 21 Days - 2nd Edition Framework Design Guidelines : Conventions, Idioms, and Patterns for Reusable .NET Libraries JBoss 4.0 - The Official Guide (Paperback)

by: David Jordan, Craig Russell

Notify me when in stock

On-line Price: $52.95 (includes GST) Paperback package 384 20%Off Retail Price You save: $13.00 Please call us to check availability	Retail Price: $65.95 Publisher: O'REILLY,Apr-2003 Category: JAVA Level: I/A ISBN: 0596002769 ISBN13: 9780596002763
Add to Shopping Cart

Java Data Objects revolutionizes the way Java developers interact with databases and other datastores. JDO allows you to store and retrieve objects in a way that's natural to Java programmers. Instead of working with JDBC or EJB's container-managed persistence, you work directly with your Java objects. You don't have to copy data to and from database tables or issue SELECTs to perform queries: your JDO implementation takes care of persistence behind-the-scenes, and you make queries based on the fields of your Java objects, using normal Java syntax.

  The result is software that is truly object-oriented: not code that is partially object-oriented, with a large database-shaped lump on the back end. JDO lets you save plain, ordinary Java objects, and does not force you to use different data models and types for dealing with storage. As a result, your code becomes easier to maintain, easier to re-use, and easier to test. And you're not tied to a specific database vendor: your JDO code is entirely database-independent. You don't even need to know whether the datastore is a relational database, an object database, or just a set of files.

  This book, written by the JDO Specification Lead and one of the key contributors to the JDO Specification, is the definitive work on the JDO API. It gives you a thorough introduction to JDO, starting with a simple application that demonstrates many of JDO's capabilities. It shows you how to make classes persistent, how JDO maps persistent classes to the database, how to configure JDO at runtime, how to perform transactions, and how to make queries. More advanced chapters cover optional features such as nontransactional access and optimistic transactions. The book concludes by discussing the use of JDO in web applications and J2EE environments.

  Whether you only want to read up on an interesting new technology, or are seriously considering an alternative to JDBC or EJB CMP, you'll find that this book is essential. It provides by far the most authoritative and complete coverage available.

Table of Contents

Foreword

  Preface

  1. An Initial Tour

          Defining a Persistent Object Model

                              The Classes to Persist

                              Declaring Classes to Be Persistent

          Project Build Environment

                              Jars Needed to Use the JDO Reference Implementation

                              Project Directory Structure

                              Enhancing Classes for Persistence

          Establish a Datastore Connection and Transaction

                              Acquiring a PersistenceManager

                              Creating a FOStore Datastore

          Operations on Instances

                              Making Instances Persistent

                              Accessing Instances

                              Modifying an Instance

                              Deleting Instances

          Summary

  2. An Overview of JDO Interfaces

          The javax.jdo Package

                              JDO Exception Classes

          The javax.jdo.spi Package

          Optional Features

                              Identity Options

                              Optional Collections

                              Transaction-Related Optional Features

  3. JDO Architectures

          Architecture Within Application JVM

                              Single PersistenceManager

                              Multiple PersistenceManagers Accessing the Same Datastore

                              Multiple PersistenceManagers Accessing Different Datastores

                              Shared Implementation Cache

          Datastore Access

                              Direct Access of Filesystem or Local Datastore

                              Remote Access of a JDO Server

                              Remote Access of a SQL Datastore

          System Architectures with a JDO Application

                              JDO Rich Client with Local Datastore

                              JDO Applications in a Web Server

                              JDO Applications as Web Services

                              Rich Client Connecting to Application Server with EJB Components

                              Web Server with EJB Server

                              EJB Session Beans Using Session Bean Fa?des

                              JDO Providing Container-Managed Persistence

  4. Defining Persistent Classes

          Kinds of Classes and Instances

                              Kinds of Classes

                              Kinds of Instances

          Java Classes and Metadata

                              JDO Metadata

                              Inheritance

                              The Media Mania Object Model

          Fields

                              Supported Types

                              Persistence of Fields

                              Complete Metadata for the Media Mania Model

  5. Datastore Mappings

          Mapping Approaches

          Relational Modeling Constructs

                              SQL 99

          Modeling Constructs in Java and Relational Models

          Mapping Classes to Tables

          Mapping a Single-Valued Field to a Column

                              Name-Mapping

                              Type-Mapping

                              Indexes

          Identity

          Inheritance

          References

          Collections and Relationships

                              Using a Foreign Key

                              Using a Join Table

                              One-to-One Relationships

                              Representing Lists and Maps

  6. Class Enhancement

          Enhancement Approaches

                              Reference Enhancer

                              Vendor-Specific Enhancement

          Binary Compatibility

          Enhancement Effects on Your Code

          Changes Made by the Enhancer

                              Metadata

                              Instance-Level Data

                              Field Mediation

  7. Establishing a JDO Runtime Environment

          Configuring a PersistenceManagerFactory

                              Connection Properties

                              Optional Feature Properties

                              Flags

                              Flags Settings in Multiple Interfaces

                              Determining the Optional Features and Default Flag Settings

                              Vendor-Specific Properties

                              Nonconfigurable Properties

          Acquiring a PersistenceManager

                              User Object

                              Closing a PersistenceManager

                              Closing a PersistenceManagerFactory

          Transactions

                              Properties of Transactions

                              Transactions and Locking in the Datastore

                              Types of Transactions in JDO

                              Acquiring a Transaction

                              Setting the Transaction Type

                              Transaction Demarcation

                              Restoring Values on Rollback

                              Determining Whether a Transaction Is Active

          Multiple PersistenceManagers

          Multithreading

  8. Instance Management

          Persistence of Instances

                              Explicit Persistence

                              Persistence-by-Reachability

          Extent Access

                              Accessing an Extent

                              Extent Iteration

                              Ignoring the Cache

          Accessing and Updating Instances

                              Explicit Marking of Modified Instances

          Deleting Instances

                              Delete Propagation

  9. The JDO Query Language

          Query Components

          Creating and Initializing a Query

          Changes in the Cache

          Query Namespaces

                              Type Names

                              Field, Parameter, and Variable Names

                              Keywords

                              Literals

          Query Execution

                              Parameter Declarations

                              Executing a Query

                              Compiling a Query

          The Query Filter

                              General Characteristics of Expressions

                              Query Operators

                              References

                              Collections

          Ordering Query Results

          Closing a Query

  10. Identity

          Overview

                              JDO Identity Types

                              Metadata

                              Identity Class

          Datastore Identity

          Application Identity

                              Primary-Key Fields

                              Persistent Class equals() and hashCode(

) Methods

                              The Application-Identity Class

                              A Single-Field Primary Key

                              A Compound Primary Key

                              A Compound Primary Key That Contains a Foreign Key

                              Application Identity in an Inheritance Hierarchy

          Nondurable Identity

          Identity Methods

                              Get the Identity Class

                              Get the Identity of an Instance

                              Getting an Instance via Its Identity

                              Changing the Application Identity of an Instanc

                              Get the Current Application Identity of an Instance

                              The String Representation of Identity

          Advanced Topics

                              Choosing an Identity Type

                              Using Identity Versus a Query

                              Identity Across PersistenceManagers

  11. Lifecycle States and Transitions

          Lifecycle States

                              Transient

                              Persistent-New

                              Hollow

                              Persistent-Clean

                              Persistent-Dirty

                              Persistent-Deleted

                              Persistent-New-Deleted

          State Interrogation

          State Transitions

                              State Transitions During a Datastore Transaction

                              State Transitions When a Transaction Completes

                              States Between Transactions

  12. Field Management

          Transactional Fields

          null Values

          Retrieval of Fields

                              Default Fetch Group

                              Retrieving All Fields

                              The Management of Fields

          Serialization

          Managing Fields During Lifecycle Events

          First- and Second-Class Objects

                              Specifying a Second-Class Object

                              Embedding Collection Elements

                              Persistent Classes as Second-Class Objects

                              Sharing of Instances

  13. Cache Management

          Explicit Management of Instances in the Cache

                              Refreshing Instances

                              Evicting Instances

          Cloning

          Transient-Transactional Instances

                              Transient-Transactional Lifecycle States

                              State Interrogation

                              State Transitions

          Making a Persistent Instance Transient

  14. Nontransactional Access

          Nontransactional Features

          Reading Outside a Transaction

          Persistent-Nontransactional State

          Retaining Values at Transaction Commit

          Restoring Values at Transaction Rollback

                              Before Image

                              Restoring Persistent Instances

                              Restoring Persistent-New Instances

          Modifying Persistent Instances Outside a Transaction

                              Hot Cache Example

  15. Optimistic Transactions

          Verification at Commit

                              Recovery from a Failed Transaction

                              Setting Optimistic Transaction Behavior

                              Optimistic Example

          Optimistic Transaction State Transitions

          Deleting Instances

          Making Instances Transactional

          Modifying Instances

          Commit

          Rollback

  16. The Web-Server Environment

          Web Servers

                              Accessing the PersistenceManagerFactory

                              Servicing Requests

                              PersistenceManager per Request

                              PersistenceManager per Application

                              PersistenceManager per Transactional Request

                              PersistenceManager per Session

                              Transactions

                              JavaServer Pages

          Struts with JDO

  17. J2EE Application Servers

          Enterprise JavaBeans Architecture

          Stateless Session Beans

                              Configuring the PersistenceManagerFactory

                              Stateless Session Beans with Container-Managed Transactions

                              Stateful Session Beans with Container-Managed Transactions

          Bean-Managed Transactions

                              javax.transaction.UserTransaction

                              javax.jdo.Transaction

                              Stateless Session Beans with Bean-Managed Transactions

                              Stateful Session Beans with Bean-Managed Transactions

          Message-Driven Beans

          Persistent Entities and JDO

                              Local Persistent Storage

                              Remote Persistent Storage

  A. Lifecycle States and Transitions

  B. JDO Metadata DTD

  C. JDO Interfaces and Exception Classes

  D. JDO Query Language BNF

  E. Source Code for Examples

  Index