Hibernate in Action is a great book that I go back to again and again. It was very well written for a technical book.

Java Persistence with Hibernate is disappointing. The first half adds very little to what is available in Hibernate in Action and the second part is half-baked. The authors should have waited for the specs to gel and written a book purely on implementing JPA with Hibernate. They should have left out the first part of the book and pointed people to Hibernate in Action.

Bigger books are not necessarily better books.

This is a boring book and hard to understand. If you want to learn Hibernate, don't buy it.

Some of the reviews for this book are a little harsh.

This is the most complete book on Hibernate on the market. It covers everything, and I mean everything. From mapping to annotations, to whatever, it's in here.

The book is written by the makers of Hibernate, and you can find an answer to pretty much every question you'll ever have explained in extreme detail, and in a very, very technical way.

The book uses the Caveat Emptor application as a reference. You keep going back to that example, which you can download from the hibernate site. It is a very complete and intricately developed application that is a reference for how to develop enterprise ready applications that could be deployed to pretty much any mission critical environment.

This book is amazing. Some reviewers have tried to use this as a Dummies book or How To book and have been frustrated, and have given this book poor reviews. That's not fair. Imagine trying to learn to swing a baseball (or cricket) bat by taking pitches from a major league pitcher. You wouldn't learn a thing, as every pitch zoomed by you at 100mph. This book is like the big league pitcher, helping you develop and design applications that are ready for the big leagues. When you understand that, you can understand why people who are new to the technology, and looking for very simple and straight forward examples, can get frustrated with this book and give it 1 or 2 stars. Really, those reviews are not fair.

If you are new to hibernate, you should start of with something a like Hibernate Made Easy: Simplified Data Persistence with Hibernate and JPA (Java Persistence API) Annotations. If you are using mapping files, then Hibernate: A Developer's Notebook is the other book you should get.

Overall, this is a five star book written by the people that know Hibernate the most. We're very luck to have a book like this to help guide us through the really, really, really tough stuff.

I have finally found a great resource on persistence. This book allows you find enough detail quickly to get going and enough in-depth knowledge and understanding to keep you coming back. A must own.

Got this book when I started working with hibernate at work. This book and its sample code saved me weeks of effort.

Hibernate is an OK framework, but a steep learning curve. This book will help you significantly reduce that learning curve.

This is the the BEST book for hibernate. better than hibernate in action and other books.

Gavin King Rocks.

As of the writing of this review in early 2008, there is no other work in the marketplace quite like this text. At over 800 pages, Bauer and King cover a lot of ground, starting with the object/relational persistence paradigm and continuing with domain models, mapping, and conversations, addressing specialized situations along the way such as working with legacy databases. Database development is not for the faint of heart, and serious work in this space requires understanding of both object-oriented technology and relational database theory, not to mention the associated business domains. Although this book has received a relatively high amount of positive reviews, readers have also understandably shared their complaints. While at the same time Java Persistence with Hibernate is probably not for everyone, there really are not that many alternatives to learning the necessary material. As with other development frameworks, it is a given that familiarity with the online documentation for Hibernate is required, with the realization that this documentation really only starts to be of benefit once the associated tools start being used. This book provides solid background to prepare the reader for the road ahead, but the reader should also be reminded that the entire book does not need to be read, nor does the material need to be read in order from front to back in order to prepare for that road. Much of the material will probably just not make sense until one gets their feet wet with the technologies. These are the reasons I choose to refer to this text as graduate school training. As Immanuel Kant, the great German philosopher, once said, "experience teaches nothing without theory, but theory without experience is mere intellectual play". The change in name for this second edition of the book reflect the fact that Hibernate is now an implementation of the Java Persistence API. Be aware that the authors traverse back and fourth between the conformance of Hibernate to JPA, and what Hibernate provides apart from JPA. I think the decision of the authors to present material on these technologies side-by-side was a wise one, because it helps keep the reader reminded that these are not separate technologies and that there are architectural tradeoffs between sticking to JPA and using Hibernate functionality beyond the specification. Well recommended.

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 have clear boundaries between each technology. JPA should have been in a separate book, btw.

Hibernate has been the source of many problems on our project and the ramp up time is huge. 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 is in our way instead of helping us.

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. 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...

I bought this book long time ago. When I come back today, I find some readers gave bad reviews on this good book. I have to say some my impression about this book:

1. It is not a book for dummy users, it covers a lot of very deep thoughts about the Java persistence.
2. I found it is hard to understand all its contents the first time when I read it. But, until I have to use Hibernate heavily in some projects, I start to read it again and found nearly every question I have in the real projects.
3. It contains many design ideas in creating your database and also how to use Hibernate properly with quite a lot of good code as examples.
4. It is definitely the best reference book out there to cover Hibernate 3.0 usage so far in the book market. Don't be fooled by those dummy readers, decent developers need this book to resolve problems.

Its like the other rewiewers say, it explains every conceivable way to do it, old hibernate using xml files, new using annotation, JPA, jumps around all over the shop, never really explians any of it very well.

If you have trouble hibernating and you are a bear who can read get this Book ! you will be asleep in minutes !

You have to know that I've tried. Honestly, I did. I hoped to be able to read each and every page of "Java persistence with Hibernate" (revised edition of "Hibernate in action"), by Christian Bauer and Gavin King. But, I gave up before reading a third of it, then I continued only reading some sections. First, because I know Hibernate, I've used Hibernate in all the Java projects I've been involved with - in the last 5 years or so. Second, because the content from the first edition is more than familiar to me. And third, because this second edition is a massive > 800 pages book (double the number of pages in the first edition). At that rate, the fourth edition will be sold together with some sort of transportation device, because a mere human will not be able to carry that amount of paper. How did this happened ?
Hibernate is the perfect example of a successful Java open-source project. Initially started as a free alternative to commercial object-relational mapping tools, it quickly became mainstream. Lots of Java developers around the world use Hibernate for the data layer inside their projects. It's very comfortable, just set some attributes or ask for a business object instance and Hibernate does all the ugly SQL for you. As a developer, you are then comfortably protected from that nasty relational database, and gently swim in a sea of nicely bound objects. Right ? No, not exactly. Each object-relationship mapping tool has its own ways of being handled efficiently, and this is where books like "Java persistence with Hibernate" come into play. This book teaches you how to work with Hibernate, with a "real-world" example: the Caveat-Emptor online auction application.

Since the first edition of the book was written, lots of things happened in the Hibernate world and you can see their impact in "Java persistence with Hibernate". Most important is the release of the 3.x version line and its different ameliorations and new features: code annotations used as mapping descriptors, package naming reorganization inside the API, but most important the standardization under the umbrella of JPA (Java Persistence API) for a smooth integration with EJB 3 inside Java EE 5 servers. And this, is a little bit funny. Yesterday, Hibernate was the main proof that it is possible to make industrial-quality projects within a "J2EE-less" environment, today Hibernate has put a suit and a tie, joined the ranks of Jboss, then Redhat, and it lures the unsuspecting Java developers towards the wonderful and (sometimes) expensive world of Java EE 5 application servers. Which is not necessarily a bad move for the Hibernate API, but it's a proof that in order to thrive as an open-source project, you need so much more than the Sourceforge account and some passion ...

Enough with that, let's take a look at the book content. Some 75% if it is in fact the content of the first edition, updated and completed. You learn what object-relational mapping is, the advantages, the quirks, the recommended way of developing with Hibernate. For a better understanding, single chapters from the initial book were expanded into 2, sometimes more, chapters. The "unit of work" is now called "a conversation" and you've got a whole new chapter (11) about conversations, which is in fact pretty good stuff about session and transaction management. Christian and Gavin done some great writing about concurrency and isolation in the relatively small 10-th chapter - which is a must read even if you're not interested in Hibernate, but you want to understand once and for all what are these concurrent transaction behaviors everyone is talking about. The entire 13th chapter is dedicated to fetching strategy and caching, which is a must read if you want performance and optimization from your application. There is also a good deal of EJB, JPA and EE 5 - related stuff scattered in multiple chapters. And finally, a solid 50-pages chapter is pimping the JSF (Java Server Faces) compliant web development framework, Jboss Seam. I have only managed to read a few pages of this final chapter, so cannot really comment. Note to self: play a little bit with that Seam thing.

To conclude, is this a fun book ? No. Is this a perfect book to convert young open-source fanatics to the wonders of Hibernate API ? Nope. Is this a book to read cover to cover during a weekend ? Not even close. Then, what is this ? First, it's the best book out there about Hibernate (and there are quite a few on the market right now), maybe even the best book about ORM in Java, in general. It has lots of references to EJB, JPA and EE, it will help you to easily sell a Hibernate project to the management. Even if the final implementation uses Spring ... And finally, it's the best Hibernate reference money can buy. When you have an issue, open the darn index and search, there are 90% chances your problem will be solved. And that's a nice accomplishment. Don't get this book because it's funny, because it's a nice read, about a new innovative open-source project. Buy it because it helps you grok ORM, write better code, deliver quality projects.

This book is easy to read and apparently provides all the information one would want to know about Hibernate. Unfortunately, I have found it nearly impossible to find the information I need when I need it. Strategies for using Hibernate directly thorugh XML configs and annotation and using JPA and EJB are mixed together, guaranteeing that 75% of what you are seeing on a given page is likely irrelavant to your needs and there are few visual clues to help you. This book is too long and detailed to be an intro and not organized well enough to be a reference. Also, the detailed exposition where tiny features are introduced one at a time make me feel like I'm being talked down to while at the same time, there is a near constant use of subtle database, UML and Java jargon which makes my brain want to explode.

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.

I wasn't very happy with this book when I first got it. In fact, I was pretty annoyed. It covered way too much material, tried to cover too many things, from mapping files to annotations to entity use to..... Man, it was frustrating. Just trying to learn the basics and understand how to use Hibernate was impossible. As a beginner, trying to learn Hibernate from this book made me want to throw the book out the window, with the hope that the book might land on the author's head.

Okay, BUT, I managed to learn Hibernate pretty much on my own. But as I got deeper into Hibernate, I found myself coming back to this book more and more. Maybe it didn't explain the basics all that well, but when it came to more advanced topics, you could find the stuff you were looking for, and with a better background in Hibernate, the technical stuff made more sense.

Once you understand Hibernate, and have learned the basics, going back to chapters in this book on deep transactions and other advanced topics really demonstrates the value of this book.

It's not a very good book for learning Hibernate. But once you do learn the basics, and you really need to use Hibernate, this is the book you absolutely need to have around.

I'm glad I didn't throw it out the window, and I'm really glad it didn't hit one of the authors.

Java Persistence with Hibernate (JPwH) is the follow up to Christian's and Gavin's Book Hibernate in Action.

This book covers Hibernate 3 and the Java Persistence API in every detail. I would recommend the book to beginners as well as advanced Hibernate users since the authors start with a very good introduction to Java Persistence in general and than dive deeper and deeper into Hibernate's feature set. At the end of each chapter you will find a very helpful comparison between Hibernate and JPA.

Sometimes I was a (very) little bit confused about the switching between Hibernate and JPA inside some of the chapters but this is actually the only downside of the book. However this point doesn't have a bad impact on the overall readability.

A big plus is also the example application that is being used throughout the book and that can be downloaded for free from the Hibernate website.

All in all this book is NOT an "utter waste", it is THE reference reading to Hibernate.

I am new to both hibernate and ORM. I brought this book thinking it will be a casual read. I agree with some of reviews, this book is very hard to read. I need to be sympathetic to authors though. The reason is this book covers a lot of facts and facts that can be translated into real production code. Obviously that is a ambitious task. Problem is reading and assimilating all this information and then quickly applying them in my current project. So I devised a way to read this book. I keep my laptop next to me, I read it page by page, writing code in the side and trying to understand what it means. By doing it I found the book is amazingly error free and just makes a lot of sense. I feel it is worth the price and time. ORM is a hard problem and this is the only available book that covers everything in ORM, JPA and hibernate.

Well, there's no doubt that this book has alot of material. The book is massive. But its not a fun book to read, and it's not very helpful at trying to teach you how to use hibernate. Even with this book and the yellow and black Beginning Hibernate book, I really felt I was learning it on my own.

I'll come back to this book to look up certain things, like when I need to do a polymorphic many to many mapping across multiple tables, but using examples like that to try and teach someone the basics isn't very effective.

I just find it so hard to believe that something that is supposed to be so simple and easy to use is so difficult to explain to people.

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.

This book is a welcome update to the original. It has much new stuff, including how to write contract-first web services using Spring Web Services. It's definitely earned a spot on my shelf until Spring 3.x :-)

This is THE reference book for Hibernate 3. Authored by the people who designed and developed the framework, it covers every aspect of the product.
If you are a beginner with Hibernate this book may be a little overwhelming and confusing with so much information so I recommend a little less encyclopedic text (I'm not paid to endorse so you'll have to find them yourself). There are several out there that are excellent.

Cutting long story short, Hibernate in Action is the Book to have if you are working on a Hibernate Project, and YES, it does offer something more than the reference manual does in my opinion, and there fore it is worth buying.( Well unless you'd want to go for that 2k $ courses at Red Hat or Exadel or Interface 21 ( Spring people ) ).

This is a bigger version of the older Hibernate in Action & can be called as reference on the desk for Hibernate professionals out there, not only does it explain hows and whens and whys of Hibernate, but the interesting aspect to me was finding useful and often intuitive patterns and their solutions in the Book and that just doesn't include Hibernate's ever popular OSIV pattern but other things as well.

The book also covers JPA and Hibernate's JPA implementation to some extent. Although i think Hibernate's Entity Manager in Manual ( reference manual ) does a better job explaining nuts and bolts. But still its something, other than that there's lots of cool stuff, like Using Objects efficiently, SQL optimizations etc. You'll definitely love this book, because it starts from simplistic examples for newbies out there but also covers enough depth and breadth ...

All in all, Best Investment you'd ever make in Hibernate Arena. Should you finish this book, you'll be an expert in Hibernate Guaranteed.

Regards
Vyas, Anirudh

If you want to *understand* Hibernate/JPA and ORM then this book is for you. Besides being most complete reference of how-to's of Hibernate/JPA it really goes a long way to explain why Java persistence is the way it is and why things should be done one way and not another. If you are serious about Java development with persistence objects then keep this book close at all times.

Direct from the source :-)

Great book to read from the original Hibernate developers. In depth and wide coverage about Hibernate.

What I liked about this book is that I actually can read it as a literary book, it's not only a reference. Something to keep by the bed. Gave me the whole picture (Object Relation Mapping in general, it's place in J2EE, Domain Driven Design, testing etc) and gory details (caching, native SQL, batching, extended PersistenceContext, etc).

16-page index including annotations, far better than googling for Answers.

In case you're only looking for the JPA Annotations details (or vice versa) you need to be alert when reading - after choosing JPA as our implementation strategy, I could skip many paragraphs and get through faster.

If you really want to understand ORM through Hibernate, this is all you need. And time to read the 841 pages, of course.

This book is still very informative, but it has grown to over 800 pages. It is no longer 'short and sweet'. One of the reasons it has doubled in size is that both Hibernate, JPA, and EJB 3.0 are covered. Moreover, the topics are interleaved, so it is hard to flip to the Hibernate specific content, for example without going through the other details.

I've struggled through about 600 of the 1000 pages of this unnecessarily large book now and have come to the conclusion that there must be something else out there that is better written, more concise, and better structured. I'm not sure what it is, but my advice is to avoid this book. It sucks. The authors clearly are not native English speakers because the sentence structure is very awkward throughout the book. It makes reading very tiresome. They haven't put much thought into the structure either. There's no basic introduction or grounding for what Hibernate is or does. The more important chapters are buried at the back of the book. There's a huge lack of consistency and barely no examples to illustrate how to use Hibernate. They try to tackle too much all at once with Hibernate, JPA, and EJB. It's so overwhelming and it needn't be.

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.

This is an incredibly dense book to read. It is not that it is disorganized or lacks conciseness (or detail), rather, it is trying to be everything to everybody and that is what makes it a hard read. In other words, I got the distinct impression that the authors were too anxious not to miss any detail(lest somebody should accuse them of oversimplification) and as a result, readability took a back seat.

I think a better presentation would have been to devote the first few chapters to simple examples covering the most useful aspects and then drill down to esoteric reference level detail in later chapters.

On a personal note, I find it odd that the authors would recommend to use HSQL over mysql as a test database when the latter comes with a plethora of tools and much nicer interfaces, all free of charge, of course.

Anyway, I would not recommend this book if you are new to Hibernate. Instead, get "Hibernate Quickly" also by Manning which is a much better read and will get you up and running in a short time.

Hibernate Quickly

This is an incredibly dense book to read. It is not that it is disorganized or lacks conciseness (or detail), rather, it is trying to be everything to everybody and that is what makes it a hard read. In other words, I got the distinct impression that the authors were too anxious not to miss any detail and as a result, readability took a back seat.

I think a better presentation would have been to devote the first few chapters to simple examples covering the most useful aspects and then drill down to esoteric reference level detail in later chapters.

On a personal note, I find it odd that the authors would recommend to use HSQL over mysql as a test database when the latter comes with a plethora of tools and much nicer interfaces, all free of charge, of course.

Anyway, I would not recommend this book if you are new to Hibernate. Instead, get "Hibernate Quickly" also by Manning which is a much better read and will get you up and running in a short time.

Hibernate Quickly

This is an incredibly dense book to read. It is not that it is disorganized or lacks conciseness (or detail), rather, it is trying to be everything to everybody and that is what makes it a hard read.

I think a better presentation would have been to devote the first few chapters to simple examples covering the most useful aspects and then drill down to esoteric reference level detail in later chapters.

On a personal note, I can not believe anyone would recommend to use HSQL over mysql as a test database.

Anyway, I would not recommend this book if you are new to Hibernate. Instead, get "Hibernate Quickly" also by Manning which is a much better read.

Hibernate Quickly

Hibernate and JPA are rather large, complex technologies. You owe it to yourself to read a book like this for a thorough understanding. The I'll-pick-it-up-from-the-online-docs probably isn't going to be enough for this topic. This book provides outstanding coverage. It's well written, and since it comes from Hibernate's creators, provides lots of insight about *why* things were done in certain way.

I do have a relatively minor complaint about the organization of the book. I'd like to see the content about advanced mapping topics moved *after* at least a basic discussion of what "conversations" looks like, how persistence contexts behave, etc. I like to read books in order, and think the fundamentals should be addressed before all the nitty-gritty advanced details.

Delivered the item as mentioned in the item description. Very happy.

The book is one of the most painful experiences I've had in recent time. I'm doing a Ph.D. right now. I know about pain.

Every chapter and section gives every minute detail of the APIs discussed, all the time. It's tough to describe how bad this makes it --- it feels like they're reading the code line by line and discussing every design decision made, in journal format. Paragraphs of side notes and gotchas are integrated right in the text, right in the normal text stream --- making it incredibly painful to filter out the important parts from the irrelevant. It's impossible to tell which parts are irrelevant until you're reading halfway into them, wasting the reader's time, patience, and memory. Then when you try to skip around, half the details you do need are just listed 'as discussed earlier.'

The examples cover little more than using single methods at a time. With the text being unreadable, it also lacks any coherent examples of even a basic application, putting anything they discuss together.

Fundamentally the text assumes that you're going to read and memorize every part of it before doing anything -- for over 800 pages, it's mindblowingly bad.

As a reference, the lack of organization guarantees you'll be digging through dozens of pages to get even basic answers. There is no reference material per se, it's all just reading through what you hope are relevant sections of the book. The index is only 16 pages, and completely worthless in helping you navigate.

3 stars for containing everything you need in there, somewhere. -1 star for being so sadistic about it. -1 star for being worthless as a reference.

I must say that I completely agree with Scott P. Stewart's review. The authors should have kept the book "pure hibernate" oriented. Constant references to JPA, interspersing xml mappings and annotations (again there is hibernate-specific & JPA standard here), causes the reader to loose focus on the subject. Otherwise, the authors have done a good job of explaining the concepts better than other hibernate books. I could find no better alternative on the subject.

If you are a beginner, you may want to first read the previous edition of this book - Hibernate in Action or grab a copy of Beginning Hibernate by Jeff Linwood & Dave Minter which I find less intimidating.

This book not only covers standard Hibernate persistence, but also JPA persistence. It covers all topics from simple to advanced. It's a complete reference manual for using Hibernate. The only thing it's lacking is coverage of how to set up Hibernate/JPA with Spring, but that's probably not in the scope of this book.

This is one of the few books I have bought which actually has useful information. And, it provides the information in a clear, concise way. If you want to understand how Hibernate works, this is the book for you!

This book does have the most information on Hibernate I've found in any book, but it is found wanting in several areas:

They never should have added discussions of JPA. This just confuses everything and makes the book unneccesarily larger. This was most likely a business decision to tie Hibernate to the new specification but it just detracts from the book.

Again and again on the forums and throughout internet discussions the topic of 'lazy initialization' errors and entity identifiers permeates. The authors repeatedly point to the pattern of 'conversations' as the solution to this issue, yet only give a cursory explanation with very simple, unrealistic examples.

I thought 'Hibernate in Action' was great but have become disappointed with this book, Hibernate in general, and the intransigent attitudes of the authors.

The paper alone in this book is probably worth the money you pay for it, weighing in at 904 pages. However, I guarantee you that they will become the most important 904 pages of your career.

Hibernate is a powerful framework, but it is also a very complex beast. That complexity is the nature of the persistence business. Whether you use SQL, object-relational mapping, or an object database, you are going to face the same problem in every case. Let me give you a hint, it isn't a problem with the framework. It's the database. The database tier is the most expensive tier to scale. If you don't treat it correctly, your application will be expensive and its performance will be dismal. If you want to know how to write applications using Hibernate, then you need this book on your desk.

Dare I say that this is the best book on core Hibernate principals that will ever be written. How can I make such a claim? I can say this because the questions about Hibernate and ORM that need to be asked are not going to change very much and this book answers them all. In that sense, the book is timeless.

This book answers all of the burning questions you have been dying to ask about Hibernate.

"Why do I get the dreaded LazyInitializationException and what does it mean?"
"What is the best way to map collections?"
"Should my collections be lazy or non-lazy?"
"How do I implement the Open Session In View pattern?"
"What is a persistence context?"
"What are detatched objects?"
"How do I avoid the use of detatched objects?"
"What's the difference between saveOrUpdate and merge?"
"Do I need to implement equals() and hashCode() for every entity?"
"What is the difference between Hibernate and JPA?"
"Should I use a DAO layer and if so, how should it be designed?"
"What is Seam?"
...and may other questions. Just browse the hibernate forums to get an idea.

Do yourself and your career a favor by clearning a weekend (perhaps several) and read this book cover to cover, rinse, and repeat.

If you are using hibernate using Java persistence API then it is a good book. This means you will be using J2EE 5 based Web container. This book is also a good companion to EJB 3.0 for using Java persistence APIs. If you are trying to understand the good-old hibernate apis then this book falls short a bit.

If you want to learn Hibernate principles (and understand the Object vs Relational dilemma), then this is probably the best book around. I found the material to be presented in a very coherent and effective tutorial style, and even though I'm an experienced OO developer and relational database designer, I learned some new ways to approach O/R mapping problems. The Hibernate object state diagram and accompanying text represent the pinnacle of pedagogy: Give the student a firm basis on which s/he can abstract deep underlying principles to use when approaching new problems.

However, if you are already familiar with Hibernate and want a deskside reference, you can get more information from the (free) online documentation. Once you've mastered the basics you won't find yourself going back to this book much (in contrast to real gems like "Programming Perl" or Evan Lenz's "XSL Pocket Reference"). This is primarily due to two major disappointments:

1) There's zero reference material. This is deliberate, and the author explains that one should just read the DTD comments (available online). Sorry, but that's a cop-out. The DTD and comments may describe the SYNTAX of the mapping configuration file, but there's a wealth of information about the SEMANTICS (what does this option really do) that's nowhere to be found.

2) The index is EXTREMELY POOR. This book has less than half the index entries of other similarly sized technical books, and many important terms are not indexed. Want to know the details on "yes_no" fields? The index doesn't even HAVE a "Y" section. You have to know in advance that this is referred to in the "Hibernate Types" section.

Couple this with the fact that the book is basically an expanded version of the online help but without the reference material, and you'll find that this is a "read-once" book. After you've assimilated it you'll use the online help instead, primarily for its searchability.

In summary, if you're new to O/R mapping and Hibernate then I'd rate the book 4 stars, taking off 1 star for the index, which is crucial in a technical book. As a complete work however, I think it deservers only 2.5 stars, but since amazon.com doesn't allow fractional stars I'll give it the benefit of the doubt and go with three.

If you want to learn Hibernate principles (and understand the Object vs Relational dilemma), then this is probably the best book around. I found the material to be presented in a very coherent and effective tutorial style, and even though I'm an experienced OO developer and relational database designer, I learned some new ways to approach O/R mapping problems. The Hibernate object state diagram and accompanying text represent the pinnacle of pedagogy: Give the student a firm basis on which s/he can abstract deep underlying principles to use when approaching new problems.

However, if you are already familiar with Hibernate and want a deskside reference, you can get more information from the (free) online documentation. Once you've mastered the basics you won't find yourself going back to this book much (in contrast to real gems like "Programming Perl" or Evan Lenz's "XSL Pocket Reference"). This is primarily due to two major disappointments:

1) There's zero reference material. This is deliberate, and the author explains that one should just read the DTD comments (available online). Sorry, but that's a cop-out. The DTD and comments may describe the SYNTAX of the mapping configuration file, but there's a wealth of information about the SEMANTICS (what does this option really do) that's nowhere to be found.

2) The index is EXTREMELY POOR. This book has less than half the index entries of other similarly sized technical books, and many important terms are not indexed. Want to know the syntax for "yes_no" fields? The index doesn't even HAVE a "Y" section. You have to know in advance that this is referred to in the "Hibernate Types" section.

Couple this with the fact that the book is basically an expanded version of the online help but without the reference material, and you'll find that this is a "read-once" book. After you've assimilated it you'll use the online help instead, primarily for its searchability.

In summary, if you're new to O/R mapping and Hibernate then I'd rate the book 4 stars, taking off 1 star for the index, which is crucial in a technical book.

This book has been helpful, and the organization makes sense. However, the lack of figures (ER diagrams, etc.) in favor of additional text is annoying.

In addition to covering Hibernate 3.2 and JPA, this book strongly advocates EJB3 session bean, and goes as far as suggesting use SLSB/SFSB to implement DAO. If you plan to use Hibernate 3.2 and EJB3 together, you will get more value for money from this book.

Since not an EJB3 fan myself, I only purchased the ebook from Manning and still keep Hibernate in Action on my bookshelf.

I have found Hibernate In Action to be an indispensible guide when developing Hibernate persistence solutions, so I was eagerly awaiting the release of its successor.

Most developers will want to use standard JPA as much as possible for portability reasons, and only use Hibernate where absolutely necessary to use features not supported by JPA.
However this book fails to cleanly separate discussion of JPA from Hibernate, meaning that if you take this approach to using JPA you end up wading through large sections of the 800+ pages of this weighty tome.

I have to agree with Ganeshji and C. Updike - this lack of any clean separation of JPA and Hibernate makes it difficult to get useful information out of the book.

This is a shame, as the writing is of a high standard - unfortunately the content is very poorly organised.

If you want seriously use hibernate or NHibernate you cannot simply miss this book. Not only it is full of useful examples, but it really teach you all you need to know to use hibernate at its full power. Hibernate is a complex beast to tame without a solid ground on basic concept like "value object", "Entity object", conversation and so on. This book really contains all you need to know to start working on hibernate without problems.

Java persistence with Hibernate is the revised edition of Manning's bestselling Hibernate in Action. It covers Hibernate 3.2 in detail along with the EJB 3.0 and Java Persistence 1.0 standards. This book is for developers who are using Hibernate as their persistence tool or for those who want to get started with Hibernate.


I highly recommend this book if you are interested in learning hibernate 3.2 and JPA specification or even if you want to choose between the two technologies. This book is the ultimate solution. If you are going to use Hibernate in your application, you have no other choice, go rush to the store and get this book.

I was prepared not to like "Java Persistence with Hibernate", due to some bad experiences with similar books on Open Source projects, but this was a very pleasant surprise.

There are likely to many reviews praising this book, but I would like to offer some points on the things it is not. This is not a evangelical book providing only the positive sides of Hibernate - Hibernate is evaluated based on realistic criteria, and its limitations and assumptions are pointed out. It isn't filled with topics that the authors want to cover rather than those required by users - the topics relate directly to the real use of Hibernate. The book isn't padded with diagrams, code samples or javadocs - diagrams weren't to large or small and the same applied to the code samples.

The omission of any mention of Spring was a little surprising, but then the book is already over 800 pages and I guess there are other related topics that didn't make the cut either.

I enjoyed reading the book as the authors obviously knew the topic, but still managed to present the material in an interesting manner and didn't get too dry. This book should be the weapon of choice for Hibernate users, not because it is written by the authors of the software, but because the presentation and quality of the information makes it an invaluable resource.

This book is a must read for any Java developer or ORM user. In addition, the chapter on Seam is fantastic. It is a great way to get started with Seam.

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.

I read this book after reading Hibernate in Action, I found almost 70% of it repeated. So im not sure wether this book is value for money for me anyway. But if your starting out in hibernate I would probably say buy this, However if you already have Hibernate in Action, its not worth the extra cost and most of the information can be found on the net after some hunting.