Java data objects (JDO) is a heavy-duty object persistence application programming interface (API). This implementation-neutral guide to JDO is organized into 15 chapters and five appendices.

The first two chapters introduce persistence and the concept of persistence by reachability. The third chapter discusses what transparent persistence is, and how JDO supports it. Chapter 4 presents the workings of the finite state machine that manages persistence. Chapter 5 presents a description of, and the intended use of, available interfaces and classes (this chapter is twice as large as any other in the book). Chapter 6 discusses queries, query filters, and data retrieval. Chapter 7 is on datastore suitability, connection management, and transaction management.

Chapter 8 presents JDO for Java 2 Enterprise Edition (J2EE) application servers. Chapter 9 discusses the why, when, and how of JDO and Enterprise Java Bean (EJB) coexistence, with thoughtful observations on EJB and servlets. Chapter 10 is on security. Chapter 11 describes writing transactional code with JDO. Chapter 12 discusses the complementary and coexisting roles of JDO and JDBC. Chapter 13 contains usage guidelines, tips, and tricks. Chapter 14 discusses the future of JDO, and chapter 15 contains code-rich examples. The appendices contain reference material, such as a listing of finite state machine (FSM) states; Extensible Markup Language (XML), document type definition (DTD), and Backus Naur form (BNF) notations; and a list of available implementations.

The style and scope of the book are geared to the technical user: this is not a casual expository introduction, and the book can be at least in part useful to JDO implementers. There is very little effort made toward evangelizing; the text presents the pros and cons of JDO fairly, and shows when it is appropriate to use JDO, and when other solutions can provide better results. From an architectural perspective, this approach affords newcomers to JDO a quick path to understanding where JDO fits in the larger picture.

The writing is analytical, and drills down to detail fearlessly in order to explain and illustrate many behavioral nuances. However, JDO is an API, and the text is concerned with implementation only as a way to present possible extensions, shortcomings, and ambiguities from a hypothetical perspective. Therefore, this book is not suitable for use as a developer’s only guide, in connection with any particular implementation. Its value in this scope is as a generic complement to more specific copy.

The text is best read or skimmed from cover to cover at first, if possible, since the scope of treatment of the subject matter varies from chapter to chapter. Architectural structure and coding details are at times intermixed, and cross-references abound; perhaps the book could have been organized more carefully. There are some copy editing errors and minor oversights of neglected graphics proofs; these do not diminish the value of the content, but may be annoying.

In sum, this book is a detailed and very technical source for understanding the basic concepts and the generic usage and workings of JDO, as well as a useful bookshelf reference for the reader familiar with the organization of the text.