Mediator

Mediator

Real world example

A general example would be when you talk to someone on your mobile phone, there is a network provider sitting between you and them and your conversation goes through it instead of being directly sent. In this case network provider is mediator.

In plain words

Mediator pattern adds a third party object (called mediator) to control the interaction between two objects (called colleagues). It helps reduce the coupling between the classes communicating with each other. Because now they don't need to have the knowledge of each other's implementation.

Wikipedia says

In software engineering, the mediator pattern defines an object that encapsulates how a set of objects interact. This pattern is considered to be a behavioral pattern due to the way it can alter the program's running behavior.

Programmatic Example

Here is the simplest example of a chat room (i.e. mediator) with users (i.e. colleagues) sending messages to each other.

First of all, we have the mediator i.e. the chat room

interface ChatRoomMediator 
{
    public function showMessage(User $user, string $message);
}
 
// Mediator
class ChatRoom implements ChatRoomMediator
{
    public function showMessage(User $user, string $message)
    {
        $time = date('M d, y H:i');
        $sender = $user->getName();
 
        echo $time . '[' . $sender . ']:' . $message;
    }
}

Then we have our users i.e. colleagues

class User {
    protected $name;
    protected $chatMediator;
 
    public function __construct(string $name, ChatRoomMediator $chatMediator) {
        $this->name = $name;
        $this->chatMediator = $chatMediator;
    }
 
    public function getName() {
        return $this->name;
    }
 
    public function send($message) {
        $this->chatMediator->showMessage($this, $message);
    }
}

And the usage

$mediator = new ChatRoom();
 
$john = new User('John Doe', $mediator);
$jane = new User('Jane Doe', $mediator);
 
$john->send('Hi there!');
$jane->send('Hey!');
 
// Output will be
// Feb 14, 10:58 [John]: Hi there!
// Feb 14, 10:58 [Jane]: Hey!

Memento

Real world example

Take the example of calculator (i.e. originator), where whenever you perform some calculation the last calculation is saved in memory (i.e. memento) so that you can get back to it and maybe get it restored using some action buttons (i.e. caretaker).

In plain words

Memento pattern is about capturing and storing the current state of an object in a manner that it can be restored later on in a smooth manner.

Wikipedia says

The memento pattern is a software design pattern that provides the ability to restore an object to its previous state (undo via rollback).

Usually useful when you need to provide some sort of undo functionality.

Programmatic Example

Lets take an example of text editor which keeps saving the state from time to time and that you can restore if you want.

First of all we have our memento object that will be able to hold the editor state

class EditorMemento
{
    protected $content;
 
    public function __construct(string $content)
    {
        $this->content = $content;
    }
 
    public function getContent()
    {
        return $this->content;
    }
}

Then we have our editor i.e. originator that is going to use memento object

class Editor
{
    protected $content = '';
 
    public function type(string $words)
    {
        $this->content = $this->content . ' ' . $words;
    }
 
    public function getContent()
    {
        return $this->content;
    }
 
    public function save()
    {
        return new EditorMemento($this->content);
    }
 
    public function restore(EditorMemento $memento)
    {
        $this->content = $memento->getContent();
    }
}

And then it can be used as

$editor = new Editor();
 
// Type some stuff
$editor->type('This is the first sentence.');
$editor->type('This is second.');
 
// Save the state to restore to : This is the first sentence. This is second.
$saved = $editor->save();
 
// Type some more
$editor->type('And this is third.');
 
// Output: Content before Saving
echo $editor->getContent(); // This is the first sentence. This is second. And this is third.
 
// Restoring to last saved state
$editor->restore($saved);
 
$editor->getContent(); // This is the first sentence. This is second.

Observer

Real world example

A good example would be the job seekers where they subscribe to some job posting site and they are notified whenever there is a matching job opportunity.

In plain words

Defines a dependency between objects so that whenever an object changes its state, all its dependents are notified.

Wikipedia says

The observer pattern is a software design pattern in which an object, called the subject, maintains a list of its dependents, called observers, and notifies them automatically of any state changes, usually by calling one of their methods.

Programmatic example

Translating our example from above. First of all we have job seekers that need to be notified for a job posting

class JobPost
{
    protected $title;
 
    public function __construct(string $title)
    {
        $this->title = $title;
    }
 
    public function getTitle()
    {
        return $this->title;
    }
}
 
class JobSeeker implements Observer
{
    protected $name;
 
    public function __construct(string $name)
    {
        $this->name = $name;
    }
 
    public function onJobPosted(JobPost $job)
    {
        // Do something with the job posting
        echo 'Hi ' . $this->name . '! New job posted: '. $job->getTitle();
    }
}

Then we have our job postings to which the job seekers will subscribe

class EmploymentAgency implements Observable
{
    protected $observers = [];
 
    protected function notify(JobPost $jobPosting)
    {
        foreach ($this->observers as $observer) {
            $observer->onJobPosted($jobPosting);
        }
    }
 
    public function attach(Observer $observer)
    {
        $this->observers[] = $observer;
    }
 
    public function addJob(JobPost $jobPosting)
    {
        $this->notify($jobPosting);
    }
}

Then it can be used as

// Create subscribers
$johnDoe = new JobSeeker('John Doe');
$janeDoe = new JobSeeker('Jane Doe');
 
// Create publisher and attach subscribers
$jobPostings = new EmploymentAgency();
$jobPostings->attach($johnDoe);
$jobPostings->attach($janeDoe);
 
// Add a new job and see if subscribers get notified
$jobPostings->addJob(new JobPost('Software Engineer'));
 
// Output
// Hi John Doe! New job posted: Software Engineer
// Hi Jane Doe! New job posted: Software Engineer

Visitor

Real world example

Consider someone visiting Dubai. They just need a way (i.e. visa) to enter Dubai. After arrival, they can come and visit any place in Dubai on their own without having to ask for permission or to do some leg work in order to visit any place here; just let them know of a place and they can visit it. Visitor pattern lets you do just that, it helps you add places to visit so that they can visit as much as they can without having to do any legwork.

In plain words

Visitor pattern lets you add further operations to objects without having to modify them.

Wikipedia says

In object-oriented programming and software engineering, the visitor design pattern is a way of separating an algorithm from an object structure on which it operates. A practical result of this separation is the ability to add new operations to existing object structures without modifying those structures. It is one way to follow the open/closed principle.

Programmatic example

Let's take an example of a zoo simulation where we have several different kinds of animals and we have to make them Sound. Let's translate this using visitor pattern

// Visitee
interface Animal
{
    public function accept(AnimalOperation $operation);
}
 
// Visitor
interface AnimalOperation
{
    public function visitMonkey(Monkey $monkey);
    public function visitLion(Lion $lion);
    public function visitDolphin(Dolphin $dolphin);
}

Then we have our implementations for the animals

class Monkey implements Animal
{
    public function shout()
    {
        echo 'Ooh oo aa aa!';
    }
 
    public function accept(AnimalOperation $operation)
    {
        $operation->visitMonkey($this);
    }
}
 
class Lion implements Animal
{
    public function roar()
    {
        echo 'Roaaar!';
    }
 
    public function accept(AnimalOperation $operation)
    {
        $operation->visitLion($this);
    }
}
 
class Dolphin implements Animal
{
    public function speak()
    {
        echo 'Tuut tuttu tuutt!';
    }
 
    public function accept(AnimalOperation $operation)
    {
        $operation->visitDolphin($this);
    }
}

Let's implement our visitor

class Speak implements AnimalOperation
{
    public function visitMonkey(Monkey $monkey)
    {
        $monkey->shout();
    }
 
    public function visitLion(Lion $lion)
    {
        $lion->roar();
    }
 
    public function visitDolphin(Dolphin $dolphin)
    {
        $dolphin->speak();
    }
}

And then it can be used as

$monkey = new Monkey();
$lion = new Lion();
$dolphin = new Dolphin();
 
$speak = new Speak();
 
$monkey->accept($speak);    // Ooh oo aa aa!    
$lion->accept($speak);      // Roaaar!
$dolphin->accept($speak);   // Tuut tutt tuutt!

We could have done this simply by having an inheritance hierarchy for the animals but then we would have to modify the animals whenever we would have to add new actions to animals. But now we will not have to change them. For example, let's say we are asked to add the jump behavior to the animals, we can simply add that by creating a new visitor i.e.

class Jump implements AnimalOperation
{
    public function visitMonkey(Monkey $monkey)
    {
        echo 'Jumped 20 feet high! on to the tree!';
    }
 
    public function visitLion(Lion $lion)
    {
        echo 'Jumped 7 feet! Back on the ground!';
    }
 
    public function visitDolphin(Dolphin $dolphin)
    {
        echo 'Walked on water a little and disappeared';
    }
}

And for the usage

$jump = new Jump();
 
$monkey->accept($speak);   // Ooh oo aa aa!
$monkey->accept($jump);    // Jumped 20 feet high! on to the tree!
 
$lion->accept($speak);     // Roaaar!
$lion->accept($jump);      // Jumped 7 feet! Back on the ground!
 
$dolphin->accept($speak);  // Tuut tutt tuutt!
$dolphin->accept($jump);   // Walked on water a little and disappeared

Strategy

Real world example

Consider the example of sorting, we implemented bubble sort but the data started to grow and bubble sort started getting very slow. In order to tackle this we implemented Quick sort. But now although the quick sort algorithm was doing better for large datasets, it was very slow for smaller datasets. In order to handle this we implemented a strategy where for small datasets, bubble sort will be used and for larger, quick sort.

In plain words

Strategy pattern allows you to switch the algorithm or strategy based upon the situation.

Wikipedia says

In computer programming, the strategy pattern (also known as the policy pattern) is a behavioural software design pattern that enables an algorithm's behavior to be selected at runtime.

Programmatic example

Translating our example from above. First of all we have our strategy interface and different strategy implementations

interface SortStrategy
{
    public function sort(array $dataset): array;
}
 
class BubbleSortStrategy implements SortStrategy
{
    public function sort(array $dataset): array
    {
        echo "Sorting using bubble sort";
 
        // Do sorting
        return $dataset;
    }
}
 
class QuickSortStrategy implements SortStrategy
{
    public function sort(array $dataset): array
    {
        echo "Sorting using quick sort";
 
        // Do sorting
        return $dataset;
    }
}

And then we have our client that is going to use any strategy

class Sorter
{
    protected $sorter;
 
    public function __construct(SortStrategy $sorter)
    {
        $this->sorter = $sorter;
    }
 
    public function sort(array $dataset): array
    {
        return $this->sorter->sort($dataset);
    }
}

And it can be used as

$dataset = [1, 5, 4, 3, 2, 8];
 
$sorter = new Sorter(new BubbleSortStrategy());
$sorter->sort($dataset); // Output : Sorting using bubble sort
 
$sorter = new Sorter(new QuickSortStrategy());
$sorter->sort($dataset); // Output : Sorting using quick sort

State

Real world example

Imagine you are using some drawing application, you choose the paint brush to draw. Now the brush changes its behavior based on the selected color i.e. if you have chosen red color it will draw in red, if blue then it will be in blue etc.

In plain words

It lets you change the behavior of a class when the state changes.

Wikipedia says

The state pattern is a behavioral software design pattern that implements a state machine in an object-oriented way. With the state pattern, a state machine is implemented by implementing each individual state as a derived class of the state pattern interface, and implementing state transitions by invoking methods defined by the pattern's superclass.The state pattern can be interpreted as a strategy pattern which is able to switch the current strategy through invocations of methods defined in the pattern's interface.

Programmatic example

Let's take an example of text editor, it lets you change the state of text that is typed i.e. if you have selected bold, it starts writing in bold, if italic then in italics etc.

First of all we have our state interface and some state implementations

interface WritingState
{
    public function write(string $words);
}
 
class UpperCase implements WritingState
{
    public function write(string $words)
    {
        echo strtoupper($words);
    }
}
 
class LowerCase implements WritingState
{
    public function write(string $words)
    {
        echo strtolower($words);
    }
}
 
class DefaultText implements WritingState
{
    public function write(string $words)
    {
        echo $words;
    }
}

Then we have our editor

class TextEditor
{
    protected $state;
 
    public function __construct(WritingState $state)
    {
        $this->state = $state;
    }
 
    public function setState(WritingState $state)
    {
        $this->state = $state;
    }
 
    public function type(string $words)
    {
        $this->state->write($words);
    }
}

And then it can be used as

$editor = new TextEditor(new DefaultText());
 
$editor->type('First line');
 
$editor->setState(new UpperCase());
 
$editor->type('Second line');
$editor->type('Third line');
 
$editor->setState(new LowerCase());
 
$editor->type('Fourth line');
$editor->type('Fifth line');
 
// Output:
// First line
// SECOND LINE
// THIRD LINE
// fourth line
// fifth line

Template Method

Real world example

Suppose we are getting some house built. The steps for building might look like
Prepare the base of house
Build the walls
Add roof
Add other floors

The order of these steps could never be changed i.e. you can't build the roof before building the walls etc but each of the steps could be modified for example walls can be made of wood or polyester or stone.

In plain words

Template method defines the skeleton of how a certain algorithm could be performed, but defers the implementation of those steps to the children classes.

Wikipedia says

In software engineering, the template method pattern is a behavioral design pattern that defines the program skeleton of an algorithm in an operation, deferring some steps to subclasses. It lets one redefine certain steps of an algorithm without changing the algorithm's structure.

Programmatic Example

Imagine we have a build tool that helps us test, lint, build, generate build reports (i.e. code coverage reports, linting report etc) and deploy our app on the test server.

First of all we have our base class that specifies the skeleton for the build algorithm

abstract class Builder
{
 
    // Template method
    final public function build()
    {
        $this->test();
        $this->lint();
        $this->assemble();
        $this->deploy();
    }
 
    abstract public function test();
    abstract public function lint();
    abstract public function assemble();
    abstract public function deploy();
}

Then we can have our implementations

class AndroidBuilder extends Builder
{
    public function test()
    {
        echo 'Running android tests';
    }
 
    public function lint()
    {
        echo 'Linting the android code';
    }
 
    public function assemble()
    {
        echo 'Assembling the android build';
    }
 
    public function deploy()
    {
        echo 'Deploying android build to server';
    }
}
 
class IosBuilder extends Builder
{
    public function test()
    {
        echo 'Running ios tests';
    }
 
    public function lint()
    {
        echo 'Linting the ios code';
    }
 
    public function assemble()
    {
        echo 'Assembling the ios build';
    }
 
    public function deploy()
    {
        echo 'Deploying ios build to server';
    }
}

And then it can be used as

$androidBuilder = new AndroidBuilder();
$androidBuilder->build();
 
// Output:
// Running android tests
// Linting the android code
// Assembling the android build
// Deploying android build to server
 
$iosBuilder = new IosBuilder();
$iosBuilder->build();
 
// Output:
// Running ios tests
// Linting the ios code
// Assembling the ios build
// Deploying ios build to server

Wrap Up Folks

And that about wraps it up. I will continue to improve this, so you might want to watch/star this repository to revisit. Also, I have plans on writing the same about the architectural patterns, stay tuned for it.