Core J2EE Patterns: Best Practices and Design Strategies - Softcover

Malks, Dan; Alur, Deepak; Crupi, John

Softcover

ISBN 10: 0130648841 ISBN 13: 9780130648846

Publisher: Prentice Hall Ptr, 2001

Synopsis

Explains how to leverage Java's architecture and mechanisms to design enterprise applications and considers code modularity, nonduplication, network efficiency, maintainability, and reusability.

About this title

About the Author

DEEPAK ALUR is an Enterprise Java Architect with the Sun Java Center with over 12 years of experience.

JOHN CRUPI is the Chief Java Architect of the Sun Java Center. He has over 15 years of experience in distributed object computing.

DAN MALKS is an Enterprise Java Architect with the Sun Java Center with over 14 years of experience.

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

Excerpt. © Reprinted by permission. All rights reserved.

Excerpts from the Foreword by Grady Booch:

The authors of Core J2EE Patterns have harvested a really useful set of patterns. They show you how to apply these patterns and how to refactor your system to take advantage of them. It's just like having a team of experts sitting at your side.

In the world of software, a pattern is a tangible manifestation of an organization's tribal memory. A pattern provides a common solution to a common problem and so, within the culture of one specific organization or within one domain, naming and then specifying a pattern represents the codification of a common solution, drawn from proven, prior experience. Having a good language of patterns at your disposal is like having an extended team of experts sitting at your side during development: by applying one of their patterns, you in effect take the benefit of their hard-won knowledge. As such, the best patterns are not so much invented as they are discovered and then harvested from existing, successful systems. Thus, at its most mature state, a pattern is full of things that work, absent of things that don't work, and revealing of the wisdom and rationale of its designers.

Deep, really useful, patterns are typically ancient: you see one and will often remark, "Hey, I've done that before." However, the very naming of the pattern gives you a vocabulary that you didn't have previously and so helps you apply that pattern in ways you otherwise might have not have realized. Ultimately, the effect of such a pattern will be to make your system simpler. Patterns not only help you build simpler systems that work, but they also help you build beautiful programs. In a culture of time starvation, writing beautiful software is often impossible. That's sad,
for as professionals, we strive to build things of quality.

By applying a good set of patterns, it is possible to bring a degree of elegance in to your systems that might otherwise have been lacking. The authors of Core J2EE Patterns have harvested a really useful set of patterns. Don't get me wrong: J2EE is certainly an important platform, enabling teams to build some very powerful systems. However, reality is, there is still a wide semantic gap between the abstractions and services that J2EE provides and the final application that a team must build. Patterns such as specified in this book represent solutions that appear again and again in filling that gap.

By applying these patterns, you thus carry out the primary means of reducing software risk: you write less software. Rather than discovering these solutions on your own, apply these patterns, which have already proven their utility in existing systems.

More than just naming a set of patterns, the authors make them approachable by specifying their semantics using the UML. Additionally, they show you how to apply these patterns and how to refactor your system to take advantage of them. Again, it's just like having a team of experts sitting at your side.

Grady Booch
Chief Scientist
Rational Software Corporation

Edition details

• Publisher: Prentice Hall Ptr
• Publication date: 2001
• Language: English
• ISBN 10: 0130648841
• ISBN 13: 9780130648846
• Binding: Paperback
• Edition number: 1
• Number of pages: 459