Команда (шаблон проектирования)

Команда
Command
Тип	поведенческий
Назначение	для обработки команды в виде объекта
Родственные шаблоны	Компоновщик, Хранитель, Прототип, Одиночка
Описан в Design Patterns	Да

Команда (англ. Command) — поведенческий шаблон проектирования, используемый при объектно-ориентированном программировании, представляющий действие. Объект команды заключает в себе само действие и его параметры.

Создание структуры, в которой класс-отправитель и класс-получатель не зависят друг от друга напрямую. Организация обратного вызова к классу, который включает в себя класс-отправитель.

В объектно-ориентированном программировании шаблон проектирования Команда является поведенческим шаблоном, в котором объект используется для инкапсуляции всей информации, необходимой для выполнения действия или вызова события в более позднее время. Эта информация включает в себя имя метода, объект, который является владельцем метода и значения параметров метода.

Четыре термина всегда связаны с шаблоном Команда: команды (command), приёмник команд (receiver), вызывающий команды (invoker) и клиент (client). Объект Command знает о приёмнике и вызывает метод приёмника. Значения параметров приёмника сохраняются в команде. Вызывающий объект (invoker) знает, как выполнить команду и, возможно, делает учёт и запись выполненных команд. Вызывающий объект (invoker) ничего не знает о конкретной команде, он знает только об интерфейсе. Оба объекта (вызывающий объект и несколько объектов команд) принадлежат объекту клиента (client). Клиент решает, какие команды выполнить и когда. Чтобы выполнить команду он передает объект команды вызывающему объекту (invoker).

Использование командных объектов упрощает построение общих компонентов, которые необходимо делегировать или выполнять вызовы методов в любое время без необходимости знать методы класса или параметров метода. Использование вызывающего объекта (invoker) позволяет вести учёт выполненных команд без необходимости знать клиенту об этой модели учёта (такой учёт может пригодиться, например, для реализации отмены и повтора команд).

Шаблон Команда может быть полезен в следующих случаях.

Кнопки пользовательского интерфейса и пункты меню

В Swing и Borland Delphi Action (действие) является объектом команды. В дополнение к способности выполнить нужную команду, Action может иметь связанную с ним иконку, сочетание клавиш, текст всплывающей подсказки и так далее. Кнопка на панели инструментов или пункт меню могут быть полностью инициализированы с использованием только объекта Action.

Запись макросов

Если все действия пользователя представлены в виде объектов команды, программа может записать последовательность действий, просто сохраняя список командных объектов в том порядке, в котором они выполняются. Затем она может «воспроизвести» одни и те же действия, выполняя те же объекты команд в той же последовательности.

Многоуровневая отмена операций (Undo)

Если все действия пользователя в программе реализованы в виде командных объектов, программа может сохранить стек последних выполненных команд. Когда пользователь хочет отменить команду, программа просто выталкивает последний объект команды и выполняет его метод undo().

Сети

Можно отправить объекты команд по сети для выполнения на другой машине, например действие игрока в компьютерной игре.

Индикаторы выполнения

Предположим, что программа имеет последовательность команд, которые она выполняет по порядку. Если каждый объект команды имеет метод getEstimatedDuration() (получить оценочную длительность), программа может легко оценить общую продолжительность процесса. Она может показать индикатор выполнения, который отражает, насколько близка программа к завершению всех задач.

Пулы потоков

Типичный класс пула потоков общего назначения может иметь метод addTask(), который добавляет рабочий элемент к внутренней очереди заданий ожидающих своего выполнения. Он поддерживает пул потоков, которые выполняют команды из очереди. Элементы в очереди являются объектами команд. Как правило, эти объекты реализуют общий интерфейс, такой как java.lang.Runnable, что позволяет пулу потоков запустить команды на выполнение, даже если он сам был написан без каких-либо знаний о конкретных задачах, для которых он будет использоваться.

Транзакции

Аналогично операции «отмена» система управления базами данных (СУБД) или установщик программного обеспечения может хранить список операций, которые были или будут выполнены. Если одна из них закончится неудачей, то все остальные могут быть отменены или быть отброшены (обычно называется откат). Например, если две связанные между собой таблицы базы данных должны быть обновлены, а второе обновление терпит неудачу, то система может откатить транзакцию, чтобы первая таблица не содержала недопустимую ссылку.

Мастера

Часто мастер (мастер установки или любой другой) представляет несколько страниц конфигурации для одного действия, которое происходит только тогда, когда пользователь нажимает на кнопку «Готово» на последней странице. В этих случаях, естественный способ отделить код пользовательского интерфейса от кода приложения является реализация мастера с помощью объекта команд. Объект команда создается при первом отображении мастера. Каждая страница мастера сохраняет свои изменения в объекте команды, поэтому объект заполняется по мере перехода пользователя. Кнопка «Готово» просто запускает метод execute() на выполнение.

#include <iostream> #include <vector> #include <string> using namespace std;  class Document {    vector<string> data;  public:    Document()    {        data.reserve(100); // at least for 100 lines    }     void Insert( int line, const string & str )    {       if ( line <= data.size() )          data.insert( data.begin() + line, str );        else          cout << "Error!" << endl;     }     void Remove( int line )    {       if( !( line>data.size() ) )          data.erase( data.begin() + line );        else          cout << "Error!" << endl;     }     string & operator [] ( int x )    {       return data[x];     }     void Show()    {       for( int i = 0; i<data.size(); ++i )       {          cout << i + 1 << ". " << data[i] << endl;        }    } };  class Command { protected:    Document * doc;  public:    virtual ~Command() {}    virtual void Execute() = 0;     virtual void unExecute() = 0;     void setDocument( Document * _doc )    {       doc = _doc;     } };  class InsertCommand : public Command {    int line;     string str;  public:    InsertCommand( int _line, const string & _str ): line( _line ), str( _str ) {}     void Execute()    {       doc->Insert( line, str );     }     void unExecute()    {       doc->Remove( line );     } };  class Invoker {    vector<Command*> DoneCommands;     Document doc;     Command* command;  public:    void Insert( int line, string str )    {       command = new InsertCommand( line, str );        command->setDocument( &doc );        command->Execute();        DoneCommands.push_back( command );     }     void Undo()    {       if( DoneCommands.size() == 0 )       {          cout << "There is nothing to undo!" << endl;        }       else       {          command = DoneCommands.back();           DoneCommands.pop_back();           command->unExecute();          // Don't forget to delete command!!!          delete command;       }    }     void Show()         {       doc.Show();     } };  int main() {    char s = '1';     int line, line_b;     string str;     Invoker inv;     while( s!= 'e' )    {       cout << "What to do: \n1.Add a line\n2.Undo last command" << endl;        cin >> s;        switch( s )       {       case '1':          cout << "What line to insert: ";           cin >> line;           --line;           cout << "What to insert: ";           cin >> str;           inv.Insert( line, str );           break;        case '2':          inv.Undo();           break;        }       cout << "$$$DOCUMENT$$$" << endl;        inv.Show();        cout << "$$$DOCUMENT$$$" << endl;     } } 

from abc import ABCMeta, abstractmethod  class Troop: 	""" 	Receiver - объект военного отряда 	"""  	def move(self, direction: str) -> None: 		""" 		Начать движение в определенном направлении 		""" 		print('Отряд начал движение {}'.format(direction))  	def stop(self) -> None: 		""" 		Остановиться 		""" 		print('Отряд остановился')  class Command(metaclass=ABCMeta): 	""" 	Базовый класс для всех команд 	"""  	@abstractmethod 	def execute(self) -> None: 		""" 		Приступить к выполнению команды 		""" 		pass  	@abstractmethod 	def unexecute(self) -> None: 		""" 		Отменить выполнение команды 		""" 		pass	  class AttackCommand(Command): 	""" 	Команда для выполнения атаки 	"""  	def __init__(self, troop: Troop) -> None: 		""" 		Constructor.  		:param troop: отряд, с которым ассоциируется команда 		""" 		self.troop = troop  	def execute(self) -> None: 		self.troop.move('вперед')  	def unexecute(self) -> None: 		self.troop.stop()  class RetreatCommand(Command): 	""" 	Команда для выполнения отступления 	"""  	def __init__(self, troop: Troop) -> None: 		""" 		Constructor. 		 		:param troop: отряд, с которым ассоциируется команда 		""" 		self.troop = troop  	def execute(self) -> None: 		self.troop.move('назад')  	def unexecute(self) -> None: 		self.troop.stop()  class TroopInterface: 	""" 	Invoker - интерфейс, через который можно отдать команды определенному отряду 	"""  	def __init__(self, attack: AttackCommand, retreat: RetreatCommand) -> None: 		""" 		Constructor.  		:param attack: команда для выполнения атаки 		:param retreat: команда для выполнения отступления 		""" 		self.attack_command = attack 		self.retreat_command = retreat 		self.current_command = None		# команда, выполняющаяся в данный момент  	def attack(self) -> None: 		self.current_command = self.attack_command 		self.attack_command.execute()  	def retreat(self) -> None: 		self.current_command = self.retreat_command 		self.retreat_command.execute()  	def stop(self) -> None: 		if self.current_command: 			self.current_command.unexecute() 			self.current_command = None 		else: 			print('Отряд не может остановиться, так как не двигается')  if __name__ == '__main__': 	troop = Troop() 	interface = TroopInterface(AttackCommand(troop), RetreatCommand(troop)) 	interface.attack() 	interface.stop() 	interface.retreat() 	interface.stop() 

<?php   /**   * Абстрактый класс "команды"   * @abstract   */     abstract class Command   {     public abstract function Execute();     public abstract function UnExecute();   }    /**   * Класс конкретной "команды"   */    class CalculatorCommand extends Command   {    /**     * Текущая операция команды     *     * @var string     */     public $operator;     /**     * Текущий операнд     *     * @var mixed     */      public $operand;     /**     * Класс, для которого предназначена команда     *     * @var object of class Calculator     */      public $calculator;      /**     * Конструктор     *      * @param object $calculator     * @param string $operator     * @param mixed $operand      */     public function __construct($calculator, $operator, $operand)     {       $this->calculator = $calculator;       $this->operator = $operator;       $this->operand = $operand;     }      /**     * Переопределенная функция parent::Execute()     */      public function Execute()     {       $this->calculator->Operation($this->operator, $this->operand);     }      /**     * Переопределенная функция parent::UnExecute()     */      public function UnExecute()     {       $this->calculator->Operation($this->Undo($this->operator), $this->operand);     }      /**     * Какое действие нужно отменить?     *     * @private     * @param string $operator     * @return string     */     private function Undo($operator)     {       //каждому произведенному действию найти обратное       switch($operator)       {         case '+': $undo = '-'; break;         case '-': $undo = '+'; break;         case '*': $undo = '/'; break;         case '/': $undo = '*'; break;         default : $undo = ' '; break;       }       return $undo;     }   }    /**   * Класс получатель и исполнитель "команд"   */   class Calculator   {    /**     * Текущий результат выполнения команд     *     * @private     * @var int     */      private $curr = 0;       public function Operation($operator,$operand)     {       //выбрать оператора для вычисления результата       switch($operator)       {         case '+': $this->curr+=$operand; break;         case '-': $this->curr-=$operand; break;         case '*': $this->curr*=$operand; break;         case '/': $this->curr/=$operand; break;       }       print("Текущий результат = $this->curr (после выполнения $operator c $operand)");     }   }    /**   * Класс, вызывающий команды   */   class User    {    /**     * Этот класс будет получать команды на исполнение     *     * @private     * @var object of class Calculator     */     private $calculator;     /**     * Массив операций     *     * @private     * @var array     */      private $commands = array();     /**     * Текущая команда в массиве операций     *     * @private     * @var int     */      private $current = 0;  	     public function __construct()     {         //создать экземпляр класса, который будет исполнять команды     	$this->calculator = new Calculator();     }         /**     * Функция возврата отмененных команд     *     * @param int $levels количество возвращаемых операций     */     public function Redo($levels)     {       print("\n---- Повторить $levels операций ");         // Делаем возврат операций       for ($i = 0; $i < $levels; $i++)         if ($this->current < count($this->commands) - 1)           $this->commands[$this->current++]->Execute();     }      /**     * Функция отмены команд     *     * @param int $levels количество отменяемых операций     */     public function Undo($levels)     {       print("\n---- Отменить $levels операций ");         // Делаем отмену операций       for ($i = 0; $i < $levels; $i++)         if ($this->current > 0)           $this->commands[--$this->current]->UnExecute();     }      /**     * Функция выполнения команд     *     * @param string $operator     * @param mixed $operand     */     public function Compute($operator, $operand)     {       // Создаем команду операции и выполняем её       $command = new CalculatorCommand($this->calculator, $operator, $operand);       $command->Execute();         // Добавляем операцию к массиву операций и увеличиваем счетчик текущей операции       $this->commands[]=$command;       $this->current++;     }   }        $user = new User();        // Произвольные команды       $user->Compute('+', 100);       $user->Compute('-', 50);       $user->Compute('*', 10);       $user->Compute('/', 2);         // Отменяем 4 команды       $user->Undo(4);         // Вернём 3 отменённые команды.       $user->Redo(3); 

import java.util.HashMap;  /** The Command interface */ interface Command {     void execute(); }  /** The Invoker class */ class Switch {     private final HashMap<String, Command> commandMap = new HashMap<>();          public void register(String commandName, Command command) {         commandMap.put(commandName, command);     }          public void execute(String commandName) {         Command command = commandMap.get(commandName);         if (command == null) {             throw new IllegalStateException("no command registered for " + commandName);         }         command.execute();     } }  /** The Receiver class */ class Light {     public void turnOn() {         System.out.println("The light is on");     }      public void turnOff() {         System.out.println("The light is off");     } }  /** The Command for turning on the light - ConcreteCommand #1 */ class SwitchOnCommand implements Command {     private final Light light;      public SwitchOnCommand(Light light) {         this.light = light;     }      @Override // Command     public void execute() {         light.turnOn();     } }  /** The Command for turning off the light - ConcreteCommand #2 */ class SwitchOffCommand implements Command {     private final Light light;      public SwitchOffCommand(Light light) {         this.light = light;     }      @Override // Command     public void execute() {         light.turnOff();     } }  public class CommandDemo {     public static void main(final String[] arguments) {         Light lamp = new Light();          Command switchOn = new SwitchOnCommand(lamp);         Command switchOff = new SwitchOffCommand(lamp);          Switch mySwitch = new Switch();         mySwitch.register("on", switchOn);         mySwitch.register("off", switchOff);          mySwitch.execute("on");         mySwitch.execute("off");     } } 

public class CommandDemo {     public static void main(final String[] arguments) {         Light lamp = new Light();          Command switchOn = lamp::turnOn;         Command switchOff = lamp::turnOff;          Switch mySwitch = new Switch();         mySwitch.register("on", switchOn);         mySwitch.register("off", switchOff);          mySwitch.execute("on");         mySwitch.execute("off");     } } 

protocol Command {     func execute() }  // Invoker class Switch {          var status: String?     var action: Command?          func register(_ command: Command) {         self.action = command     }          func execute() {         self.action?.execute()     }      }  // Receiver class Light {          func turnOn() {         print("The light is ON")     }          func turnOff() {         print("The light is OFF")     }      }  class SwitchOnCommand: Command {          private var light: Light          init(_ light: Light) {         self.light = light     }          func execute() {         light.turnOn()     }      }  class SwitchOffCommand: Command {          private var light: Light          init(_ light: Light) {         self.light = light     }          func execute() {         light.turnOff()     }      }  // USE let invoker = Switch() let reciver = Light()          let commaneNO = SwitchOnCommand(Light()) invoker.register(commaneNO) invoker.execute()  let commandOff = SwitchOffCommand(Light()) invoker.register(commaneNO) invoker.execute()

module EngineCommands     # Abstract class 'Command'     class Command         def execute         end     end      # Receiver     class Engine         attr_reader :state          def initialize rpm             @state, @rpm = false, rpm if rpm.is_a? Integer         end          def turnOn; @state = true; end         def turnOff; @state = false; end     end      # ConcreteCommand1     class CommandTurnOn < Command         def initialize engine             @engine = engine if engine.is_a? Engine         end          def execute             @engine.turnOn         end     end      # ConcreteCommand2     class CommandTurnOff < Command         def initialize engine             @engine = engine if engine.is_a? Engine         end          def execute             @engine.turnOff         end     end      # Invoker     class Invoker         def initialize             @commands = Hash.new         end          def registerCommand commandName, command             @commands[commandName] = command if command.is_a? Command and @commands[commandName].is_a? NilClass         end          def executeCommand commandName             @command = @commands[commandName]             unless @command.is_a? NilClass                 @command.execute             else                 raise TypeError.new             end         end     end end  # Client module Client     include EngineCommands      invoker = Invoker.new      engine = Engine.new(250)      commandTurnOn = CommandTurnOn.new(engine)     commandTurnOff = CommandTurnOff.new(engine)      invoker.registerCommand "turnOn", commandTurnOn     invoker.registerCommand "turnOff", commandTurnOff      puts "\t   Engine State before using command's: #{ engine.state }                                " # => Engine State before using command's: false     puts "\t   Engine State after using command 'turnOn': #{ invoker.executeCommand "turnOn" }       " # => Engine State after using command 'turnOn': true     puts "\t   Engine State after use command 'turnOff': #{ invoker.executeCommand "turnOff"  }      " # => Engine State after use command 'turnOff': false end 

• Паттерн проектирования Command (Команда) — назначение, описание, реализация на C++, достоинства и недостатки

В статье не хватает ссылок на источники (см. рекомендации по поиску). Информация должна быть проверяема, иначе она может быть удалена. Вы можете отредактировать статью, добавив ссылки на авторитетные источники в виде сносок. (20 октября 2024)