POJOs in Action: Developing Enterprise Applications with Lightweight Frameworks (Paperback)

~ (Author)
Key Phrases: eager loading, datastore identity, default fetch group, Pessimistic Offline Lock, Optimistic Offline Lock, Acknowledge Order (more...)

Editorial Reviews

Review

A solid, valuable and easy-to-read work. -- JavaRanch

Product Description

The standard platform for enterprise application development has been EJB but the difficulties of working with it caused it to become unpopular. They also gave rise to lightweight technologies such as Hibernate, Spring, JDO, iBATIS and others, all of which allow the developer to work directly with the simpler POJOs. Now EJB version 3 solves the problems that gave EJB 2 a black eye-it too works with POJOs. "POJOs in Action" describes the new, easier ways to develop enterprise Java applications. It describes how to make key design decisions when developing business logic using POJOs, including how to organize and encapsulate the business logic, access the database, manage transactions, and handle database concurrency. This book is a new-generation Java applications guide: it enables readers to successfully build lightweight applications that are easier to develop, test, and maintain.

See all Editorial Reviews

Product Details

• Paperback: 560 pages
• Publisher: Manning Publications; illustrated edition edition (January 1, 2006)
• Language: English
• ISBN-10: 1932394583
• ISBN-13: 978-1932394580
• Product Dimensions: 9.2 x 7.3 x 1.2 inches
• Shipping Weight: 2.5 pounds (View shipping rates and policies)
• Average Customer Review: 4.5 out of 5 stars  See all reviews (29 customer reviews)
• Amazon.com Sales Rank: #91,983 in Books (See Bestsellers in Books)

Customer Reviews

Most Helpful Customer Reviews

8 of 9 people found the following review helpful:

5.0 out of 5 stars He Writes with an air of Experience, March 21, 2006

By	John Matlock "Gunny" (Winnemucca, NV) - See all my reviews (REAL NAME)

It seems that the Java community has been so fast in developing new tools to assist in system development that it's hard to keep track. In fact, it almost seems that you could spend virtually all your working time on just reading the big thick manuals that each new development seems to require. And then when you want some guidence on which took you should use on any particular project you are faced with an almost religious ferver as to this one vs. that one.

This book is a practical guide to using the new lightweight frameworks with POJO's (Plain Old Java Objects). It gives you an overview of Hibernate, JDO and Spring. More important, is that it defines the features of each with relation to the others. That in, for this kind of thing use this one, and for that kind of thing, use that one.

It's clear that Mr. Richardson has used these programs to develop real applications and he shares his knowledge well.

4 of 4 people found the following review helpful:

4.0 out of 5 stars Get your POJO workin', December 2, 2006

By	Thing with a hook - See all my reviews

This book covers the use of several lightweight frameworks for developing enterprise applications. If you have no clue at all about the issues involved in enterprise Java, I would not advise reading this yet. Despite being C#-based, Applying Domain-Driven Design and Patterns by Jimmy Nilsson would provide the gentle introduction required. On the other hand, if you've had previous experience with server side programming, and want to be brought up to speed quickly on how POJO-based frameworks can be used to replace EJB 2.x style development, this is right up your alley. If you've got used to computer books belying their dimensions with disappointingly little information, you'll be pleasantly surprised with PiA - it's packed with good content.

What's nice about this book is that it goes beyond the basics of the likes of Spring that most people have read several times already (e.g. explaining what dependency injection is) and actually shows how it obviates the need to run in an EJB container and do JNDI look ups. You don't just get to read about, e.g. lazy and eager loading, the author shows you how to use Hibernate and JDO to implement those strategies. That said, this book is not a replacement for documentation or specialised references, so it doesn't get too bogged down. Particularly helpful is that the author provides pros and cons for each of the different approaches he advocates, which helps put them into perspective.

The focus of the book is on using Object Relational Mapping tools, either Hibernate or JDO, in combination with Spring's dependency injection and AOP-based interceptors for transactions. There is also converage of the more procedural-based iBATIS, and using EJB3, although the author does not seem to be a big fan of the latter, despite it being an improvement on EJB2. Many of the persistence-related patterns in Martin Fowler's Patterns of Enterprise Application Architecture are covered here, including the concurrency patterns like pessimistic and optimistic locking. The author shows how to implement these patterns with the frameworks, often showing multiple ways of doing things. He's not afraid to highlight where one framework is lacking compared to another, which is refreshing.

As you can perhaps tell, the coverage is predominantly devoted to the persistence layer - there's not much here on the presentation layer, although there is some material on using servlets. If you're looking for lots of detail on how to hook your domain model up to, say, Struts, or one of the many other web frameworks, you won't find much here.

My only quibble with the book is that although the author pushes increased testability as a important benefit of freeing oneself from EJB containers (a good thing) and uses JUnit tests to illustrate how to develop a POJO-based application (another good thing), the tests use mock objects heavily. I hesitate to call that a bad thing, as clearly there's a whole bunch of people who are much cleverer than I using them productively, but here there's so much set up and setting of expectations, that the actual test is hard to spot, and the intention difficult to fathom. Your mileage may of course vary.

If you're neither an enterprise dummy nor expect, I wholeheartedly recommend this excellent book.

11 of 14 people found the following review helpful:

2.0 out of 5 stars Doesn't live upto the promise, January 31, 2006

By	Kamal Govindraj (Bangalore, India) - See all my reviews (REAL NAME)

If you have already read or know about Hibernate, Spring and Domain Driven Design (one who would respond to the title "POJOs in Action" would certainly do) there isn't a lot of new things in here.

It makes an attempt to tie all these together and provide a unified view for developing application. But not very successfully.

There is some good coverage on the handling concurrency and how to choose the appropriate approach.

I think the unit testing approaches advocated go a little overboard. There are so many mocks that the intent of the test itself is lost. The approach of testing DAOs that creates big monster tests that club together testing of a number of methods into one test also seems to be a less than desirable approach. The other popular approach of using DBUnit and rolling back after each test is not even mentioned.

A few of the choices that are made (like using JDO instead of Hibernate) also seem to be against general consensus.

It also is not a very good/faithful example of DDD approach. Having a parallel hierarcy for PendingOrders and Order doesn't seem right. It only uses the concepts that are probably well understood. I would have liked to see examples of an Aggregate, RootEntity, Bounded context etc. Even the emphasis on using smart value objects is missing (there is code that uses the java date API)

The biggest pain point of using these frameworks (atleast for me) is how to make it work with Struts. I think it is a big omission. Even all the concurrency schemes become far more complicated when you have to make it work in a web application.

On the whole I don't think the book delivers what it promises. I am a bit disappointed.