- 1 -
Core J2EE™ Patterns: Best Practices and Design Strategies
Foreword
Preface
Sun Java Center and the J2EE Pattern Catalog
What This Book is About?
What This Book Is Not?
Who Should Read this Book?
How This Book is Organized
Companion Website and Contact Information
Acknowledgments
I: PATTERNS AND J2EE
1. INTRODUCTION
What Is J2EE ?
What Are Patterns?
J2EE Pattern Catalog
Patterns, Frameworks, and Reuse
Summary
2. J2EE PLATFORM OVERVIEW
A Brief Perspective
J2EE Platform
J2EE Patterns and J2EE Platform
Summary
II: DESIGN CONSIDERATIONS, BAD PRACTICES, AND REFACTORINGS
3. PRESENTATION TIER DESIGN CONSIDERATIONS AND BAD PRACTICES
Presentation Tier Design Considerations
Presentation Tier Bad Practices
4. BUSINESS TIER DESIGN CONSIDERATIONS AND BAD PRACTICES
Business Tier Design Considerations
Business and Integration Tiers Bad Practices
5. J2EE REFACTORINGS
Presentation Tier Refactorings
Business and Integration Tier Refactorings
General Refactorings
III: J2EE PATTERN CATALOG
- 2 -
Part 3 includes the following four chapters:
6. J2EE PATTERNS OVERVIEW
What Is a Pattern?
Identifying a Pattern
The Tiered Approach
J2EE Patterns
Guide to the Catalog
J2EE Pattern Relationships
Relationship to Known Patterns
Patterns Roadmap
Summary
7. PRESENTATION TIER PATTERNS
Intercepting Filter
Front Controller
View Helper
Consequences
Related Patterns
Composite View
Service to Worker
Dispatcher View
8. BUSINESS TIER PATTERNS
Business Delegate
Value Object
Session Facade
Composite Entity
Value Object Assembler
Value List Handler
Service Locator
9. INTEGRATION TIER PATTERNS
Data Access Object
Service Activator
Epilogue J2EE PATTERNS APPLIED
PSA Overview
Use Case Model
Use Cases, Patterns, and Pattern Frameworks
Create Project Use Case
Reserve Resource Use Case
Find Available Resources Use Case
BIBLIOGRAPHY
- 3 -
Foreword
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.
- 4 -
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
