Customer Reviews

Java Persistence with Hibernate

5 star:		(28)
4 star:		(13)
3 star:		(10)
2 star:		(10)
1 star:		(13)

 

 

I feel a little odd rating this thing as low as two stars. After all, it does pack a lot of information into its 800+ pages. And that does make it a single point of reference ... sort of.

It's when I actually tried to use this fat tome to learn how to work with Hibernate that I encountered the first problem. I can't recommend that approach. This book is a terrible way to learn how to use Hibernate. It talks endlessly about all kinds of detail about everything you might want to do, and even provides many incomplete code snippets. But surprisingly it doesn't sit you down and walk you through a simple application actually using Hibernate. The authors do provide a full-blown application you can download and work through - but that won't be easy, dear reader, and it will take you a while to distill the basics from the advanced usage.

This seems to be a problem with most Hibernate books, for some reason - they all think they need to explain ORM to the world rather than simply show how to create an application. Explaining ORM AND showing how to build an application might be better.

So, OK, perhaps, I thought, this will become my master reference. Then I encountered the second problem. There's no good way to drill quickly to a nugget of information you need, which, after all, is the essence of a reference. Instead you will have to read through the theoretical explanations and design discussions to figure out if the trail leads you to the specific nugget you need to get your software working.

In the end I realized that the book is not good as a tutorial and not good as a reference and I was left to wonder what it might be good for. This surprised me, to be honest.

As far as I am aware, no practical Hibernate book has been written, so it would be unfair to single out this one. (The Manning book, Hibernate Quickly, is simply incorrect at too many points - you have to figure out the coding and config errors.) So I'm not singling out this one. However, in my view the praise for this book is directed at the terrific work done by the authors in creating and maintaining Hibernate rather than their work on this book. Their work in this book is unfocused and, while comprehensive and correct, ultimately difficult to use for any practical purpose.

If you want to learn how to use Hibernate, the best way I know is to work with some of the tutorials available on the Web or to download an app server and follow their documentation. You might not learn about "theta-style joins", but you will certainly learn to use Hibernate to create software much more quickly that way than by using this book.

Hibernate is an ambitious project that aims to be a complete solution to the problem of managing persistent data in java. With the most recent version (3.2) out in the wild now, it is better than ever. A whole slew of new features have been added, a bunch of them improved from its earlier incarnation, but to trump it all - hibernate now supports the new EJB 3.0 standard for persistence, named JPA. As a matter of fact, Gavin King, creator of hibernate, was one among the expert group members for that JSR and helped shape its API.

This book aims to be a definitive source of reference for both hibernate and its JPA implementation. The authors undertake an arduous task of explaining each and every detail both in hibernate and JPA parlance. The end result is a comprehensive tutorial/reference guide of both worlds in one well-written and easy-to-read book. Think about this, if your goal is to to learn only hibernate, you have it here, or if all you need is to learn the JPA specification, you got that here too. The most beneficial of all, if you wanted to learn both, compare and contrast them, and make an informed decision of the best approach for your next project, then you are still in the right place. Can this get any better? Keep reading.

With a whopping 850+ pages, this book has loads of information for a reader at any experience level. The entire subject area is broadly organized into 3 parts.

Part 1: Getting started with Hibernate and JPA
Part 2: Mapping concepts and strategies
Part 3: Conversational object processing

Part 1 introduces you to the object/relational paradigm mismatch - both structural and conceptual aspects. Then, we are taken through a tour of how to start a new hibernate project. The authors then lay-out the types of projects that will benefit from ORM and those that wont. Based on the conclusion that the projects with rich domain model will best benefit from ORM, we are then briefly introduced to the art of creating rich domain models using an example application (Caveat Emptor). This example application will be used throughout the rest of the book to explain various concepts and strategies.

Part 2 is largely about the most important concept of hibernate - mapping classes to tables. Starting with the simplest scenario, the authors discuss every possible use-case that may present itself in a data-driven application and provide a mapping solution for the same. One-to-One, One-to-Many, Many-to-One, Many-to-Many, Inheritance mapping, component mapping, mapping collections of components and many more are discussed in detail, along with recommendations on which one to use when. The authors also discuss the pitfalls when taking a bottom-up approach and its solutions. Every chapter explains the mapping meta-data in all 3 formats - hibernate XML, JPA XML and JPA annotations. Since JPA has some limitations, every possible limitation is pointed out and ways to get back to native hibernate to achieve the same effect is discussed.

Part 3 is a complete tutorial on the API for storing and retrieving objects. The authors start with the basics of how to persist, retrieve, query etc., and proceed by dedicating entire chapters for every advanced concept. Transactions & Concurrency, Implementing Conversations, Modifying objects efficiently, Retrieving objects using query and criteria api all receive their own chapters. Every chapter explains the API in both native hibernate as well as JPA parlance. Whenever a JPA limitation is encountered, the authors show the best fall-back strategy to native hibernate.

Towards the end, the authors briefly show us the art and science of writing layered applications with hibernate. As an added bonus, we also get a primer into JBoss Seam, which solves many problems related to writing layered applications using the now famous EJB 3.0 specification. Two appendices, one explaining the fundamentals of SQL and the other acting as a reference for mapping concepts are also very useful.

The authors are very ambitious in trying to cover all the features of both Hibernate 3.x and JPA specification. This is an arduous task and kudos for just aiming for that level of comprehensiveness. Praises aside, i am not very impressed with the ad-hoc approach taken to explain both these giants side-by-side. Some chapters clearly separate hibernate and JPA sections, whereas some chapters entangle them into a mess. I personally preferred the chapters that clearly separated these sections. That gives me the choice, as a reader, to select one or the other, and to focus on my choice. But for some reason, most chapters chose to discuss them in an entangled fashion leaving me more confused than i was before the start.

I was expecting at least a primer on Hibernate/Lucene integration, but the authors chose to safely eliminate the topic, probably because the feature is still in its infancy. Also, it was strange that there was no trace of spring framework anywhere in the book, knowing for a fact that spring has a lot to offer to any ORM implementation.

Though there is room for improvement, there is currently no match for this book in terms of the coverage offered. Explanations are lucid, examples are excellent, and the author's ability to foresee the next questions in the reader's mind and address them immediately is fabulous .

I highly recommend this book
- For those who are interested in learning hibernate 3.x and JPA specification
- For those who crave practical advices for real-world scenarios
- For those who wish to choose between native hibernate and JPA, based on facts, not just techno-babble

In case you are wondering what i chose, i chose native hibernate.

Technically speaking you cannot get much better than this. Java Persistence with Hibernate is accurate, complete, detailed, and full of practical examples. I know this expression is overused but this is really the definite reference, the Bible of Hibernate. Basically any rasonable question you might have about how to use this wonderful persistence tool is in this book.
My only gripe is that while this book makes a great reference or a great aid to the experienced developer to bring his hibernate skills to the best level, it fails miserably when used to learn Hibernate from scratch. It's a pity because with a little more effort this could have been the perfect Hibernate book. In particular, 90 % of the example code is from the 'Caveat Emptor' hibernate reference application. Perfectly nice to the veteran developer, but a beginner needs to see the code in action immediately, and building and analyzing 'Caveat Emptor' or translate the original code into his own 'experiments' will probably be way out of his reach. Finally, the writing style is lofty, self-conceited and abysmally boring, and fails to point out what is important from the (almost always) irrelevant details. This being said, Hibernate Foundations are all in this book, which makes a real treasure trove for a senior developer who has already fought a few battles with Hibernate. A good Hibernate intro book has still to be written, so my only advice to the newbie is try some online tutorials, maybe browse the hibernate official website, find something more 'human-friendly' and 'New-Testament-like' , get to play with Hibernate a little, to the point where you can write a very simple, even rudimentary application, and then you will be ready to start wrestling with this bible.

Are you considering using hibernate via JPA? Then it's a must read. However, I concur with Ganeshji. The book is ambitious, and the mixing of JPA with "plain ole" hibernate got confusing at times. I also have a copy of Pro EJB 3, and although I didn't expect to get much out of it, it is much more concise since it sticks to the JPA spec. So I tend to reference it first to get the basics from a pure JPA perspective, and then use Java Persistence with Hibernate to "reach behind" JPA into hibernate's extensions, and to help understand the book better.

1) the book is way too long, it should have been released as two separate books: an update to Hibernate in Action and a new Java Persistence in Action (see Mike Keith's Apress book on JPA!)

2) why is there a random Seam chapter at the end? obviously it ties in with the implementing conversations (chapter 11) and the purpose of Seam is essentially to improve and simplify Java EE while tying together JSF and EJB 3, but does it really need to be in this already way too long book? And if you're interested in learning about Seam, read Seam in Action by Dan Allen, that's the best book out thus far on Seam.

3) there is no chapter on when and why you would use the Hibernate API (e.g. Criteria) which is not available in the current JPA 1.0 spec. When and in what scenarios is it worthwhile and/or necessary to deviate from JPA? And if you do, what are the possible consequences (e.g. if you subsequently use a different persistence provider, then you must refactor the Hibernate AIP out). What is currently deficient about JPA 1.0, etc.?

4) there is no chapter on comparing and contrasting the various JPA persistence provider options like OpenJPA, Kodo, Hibernate, Toplink Essentials. Why should one use Hibernate if Toplink is the reference implementation for the JPA spec?

5) there is no chapter on using Hibernate/JPA in a clustered environment (although there is some coverage on JBossCache, JGroups and second level cache).

6) Caveat Emptor Seam version is still not available (and there is no release date)!

7) there is no ORM design patterns chapter which would describe material like DAO and Open Session in View pattern, for example.

8) it would be nice if there were some more pictures (Seam in Action does very well in this regard!)

9) last but not least, and this is the main reason I'm rating this book so poorly, is that there is a ton of information in this book but it is EXTREMELY difficult to read, follow, and digest. The authors go back and forth between JPA code and Hibernate code (and XML configs) constantly and it is very, very confusing.

So. If you want to be more confused about JPA and Hibernate (ORM is definitely not the easiest subject to digest and learn), then waste your money and buy and attempt to read this book.

Otherwise, just stick to the specs, reference docs and forums. Or wait for the potential Hibernate in Practice (there is a Spring in Practice book coming soon!)

This book is too detailed and drifts too much into the intricate details of ORM, Hibernate and JPA. Unless you have loads of time on your hands (like the 8 months one reviewer spent on it) this is not a great book. Its not a great refernce book either because its very difficult to find an answer to anything specific you are looking for. I think the only people this book will appeal to are the hard core hibernate junkies... who really don't need to read another book about hibernate because they know enough already by the time they are ready for this book.

I found this book very long-winded, poorly organized, and it makes for a poor introduction to the complicated subject of hibernate. The examples take a long time to set up and even longer to work through. And they're too complicated for a good tutorial. If anything, they often serve to confuse the subject by going into advanced issues when they should be sticking to the basics. And the early examples start with the old-style xml mapping, which isn't even how most of us will be mapping things these days, so we waste a lot of time learning an outdated technique. Furthermore, the examples often don't cover some of the cases I've had to work with in my code, so they're not as useful as they could be.

For example, I want to reverse-engineer a database from an existing schema. Hibernate supposedly has a tool to do this, and there's a section in the book that covers it, but much what what they say doesn't actually work. (Some parts worked so poorly that I'm not sure if the reverse-engineering tool is finished yet.)

This all becomes even less tolerable by the verbosity of the prose. They will often take two paragraphs to tell us what could be stated in a single sentence. And they sometimes take a few tedious paragraphs to introduce a complicated subjects, only to tell is they won't be teaching it to us for a few more chapters.

The authors are certainly well-versed in their subject, so this book may well be a useful reference for more experienced users, but if you want to learn Hibernate quickly, you should probably look elsewhere.

It seems that many of the 3-star and less reviews here sum up my thoughts so I'll try not to repeat much of that. The worst part of this book is the horrible explanations and partial examples. Even when you find the section you are interested in you then have to wade through three different flavors of solutions: Hibernate with XML, Hibernate with annotations, and JPA. I should be pleased that I have more information but the problem is that these authors don't create clear boundaries among each technology. JPA should have been in a separate book, btw.

Hibernate has been the source of many, many problems on our project. These are often the mysterious bugs that leave us scratching our heads, and often the fixes to these problems are difficult as well. Yes, if our staff had a PhD in Hibernate we wouldn't run into many of these problems, but isn't it also a problem that a technology is so difficult to learn? It reminds me of EJB 1.0-2.0. Both make a lot of empty promises but end up causing frustration and lost time. A fun game we often play at work is "How can we do what we want in Hibernate?" In other words, we want to do things, but Hibernate makes achieving the task like solving a puzzle.

I hate Hibernate. I hate this beast of a book. And I hate books written by the creators of their own technology. The authors are arrogant and have a poor understanding of how to teach. I even had to read another book (Beginning Hibernate) in order to handle this book despite JPwH claiming to be useful for beginners. Despite by complaints, I give this book 3 stars because clearly a lot of work has gone into it plus it has helped out now and then, but boy do these guys know how to make things painful. In the end, I'd like to rip out Hibernate and switch to something like Ibatis SQLMaps, perhaps...

*** 2009 UPDATE *** We decided against Hibernate on our new project. I have also read the free 70+ page intro document on Ibatis SQLMaps. I'm now thoroughly convinced that SQLMaps is the direction our project should head. Much easier and less mysteries.

This book is pretty awful. It takes a fairly complex technology (Hibernate) and muddies it up. It is long-winded, disorganized, and redundant. I would recommend online tutorials and docs over this paperweight.

No doubt, this is the one book to have on Hibernate, and if you are reading this, you probably know why you need Hibernate. My biggest complaints about the book are the lack of clear separation between describing meta data and the different techniques for representing meta data, and worse, the lack of a usable index. I have had a near 0% hit rate when looking up anything in the index, and there are no usable reference pages. A quick-reference Bauer hopes to create will not be much help if it lacks depth appropriate for the depth of the architecture.

I give this 3 stars by starting at 5 stars for the software itself, subtracting one for the ad-hoc approach to documenting how to use it, and subtracting another for it's lack of usefulness as a reference. Although as I said before, I don't think there is a better book out there for Java persistence.