[ Team LiB ] • Table of Contents • Index • Reviews • Reader Reviews • Errata J2EE Design Patterns By William Crawford, Jonathan Kaplan Publisher: O'Reilly Pub Date: September 2003 ISBN: 0-596-00427-3 Pages: 368 Crawford and Kaplan's J2EE Design Patterns approaches the subject in a unique, highly practical and pragmatic way. Rather than simply present another catalog of design patterns, the authors broaden the scope by discussing ways to choose design patterns when building an enterprise application from scratch, looking closely at the real world tradeoffs that Java developers must weigh when architecting their applications. Then they go on to show how to apply the patterns when writing realworld software. They also extend design patterns into areas not covered in other books, presenting original patterns for data modeling, transaction / process modeling, and interoperability. [ Team LiB ] [ Team LiB ] • Table of Contents • Index • Reviews • Reader Reviews • Errata J2EE Design Patterns By William Crawford, Jonathan Kaplan Publisher: O'Reilly Pub Date: September 2003 ISBN: 0-596-00427-3 Pages: 368 Copyright Preface Audience Organization of This Book For Further Reading Conventions Used in This Book Comments and Questions Acknowledgments Chapter 1. Java Enterprise Design Section 1.1. Design Patterns Section 1.2. J2EE Section 1.3. Application Tiers Section 1.4. Core Development Concepts Section 1.5. Looking Ahead Chapter 2. The Unified Modeling Language Section 2.1. Origins of UML Section 2.2. The Magnificent Seven Section 2.3. UML and Software Development Lifecycles Section 2.4. Use Case Diagrams Section 2.5. Class Diagrams Section 2.6. Interaction Diagrams Section 2.7. Activity Diagrams Section 2.8. Deployment Diagrams Chapter 3. Presentation Tier Architecture Section 3.1. Server-Side Presentation Tier Section 3.2. Application Structure Section 3.3. Building a Central Controller Chapter 4. Advanced Presentation Tier Design Section 4.1. Reuse in Web Applications Section 4.2. Extending the Controller Section 4.3. Advanced Views Chapter 5. Presentation Tier Scalability Section 5.1. Scalability and Bottlenecks Section 5.2. Content Caching Section 5.3. Resource Pool Chapter 6. The Business Tier Section 6.1. The Business Tier Section 6.2. Domain Objects Chapter 7. Tier Communications Section 7.1. Data Transfer Patterns Chapter 8. Database and Data Patterns Section 8.1. Data Access Patterns Section 8.2. Primary Key Patterns Section 8.3. Object-Relational Mappings Chapter 9. Business Tier Interfaces Section 9.1. Abstracting Business Logic Section 9.2. Accessing Remote Services Section 9.3. Finding Resources Chapter 10. Enterprise Concurrency Section 10.1. Transaction Management Section 10.2. General Concurrency Patterns Section 10.3. Implementing Concurrency Chapter 11. Messaging Section 11.1. Messaging in J2EE Section 11.2. Messaging and Integration Section 11.3. Message Distribution Patterns Section 11.4. Message Types Section 11.5. Correlating Messages Section 11.6. Message Client Patterns Section 11.7. Messaging and Integration Section 11.8. For Further Reading Chapter 12. J2EE Antipatterns Section 12.1. Causes of Antipatterns Section 12.2. Architectural Antipatterns Section 12.3. Presentation Tier Antipatterns Section 12.4. EJB Antipatterns Appendix A. Presentation Tier Patterns Section A.1. Architectural Patterns Section A.2. Advanced Architectural Patterns Section A.3. Scalability Patterns Appendix B. Business Tier Patterns Section B.1. Business Tier Patterns Section B.2. Data Transfer Patterns Section B.3. Database Patterns Section B.4. Business Tier Interface Patterns Section B.5. Concurrency Patterns Appendix C. Messaging Patterns Section C.1. Message Distribution Patterns Section C.2. Message Client Patterns Section C.3. Messaging Integration Patterns Appendix D. J2EE Antipatterns Section D.1. Architectural Antipatterns Section D.2. Presentation Tier Antipatterns Section D.3. Business Tier Antipatterns Colophon Index [ Team LiB ] [ Team LiB ] Copyright Copyright © 2003 O'Reilly & Associates, Inc. Printed in the United States of America. Published by O'Reilly & Associates, Inc., 1005 Gravenstein Highway North, Sebastopol, CA 95472. O'Reilly & Associates books may be purchased for educational, business, or sales promotional use. Online editions are also available for most titles (http://safari.oreilly.com). For more information, contact our corporate/institutional sales department: (800) 998-9938 or [email protected]. Nutshell Handbook, the Nutshell Handbook logo, and the O'Reilly logo are registered trademarks of O'Reilly & Associates, Inc. Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in this book, and O'Reilly & Associates, Inc. was aware of a trademark claim, the designations have been printed in caps or initial caps. Java and all Java-based trademarks and logos are trademarks or registered trademarks of Sun Microsystems, Inc., in the United States and other countries. O'Reilly & Associates, Inc. is independent of Sun Microsystems. The association between the image of a mollusk and the topic of J2EE design patterns is a trademark of O'Reilly & Associates, Inc. While every precaution has been taken in the preparation of this book, the publisher and authors assume no responsibility for errors or omissions, or for damages resulting from the use of the information contained herein. [ Team LiB ] [ Team LiB ] Preface So, you want to build enterprise applications? Back in 1996, we were working on a web-based clinical data management system for a major Boston hospital. Java 1.0.2 had recently been released, and development tools were beginning to trickle onto the market. The Write Once, Run Anywhere promise of Java was beguiling, not in the least because we didn't have development environments that mirrored the deployment environments. And here was this object-oriented, strongly typed language with-even then-an excellent standard class library. It seemed like a perfect fit, at least in theory. In the end, the application sprouted several Java applets and an early, crude database-backed web site. Replacing Perl scripts with Java code required some fancy footwork, since none of the available web servers had any native Java integration. Performance was questionable, maintenance was iffy, and at a few points we found ourselves backtracking to Perl and C++. The application itself turned into a strange amalgamation of Perl CGI scripts, server-side Java applications (including part of a custom-built web server), HTML, and C++ CGI programs. Our primary problem was that the necessary infrastructure for both developing and deploying the application just wasn't in place. Java's support for relational databases was primitive, and while the language has always supported certain operations as a web client, it wasn't until the Java Servlet API was introduced the following year that Java gained a standard, high performance mechanism for integrating into a web server. These limitations meant that while we could use Java for some of our development activities, those activities were sharply bounded. It also meant that we couldn't take much with us as we moved on to future projects with different environments and tool sets, all of which behaved more or less differently. Now, Java has found its place in the enterprise world. Performance is competitive with any approach you care to name. The APIs that have been added during the subsequent four iterations of the language give Java broader native support for enterprise activities than any other language available. From a standing start when we first tried it in 1996, Java has become the lingua franca for server- side business programming. The cross-platform graphical user interface, which seemed to be the most promising aspect of Java, is only now beginning to take off in a real way, mostly in products focused on developers and system administrators. But Java has taken off behind the scenes for building e-commerce web sites, intranet business applications, and mission-critical distributed computing systems. Millions of people interact with enterprise Java every day, often without realizing it. Even if we'd had the full resources of the modern Java environment available to us, success wouldn't be guaranteed. (Actually, the application in question worked out pretty well overall, but it's not an experience that we'd like to repeat.) Tools can be used poorly or inefficiently, and the sheer scope of the J2EE environment-which now includes thousands of classes-means that very few individual developers have built up a reservoir of experience in every area. J2EE has created standards and made implementation easier, but the fundamental design issues are still as relevant as ever. We just have more ways to tackle them and more tools to eliminate the grunt work. And, of course, a standard, consistent, widely deployed platform to build those solutions on. This is a book about building effective applications for enterprise environments, using Java 2, Enterprise Edition ( J2EE). This book is not about how to use the individual components of the J2EE specification, although we touch upon aspects of most of the components; a brief overview is provided below. Rather, this book is about the patterns that underlie effective software designs. In addition to 12 combined years of experience building Enterprise Java systems, the authors, like the development community at large, have been the beneficiaries of over a