Customer Reviews

Core J2EE Patterns: Best Practices and Design Strategies

5 star:		(36)
4 star:		(10)
3 star:		(3)
2 star:		(1)
1 star:		(2)

 

 

Having just completed the initial design and development phase of a J2EE web-based implementation of a major application vendors product, I bought this book. I dont 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 dont change all that much. I didnt acknowledge this trend as patterns because I called it experience.

Ive bought a hundred books over the years, from the Martin books back in the 70s to Monson-Haefel in 2000. With very few exceptions, such as Alexanders 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 Bruschmanns 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 Javasofts 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 dont 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 shouldnt 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 youve 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 dont. 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 wasnt 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.

The beta version of the J2EE Pattern Catalog found on the Web, has evolved into this great book. The authors have made a nice job in categorizing and illustrating useful patterns for the J2EE platform. I recommend everyone that is involved with J2EE design to have a copy on the bookshelf.

A pattern is a reuse mechanism and a way to facilitate communication between developers, designers, and architects. I believe almost every pattern presented in this book fulfil those requirements. The exceptions are Service to Worker pattern and the Dispatcher View patterns that are trying to resolve too much at one time. Dispatcher View, though, is a good name, but Service to Worker does not feel like a great pattern name.

This book also contains a chapter about bad practice, which is as important as good practice. The authors are inspired by Martin Fowler's book about refactoring and have provided a chapter about how to refactor bad J2EE design into good J2EE patterns.

Patterns are one of the best reuse mechanisms we have in the software community and I find this catalog of good, documented patterns very useful. I hope we will se more books of this kind in the future.

This book provides two important services: 1) it catalogues the important patterns for modern object-oriented server development 2) it concretely describes these patterns in the context of J2EE technologies. As a bonus, it clearly describes the motivations and reasons for refactoring existing services - something difficult to explain to management.

There is a wealth of practical experience expressed in these pages. It does not focus on code examples, but there is easily enough code provided to "get the idea". I, for one, find tedious those books that emphasize page after page of code instead of the concepts and design principles illustrated by the code. This book emphasizes design rather than coding, and provides clear explanations of the reasons for and advantages of certain design decisions.

I consider this book one of the most important computer books I have bought in recent years. It will have a long shelf life - unlike most books I buy these days.

This book is about server-side Java development under J2EE. It presents a collection of design patterns, the names of which are well known in the Java development community and referenced in other J2EE texts. If you plan to do J2EE development, this book serves as an excellent introduction and catalog of these "best practices" design patterns.

Also interesting about this book, is its presentation of the J2EE architectural model as having three logical tiers: the presentation tier, the business tier, and the integration tier. Design patterns are presented in terms of these tiers.

Preceding the pattern catalog, the authors present a section on bad practices (also arranged by tiers) and a set of refactorings to remedy those bad practices. This is a good section to help you recognize where your current design is weak and what exactly makes it weak.

Mixed in throughout the text are recommendations on the proper use of EJB's, and this is the only caution I have about this book. It was written around the time of J2EE 1.2, prior to Message Beans and the improvements in Container Managed Persistence (CMP 2.0) that appeared in J2EE 1.3. Some design recommendations may be out-dated, but the patterns still hold true.

Not another line of code for Servlets, JSPs, or EJBs should be written by anyone who hasn't read this book and understood the concepts explained. This book is about best practices in designing and coding J2EE applications. The lessons explained here were developed by the Sun Java Center based on their work in the field. As they developed applications for clients they noticed that the same problems occurred over and over again. This book documents the standard solutions to solve these problems that were built as a catalog of design patterns and best practices.

Part 1 is an introduction to design patterns and the J2EE platform. Part 2 is a catalog of bad practices (the authors describe these as, "less than optimal ways to solve problems"), and refactorings (ways to correct these problems). Developers working with poorly designed J2EE applications will find this section especially helpful.

In Part 3, fifteen separate design patterns and strategies are explained. Each pattern is described in detail with the motivation for using the pattern and the design goals to be achieved. UML class and sequence diagrams are included along with detailed code examples that serve to further clarify the pattern. These patterns aren't theoretical constructs but rather are practical strategies that can be applied to real world applications. Using the strategies in this book will make you more productive and your code easier to understand and maintain.

Anyone designing, architecting, or coding with J2EE will find this book to be extremely useful.

This book is a must if your are in the J2EE industry and unless you are content to being a head-down coder! All the architects and serious developers, who not only wants to make the sw work but wants to make it efficient and well-structured too, should go thru it, the examples are very helpful and categorizing the patterns in three different tiers provide a intuitive way to look at those.

Without making this review any longer, what I'll suggest, NOT as a prerequisite, but as a supplement, is the Gang of Four's (Eric gamma et. al.) 'Design Patterns' book...

After being tempted at java.sun.com with online version, I figured I would pick this book up to have as a good reference. After all, there's something to be said for having it in print =)

Unfortunately, I found the examples *severely* lacking. I returned the book practically immediately when I realized that it didn't fit my learning style. Much like the author of another book on design I own, MEGO (My Eyes Glaze Over) until I see a good example. I understand the patterns, but I would really have liked to have seen at least a *toy* example.

Imagine reading GoF and seeing this:

+++
Command pattern is blah blah blah. Here's an example:

Command comm = getCommand();
comm.execute();
+++

That example really wouldn't tell you how the Command pattern works in context, etc. At the end of each pattern in GoF, there's a really nice example (not in Java, but hey, no one's perfect ;) If this book had that, or at least a pointer inside of a larger example, THAT would have been it for me. I would have given it 5 stars.

What they COULD have done was said, "Here's what a Front Controller is. See x.java and y.java inside of PetStore or Adventure for a really good example."

The funny thing is that most of the example code is taken up by servlet overhead. Everything calls doProcess, etc. I don't need to see that code 10x.

As it stands, I'm giving it a '1' because the examples are so poorly done as to make the book practically worthless to me. I know I don't speak for everyone considering the rave reviews this book has gotten, but it certainly was not a match for my particular learning style.

This work provides key design idioms for the J2EE platform, and therefore promotes the maturity of the platform for serious architects and designers.

The 15 patterns are presented clearly, delineated into logical tiers (6 presentation, 7 business and 2 "integration" tier) together with well-reasoned rationale. There is also a refactoring session which, although not comprehensive, provides a road-map for moving existing implementations to this pattern-oriented new world.

I would expect this work to become synonymous with well-architected J2EE systems, and perhaps to provide the motivation for architectural review of existing systems. In particular these patterns provide obvious advantages for reuse and maintainability. At the very least they provide a common grammar for communicating design concepts.

The sample source code is useful as a starting point on its own.

An excellent reference for J2EE programmers and architects. I really enjoyed the chapters on bad practices (ala anti-patterns) in J2EE. It's equally important to identify the "bad smells" in a design as it is to come up with a good design. Having the patterns organized by "layers" was very welcomed. The class and sequence diagrams are printed inline with the text. This is a nice amenity to the book; the design patterns published in the book were originally found on the JDC site in beta form and all the diagrams were scaled down in size. The only way to view them was to click on them and look at them in a new document view. This book will certainly be a mainstay on my desktop at consulting engagements. I just hope the J2EE community can get more of these types of books.

As an aspiring architect, this book was excellent. It was easy to read, and well ground with Java specific code samples (servlets, JSP, etc). This made the book far more tangible than other design books.