Design patterns are intended to encode best computer system design practices. Based on the experience gained, via the analysis of the outcome of numerous actual enterprise software development projects, these general schemas can be readily applied as cookbook solutions, when one has to make system architectural decisions. This book offers a hands-on approach to the presentation of some of the most useful design patterns, using Java as a medium to show how these sometimes quite abstract concepts can be applied in practice.
The structure of the book is straightforward and systematic. After a general presentation of the motivation for, and the history of, design patterns, and a short introduction to unified modeling language (UML), used throughout the book mostly for picturing class relationships and behavior sequences, each of the 42 design patterns covered in the book is presented in turn. The corresponding chapters are grouped into six categories: basic, creational, collectional, structural, behavioral, and concurrency. All chapters have the same structure: a short description of the pattern’s intent, possibly a comparison with other similar-looking patterns, a couple of examples that include Java code to illustrate the pattern goal, and one or more questions to the reader to enhance his or her understanding of the subject matter. A final section introduces a case study that shows how one can use some of the design patterns just covered to address the architectural design of a Web hosting company.
The core of the book is the presentation of the six pattern categories. Basic patterns promote sound object-oriented design and programming practices, via the use of private methods or immutable objects. Creational patterns focus on the creation aspect of object management, via the factory method, to delegate the creation process when dealing with a class hierarchy, or singletons, which ensure that only one instance of a given class ever exists. Collectional patterns deal with groups of objects, for instance, to avoid duplication of common invariant data among objects of the same class, via the Flyweight pattern. Structural patterns look at issues such as the degree of coupling between objects, for example, via the notions of proxies, to control object accesses, or aggregate enforcers, to ensure that the initialization of groups of objects is performed in full. Behavioral patterns introduce general schemes to implement algorithms, for instance, via the notion of interpreters or strategies, which decide at runtime which element in a collection of related algorithms should be run. Finally, concurrency patterns look at distributed processing issues, such as critical sections or read-write locks.
As can be seen, this book provides a wide spectrum, and down-to-earth, introduction to design patterns, emphasizing the practical aspects of this approach, and showing which features of Java can be used to simplify the implementation of such patterns. The book’s structure doesn’t require the reader to read it cover-to-cover, although this could indeed be advised to those who want to enhance their design toolboxes with elegant approaches; the book can also be put on the shelf, and opened when a particular issue comes up during the design process. All the Java code provided in the book can be downloaded, and I found the author’s programming style particularly clean and illustrative. This book could, indeed, also be of use to teachers looking for interesting programming exercises, and challenging ways to tackle them. So, if you ever wondered what hides behind arcane names such as fa¿ade, abstract factory, or singleton, and want to get straight down to business with clean Java code that puts these concepts to work right away, this book is for you. A word of caution, nonetheless: a good knowledge of Java is required to properly grasp the material, since some of it is rather abstract.
