Customer Reviews

Using and Understanding Java Data Objects

5 star:		(2)
4 star:		(0)
3 star:		(1)
2 star:		(0)
1 star:		(1)

 

 

This book is loosely divided into three parts: a conceptual overview,
an API tour, and some application case studies. The opening overview
is dense and would probably be scary for someone new to object
persistence.

The API tour is the largest section, with one chapter devoted to each
key JDO interface. These chapters read like heavily annotated
Javadocs; the subheads roughly correspond to the interface methods.
Each chapter is accompanied by a UML diagram of that chapter's
interface; a simple listing would have been more useful.

The case studies are definitely the best part of the book. Each is
filled with practical advice for using JDO in a particular environment
(servlets, EJBs, desktop apps). This material could save you countless
hours of frustration.

One thing this book lacks is code. When code does appear, it's often
an Ant build file, or a class showing how to use the "transient"
keyword, or something else peripheral to the main topic of the
book. There is essentially no real JDO code at all until the case
studies at the end of the book.

Also noticeably missing is an introductory tutorial. There's no
"Hello, JDO" program here. Many programmers, myself included, want to
see a basic program like this; its absence here is disappointing.

This would make a good second book on JDO -- a reference you could
turn to for details after you already knew your way around. Most
people would also want a book with more code and tutorial content, and
the writing is rough around the edges, but the case studies are ful of
great advice.

I'm the kind of person who learns something one day and uses it the next. I like books that serve as an introduction and as a reference.

This book gives a good introduction the terminology of object-oriented persistence. It explains terms like "persistent object identity," "transparent persistence," and "second class objects." I found the chapter on the JDO query language to be very helpful, especially the step-by-step comparison with SQL. At the same time, I'm sure that I'll be looking over the state diagrams in the chapter on transactions more than once in the coming weeks.

Although he's clearly enthusiastic about JDO, the author doesn't pretend that everything is rosy. I like the fact that he talks about the specification's shortcomings and offers practical workarounds. Given some of the discussions I found on the net about byte code enhancement, I wondered whether it was a good or bad thing. The chapter on enhancement gives a tour de force of the advantages and side effects of byte code enhancement.

The open source code that comes with the book has examples for several kinds of applications, as well as tools to explore JDO. You have to work to set the tools up, but they offer some good insights into JDO.

Overall, an excellent introduction to JDO that covers a lot of ground.

Java Objects brought home the developer's dream of " Write once, run anywhere ".
Java Data Objects ( JDOs) are all set to bring home another dream " Write once, store anywhere " - that is, if only the political bickering and political FUDS could cease.

The book under review glosses over the political bickerings, but at the technical level
it shines brilliantly. The author knows that politics and technical acumen do not mix and match well together.

The first chapter introduces the reader to the rather small and compact world of Java Data Objects. With about only half a dozen interfaces and classes and a few more helper classes, JDO is a small world unto itself. But " Small is Powerful " and tiny JDO could change the software world as effectively as tiny Napoleon did the physical world. After introducing JDOs in the first chapter, the author examines in great detail but clear language each of the major interfaces and classes in subsequent chapters. The book concludes with using JDOs in building realistic GUI applications, web applications and enterprise applications using EJBs. Throughout the book the reader maintains touch with the basic logic of JDOs and the interconnections between the
various interfaces and classes.

The heart of JDO consists of a persistence service. Normal application classes are made to pass through an enhancer which enhances or enriches those classes with extra code so that the classes are able to recognize and interact with the new world of JDO. Once the classes reach the JDO universe , the persistence service takes charge of database operations like create, delete, update, and retrieve. This means the developer does not worry about any persistence code in his classes. JDO takes care of it on his behalf. This again means, projects can be finished more quickly, and java developers need not be experts on SQL or propriety database languages like PL/SQL. So less becomes more - the less the java developers know, the better it is. I personally have doubts about this beautiful slogan. How long can less and less keep on becoming more and more? Can zero knowledge be ultimately identified with infinite knowledge?

The code enhancer is represented by the PersistenceCapable interface. It passes the enriched code to the PersistenceManager interface which then uses interfaces like
Query and Transaction to conduct queries and transactions etc. This is the basic logic and flow of events and the names of interfaces and classes reflect this logic and flow.

I highly recommend Ezzio's book for its clarity, simplicity of language, and technical acumen of the author.

Now back to some politics which Ezzio has avoided so deftly. JDO is a grass-root movement opposed by the powerful and the mighty. And like any grass-root movement it is in dire need of a slogan. I can think of nothing better than " Developers of the world, unite under the banner of JDO".

Rat
Oslo, Norway

Bang your head against a rock instead of buying this book! Because, it really couldn't be any worse than reading this author's writing.