David Jordan

Java Data Objects (eBook, PDF)

Store Objects with Ease

• Format: PDF

Produktbeschreibung

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.

---

Dieser Download kann aus rechtlichen Gründen nur mit Rechnungsadresse in A, B, BG, CY, CZ, D, DK, EW, E, FIN, F, GR, HR, H, IRL, I, LT, L, LR, M, NL, PL, P, R, S, SLO, SK ausgeliefert werden.

Produktdetails

• Verlag: O'Reilly Media
• Seitenzahl: 382
• Erscheinungstermin: 22. April 2003
• Englisch
• ISBN-13: 9781491946404
• Artikelnr.: 39598132

Autorenporträt

David Jordan founded Object Identity, Inc. in 2001 to provide JDO consulting services. He became interested in the integration of object type systems and databases while earning his M.S. in Computer Science in the early 1980s. At Bell Labs in 1985, he initiated the development of the first C++ object database. He has developed a variety of applications using C++ object models on top of network, relational, and object database systems. Bell Labs appointed him a Distinguished Member of Technical Staff in 1990 for his contributions in object and database technologies. The Object Data Management Group (ODMG) asked him to serve as their C++ editor in 1993. He served in that role until 2000 and was appointed their Java editor in 1998. He coedited four books published by the ODMG. David served as a C++ Report columnist describing the ODMG standard from 1994 to 1996, at which point he stopped to write his first book, C++ Object Databases. David started using Java in late 1995. Upon his selection as ODMG's Java editor, he became a columnist for Java Report, initially covering ODMG and then JDO. David was part of the small group that initiated JSR-12, and he became one of the initial members of the JDO expert group. The JDO specification has a special acknowledgment of David's contributions to the JDO standard. When the JDOcentral.com community web site was formed, David was selected to serve as its moderator. David can be reached at [e-mail] Craig Russell studied applied mathematics at Harvard University (B.A. '70 - '71) and acquired practical experience working as a technician repairing mainframes with the computing power of a 1997 model laptop. His early experiences in distributed computing included building applications with CICS and DL/I and designing heterogeneous network server implementations for file, print, and communications sharing among personal computers. Craig later dealt with issues of persistent object interoperability among Smalltalk, C++, and Java and integrating object and relational databases using X/OPEN XA protocols and commercial transaction processing systems. Craig served as the Java Chair of the Object Data Management Group and played a key role in the development of the ODMG 3.0 Java binding. For the next standard for database access from Java, the ODMG decided to support the Java Community Process as the delivery vehicle. With support from all major relational database and middleware vendors, Java Specification Request 12, Java Data Objects, was proposed in May 1999 and released in April 2002. Concurrent with the development of the JDO standard, Craig's primary responsibility was to lead the implementation of the object-relational database engine for several Sun products, including Java Blend and Forte for Java Transparent Persistence. Craig currently is the architect for the Container Managed Persistence implementation of Sun ONE Application Server, where he deals with the reality of implementing the high-performance, specification-compliant version of the object-relational database component of the J2EE application server.

Inhaltsangabe

Dedication
Foreword
Preface
Who Should Read This Book?
Organization
Software and Versions
Using Code Examples
Conventions
Comments and Questions
Acknowledgments
Chapter 1: An Initial Tour
1.1 Defining a Persistent Object Model
1.2 Project Build Environment
1.3 Establish a Datastore Connection and Transaction
1.4 Operations on Instances
1.5 Summary
Chapter 2: An Overview of JDO Interfaces
2.1 The javax.jdo Package
2.2 The javax.jdo.spi Package
2.3 Optional Features
Chapter 3: JDO Architectures
3.1 Architecture Within Application JVM
3.2 Datastore Access
3.3 System Architectures with a JDO Application
Chapter 4: Defining Persistent Classes
4.1 Kinds of Classes and Instances
4.2 Java Classes and Metadata
4.3 Fields
Chapter 5: Datastore Mappings
5.1 Mapping Approaches
5.2 Relational Modeling Constructs
5.3 Modeling Constructs in Java and Relational Models
5.4 Mapping Classes to Tables
5.5 Mapping a Single-Valued Field to a Column
5.6 Identity
5.7 Inheritance
5.8 References
5.9 Collections and Relationships
Chapter 6: Class Enhancement
6.1 Enhancement Approaches
6.2 Binary Compatibility
6.3 Enhancement Effects on Your Code
6.4 Changes Made by the Enhancer
Chapter 7: Establishing a JDO Runtime Environment
7.1 Configuring a PersistenceManagerFactory
7.2 Acquiring a PersistenceManager
7.3 Transactions
7.4 Multiple PersistenceManagers
7.5 Multithreading
Chapter 8: Instance Management
8.1 Persistence of Instances
8.2 Extent Access
8.3 Accessing and Updating Instances
8.4 Deleting Instances
Chapter 9: The JDO Query Language
9.1 Query Components
9.2 Creating and Initializing a Query
9.3 Changes in the Cache
9.4 Query Namespaces
9.5 Query Execution
9.6 The Query Filter
9.7 Ordering Query Results
9.8 Closing a Query
Chapter 10: Identity
10.1 Overview
10.2 Datastore Identity
10.3 Application Identity
10.4 Nondurable Identity
10.5 Identity Methods
10.6 Advanced Topics
Chapter 11: Lifecycle States and Transitions
11.1 Lifecycle States
11.2 State Interrogation
11.3 State Transitions
Chapter 12: Field Management
12.1 Transactional Fields
12.2 null Values
12.3 Retrieval of Fields
12.4 Serialization
12.5 Managing Fields During Lifecycle Events
12.6 First- and Second-Class Objects
Chapter 13: Cache Management
13.1 Explicit Management of Instances in the Cache
13.2 Cloning
13.3 Transient-Transactional Instances
13.4 Making a Persistent Instance Transient
Chapter 14: Nontransactional Access
14.1 Nontransactional Features
14.2 Reading Outside a Transaction
14.3 Persistent-Nontransactional State
14.4 Retaining Values at Transaction Commit
14.5 Restoring Values at Transaction Rollback
14.6 Modifying Persistent Instances Outside a Transaction
Chapter 15: Optimistic Transactions
15.1 Verification at Commit
15.2 Optimistic Transaction State Transitions
15.3 Deleting Instances
15.4 Making Instances Transactional
15.5 Modifying Instances
15.6 Commit
15.7 Rollback
Chapter 16: The Web-Server Environment
16.1 Web Servers
16.2 Struts with JDO
Chapter 17: J2EE Application Servers
17.1 Enterprise JavaBeans Architecture
17.2 Stateless Session Beans
17.3 Bean-Managed Transactions
17.4 Message-Driven Beans
17.5 Persistent Entities and JDO
Lifecycle States and Transitions
JDO Metadata DTD
JDO Interfaces and Exception Classes
Interfaces
Exceptions
JDO Query Language BNF
Parameter Declaration
Variable Declaration
Import Declaration
Ordering Specification
Type Specification
Names
Literal
Filter Expressions
Source Code for Examples
The com.mediamania.appserver package
The com.mediamania.content package
The com.mediamania.hotcache package
The com.mediamania.store package
Colophon