Software Architecture Design Patterns in Java

by Kuchana; Partha

• ISBN13: 9780849321429
• ISBN10: 0849321425
• Edition: 1st
• Format: Hardcover
• Copyright: 2004-04-27
• Publisher: Auerbach Public

Summary

Software engineering and computer science students need a resource that explains how to apply design patterns at the enterprise level, allowing them to design and implement systems of high stability and quality.Software Architecture Design Patterns in Java is a detailed explanation of how to apply design patterns and develop software architectures. It provides in-depth examples in Java, and guides students by detailing when, why, and how to use specific patterns.This textbook presents 42 design patterns, including 23 GoF patterns. Categories include: Basic, Creational, Collectional, Structural, Behavioral, and Concurrency, with multiple examples for each. The discussion of each pattern includes an example implemented in Java. The source code for all examples is found on a companion Web site.The author explains the content so that it is easy to understand, and each pattern discussion includes Practice Questions to aid instructors. The textbook concludes with a case study that pulls several patterns together to demonstrate how patterns are not applied in isolation, but collaborate within domains to solve complicated problems.

Table of Contents

SECTION I: AN INTRODUCTION TO DESIGN PATTERNS
1 Design Patterns: Origin and History	3	(6)
Architectural to Software Design Patterns	3	(1)
What Is a Design Pattern?	4	(1)
More about Design Patterns	4	(2)
About This Book	6	(3)
Source Code	6	(1)
Source Code Disclaimer	6	(3)
SECTION II: UNIFIED MODELING LANGUAGE (UML)
2 UML: A Quick Reference	9	(14)
Structure Diagrams	9	(1)
Behavior Diagrams	9	(1)
Model Management Diagrams	9	(1)
Class Diagrams	10	(8)
Class	10	(1)
Inner Class	11	(1)
Access Specifiers	12	(1)
Static	12	(1)
Abstract Class/Method	13	(1)
Exception	13	(1)
Note	13	(1)
Generalization	13	(1)
Interface	14	(1)
Realization	15	(1)
Dependency	15	(1)
Class Association	16	(2)
Multiplicity	16	(1)
Navigability	16	(1)
Composition	17	(1)
Aggregation	17	(1)
Sequence Diagrams	18	(5)
Object	18	(1)
Message	18	(1)
Self Call	19	(4)
SECTION III: BASIC PATTERNS
3 Interface	23	(8)
Description	23	(1)
Example	24	(6)
Practice Questions	30	(1)
4 Abstract Parent Class	31	(6)
Description	31	(1)
Example	32	(3)
Abstract Parent Class versus Interface	33	(2)
Practice Questions	35	(2)
5 Private Methods	37	(2)
Description	37	(1)
Example	37	(1)
Practice Questions	38	(1)
6 Accessor Methods	39	(8)
Description	39	(1)
Accessor Method Nomenclature	40	(1)
Example	40	(1)
Direct Reference versus Accessor Methods	41	(2)
Practice Questions	43	(4)
7 Constant Data Manager	47	(6)
Description	47	(1)
Example	47	(1)
Practice Questions	48	(5)
8 Immutable Object	53	(8)
Description	53	(5)
Example	58	(1)
Practice Questions	58	(3)
9 Monitor	61
Description	61	(1)
Example	61	(1)
Practice Questions	62	(3)
SECTION IV: CREATIONAL PATTERNS
10 Factory Method	65	(72)
Description	65	(2)
Example	67	(4)
Practice Questions	71	(2)
11 Singleton	73	(1)
Description	73	(1)
Who Should Be Responsible?	73	(1)
Example	73	(4)
Make the Constructor Private	75	(1)
Static Public Interface to Access an Instance	75	(2)
Practice Questions	77	(2)
12 Abstract Factory	79	(1)
Description	79	(1)
Abstract Factory versus Factory Method	80	(1)
Example I	81	(8)
Example II	89	(5)
Logical Flow When the Application Is Run	93	(1)
Practice Questions	94	(1)
13 Prototype	95	(1)
Description	95	(1)
Shallow Copy versus Deep Copy	96	(6)
Shallow Copy Example	97	(2)
Deep Copy Example	99	(3)
Example I	102	(4)
Design Highlights of the Hosting Plan Kit Class	103	(3)
Example II	106	(5)
Redesign the UserAccount Class	108	(1)
Create a Prototype Factory Class	109	(2)
Practice Questions	111	(2)
14 Builder	113	(1)
Description	113	(3)
Example I	116	(8)
A Side Note	116	(5)
Back to the Example Application	121	(3)
Example II	124	(7)
Example III	131	(3)
Practice Questions	134	(3)
SECTION V: COLLECTIONAL PATTERNS
15 Composite	137	(58)
Description	137	(1)
Example	137	(1)
Design Approach I	137	(2)
FileComponent	138	(1)
getComponentSize()	138	(1)
DirComponent	138	(41)
addComponent(FileSysternComponent)	139	(1)
getComponent(int)	139	(1)
getComponentSize()	139	(1)
Design Approach II	139	(5)
Practice Questions	144	(3)
16 Iterator	147	(1)
Description	147	(1)
Iterators in Java	147	(1)
Filtered Iterators	148	(1)
Internal versus External Iterators	148	(1)
Example: Internal Iterator	149	(1)
Client/Container Interaction	149	(4)
Example: External Filtered Iterator	153	(6)
Practice Questions	159	(2)
17 Flyweight	161	(1)
Description	161	(1)
How to Design a Flyweight in Java	162	(1)
Design Highlights	162	(3)
Example	165	(1)
Design Approach I	166	(4)
Design Approach II	170	(4)
Practice Questions	174	(5)
18 Visitor	179	(1)
Description	179	(1)
Design Idea 1	179	(1)
Design Idea 2	180	(1)
Defining New Operations on the Object Collection	180	(1)
Adding Objects of a New Type to the Collection	180	(1)
Example	181	(1)
Design Approach I	181	(1)
Design Approach II	182	(1)
Design Approach III (Composite Pattern)	182	(1)
Design Approach IV (The Visitor Pattern)	183	(4)
Application Flow	184	(3)
Defining a New Operation on the Order Object Collection	187	(1)
Adding a New Order Type to the Collection	187	(1)
Practice Questions	187	(8)
SECTION VI: STRUCTURAL PATTERNS
19 Decorator	195	(110)
Description	195	(1)
Characteristics of a Decorator	195	(1)
Example	195	(3)
Concrete Logger Decorators	198	(2)
HTMLLogger	198	(1)
EncryptLogger	199	(1)
Adding a New Message Logger	200	(1)
Adding a New Decorator	201	(2)
Practice Questions	203	(2)
20 Adapter	205	(1)
Description	205	(1)
Class Adapters versus Object Adapters	206	(1)
Class Adapter	206	(1)
Object Adapter	206	(1)
Example	206	(5)
Address Adapter as an Object Adapter	211	(6)
Practice Questions	217	(2)
21 Chain of Responsibility	219	(1)
Description	219	(1)
Example	220	(7)
Practice Questions	227	(2)
22 Facade	229	(1)
Description	229	(2)
Example	231	(5)
Important Notes	236	(1)
Practice Questions	237	(6)
23 Proxy	243	(1)
Description	243	(1)
Proxy versus Other Patterns	244	(2)
Proxy versus Decorator	244	(1)
Proxy versus Facade	245	(1)
Proxy versus Chain of Responsibility	246	(1)
RMI: A Quick Overview	246	(2)
RMI Components	246	(1)
RMI Communication Mechanism	247	(1)
RMI and Proxy Pattern	248	(1)
Example	248	(8)
Additional Notes	256	(3)
Compilation and Deployment Notes	256	(3)
Practice Questions	259	(2)
24 Bridge	261	(1)
Description	261	(2)
Example	263	(7)
Abstraction Implementation Design	264	(2)
Abstraction Interface Design	266	(1)
Design Highlights of the Abstraction Interface Classes	266	(4)
Bridge Pattern versus Adapter Pattern	270	(1)
Practice Questions	270	(3)
25 Virtual Proxy	273	(1)
Description	273	(1)
Advantage	273	(1)
Disadvantage	273	(1)
Example	274	(3)
Practice Questions	277	(2)
26 Counting Proxy	279	(1)
Description	279	(1)
Example	279	(3)
Practice Questions	282	(1)
27 Aggregate Enforcer	283	(1)
Description	283	(1)
Example	284	(2)
Design Approach I (On-Demand Initialization)	284	(1)
Design Approach II (Early Initialization)	284	(1)
Design Approach III (Final Variables)	284	(2)
Practice Questions	286	(3)
28 Explicit Object Release	289	(1)
Description	289	(1)
The finalize Method	289	(1)
When an Object Goes Out of Scope, It Is Believed to Be Garbage Collected Immediately	289	(1)
The Garbage Collection Process Runs as a Low-Level Background Daemon Thread	290	(1)
The finally Statement	290	(1)
Example	290	(4)
Best Case Scenario	291	(1)
Exception Scenario 1	291	(1)
Exception Scenario 2	291	(3)
Practice Questions	294	(1)
29 Object Cache	295	(1)
Description	295	(1)
Example	296	(3)
Practice Questions	299	(6)
SECTION VII: BEHAVIORAL PATTERNS
30 Command	305	(130)
Description	305	(3)
Example I	308	(6)
Example II	314	(1)
Application Flow	314	(1)
Practice Questions	315	(6)
31 Mediator	321	(1)
Description	321	(1)
Mediator versus Facade	322	(1)
Example I	323	(5)
Client Usage of the Mediator	325	(1)
User Interface Objects: Mediator Interaction	325	(3)
Example II	328	(4)
Practice Questions	332	(1)
32 Memento	333	(1)
Description	333	(1)
Example	333	(7)
DataConverter (Originator)	334	(3)
ID	334	(3)
Memento	337	(1)
process	337	(1)
createMemento	337	(1)
setMemento	337	(1)
DCC1 Tent (Client)	337	(1)
MementoHandler	338	(2)
Practice Questions	340	(3)
33 Observer	343	(1)
Description	343	(1)
Adding New Observers	344	(1)
Example	345	(8)
Subject-Observer Association	349	(7)
Logical Flow	351	(2)
Practice Questions	353	(2)
34 Interpreter	355	(1)
Description	355	(1)
Example	356	(9)
Infix-to-Postfix Conversion (Listing 34.8)	360	(3)
Construction of the Tree Structure (Listing 34.9)	363	(2)
Postorder Traversal of the Tree	365	(1)
Additional Notes	365	(4)
Infix-to-Postfix Conversion	365	(1)
Infix Expression	365	(1)
Postfix Expression	366	(1)
Conversion Algorithm	366	(1)
Example	367	(1)
Binary Tree Traversal Techniques	367	(21)
Preorder (Node-Left-Right)	368	(1)
In-Order (Left-Node-Right)	368	(1)
Postorder (Left-Right-Node)	368	(1)
Level-Order	369	(1)
Practice Questions	369	(2)
35 State	371	(1)
Description	371	(1)
Stateful Object: An Example	371	(2)
Example	373	(12)
Practice Questions	385	(2)
36 Strategy	387	(1)
Description	387	(1)
Strategies versus Other Alternatives	387	(1)
Strategy versus State	388	(1)
Example	388	(9)
SimpleEncryption	388	(2)
CaesarCypher	390	(1)
SubstitutionCypher	390	(1)
CodeBookCypher	390	(7)
Practice Questions	397	(2)
37 Null Object	399	(1)
Description	399	(1)
Example	400	(3)
Practice Questions	403	(2)
38 Template Method	405	(1)
Description	405	(1)
Abstract Class	405	(1)
Concrete Class	406	(1)
Example	406	(5)
Additional Notes	411	(4)
Mod 10 Check Digit Algorithm	411	(4)
Practice Questions	415	(2)
39 Object Authenticator	417	(1)
Description	417	(1)
Example	417	(4)
Practice Questions	421	(2)
40 Common Attribute Registry	423	(1)
Description	423	(3)
Example	426	(4)
Practice Questions	430	(5)
SECTION VIII: CONCURRENCY PATTERNS
41 Critical Section	435	(26)
Description	435	(1)
Example	435	(3)
Approach I (Critical Section)	436	(1)
Approach II (Static Early Initialization)	437	(1)
Practice Questions	438	(1)
42 Consistent Lock Order	439	(1)
Description	439	(2)
Example	441	(3)
Practice Questions	444	(1)
43 Guarded Suspension	445	(1)
Description	445	(1)
Example	446	(3)
Use of wait() and notify() in the ParkingLot Class Design	448	(1)
Practice Questions	449	(2)
44 Read-Write Lock	451	(1)
Description	451	(4)
Design Highlights of the ReadWriteLock Class	452	(10)
Lock Statistics	452	(1)
Lock Methods	452	(1)
Lock Release	452	(3)
Example	455	(2)
Practice Questions	457	(4)
SECTION IX: CASE STUDY
45 Case Study: A Web Hosting Company	461	(16)
Objective	461	(1)
KPS Hosting Solutions: A Brief Overview	461	(1)
Requirements	462	(1)
Functional	462	(1)
Technical	463	(1)
Business Objects and Their Association	463	(1)
Framework for Application Processing	464	(10)
Enterprise Service Level	466	(2)
Generic Interface Contract	466	(1)
Sample Interface Contract	467	(1)
Task Level	468	(2)
Generic Task-Handler Mapping	469	(1)
Sample Task-Handler Mapping	469	(1)
Error Processing	470	(1)
Enterprise Services Design	470	(1)
Address Validation	471	(1)
Credit Card Service	472	(1)
Validation	472	(1)
Search Management	472	(1)
Customer Management	472	(2)
Conclusion	474
SECTION X: APPENDICES
Appendix A: List of Design Patterns	477	(1)
Appendix B: References	479	(2)
Index	481