Core J2EE Patterns: Best Practices and Design Strategies (Sun Core Series) [ハードカバー]

Patterns, are such essences. They are best practices from experiences on how to design the systems/components at different levels. And Core J2EE Patterns are such collections in the J2EE context.

Even though the authors claim that these patterns are used under the J2EE context, I see most of them also application in a more general context. For example,

If a remote service is to be provided, it is good practice to use Session Facade (or Remote Facade), and it will provide service by delegating to the Application Service (or Service Layer) or Business Delegate.

To facilitate the client to access a remote service, Business Delegate can be applied to hide the remoteness, in which it will use Service Locator to look up the remote service. In this sense, Business Delegate also functions as a proxy of the remote service.

To decouple the Business Object from accessing the resources directly, Data Access Object is a good design to be applied.

To move the data between the tiers or processes, Data Transfer Object can be use.

If studying carefully, you will a lot of patterns and concepts can be applied to non-J2EE applications. And a lot of them can be traced back to the seminal work of GoF (Design Patterns). That is why I said the design skill should be essential to a developer, these techniques are correlated and inter-connected, and accumulated by experience. They are relatively stable (IMO), though the technologies are changing (rapidly).

The other good things about book, the authors not only document the best practices (patterns) of J2EE applications to learn, they also list a set of bad practices (anti-patterns) to avoid, in between, they provide a bridge, the refactoring, to go from bad to good.

Also, no pattern is an island. All patterns are related, and to form a bigger or higher level of pattern, and these higher level of patterns collaborate with each other and eventually form the whole architecture of the system, that is pattern oriented architecture. In last episode, the authors gave such an example, and they call it a micro architecture.

The authors also refer to the work of Martin Fowler's Patterns of Enterprise Application Architecture(which list patterns of more general enterprise application patterns besides J2EE) to clear out some gaps between the two books, e.g., Value Object in 1st edition really means Transfer Object, which is the same pattern listed as Data Transfer Object in Fowler's book. And Value Object is just another pattern in PEAA.

The writing style is very smooth, succinct and to the point. The pattern template is classic, with the authors chose strategies for implementation variations. The examples are probably excerpt from real projects, however, there are some errors in the code, which made me doubt that these codes were ever compiled. But, hey, it is the concept that is more important :-)

In all J2EE applications I have developed since then I have used the patterns and refactorings presented here to great benefit. In addition, the common vocabulary allows my project teams to discuss potential designs much more quickly and unambiguously, since we understand exactly what someone has in mind when they say something like "We should use Business Delegates in our Struts Actions to access our business services, and we should use Transfer Objects to pass data between the tiers, and use Data Access Objects to access our data stores."

The Second Edition brings updates to the original patterns plus several new patterns and the concept of micro-architectures. In addition to the updated and new patterns, this edition also discusses many patterns in the context of widely-used frameworks such as Struts and JSTL. For example, the book notes that the Struts ActionServlet is a Front Controller which hands the request to the Struts RequestProcessor, which implements the new ApplicationController pattern.

Understanding and applying the patterns and refactorings is certain to make your application designs more robust, clean, and maintainable. In addition you will be able to talk about J2EE refactoring and design at a much more abstract and concise level while simultaneously being able to cover a lot more ground much more quickly since everyone will know exactly what is meant by the patterns you are discussing. Along with the GoF's Design Patterns and Fowler's Refactoring books, Core J2EE Patterns is a must-have guide that every J2EE developer and architect should own.

Part 1 is an introduction to design patterns and the J2EE platform followed by a catalog of design considerations, bad practices and refactorings. Developers working with poorly designed J2EE applications will find this section especially helpful.

Part 2 is the collection of the design patterns and strategies. Each pattern is described in the expected level of detail. The format will remind you of the GoF book. Since this has become the standard format for presenting design patterns this should not be a surprise. The patterns are well thought, explained clearly, and demonstrated with some good code samples. If you have the first edition you will be very impressed with the improvements made in this new edition. It appears that virtually every pattern has been reworked to make the pattern easier to understand and use.

This is the book that every J2EE architect and programmer should have on their desk. Using the strategies in this book will make your applications more robust, make you more productive, and make your code easier to understand and maintain. Anyone designing, architecting, or coding with J2EE will find this book to be extremely useful.