Java Data Objects

The first book to introduce JDO, an enhancement for databases with improvements in application portability, performance and reliability. Complete coverage of JDOQL, a new query language. CD-ROM included.

User review
Review of Java Data Objects by Robin Roos
This book is an introduction to the Java Data Object (JDO) technology. It is oriented towards potential users (managers, architects and developers) of a JDO implementation. Some mention is made of JDO implementation details but not nearly enough to guide someone that wants to provide a JDO implementation.

While providing similar information this book is far more readable than the JDO specification. It covers the following subjects:
· Object Persistence background
· A simple example to set content
· An overview of JDO
· The lifecycle model of JDO objects
· The primary classes and interfaces a JOO programmer uses
· JDO Transaction Management
· How to do JDOQL queries
· How to process JDO exceptions
· How to create JDO Persistence Descriptors )(in XML)
· How to use JDO from a managed (i.e., J2EE) environment

The book concludes with comparisons between and descriptions of several commercial JDO implementations and speculates on future enhancements to the JDO specification.

The book also has several appendixes covering some helper classes supplied with the book, the JDO Descriptor XML DTD, some reference information, a bibliography, a glossary of terms and an index of terms. Also included is a CD-ROM with trial versions of several JDO implementations.

Overall the quality of the book is high. It flows well and is readable. There are a few places where a word or two is missing from the sentences. A few of the examples have minor flaws.

The book is tutorial in form. It provides a running set of examples based on a data model for managing business partner relationships. The book has numerous figures to help illustrate its points including extensive use of UML class and state transitions diagrams and code snippets. It provides a fair amount of reference material, but when doing JDO coding it is likely you will still need to refer to the JDO JavaDoc.

As the book describes, JDO is a persistence mechanism for Java objects. It is intended to provide transparent persistence (i.e., no need to specially design you classes to be persistent). JDO relieves the programmer from worrying about many of the fine details needed to create a working object persistence system. It typically uses an Aspect-Oriented Programming like solution where persistent features are added (i.e., via enhancement) to a class by a post-processor that modifies the .class file. JDO is quite abstract in nature and is data store agnostic, in that it can be implemented on object, relational, document, file or other types of data stores. JDO is often considered as an alternative to using Entity EJBs or as one possible implementation of Entity EJBs using CMP or BMP.

One area of particular interest to me not covered in the book is how to map JDO onto existing legacy databases (or control the mapping to any target data store). Perhaps this information is provided by the individual JDO implementation vendors.

While not a comment on the book, it appears JDO itself has some functional and performance issues that are yet to be addressed. If you are considering using JDO, I suggest you understand these limitations before you make your decision to use JDO.

User review
Wonderful book
I'm reading this book and actually I can't say that it's the best book because I haven't read all the books , but I can say that it's one of the best book because it explains very well in a didactic manner all the intricacies of JDO. You won't need any knowing about JDO for reading this book.

All my congratulations and my thanks for the author Robin Roos for this book.

User review
A good introduction to JDO
Java Data Objects by Robin M. Roos is one of the first books
available on the subject of JDO. The author does a good job of
explaining the impetus for the creation of JDO and the concept
of transparent persistence. The first 200 pages of the book are
effective at presenting the meat of what JDO is about in a way
that is more readable than the JDO specification of about equal
length. If you like reading specifications, then you probably
wouldn't buy this book anyway. For Java architects, designers,
and programmers looking to understand JDO, this book is a good
start. It is assumed that the reader has a background with Java
development, but not necessarily persistence methods. Of course,
Chapter 11's discussion of JDO and J2EE will make more sense if
you are familiar with the J2EE.

The book has a good flow and an easy to read style (I love the
occasional use of `whilst`, but maybe that's just me). Java Data
Objects succeeds for the most part in not relying on any forward
references. The only one I remember was the concept of `fetch
groups`, which isn't defined until pg. 156. It also does a good
job of staying vendor neutral and presenting the technology as
defined by the spec. The author was careful to point out vendor-
dependent features. I enjoyed the careful use of UML, state
transition, and object interaction diagrams in the text to explain
key concepts. Particularly, chapters 4's explanation of an
object's lifecycle and chapter 5's description of the persistent
object model. Chapter 6 is a walkthrough of the most commonly
used JDO classes and interfaces.

The book is well written and easy to follow. For the architect,
designer, or developer considering new ways to persist objects
(in a relational or object db), JDO is definitely an interesting
new alternative to consider. I had a few issues with the
examples and the CD, but frankly I didn't want to spend a lot
of time learning different product environments at the time I
was experimenting with the examples. Here's a suggestion: why
not include the JDO RI from Sun on the CD? It might be nice to
provide a set of scripts which use the reference implementation
as an alternative to the commercial offerings.

User review
good introduction to JDO
I just started using JDO. This book was a good introduction. Altho it lacks some of the details of the specification, it was much easier to understand. At just over 200 pages of text, it was easy to read cover to cover.

Some books elaborate beyond their relevant specification, e.g., The Java Class Libraries series. That's fine for a reference book, but I wouldn't want to read the whole thing all at once. Robin Roos' book abstracts some of the complexity from JDO to explain it in a way that I think a lot of people will find easier to understand.

Coming from a JDBC and home-grown persistence layer background, I can appreciate how complex the issues are. So I was impressed with how simple Robin's explanations were. I doubt it will be the last JDO book that I buy, but I'm glad that it was the first.

This book is not a big comparison of the major persistence layer technology choices today, nor an analysis of the application of JDO to a major project. If you're trying to evaluate JDO against the other technologies, then you'll need to look at the online debates. But if you want to try JDO for yourself, then this is a good start.

User review
Good coverage with relevant examples
I hesitated before buying this book because of its first review here at [Amazon.com], but now I'm glad bought it. Roos introduces the subject well and with enthusiasm. A fairly compelling case is made for JDO. And that includes some forthright but well supported comments on JDO vs Entity Beans. No punches pulled!

The examples are relevant but not unnecessarily complex. The usage of JDO and the underlying theme of `transparent persistence` both come through clearly. The book seems fair and points out some weaknesses in JDO (eg interface extents). Getting a heads-up on likely problems is important when starting out with something new.

I particularly enjoyed the J2EE chapter. We write web apps where JDO really might be a winner.

Object/Relational mapping? Roos points out that JDO is not an object/relational mapping standard. Although most implementations work against relational databases JDO does not standardize the mapping representation which remains vendor-proprietary. Instead JDO is an API for object persistence. It standardizes how persistent objects behave and how applications should use them. The final chapter looks ahead to anticipate future JDO refinements which include a standardized O/R mapping.

I'm docking one star because the source code was not immediately available, but I have downloaded it now.