PHP: Composite

Composite is a structural design pattern that allows composing objects into a tree-like structure and work with the it as if it was a singular object.

Composite became a pretty popular solution for the most problems that require building a tree structure. Composite's great feature is the ability to run methods recursively over the whole tree structure and sum up the results.

Application of the pattern in PHP

Complexity:

Popularity:

Usage examples: The Composite pattern is commonly used when working with object trees. The simplest example would be applying the pattern to elements of the DOM tree, working with the composite and simple elements of the tree in the same way.

Example: Structure of the Pattern

This example illustrates the structure of the Composite design pattern and focuses on following questions:

What classes does it consists of?

What roles do these classes play?

In what way the elements of the pattern are related?

After learning about the pattern's structure it will be easier for you to grasp the following example, based on a real world PHP use case.

CompositeStructural.php: Structural Example

<?php
namespace RefactoringGuru\Composite\Structural;
/**
* The base Component class declares common operations for both simple and
* complex objects of a composition.
*/
abstract class Component
{
/**
* @var Component
*/
protected $parent;
/**
* Optionally, the base Component can declare an interface for setting and
* accessing a parent of the component in a tree structure. It can also
* provide some default implementation for these methods.
*/
public function setParent(Component $parent)
{
$this->parent = $parent;
}
public function getParent(): Component
{
return $this->parent;
}
/**
* In some cases, it would be beneficial to define the child-management
* operations right in the base Component class. This way, you won't need to
* expose any concrete component classes to the client code, even during the
* object tree assembly. The downside is that these methods will be empty
* for the leaf-level components.
*/
public function add(Component $component) { }
public function remove(Component $component) { }
/**
* You can provide a method that lets the client code figure out whether a
* component can bear children.
*/
public function isComposite(): bool
{
return false;
}
/**
* The base Component may implement some default behavior or leave it to
* concrete classes (by declaring the method containing the behavior as
* "abstract").
*/
public abstract function operation();
}
/**
* The Leaf class represents the end objects of a composition. A leaf can't have
* any children.
*
* Usually, it's the Leaf objects that do the actual work, whereas Composite
* objects only delegate to their sub-components.
*/
class Leaf extends Component
{
public function operation()
{
return "Leaf";
}
}
/**
* The Composite class represents the complex components that may have children.
* Usually, the Composite objects delegate the actual work to their children and
* then "sum-up" the result.
*/
class Composite extends Component
{
/**
* @var Component[]
*/
protected $children = [];
/**
* A composite object can add or remove other components (both simple or
* complex) to or from its child list.
*/
public function add(Component $component)
{
$this->children[] = $component;
$component->setParent($this);
}
public function remove(Component $component)
{
$this->children = array_filter($this->children, function ($child) use ($component) {
return $child == $component;
});
$component->setParent(null);
}
public function isComposite(): bool
{
return true;
}
/**
* The Composite executes its primary logic in a particular way. It
* traverses recursively through all its children, collecting and summing
* their results. Since the composite's children pass these calls to their
* children and so forth, the whole object tree is traversed as a result.
*/
public function operation()
{
$results = [];
foreach ($this->children as $child) {
$results[] = $child->operation();
}
return "Branch(".implode("+", $results).")";
}
}
/**
* The client code works with all of the components via the base interface.
*/
function clientCode(Component $component)
{
// ...
print("RESULT: ".$component->operation());
// ...
}
/**
* This way the client code can support the simple leaf components...
*/
$simple = new Leaf();
print("Client: I've got a simple component:\n");
clientCode($simple);
print("\n\n");
/**
* ...as well as the complex composites.
*/
$tree = new Composite();
$branch1 = new Composite();
$branch1->add(new Leaf());
$branch1->add(new Leaf());
$branch2 = new Composite();
$branch2->add(new Leaf());
$tree->add($branch1);
$tree->add($branch2);
print("Client: Now I've got a composite tree:\n");
clientCode($tree);
print("\n\n");
/**
* Thanks to the fact that the child-management operations are declared in the
* base Component class, the client code can work with any component, simple or
* complex, without depending on their concrete classes.
*/
function clientCode2(Component $component1, Component $component2)
{
// ...
if ($component1->isComposite()) {
$component1->add($component2);
}
print("RESULT: ".$component1->operation());
// ...
}
print("Client: I don't need to check the components classes even when managing the tree:\n");
clientCode2($tree, $simple);

Output.txt: Output

Client: I get a simple component:
RESULT: Leaf
Client: Now I get a composite tree:
RESULT: Branch(Branch(Leaf+Leaf)+Branch(Leaf))
Client: I can merge two components without checking their classes:
RESULT: Branch(Branch(Leaf+Leaf)+Branch(Leaf)+Leaf)

Example: Real World Example

The Composite pattern can streamline the work with any tree-like recursive structures. The HTML DOM tree is an example of such a structure. For instance, while the various input elements can act as leaves, the complex elements like forms and fieldsets play the role of composites.

Bearing that in mind, you can use the Composite pattern to apply various behaviors to the whole HTML tree in the same way as to its inner elements without coupling your code to concrete classes of the DOM tree. Examples of such behaviors might be rendering the DOM elements, exporting it into various formats, validating its parts, etc.

With the Composite pattern, you don't need to check whether it's the simple or complex type of element before executing the behavior. Depending on the element's type, it either gets executed right away or passed all the way down to all element's children.