PHP Advanced and Object-Oriented Programming (2013)

The Composite Pattern

The Singleton and Factory patterns are creational: used to generate one or more objects. Another category of patterns is structural. These patterns apply in situations where a nontraditional class structure, or a modification of an existing class structure, is required. For an example of a structural pattern, I want to introduce Composite.

The focus in Chapter 5 is on inheritance as a way of basing one class definition on another. In Chapter 6, I talk about composition, which is another design approach. The composition explained there involves one class type (e.g., Department) being composed of other class types (e.g.,Employees), which will commonly happen. Similarly, the Composite pattern applies in situations where you have an object that might represent a single entity or a composite entity, but still needs to be usable in the same manner.

For example, an HTML form contains one or more form elements. From a programming perspective, certain behaviors will apply to both the entire form and its individual components:

• Display

• Validate

• Show errors

Addressing these needs without using patterns would require that you replicate a lot of code in two different classes (i.e., Form and FormElement). And, as you should know by now, replication makes for bad programming. The solution to this problem is to apply Composite so that the entire form or just an individual component can be treated the same. For example, you could show errors on the form or on a single element; you could validate the entire form at once or just a single element (e.g., validate the availability of a username via Ajax).

Another sign that the Composite pattern may apply is when you’re working with a tree-like structure. For example, the whole form is the root of the tree, and the different form elements would be the branches (often called “leaves” in Composite jargon).

To implement the Composite pattern, you’ll normally start with an abstract base class that will be extended by the different subclasses. The base class needs to identify the methods for adding and removing “leaves” (or composite items). The base class also needs to identify any functionality that the composite, or its subelements, needs to do:

abstract class FormComponent {
abstract function add (FormComponent $obj);
abstract function remove (FormComponent $obj);
abstract function display();
abstract function validate();
abstract function showError();
}

As you can see, the abstract class here is also using type hinting (see Chapter 6). The first two methods are key to Composite. The other three represent the specific functionality needed by this particular example.

Each subclass now inherits from this derived class. By definition, each must also define the implementation of the abstract methods. Here’s a partial example:

class Form extends FormComponent {
private $_elements = array();
function add(FormComponent $obj) {
$this->_elements[] = $obj;
}
function display() {
// Display the entire form.
}
}
class FormElement extends FormComponent {
function add(FormComponent $obj) {
return $obj; // Or false.
}
function display() {
// Display the element.
}
}

As you can see in that code, the Form class implements a true add() method, which allows you to add elements to a form:

$form = new Form();
$email = new FormElement();
$form->add($email);

Note that the FormElement class still has to define the add() method, but the method shouldn’t do anything, because you don’t add subelements to that class type. Instead, such add methods will conventionally return the object that’s being added, or false, or throw an exception.

With these class definitions, you can now treat entire forms or individual form elements in the same manner.

To demonstrate another implementation of the Composite pattern, let’s create a variation on the Department-Employee example. Here, there will be two types of work units: employees and teams, with the latter being made up of employees. Jobs to be done can be assigned to, and completed by, either.

To create a Composite design

1. Begin a new PHP script in your text editor or IDE, to be named WorkUnit.php (Script 7.5):

<?php # Script 7.5 - WorkUnit.php

2. Start defining the WorkUnit class:

abstract class WorkUnit {

Again, this is an abstract class, because you won’t create objects of this class type.

3. Declare two protected attributes:

protected $tasks = array();
protected $name = NULL;

These two attributes will be used by any class that extends this one. The first attribute stores the jobs to be done. The second stores the name of the current object, be it a team or an employee.

4. Define the constructor:

function _ _construct($name) {
$this->name = $name;
}

The constructor is not abstract; it’s fully implemented and assigns the name of the team or employee to the protected attribute.

Script 7.5. The WorkUnit abstract class is extended by two concrete classes to implement the Composite pattern.