book

J2EE Design Patterns

by William Crawford, Jonathan Kaplan

September 2003

Intermediate to advanced

368 pages

10h 16m

English

O'Reilly Media, Inc.

Read now

Unlock full access

A Note Regarding Supplemental Files
Preface
Audience
Organization of This Book
For Further Reading
Conventions Used in This Book
Comments and Questions
Acknowledgments
William CrawfordJonathan Kaplan
1. Java Enterprise Design
1.1. Design Patterns
1.1.1. The Anatomy of a Pattern1.1.2. Presenting Patterns

1.2. J2EE
1.3. Application Tiers
1.3.1. Component-Based Development1.3.1.1. Characteristics of components
1.4. Core Development Concepts
1.4.1. Extensibility1.4.1.1. Techniques for extensibility1.4.2. Scalability1.4.3. Reliability1.4.4. Timeliness
1.5. Looking Ahead
2. The Unified Modeling Language
2.1. Origins of UML
2.2. The Magnificent Seven
2.3. UML and Software Development Lifecycles
2.4. Use Case Diagrams
2.5. Class Diagrams
2.5.1. Relationships Between Classes2.5.1.1. Aggregation and composition2.5.2. Describing Patterns with Class Diagrams2.5.3. Objects2.5.4. Packages
2.6. Interaction Diagrams
2.6.1. Sequence Diagrams2.6.2. Collaboration Diagrams
2.7. Activity Diagrams
2.8. Deployment Diagrams
3. Presentation Tier Architecture
3.1. Server-Side Presentation Tier
3.2. Application Structure
3.2.1. The Model-View-Controller Pattern3.2.2. Using MVC in J2EE3.2.2.1. The data model3.2.2.2. The controller servlet3.2.2.3. JSP: The view
3.3. Building a Central Controller
3.3.1. The Front Controller Pattern3.3.2. The Front Controller Servlet3.3.2.1. Deploying the front controller3.3.3. The Decorator Pattern3.3.4. Decorating the Front Controller3.3.4.1. Implementing a decorating filter3.3.4.2. Deploying decorating filters3.3.4.3. Other decorators
4. Advanced Presentation Tier Design
4.1. Reuse in Web Applications
4.2. Extending the Controller
4.2.1. The Service to Worker Pattern4.2.2. Service to Worker in J2EE4.2.2.1. Models and views4.2.2.2. Actions4.2.2.3. The dispatcher4.2.2.4. The front controller
4.3. Advanced Views
4.3.1. The View Helper Pattern4.3.2. Implementing a View Helper4.3.2.1. Parsing the RSS4.3.2.2. Using the RSS: Custom tags4.3.3. Composite View4.3.3.1. The Composite View pattern4.3.3.2. Implementing composite views4.3.3.3. Reusing the front controller and dispatcher4.3.3.4. Building the custom tags4.3.3.5. Using templates
5. Presentation Tier Scalability
5.1. Scalability and Bottlenecks
5.2. Content Caching
5.2.1. Caching Content Components5.2.2. The Asynchronous Page Pattern5.2.2.1. Implementing the Asynchronous Page pattern5.2.3. Dynamic Content Caching5.2.4. The Caching Filter Pattern5.2.5. Implementing a Caching Filter
5.3. Resource Pool
5.3.1. The Resource Pool Pattern5.3.2. Implementing a Resource Pool
6. The Business Tier
6.1. The Business Tier
6.1.1. Business Tier Components6.1.1.1. Business tier components6.1.1.2. Supporting players
6.2. Domain Objects
6.2.1. Domain Object Model6.2.2. Building an Object Model6.2.2.1. Define the vision6.2.2.2. Gather the user cases6.2.2.3. Find object candidates6.2.2.4. Implementing a domain object model in J2EE6.2.3. Composite Entity/Entity Façade Pattern6.2.3.1. A composite entity schema
7. Tier Communications
7.1. Data Transfer Patterns
7.1.1. Data Transfer Objects7.1.1.1. Data objects as DTOs7.1.1.2. Dedicated data transfer objects7.1.2. Data Transfer Hash Pattern7.1.3. Row Set DTOs
8. Database and Data Patterns
8.1. Data Access Patterns
8.1.1. Data Access Object Pattern8.1.2. DAO Factory Pattern8.1.3. Lazy Load8.1.4. The IsDirty Pattern8.1.5. Procedure Access Object
8.2. Primary Key Patterns
8.2.1. PK Block Generator Pattern8.2.2. Stored Procedures for Primary Keys Pattern
8.3. Object-Relational Mappings
8.3.1. Complex Class Relations8.3.2. Table Inheritance Pattern8.3.2.1. Concrete Table Inheritance strategy8.3.2.2. Class Table Inheritance strategy8.3.3. The Serialized Entity Pattern8.3.3.1. A serialized entity example8.3.3.2. XML and serialized entities8.3.4. The Tuple Table Pattern8.3.4.1. A tuple table example
9. Business Tier Interfaces
9.1. Abstracting Business Logic
9.1.1. Business Delegate9.1.1.1. Organizing business logic into business delegates9.1.1.2. Business delegate implementation9.1.1.3. Nesting business delegates9.1.1.4. Stateful business delegates9.1.2. Business Delegate Factory Pattern9.1.2.1. Modifying business delegate behavior
9.2. Accessing Remote Services
9.2.1. The Service Adapter Pattern9.2.2. Session Façade9.2.2.1. Implementing a session façade9.2.2.2. Web services session façades9.2.2.3. Session façade and business delegate
9.3. Finding Resources
9.3.1. The Service Locator Pattern9.3.2. Service Locator Variations9.3.3. Implementing a Service Locator
10. Enterprise Concurrency
10.1. Transaction Management
10.1.1. About Transactions10.1.2. ACID Transaction Pattern10.1.2.1. Transaction isolation10.1.2.2. System and business transactions10.1.3. Transactions and Objects10.1.4. Transactional Context Pattern10.1.4.1. Implementing transactional context with business delegates
10.2. General Concurrency Patterns
10.2.1. Locking Resources10.2.2. Optimistic Concurrency Pattern10.2.3. Pessimistic Concurrency Pattern
10.3. Implementing Concurrency
10.3.1. Lockable Object Pattern10.3.2. Lock Manager Pattern10.3.2.1. Online lock manager strategy10.3.2.2. Offline lock manager strategy10.3.3. Version Number Pattern
11. Messaging
11.1. Messaging in J2EE
11.1.1. Asynchronous Messaging Versus Web Services
11.2. Messaging and Integration
11.2.1. Types of Messaging11.2.1.1. Guaranteed messaging11.2.1.2. Nonguaranteed messaging11.2.1.3. Persistent and nonpersistent messages in JMS
11.3. Message Distribution Patterns
11.3.1. Point-to-Point Distribution Pattern11.3.2. Publish-Subscribe Pattern11.3.3. Malformed Message Channel Pattern
11.4. Message Types
11.4.1. Event Message11.4.2. Document Message11.4.3. Command Message
11.5. Correlating Messages
11.5.1. Sequenced Message Pattern
11.6. Message Client Patterns
11.6.1. Message Handler Pattern11.6.2. Polling Consumer Pattern11.6.3. Event-Driven Consumer Pattern11.6.4. Message Façade Pattern11.6.5. Message Selector Pattern11.6.6. Competing Consumers Pattern
11.7. Messaging and Integration
11.7.1. Pipes and Filters Pattern11.7.2. Content-Based Routing Pattern11.7.3. Content Aggregator Pattern11.7.4. Control Bus Pattern
11.8. For Further Reading
12. J2EE Antipatterns
12.1. Causes of Antipatterns
12.2. Architectural Antipatterns
12.2.1. Excessive Layering12.2.1.1. Reducing layers12.2.2. Leak Collection12.2.2.1. Reclaiming lost memory
12.3. Presentation Tier Antipatterns
12.3.1. The Magic Servlet12.3.1.1. Refactoring the magic servlet12.3.2. Monolithic/Compound JSPs12.3.2.1. Fixing monolithic and compound JSPs12.3.3. Overstuffed Session12.3.3.1. Unstuffing the session
12.4. EJB Antipatterns
12.4.1. Everything Is an EJB12.4.1.1. Escaping EJBs12.4.2. Round-Tripping12.4.2.1. Reducing round-tripping12.4.3. Stateful When Stateless Will Do12.4.3.1. Turning stateful into stateless
A. Presentation Tier Patterns
A.1. Architectural Patterns
A.2. Advanced Architectural Patterns
A.3. Scalability Patterns
B. Business Tier Patterns
B.1. Business Tier Patterns
B.2. Data Transfer Patterns
B.3. Database Patterns
B.4. Business Tier Interface Patterns
B.5. Concurrency Patterns
C. Messaging Patterns
C.1. Message Distribution Patterns
C.2. Message Client Patterns
C.3. Messaging Integration Patterns
D. J2EE Antipatterns
D.1. Architectural Antipatterns
D.2. Presentation Tier Antipatterns
D.3. Business Tier Antipatterns
About the Authors
Colophon
Copyright

Content preview from J2EE Design Patterns

Name

Serialized Entity Pattern

Goal

To easily persist Java objects to the database.

Participants

Data object: An object representing some data that we want to store.
DAO: Uses Java object serialization to translate the object into a set of bytes.
Database table: Stores the set of bytes.

Interactions

The client passes a data object to a DAO. The DAO uses Java object serialization to translate the object into a set of bytes, which are stored directly in the database. When the client needs to retrieve the object, the DAO reads the bytes back from the database and reconstitutes the object.

Notes

Using serialization has two major drawbacks: the data cannot be queried directly in the database, and the data must be converted if the structure of the underlying objects changes. Using objects that can write themselves to XML alleviates both these concerns.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 0596004273Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills