Core J2EE Patterns: Best Practices and Design Strategies Review

Average Reviews:

(More customer reviews)Having just completed the initial design and development phase of a J2EE web-based implementation of a major application vendor's product, I bought this book. I don't know whether I was trying to see what I could have done better or what I, hmmm, messed up?
A little history ' I have been in the application development field for 25 years, working up from being a coder to a consulting enterprise architect. Having worked with a lot of technologies over the years, I have noticed that while some things change every 18-36 months, some things don't change all that much. I didn't acknowledge this trend as 'patterns' because I called it experience.
I've bought a hundred books over the years, from the Martin books back in the 70's to Monson-Haefel in 2000. With very few exceptions, such as Alexander's Timeless Way of Building and a few others, they were trivial or excellently focused on a very small segment of what you need to know (such as EJB) to be a system architect. Or, in attempting to focus on the bigger picture, they show absolutely no practical detail, and in their own way, are useless.
Now, after all that BS, I get down to the book. This is an outstanding document of a large number of essential enterprise level patterns applied to the J2EE context. Just as Bruschmann's Pattern-Oriented Software Architecture, A System of Patterns took patterns that, by themselves, are trivial and combined them into architecturally significant frameworks; this book shows architectural patterns that are significant in the light of J2EE and Javasoft's Model 2 reference architecture.
Anybody that has worked with Model 2 knows that it is a naïve architecture. It uses practically every part of J2EE because it is there (remember that both were created by Sun) and the patterns of communication and service support really don't work robustly. You will have to significantly enhance the Controller, how the View gets data from the Model, exception handling and propagation, how services are provided and much more.
It seems that the authors of this book realize that. Look at the Front Controller, Service to Worker and Dispatcher View patterns. Check out how the Business Delegate, Session Façade and Composite Entity patterns work. For services, the Service Locator and Service activator patterns are significant. If you have any reservations about Entity Beans (more later), check out the Data Access Object.
If the View Helper, Composite View, Value Object, V.O. Assembler, Value List Handler are new to you, read this book. As an architect, they shouldn't be new.
On Entity Beans, I have to say that the authors did an excellent job. In providing patterns such as Composite Entity and DAO, they help to reduce the triviality of the 1.0 Entity Bean Specification. Within the Composite Entity, the Composite Entity Contains Coarse-Grained Object Strategy and the Composite Entity Implements Coarse-Grained Object Strategy may seem the same, but they are not. They are both powerful ways of leveraging Entity Beans. The Lazy Loading and Dirty Marker Strategies are excellent, also.
A few places in the book have what I believe are errors, or at least naïve statements. The introduction to Entity Beans reads like a java marketing hack wrote it. If you've worked with Entity Beans, you might have run into the fact that they are a relatively simple solution to what can be an extremely complex problem. Many people do not even use them. I usually don't. The Synchronizer Token is interesting, but it seems to assume a single VM on a single machine. What happens to this token when you are stateless, in a multiple VM, multiple node load-balanced cluster? You have to address the location transparent, session state management service scheme before you can deal with this.
Look at the bad practices. I did, with one hand over my eyes! Luckily, I wasn't guilty. These are things that should be obvious to you as a system architect. If not read them and remember them.
All in all, this is one of the best books I have read this decade! In terms of practicality, this is the J2EE architecture book to buy.

Click Here to see more reviews about: Core J2EE Patterns: Best Practices and Design Strategies

Sun Microsystems' Java 2 Platform, Enterprise Edition (J2EE) has become the platform of choice for Web-centric distributed enterprise application development. Expert consultants from the Sun Java Center have been helping customers build J2EE-based solutions since the earliest days of the technology, focusing primarily on up-front design and architecture. Along the way, they've identified powerful J2EE design patterns that lead to applications with superior performance, scalability, and robustness. This book brings those design patterns together, sharing Sun's best practices for development with Java Server Pages (JSP), Servlets, EJB, and other J2EE technologies. It presents a complete catalog of J2EE patterns encapsulating proven and recommended designs for common J2EE-related problems, organized into presentation tier, business tier and integration tier solutions. Presentation tier patterns describe solutions involving JSP and servlets; business tier patterns describe solutions involving EJB; and integration tier patterns describe solutions involving JDBC and Java Messaging Service (JMS). The book also identifies bad practices to be avoided.Finally, it presents an end-to-end multi-tier case study covering every stage of enterprise development.

Click here for more information about Core J2EE Patterns: Best Practices and Design Strategies