3.2. Command

3.2.1. Purpose

To encapsulate invocation and decoupling.

We have an Invoker and a Receiver. This pattern uses a “Command” todelegate the method call against the Receiver and presents the samemethod “execute”. Therefore, the Invoker just knows to call “execute” toprocess the Command of the client. The Receiver is decoupled from theInvoker.

The second aspect of this pattern is the undo(), which undoes the methodexecute(). Command can also be aggregated to combine more complexcommands with minimum copy-paste and relying on composition overinheritance.

3.2.2. Examples

• A text editor : all events are Command which can be undone, stackedand saved.
• Symfony2: SF2 Commands that can be run from the CLI are built withjust the Command pattern in mind
• big CLI tools use subcommands to distribute various tasks and packthem in “modules”, each of these can be implemented with the Commandpattern (e.g. vagrant)

3.2.3. UML Diagram

3.2.4. Code

You can also find this code on GitHub

CommandInterface.php

<?php
 
namespace DesignPatterns\Behavioral\Command;
 
interface CommandInterface
{
    /**
     * this is the most important method in the Command pattern,
     * The Receiver goes in the constructor.
     */
    public function execute();
}

HelloCommand.php

<?php
 
namespace DesignPatterns\Behavioral\Command;
 
/**
 * This concrete command calls "print" on the Receiver, but an external
 * invoker just knows that it can call "execute"
 */
class HelloCommand implements CommandInterface
{
    /**
     * @var Receiver
     */
    private $output;
 
    /**
     * Each concrete command is built with different receivers.
     * There can be one, many or completely no receivers, but there can be other commands in the parameters
     *
     * @param Receiver $console
     */
    public function __construct(Receiver $console)
    {
        $this->output = $console;
    }
 
    /**
     * execute and output "Hello World".
     */
    public function execute()
    {
        // sometimes, there is no receiver and this is the command which does all the work
        $this->output->write('Hello World');
    }
}

Receiver.php

<?php
 
namespace DesignPatterns\Behavioral\Command;
 
/**
 * Receiver is specific service with its own contract and can be only concrete.
 */
class Receiver
{
    /**
     * @var bool
     */
    private $enableDate = false;
 
    /**
     * @var string[]
     */
    private $output = [];
 
    /**
     * @param string $str
     */
    public function write(string $str)
    {
        if ($this->enableDate) {
            $str .= ' ['.date('Y-m-d').']';
        }
 
        $this->output[] = $str;
    }
 
    public function getOutput(): string
    {
        return join("\n", $this->output);
    }
 
    /**
     * Enable receiver to display message date
     */
    public function enableDate()
    {
        $this->enableDate = true;
    }
 
    /**
     * Disable receiver to display message date
     */
    public function disableDate()
    {
        $this->enableDate = false;
    }
}

Invoker.php

<?php
 
namespace DesignPatterns\Behavioral\Command;
 
/**
 * Invoker is using the command given to it.
 * Example : an Application in SF2.
 */
class Invoker
{
    /**
     * @var CommandInterface
     */
    private $command;
 
    /**
     * in the invoker we find this kind of method for subscribing the command
     * There can be also a stack, a list, a fixed set ...
     *
     * @param CommandInterface $cmd
     */
    public function setCommand(CommandInterface $cmd)
    {
        $this->command = $cmd;
    }
 
    /**
     * executes the command; the invoker is the same whatever is the command
     */
    public function run()
    {
        $this->command->execute();
    }
}

3.2.5. Test

Tests/CommandTest.php

<?php
 
namespace DesignPatterns\Behavioral\Command\Tests;
 
use DesignPatterns\Behavioral\Command\HelloCommand;
use DesignPatterns\Behavioral\Command\Invoker;
use DesignPatterns\Behavioral\Command\Receiver;
use PHPUnit\Framework\TestCase;
 
class CommandTest extends TestCase
{
    public function testInvocation()
    {
        $invoker = new Invoker();
        $receiver = new Receiver();
 
        $invoker->setCommand(new HelloCommand($receiver));
        $invoker->run();
        $this->assertEquals('Hello World', $receiver->getOutput());
    }
}