Core J2EE Patterns: Best Practices and Design Strategies [Paperback]

Dan Malks (Author), Deepak Alur (Author), John Crupi (Author)

Book Description

Series: Sun Microsystems Press | Publication Date: June 26, 2001

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.

Editorial Reviews

Amazon.com Review

Patterns are basically design solutions for recurring problems, so Core J2EE Patterns contains recurring design solutions for persons using J2EE. The authors break these solutions down into presentation, business, and integration patterns.

As is usual with pattern books, you won't find much code here. The book majors on problem discussions, analysis of the factors you should consider in your design, and strategies for the solution implementation. The authors constantly encourage abstraction, code modularity, non-duplication of code, network efficiency, code maintainability, and solution reusability.

While these are the aims we've been encouraged to pursue for years, too many pattern books operate at such a high theoretical level they fail to appeal to working programmers. In practice, you could use the patterns discussed with any language, but by concentrating on using Java, Core J2EE Patterns is able to take a more hands-on approach.

Okay, so you won't find detail at the level of APIs, but you will find discussion of where to implement functionality to best leverage Java's architecture and which Java mechanisms to use: for example, implementing entity beans as coarse-grained--rather than fine-grained--objects to reduce the transaction overhead. Not the sort of implementation advice you'll find in language-agnostic pattern books.

Core J2EE Patterns enables you to dramatically cut the design time on enterprise-level Java-based projects while increasing the likelihood that the project will reach a timely fruition. Recommended. --Steve Patient, Amazon.co.uk

From the Back Cover

Over the last few years, Java 2 Platform, Enterprise Edition (J2EE) technology has emerged and matured as a standard platform for building enterprise applications. While the platform has matured into a solid offering for developing and deploying enterprise applications, it does offer its challenges. As developers, often we confuse learning the technology with learning to design with the technology. In this book, senior architects from the Sun Java Center, Sun's Java consulting organization share with the reader their cumulative design experience with and expertise on J2EE technology.

The primary focus of the book is on patterns, best practices, design strategies, and proven solutions using the key J2EE technologies including JavaServer Pages (JSP), Servlets, Enterprise Java Beans (EJB), and Java Message Service (J.M.S) API. Other ancillary technologies like JDBC and JNDI are also discussed as relevant to their usage in these patterns. The J2EE Patterns catalog with 16 patterns and numerous strategies is presented to document and promote best practices for these technologies.

In addition to the patterns and strategies, the book offers the following:

• Presents various design strategies for the presentation tier and business tier design.
• Identifies bad practices in presentation, business, and integration tiers, and offers directions to remedy them by using certain patterns, strategies, and refactorings.
• Refactorings for various tiers and mechanics to move away from a bad implementation to a better solution.
• Sample code and examples for patterns, strategies, and refactorings.

Core J2EE Patterns delivers:

• Proven solutions for enterprise applications
• J2EE Patterns Catalog with patterns for JSP technology, EJB technology, and J.M.S.
• Identifies bad practices and recommends solutions
• Refactorings to improve existing designs using patterns, strategies, and best practices
• UML Diagrams illustrate structure and behavior of each pattern

See all Editorial Reviews

Product Details

• Paperback: 496 pages
• Publisher: Pearson Education; 1st edition (June 26, 2001)
• Language: English
• ISBN-10: 0130648841
• ISBN-13: 978-0130648846
• Product Dimensions: 9.2 x 7 x 1.4 inches
• Shipping Weight: 2.3 pounds
• Average Customer Review: 4.5 out of 5 stars  See all reviews (52 customer reviews)
• Amazon Best Sellers Rank: #1,341,948 in Books (See Top 100 in Books)

More About the Author

Discover books, learn about writers, read author blogs, and more.

Customer Reviews

Most Helpful Customer Reviews

44 of 46 people found the following review helpful:

5.0 out of 5 stars An all-star guide for practical J2EE enterprise architecture, August 7, 2001

By 

David Tomlinson "chinese_bookie" (Chicago) - See all my reviews
(REAL NAME)   

This review is from: Core J2EE Patterns: Best Practices and Design Strategies (Paperback)

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.

23 of 26 people found the following review helpful:

5.0 out of 5 stars Great book about J2EE design!, August 6, 2001

By 

Dennis Djenfer (Stockholm, Sweden) - See all my reviews

This review is from: Core J2EE Patterns: Best Practices and Design Strategies (Paperback)

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.

15 of 16 people found the following review helpful:

5.0 out of 5 stars A great achievement, October 13, 2001

By 

Gary Bollinger (Olney, Maryland USA) - See all my reviews

This review is from: Core J2EE Patterns: Best Practices and Design Strategies (Paperback)

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.