Customer Reviews

Hibernate in Action (In Action series)

5 star:		(41)
4 star:		(8)
3 star:		(6)
2 star:		(6)
1 star:		(2)

 

 

From a documentation point of view, Hibernate is one of the most notable exception in the world of open-source LGPL'ed projects. Its website offers a plethora of information, from solid documentation (the reference has no less than 141 pages) and various FAQs to sample projects and third-party resources. The forum is quite active and you may get answers to tricky questions. Or a little bit of rough treatment in case you haven't RTFM - but that is understandable, given the number of questions that the authors have to answer every day.

Under these circumstances, one might wonder what Gavin King (Hibernate founder) and Christian Bauer (documentation/website maintainer and Hibernate core developer) can add in order to be able to write a 400-pages book about Hibernate. I mean - sure - only by joining the reference documentation, different FAQs and guides, one can easily 'extract' a hefty 'manuscript' with more than 200 pages.

Well, I am extremely glad to tell you that this is not the case. The book not only gets you up to speed with Hibernate and its features (which the documentation does quite well). It also introduces you to the <strong>right way of developing and tuning an industrial-quality Hibernate application</strong>. I consider myself a pretty seasoned Hibernate developer, being familiar with the API since its 1.2 version in Q1-2002 (if I remember well the first app when we used Hibernate). However, I was proved wrong by "Hibernate in action" which describes best practices and even API features that were unknown or vaguely known to me. That is, until now.

The first chapter, in the good tradition of all first chapters in the world, is an introduction. It's a very well written introduction about why do we need ORM solutions in OO applications. The chapter explains the O/R impedance mismatch, while declaring quickly that OODB suck (immature and not widely adopted). Wel'll also find out that EJB also suck from a persistence point of view (for various reasons). Which can be quite a surprise knowing that Gavin is one of the authors of EJB3.0 specs. Or, on the contrary, this will explain a lot of things in the new EJB specs.

Now that we have cleared the "why Hibernate" issue, let's continue to the second chapter. Which - tradition obliged - is a "Hello, world" and a "Let's get started" chapter. Here you go, almost 50 pages later you should be able to write simple Hibernate-based persistence layers and integrate within an application server, like for instance ... Jboss ! Humm, well, why not ? They are sponsors of the Hibernate project, after all.

In the 3rd chapter, our fresh knowledge will be put to good use by starting the development of an online auction application called CaveatEmptor. This app will follow our reading progression and will grow bigger and smarter chapter by chapter. But for the moment, we are at the inception phase. What gives : a little bit of analysis, a stylish class diagram of the domain model and the resulting mapping file. And if you thought (based on 2nd chapter) that the mapping file is very intuitive and simple, you're in for a big surprise : it is, indeed, intuitive and simple ! Quite bizarre for an open-source project. As a matter of fact, the mapping file is one of the pivotal elements of Hibernate, since it addresses directly the O/R impedance mismatch, a recipy for transparent linking your POJOs and the constrained relational model. No wonder that a big part of this chapter is aimed at explaining why and how the mapping works in Hibernate. You'll see how class associations and inheritance translate at the metadata and mapping level. You'll start to understand the things that you took for granted in the previous chapter and you'll have that pleasant "uuh, I see" chain reaction. Hold on, it's just the beginning.

Because chapter 4 is going to explain once and for all the lifecycle of persistent object in Hibernate, their behavior from a persistence point of view as well as the available fetching strategies. And if you thought you already knew everything by heart from the documentation ... well, maybe you do know everything by heart. Nevertheless, it's very well synthetized in chapter 4 and I'll recommend it anytime to a coworker eager for Hibernate knowlege.

In the next chapter (the 5th) the rollercoaster slows down a bit. That is, if you already know the behavior associated with the four possible isolation modes in transactions, what are the different types of locking, what (the hell) MVCC means and the importance of transaction scopes. Chances are you already know some of this stuff quite well, but everybody needs a refresher from time to time, especially when it's well explained and when it comes with versioning and caching (1st and 2nd level) in Hibernate as a desert. By the way, I thought that OSCache supports clustering, not only SwarmCache and JbossCache, as stated in the book. There's even a thoroughly explained example of using JbossCache as a level 2 clustered cache for Hibernate, but it shouldn't be too hard to convert to other types of caching systems.

Now, if I were the author of the book, I would have placed chapter 6 before chapter 5. But I am not the author, which is quite fortunate for you dear readers since Christian and Gavin are much more competent than me at writing books about Hibernate (and probably at some other unrelated domains). They have decided to go back to mapping in chapter 6, after the short transaction/caching intermezzo. Well, they should know better... it's time for a serious dose of <strong>advanced</strong> mapping. This chapter is attacking interesting subjects such as custom mapping types (simple or composite) and (finally) the mapping of collections. Special guests stars: the whole gang of "sets, bags, lists and maps", together with explanations about their relational equivalent (associations, associations and associations !). Oh and yes "polymorphic association" (section 6.4.3) - I wasn't even aware that Hibernate is able to do that... guess I'm not that 'seasoned' (as a Hibernate developer) after all.

The 7th chapter is about "Retrieving objects efficiently" : about 45 pages for the 'retrieving' part and 6 pages for the 'efficiently' part. Fair enough ! You'll learn how to master basic HQL queries (parameters, pagination ...). You'll get a grip on the query by criteria API, as well as on advanced stuff such as dynamic queries, filters, subqueries and native SQL (very powerful). At the end of the chapter there's the Hibernate-specific solution for the n+1 selects problem, query caching and result iterators.

Following this wealth of useful knowledge, the 8th chapter starts a bit dry. Nevertheless, after a short introduction about Hibernate in managed environments, you'll find yourself again in the land of advanced programming techniques : application-level transaction implementation ! This is mostly new stuff (at least for me) - a great collection of best practices for transactional behavior management in industrial-quality apps. Somewhat unrelated but still interesting, the chapter ends with legacy schemas integration and a smart implementation example for audit logging.

The 9th (and last) chapter is about the roundtrip development in Hibernate using the classical toolset : Middlegen and/or hbm2java and/or XDoclet. All the available techniques are presented in a very detailed, step-by-step manner.

Wait : don't close the book, there's more ! Ignore Appendix A (a short and rather uninteresting document about SQL fundamentals - that is, if you know SQL). Appendix B contains mildly un-fascinating ORM implementation strategies <EM>pour les connaisseurs</EM> (come on guys, I'm just a dumb user). But - Appendix C is a great collection of real-world stories and by all means read them all ! Especially the last one, a treasure of hard to find knowledge (no spoilers, please...).

In the end, I have to confess that there is something truly interesting about 'Hibernate In Action' : albeit very technical, it reads astonishingly easy - and this kind of books is unfortunately very rare nowadays. My congratulations to the authors for this excellent piece of work - it was worth the wait.

As for you dear potential reader, if you already know all the information detailed in the book, I bow before you, great Hibernate wizard. But if you don't, what are you waiting for ? Because, if you're going to read only one technical book this summer, make sure that it's 'Hibernate In Action' (or, at least chapters 6,7 and 8, if you are that good !).

This book is for Hibernate 2. Hibernate 3 is covered by the same authors in Java Persistence with Hibernate

This is not a bad book. I'm glad I bought it and glad I read it. Its problem is that it doesn't live up to its hype. It is not "the ultimate Hibernate reference" by any stretch. In fact, it's not much of a reference at all, so if your expectations of it are too high, you may end up disappointed.

If you are serious about learning Hibernate and want to get as much depth and background on as many aspects of it as possible, this book is definitely worth reading. The text is well-written and clear, and the information is straight from the most qualified Hibernate committers.

On the downside, this book is missing most of the important administrative and troubleshoting information you will want when you are actually using Hibernate, the book isn't organized so you can easily find any particular detail, and Hibernate is moving on, so some of the information is dated.

Ultimately, if you want practical information or a good reference on Hibernate, I don't think the question you want to ask is "what book should I buy?" You want to ask "why should I buy a book at all when I get much better info for free from google search?"

When you are first getting started, the "getting started" example from the online doc distributed with Hibernate is comprehensive and useful. By contrast, the "Hello World" example in this book is superficial and missing information you need. For example, the very first thing when you work with Hibernate you'll have to include about a dozen .jar files into your project, and you have several choices among alternative jars that you won't care much about `till you become more advanced. Some help is online, little or none is in "Hibernate in Action."

I think Hibernate is all-in-all a great piece of software. Object-to-relational mapping is a hard problem to solve, Hibernate does a great job at the basics of it, and the world is a better place because the boys from jboss donated us their solution. When it works it's like good magic should be. But when it fails, it fails hard, horks all over itself, and spews out a bunch of mostly unhelpful junk. Hibernate suffers from having been developed by an insular group of developers who are too close to their problem, and who have lucrative day jobs as consultants they need to get back to. The result is not much in the way of troubleshooting help, and troubleshooting help is what you'll find you need most. Hint 1 - you won't find such help in "Hibernate in Action" so go to google and type in the text of the error message you get. Hint 2 - you will find a lot more people asking the same question than people answering it. Perservere and be a good detective and you will figure out what you need.

References are organized so you can easily find that one little detail of information you need right now. References have things like short sections with short clear titles that are language keywords or clearly intuitive concepts. References also have long, detailed indexes with a lot of repitition. "Hibernate in Action" has none of this, and it is devilishly hard to find details in it even though you know they are in there somewhere. My copy has about 25 little sticky note bookmarks to help me find things, but most often I don't bother and I just go straight to google.

Finally, Hibernate has evolved since this book was published. My favorite change is that it now includes support for Java 5 annotations as an alternative to XML or XDoclet configuration. Hibernate is notable, like Struts, in helping you get out of J2EE-EJB hell, and into XML configuration purgatory. Annotations rock in relieving you of the keeping-the-XML-in-sync-with-the-Java torture, and you need a reference that doesn't steer you towards doing it the old way. AFAIK, as of this writing, that's only available online.

This is the the authoritative user's guide to Hibernate. There is no easier way to attain a level of competency in the use of Hibernate sufficient for most real-world projects.

For those who are less experienced in Java programming, I recommend first buying the introduction to Hibernate from the Developer's Notebook series. This was my first Hibernate book, and it had me up and running with a very simple demonstration of how Hibernate works in about ten minutes. But this book won't give you the depth of knowledge you need to do anything more than a very simple project. After you're up and running with the basics, move on to Hibernate In Action.

For those who have somehow attained proficiency in the most commonly-used features of Hibernate without reading Hibernate In Action, you might not need it any more. It hits the sweet spot of containing everything that most developers will need for most projects without burying the reader in arcana. However, its coverage of more advanced features such as Interceptors is rather limited. By the time you have reached an intermediate level of expertise in Hibernate, you'll probably be able to make do with the Javadoc and online documentation to get a handle on the advanced stuff.

This is another one of those books that shouldn't be torn into until you have some idea of what you are looking for. Hibernate, the software system that is the heart of the book is (in my mind at least) the glue that goes between Java and a SQL database. You should have some experience with both Java and SQL to begin to understand the power that Hibernate brings to the table.

Once you have that down, then this book becomes well worth the cost. It's true that Open Source projects, such as Hibernate, have on-line documentation. But that documentation is written differently than a book. It is aimed at a different audience, and often doesn't have the consistent front to back approach that a well thought out book has.

This book is an excellent example. While the on-line documentation is good, (Mr. Bauer, one of the authors is in charge of the on-line documentation) the book is better. It begins with a description of what you are trying to do (often left out in computer books) and leads you on in a consistent manner through the entire Hibernate system. Excellent Book!

Disclaimer: I'm only on chapter 4 at the moment, so my opinion may change as I complete the book.

The first three chapters are fantastic; simply the best introduction to the concepts in Hibernate that I've ever seen. I wouldn't mind seeing some more examples and table layouts, but really, I have no complaints. The recommendations of good practices are illuminating and excellent. For these three chapters alone, the book was a worthwhile purchase.

In chapter 4, something bad happens; the writing suddenly becomes very generic without the usual guidance as to what concepts you should use and when. It could also really use some schema and sequence diagrams to clarify what's happening behind-the-scenes, especially with the more convoluted detached objects.

The index hasn't been very helpful so far, but the table of contents is detailed enough to make up for some of that.

One thing that might help is a reference section that goes over each item in the hibernate config and mapping files and explaining what that option does, with an example, and what other options it interoperates with (also with examples). Then again, much of that is actually available from the Hibernate FAQ, so perhaps they supplement each other.

Like I said, I'm still happy with the book, but it might only be a one-time read. I'll update this review after I finish the book.

Data persistence is quite naturally at the heart of most enterprise applications. There are a myriad of choices the Java developer faces in choosing a persistence mechanism. JDBC and EJBs have long been the standard options, along with relative newcomer JDO, and various commercial Object/Relational Mapping (ORM) solutions. All of these have their place, but they also come with some baggage as well. Enter Hibernate, a popular open-source solution for ORM designed to meet some of the perceived shortcomings of the more traditional Java persistence mechanisms.

Manning's "Hibernate In Action", written by two members of the core Hibernate team (including the project's founder), takes the reader step-by-step through the process of getting up and running with Hibernate. The book begins with an introduction to issues involved in object / relational persistence. Naturally, Hibernate addresses each concern raised with this topic. Right from the beginning I couldn't help but get the feeling that the authors were trying to sell me something. The rest of the book however proceeds in typical Manning "In Action" style by diving into the nuts and bolts of what it takes to get up and running using Hibernate. An example application, an online auction application, is used throughout the book to illustrate the implementation of a Hibernate solution. The examples are clear and easy to follow, and serve adequately to prepare the reader to implement Hibernate in their own applications.

"Hibernate In Action" has to be considered the definitive tome on Hibernate. As the authors are intimately involved with the project, the insight on Hibernate that they provide can't be easily duplicated. That said, the authors' own, often controversial, opinions on common design practices (DTOs for example) are sprinkled liberally throughout the text, and this may turn off some readers. Still, if your project is going to be using hibernate or is considering using Hibernate, this book is a must-have.

This book was my first introduction to Hibernate. It was very good to begin with. Some chapters can even be useful when you already know Hibernate. But the book lacks some more deep coverage of some advanced issues. Combined with documentation on hibernate.org it is sufficent for most scenarios.

But it would need to be updated for Hibernate 3. Therefor only 4 stars.

Just about everything I could say about this book has been already said. This is truely a great book.

It is mainly aimed at a developer audience with a fair degree of Hibernate experience. I would not recommend this book to a fledgling. The style is not to present a flowing tutorial, with full code examples explained; instead, this is a topical, how-to book, with code snippets. It is a much more readable form of the Hibernate 2.1 reference guide, providing some glue between the topics.

Having said the above, just be aware that this is not a typical Manning "In Action" book. Even though there is a full, downloadable code example, the book does not walk you through it - except where the code is used to highlight a discussed topic.

The authors are currently writing an update to this book, which the publisher indicated to me would be out perhaps by September or October.

If you cannot wait until then, Hibernate Quickly, published by Manning, should be out in the next couple of weeks. Also, Pro Hibernate will be published in July.

Hibernate is arguably one of the most interesting and useful Open Source projects around. If you develop enterprise Java applications that have to do with a relational database (and which one doesn't?), then you should seriously consider using an Object/Relational Mapping (ORM for short) tool as an alternative to straight JDBC, in particular if you have a rich domain model and you'd like to exploit the object-oriented features of the language, like polymorphism, and core libraries like the Collections API.

This book comes straight from the source. Gavin is actually the founder of the project and Christian is one of the most prominent developers. It is not surprising, therefore, that the book explains some of the design decisions that have shaped Hibernate into what it is now, like using runtime bytecode generation in preference to source code generation or post-compilation bytecode manipulation.

Hibernate is not easy to learn and use proficiently if you're not prepared to study it thouroughly and this book does a good job of explaining tricky subjects like the persistent objects' lifecycle, exotic mappings, transactions and so on. However, it would be quite hard to use it as a single reference source while working with Hibernate. You should be prepared to refer constantly to the reference documentation, the API docs and the huge knowledge base available through the online forums.

At a little more than 400 pages, it is not a particularly thin book, yet I would have appreciated a more systematic treatment of the APIs and the different types of mappings, with more code samples. As it is, you'll find it a very useful and interesting book if you're about to start a new project and want to know whether Hibernate is the right solution to your persistence problems. If you're a developer interested in using Hibernate, I suggest giving it as a present to your technical mamanger or team leader. In this case, I'd give it five stars

On the other hand, if you're already experienced with Hibernate, it is much less useful but nonetheless very iteresting and well-written, so I'd give it four stars.