As ColdFusion developers, we tend to build applications based on pages that display information and queries to retrieve information and save information. We tend to think solely of how we are going to implement the code required to perform a certain function. Many times we are not able to consider the commonality of a certain problem and whether an already established design exists somewhere. Often we are not able to set aside time to do this research. Knowing and utilizing design patterns allows us to think in a common language, with an ever-expanding library of well thought out solutions to consider when architecting an application. Recognition of these patterns in our everyday jobs can make us significantly more productive and seem even smarter than we are. In the past three issues ofCFDJ, I have been showing you how other languages use object-oriented design patterns and how those patterns can be implemented in ColdFusion MX. This month's pattern differs significantly from the previous three so we should probably go over what makes it different. Let's start by examining the three main categories that design patterns fall into: creational, structural, and behavioral. Creational patterns: Encapsulate and abstract the instantiation process. That is, we may make creating a CFC through or createObject() the responsibility of another CFC or of a custom tag. It can be useful for simplifying the code needed to initiate certain processes. Since ColdFusion MX is not purely object oriented, there is significantly less "object creation." This means there is probably less insight to be gained reviewing creational patterns. However, the Singleton pattern comes to mind as a creational pattern that can relate to managing the state of an application. Structural patterns: Deal with how inheritance, interface implementation, and most specifically object composition make objects more suitable for a wide array of tasks. In other words, a CFC that contains other CFC instances can utilize these instances to perform operations within its methods. This can allow us to combine related CFCs and operations into a single interface. Behavioral patterns: Encapsulate varying algorithms and control flow, assigning responsibilities and fostering communication between objects when appropriate. The Template Method pattern, Iterator pattern, and Strategy pattern, which have been covered in previous issues, are all behavioral patterns. In one way or another they abstract the behavior of a CFC's methods, allowing us to implement multiple behaviors from a single interface. One piece of commonality among these three is that they often deal with encapsulating not only common code but varying code, although for substantially different reasons. Additionally, because we are advised in object- oriented design to "program to an interface, not an implementation," they usually provide common interfaces. This month we will take a look at our first structural design pattern, the Composite pattern. The Composite Pattern As we do every month when talking about object-oriented design patterns, we like to refer to the original "intent" of the pattern as laid out in the book, Design Patterns: Elements of Reusable Object-Oriented Software. As the preeminent work on the subject of design patterns, its authors, the so-called "Gang of Four," established the general intent of the Composite pattern to be the following: Compose objects into tree structures to represent whole-part hierarchies. Composite lets clients treat individual objects and compositions of objects uniformly. The Composite pattern, and more specifically composition by aggregation, helps us to create tree structures to encapsulate not just related objects but a series of related objects that, themselves, may contain other objects ofthe same or related types. This results in a sort of object family tree. Now all we need is to be able to build an interface that allows us to treat parent and child objects uniformly. We will use a fairly standard example of composition by aggregation using employees, bosses, and subordinates to explore what structural patterns can help us achieve. But before we get too deep let's quickly run down what an object is and how it's implemented in ColdFusion. Although a review for some of you, it's important because the object plays such a vital role in understanding design patterns. What Is an Object? This is actually a pretty simple question with a fairly complicated answer. The word objectitself is used in several
