PHP Diseño modo de comando Patrones

PHP Diseño modo de comando Patrones

El modo de comando, también conocido como modo de acción o transacción, se ejemplificará un restaurante con una gran cantidad de materiales de enseñanza. A medida que nuestros pedidos de los clientes son emitidos por el camarero es el destinatario de este comando, el menú es el comando real, mientras que el chef es el ejecutor de este comando. Así pues, qué este modelo de resolver? Cuando se quiere cambiar de rumbo cuando sea necesario y al igual que el camarero dijo que transmitiría al chef, es decir, hemos conseguido disociar los clientes y cocineros. El desacoplamiento es la persona que llama y ejecutor. Por supuesto, una gran cantidad de patrones de diseño para hacer esto, pero el modo de comando puede hacer es hacer un receptor de órdenes que alcanzan varios comandos (órdenes camarero, conseguir bebidas, sirviendo), o para transmitir un comando para lograr más (cocinar platos calientes, platos fríos cocinero, alimento básico principal). Este es el modo de comando para jugar un lugar real! !

GOF diagrama de clases y las explicaciones

GoF define: encapsular una solicitud de un objeto, con lo que sus clientes utilizando diferentes parametrización de la solicitud; la cola de peticiones o solicitudes de registro, y el apoyo operación reversible

La figura clase GoF

la implementación del código

class Invoker
{
    public $command;
    
    public function __construct($command)
    {
        $this->command = $command;
    }

    public function exec()
    {
        $this->command->execute();
    }
}

En primer lugar, definimos un destinatario de un comando o un comando del solicitante es más apropiado. Inglés definición del diagrama de clases de esta palabra es "orando persona." Que es, por sus operaciones e iniciar comandos.

abstract class Command
{
    protected $receiver;

    public function __construct(Receiver $receiver)
    {
        $this->receiver = $receiver;
    }

    abstract public function execute();
}

class ConcreteCommand extends Command
{
    public function execute()
    {
        $this->receiver->action();
    }
}

El siguiente es el comando, que es nuestro "menú". Este papel de comandos es definir quién es el verdadero ejecutor sí.

class Receiver
{
    public $name;

    public function __construct($name)
    {
        $this->name = $name;
    }

    public function action()
    {
        echo $this->name . '命令执行了！', PHP_EOL;
    }
}

Las tomas de control, es decir, actores, personas reales para ejecutar el comando.

// 准备执行者
$receiverA = new Receiver('A');

// 准备命令
$command = new ConcreteCommand($receiverA);

// 请求者
$invoker = new Invoker($command);
$invoker->exec();

Llamar al cliente, tenemos que contactar un buen desempeño es escoger un buen cocinero del restaurante (receptor), que está listo para menú de comandos (Command), y finalmente al camarero (invocador).

• De hecho, los ejemplos de este hotel ha sido muy claro, realmente perfecto para analizar el modo de comando
• Dicho esto, puede ser un buen pedidos múltiples o para varios cocineros que? No se preocupe, el código siguiente para ayudar a resolver este problema

código completo: https://github.com/zhangyue0503/designpatterns-php/blob/master/09.command/source/command.php

<?php

class Invoker
{
    private $command = [];

    public function setCommand(Command $command)
    {
        $this->command[] = $command;
    }

    public function exec()
    {
        if(count($this->command) > 0){
            foreach ($this->command as $command) {
                $command->execute();
            }
        }
    }

    public function undo()
    {
        if(count($this->command) > 0){
            foreach ($this->command as $command) {
                $command->undo();
            }
        }
    }
}

abstract class Command
{
    protected $receiver;
    protected $state;
    protected $name;

    public function __construct(Receiver $receiver, $name)
    {
        $this->receiver = $receiver;
        $this->name = $name;
    }

    abstract public function execute();
}

class ConcreteCommand extends Command
{
    public function execute()
    {
        if (!$this->state || $this->state == 2) {
            $this->receiver->action();
            $this->state = 1;
        } else {
            echo $this->name . '命令正在执行，无法再次执行了！', PHP_EOL;
        }

    }
    
    public function undo()
    {
        if ($this->state == 1) {
            $this->receiver->undo();
            $this->state = 2;
        } else {
            echo $this->name . '命令未执行，无法撤销了！', PHP_EOL;
        }
    }
}

class Receiver
{
    public $name;
    public function __construct($name)
    {
        $this->name = $name;
    }
    public function action()
    {
        echo $this->name . '命令执行了！', PHP_EOL;
    }
    public function undo()
    {
        echo $this->name . '命令撤销了！', PHP_EOL;
    }
}

// 准备执行者
$receiverA = new Receiver('A');
$receiverB = new Receiver('B');
$receiverC = new Receiver('C');

// 准备命令
$commandOne = new ConcreteCommand($receiverA, 'A');
$commandTwo = new ConcreteCommand($receiverA, 'B');
$commandThree = new ConcreteCommand($receiverA, 'C');

// 请求者
$invoker = new Invoker();
$invoker->setCommand($commandOne);
$invoker->setCommand($commandTwo);
$invoker->setCommand($commandThree);
$invoker->exec();
$invoker->undo();

// 新加一个单独的执行者，只执行一个命令
$invokerA = new Invoker();
$invokerA->setCommand($commandOne);
$invokerA->exec();

// 命令A已经执行了，再次执行全部的命令执行者，A命令的state判断无法生效
$invoker->exec();

• Esta vez se resuelve una serie de órdenes de una sola vez, una serie de problemas cocineros, así como la manera de resolver si la orden equivocado, y los problemas REVOKE
• Se puede ver, el funcionamiento en modo de comando se llama un objeto y sabe cómo lograr este objeto implementa desacoplamiento
• Este multi-comando para lograr más de ejecutor de, algo así como una combinación de modos implementado
• En este caso, añadir nuevos comandos que no afectarán el ejecutivo, que no afectará a los clientes. Cuando un nuevo cliente necesita un nuevo comando, sólo tiene que añadir el mando y la lata solicitante. Incluso con la demanda modificada, sino también para modificar el solicitante.
• laravel marco de un planificador de eventos, además del patrón de observador, también es evidente que se parece un modo de comando

Nuestra fábrica de teléfonos móviles y restaurante, de hecho, no es diferente, cuando tenemos que hacer que las fundiciones de teléfono, sino también la primera orden, esta orden puede ser visto como un comando. En este orden, se requerirá que usted necesita para utilizar las partes, qué tipo de CPU, qué tipo de memoria, qué tipo de sistema de pre-instalados. A continuación, los trabajadores fab para la producción de acuerdo con esta orden. En el proceso, no importa es un trabajador o un grupo de trabajadores para ejecutar la orden, sólo quiero esta orden al pueblo y el trasero en él, y luego simplemente esperar a que el teléfono aceptación producido un poco! !

código completo: https://github.com/zhangyue0503/designpatterns-php/blob/master/09.command/source/command-up.php

Ejemplos

la función de SMS ha vuelto, hemos encontrado que, además del modo de fábrica, miradas modo comando como también es una manera buena para lograr Oh. En este caso, estamos todavía algunos que el uso de SMS y empuje la interfaz no hablaba mucho, lo usamos para poner en práctica un modo de comando. Por supuesto, los amigos interesados ​​pueden realizar nuestra función ha de recuperación de mensajes, piensan acerca de la cancelación comando anterior es la forma de lograr.

La figura Clase SMS

El código fuente completo: https://github.com/zhangyue0503/designpatterns-php/blob/master/09.command/source/command-message.php

<?php

class SendMsg
{
    private $command = [];

    public function setCommand(Command $command)
    {
        $this->command[] = $command;
    }
    
    public function send($msg)
    {
        foreach ($this->command as $command) {
            $command->execute($msg);
        }
    }
}

abstract class Command
{
    protected $receiver = [];

    public function setReceiver($receiver)
    {
        $this->receiver[] = $receiver;
    }

    abstract public function execute($msg);
}

class SendAliYun extends Command
{
    public function execute($msg)
    {
        foreach ($this->receiver as $receiver) {
            $receiver->action($msg);
        }
    }
}

class SendJiGuang extends Command
{
    public function execute($msg)
    {
        foreach ($this->receiver as $receiver) {
            $receiver->action($msg);
        }
    }
}

class SendAliYunMsg
{
    public function action($msg)
    {
        echo '【阿X云短信】发送：' . $msg, PHP_EOL;
    }
}

class SendAliYunPush
{
    public function action($msg)
    {
        echo '【阿X云推送】发送：' . $msg, PHP_EOL;
    }
}

class SendJiGuangMsg
{
    public function action($msg)
    {
        echo '【极X短信】发送：' . $msg, PHP_EOL;
    }
}

class SendJiGuangPush
{
    public function action($msg)
    {
        echo '【极X推送】发送：' . $msg, PHP_EOL;
    }
}

$aliMsg = new SendAliYunMsg();
$aliPush = new SendAliYunPush();
$jgMsg = new SendJiGuangMsg();
$jgPush = new SendJiGuangPush();

$sendAliYun = new SendAliYun();
$sendAliYun->setReceiver($aliMsg);
$sendAliYun->setReceiver($aliPush);

$sendJiGuang = new SendJiGuang();
$sendAliYun->setReceiver($jgMsg);
$sendAliYun->setReceiver($jgPush);

$sendMsg = new SendMsg();
$sendMsg->setCommand($sendAliYun);
$sendMsg->setCommand($sendJiGuang);

$sendMsg->send('这次要搞个大活动，快来注册吧！！');

explicación

• En este ejemplo, el comando todavía es un multi-modo multi-intérprete
• En este ejemplo se contrastará con la fábrica abstracta, elija un acto de la misma función utilizando diferentes patrones de diseño para lograr, pero tenga en cuenta que la fábrica más abstracto es obtener resultados de objetos un objeto, mientras que el modo de comando es
• Podemos ver el modo de comando es ideal para la formación de una cola de comandos, multi-comando de modo que se pueden ejecutar comandos uno por uno abajo
• Se permite a la parte receptora para decidir si la solicitud de veto, receptor como ejecutores tienen más derecho a hablar