设计模式：命令模式（Command）

UestcXiye

于 2024-05-23 00:15:00 发布

阅读量782

点赞数 29

分类专栏：设计模式文章标签：设计模式命令模式

本文链接：https://blog.csdn.net/ProgramNovice/article/details/138792893

版权

设计模式专栏收录该内容

19 篇文章 0 订阅

订阅专栏

设计模式：命令模式（Command）

设计模式：命令模式（Command）

设计模式：命令模式（Command）

命令模式（Command）属于行为型模式（Behavioral Pattern）的一种。

行为型模式（Behavioral Pattern）是对在不同的对象之间划分责任和算法的抽象化。

行为型模式不仅仅关注类和对象的结构，而且重点关注它们之间的相互作用。

通过行为型模式，可以更加清晰地划分类与对象的职责，并研究系统在运行时实例对象之间的交互。在系统运行时，对象并不是孤立的，它们可以通过相互通信与协作完成某些复杂功能，一个对象在运行时也将影响到其他对象的运行。

行为型模式分为类行为型模式和对象行为型模式两种：

类行为型模式：类的行为型模式使用继承关系在几个类之间分配行为，类行为型模式主要通过多态等方式来分配父类与子类的职责。
对象行为型模式：对象的行为型模式则使用对象的聚合关联关系来分配行为，对象行为型模式主要是通过对象关联等方式来分配两个或多个类的职责。根据“合成复用原则”，系统中要尽量使用关联关系来取代继承关系，因此大部分行为型设计模式都属于对象行为型设计模式。

模式动机

在软件设计中，我们经常需要向某些对象发送请求，但是并不知道请求的接收者是谁，也不知道被请求的操作是哪个，我们只需在程序运行时指定具体的请求接收者即可。此时，可以使用命令模式来进行设计，使得请求发送者与请求接收者消除彼此之间的耦合，让对象之间的调用关系更加灵活。

命令模式可以对发送者和接收者完全解耦，发送者与接收者之间没有直接引用关系，发送请求的对象只需要知道如何发送请求，而不必知道如何完成请求。这就是命令模式的模式动机。

模式定义

命令模式（Command）别名为动作（Action）模式或事务（Transaction）模式，属于行为型模式。

命令模式（Command）将一个请求封装为一个对象，从而使我们可用不同的请求对客户进行参数化；对请求排队或者记录请求日志，以及支持可撤销的操作。

模式结构

命令模式（Command）包含如下角色：

抽象命令类（Command）：一个抽象接口，定义了执行操作的统一方法。具体的命令类会实现这个接口，并提供执行相应操作的具体逻辑。
具体命令类（Concrete Command）：实现了命令接口，负责执行具体的操作。它拥有接收者对象，并通过调用接收者的功能来完成命令要执行的操作。
接收者（Receiver）：执行实际命令的类，命令对象会调用接收者的方法来执行请求。
调用者/请求者（Invoker）：发送命令的对象，它包含了一个或多个命令对象并能触发命令的执行。调用者并不直接处理请求，而是通过将请求传递给命令对象来实现。
客户端（Client）：创建具体命令对象并设置其接收者，将命令对象交给调用者执行。

顺序：调用者–>命令–>接收者。

在这里插入图片描述

时序图

在这里插入图片描述

模式实现

调用者：

#ifndef _INVOKER_H_
#define _INVOKER_H_

#include <iostream>

#include "Command.h"

class Invoker
{
private:
	Command* m_pCommand;

public:
	Invoker(Command* pCommand) : m_pCommand(pCommand) {};
	virtual ~Invoker() {};

	void call()
	{
		std::cout << "invoker calling." << std::endl;
		m_pCommand->execute();
	}
};

#endif // !_INVOKER_H_

抽象命令类：

#ifndef _COMMAND_H_
#define _COMMAND_H_

class Command
{
public:
	virtual void execute() = 0;
};

#endif // !_COMMAND_H_

具体命令类：

#ifndef _CONCRETE_COMMAND_H_
#define _CONCRETE_COMMAND_H_

#include <iostream>

#include "Command.h"
#include "Receiver.h"

class ConcreteCommand : public Command
{
private:
	Receiver* m_pReceiver;

public:
	ConcreteCommand(Receiver* pReceiver) : m_pReceiver(pReceiver) {};
	virtual ~ConcreteCommand() {};

	virtual void execute()
	{
		std::cout << "ConcreteCommand::execute" << std::endl;
		m_pReceiver->action();
	}
};

#endif // !_CONCRETE_COMMAND_H_

接收者：

#ifndef _RECEIVER_H_
#define _RECEIVER_H_

#include <iostream>

class Receiver
{
public:
	void action()
	{
		std::cout << "receiver action." << std::endl;
	}
};

#endif // !_RECEIVER_H_

在单线程环境下的测试

测试程序：

#include <stdlib.h>

#include "ConcreteCommand.h"
#include "Invoker.h"
#include "Receiver.h"

using namespace std;

int main()
{
	Receiver* pReceiver = new Receiver();
	ConcreteCommand* pCommand = new ConcreteCommand(pReceiver);
	Invoker* pInvoker = new Invoker(pCommand);
	pInvoker->call();


	delete pReceiver;
	delete pCommand;
	delete pInvoker;

	system("pause");
	return 0;
}

运行结果：

在这里插入图片描述

在多线程环境下的测试

略。

模式分析

命令模式的本质是对命令进行封装，将发出命令的责任和执行命令的责任分割开。

每一个命令都是一个操作：请求的一方发出请求，要求执行一个操作；接收的一方收到请求，并执行操作。
命令模式允许请求的一方和接收的一方独立开来，使得请求的一方不必知道接收请求的一方的接口，更不必知道请求是怎么被接收，以及操作是否被执行、何时被执行，以及是怎么被执行的。
命令模式使请求本身成为一个对象，这个对象和其他对象一样可以被存储和传递。
命令模式的关键在于引入了抽象命令接口，且发送者针对抽象命令接口编程，只有实现了抽象命令接口的具体命令才能与接收者相关联。

优缺点

优点：

解耦：命令模式可以将发送命令的对象和执行命令的对象解耦，使得两者可以独立变化。
可扩展性：可以方便地添加新的命令类和接收者类，而无需修改现有的代码结构。
容易实现撤销和重做功能：由于每个命令对象都封装了具体的操作，可以很容易地实现命令的撤销和重做功能。
支持操作的队列化和延迟执行：命令对象可以被组织成队列或堆栈，实现对操作的排队和延迟执行。

缺点：

增加了类和对象的数量：使用命令模式可能会增加一些新的类和对象，从而增加了代码的复杂性。
需要额外的开销：封装命令对象和操作会增加一些额外的开销，可能会稍微降低性能。
可能导致过多的具体命令类：如果系统的命令比较多，可能会导致需要创建很多具体的命令类，增加了代码维护的难度。

适用场景

在以下情况下可以使用命令模式：

系统需要将请求调用者和请求接收者解耦，使得调用者和接收者不直接交互。
系统需要在不同的时间指定请求、将请求排队和执行请求。
系统需要支持命令的撤销（Undo）操作和恢复（Redo）操作。
系统需要将一组操作组合在一起，即支持宏命令。

应用场景

餐厅点餐：在一家餐厅中，服务员充当调用者，厨师充当接收者，菜品可以作为具体命令。当顾客想点菜时，服务员会将顾客的需求封装成一个命令对象，并传递给厨师。厨师根据命令对象中的信息来完成相应的烹饪工作。这样，顾客和厨师之间不需要直接沟通，而是通过命令对象来实现点餐和烹饪的解耦。
遥控器控制家电：拿电视遥控器举例，遥控器是调用者，电视是接收者。每个按键都可以看作是一个具体命令，例如音量加、音量减、切换频道等。当用户按下某个按键时，遥控器会发送相应的命令给电视，然后电视根据命令执行相应的操作，如增加音量、减小音量或切换频道。
很多系统都提供了宏命令功能，如UNIX平台下的Shell编程，可以将多条命令封装在一个命令对象中，只需要一条简单的命令即可执行一个命令序列，这也是命令模式的应用实例之一。
Runnable接口：Java中的Runnable接口就是一个典型的命令模式的应用。Runnable接口封装了需要执行的任务，然后可以交给线程去执行。
Timer和TimerTask类：这两个类用于定时任务调度，TimerTask类封装了要执行的任务，然后由Timer类作为调用者执行这些任务。
Statement接口：在Java中与数据库交互时，SQL语句被封装成Statement对象，然后由数据库驱动程序执行相应的命令。

应用实例

实例 1：餐厅点餐

在一家餐厅中，服务员充当调用者，厨师充当接收者，菜品可以作为具体命令。当顾客想点菜时，服务员会将顾客的需求封装成一个命令对象，并传递给厨师。厨师根据命令对象中的信息来完成相应的烹饪工作。

UML 类图：

在这里插入图片描述

完整程序：

#include <iostream>
#include <stdlib.h>
using namespace std;

// 接收者 Chef：实现具体的烹饪操作
class Chef
{
public:
	void cook()
	{
		cout << "厨师执行点菜命令：正在烹饪菜品" << endl;
	}
	void cancelCook()
	{
		cout << "厨师执行取消命令：停止烹饪菜品" << endl;
	}
};

// 抽象命令类 Command：定义了点菜和取消点菜的方法
class Command
{
public:
	virtual void order() = 0;
	virtual void cancelOrder() = 0;
};

// 具体命令类 OrderCommand：实现命令接口，并将点菜的请求和具体的烹饪者（厨师）关联起来
class OrderCommand : public Command
{
private:
	Chef *m_pChef;

public:
	OrderCommand(Chef *chef) : m_pChef(chef){};
	virtual ~OrderCommand(){};

	virtual void order()
	{
		cout << "处理请求，安排厨师烹饪菜品" << endl;
		m_pChef->cook();
	}
	virtual void cancelOrder()
	{
		cout << "处理请求，取消厨师烹饪菜品" << endl;
		m_pChef->cancelCook();
	}
};

// 调用者类 Waiter：
class Waiter
{
private:
	Command *m_pCommand;

public:
	Waiter(){};
	Waiter(Command *command) : m_pCommand(command){};
	virtual ~Waiter(){};

	void takeOrder()
	{
		cout << "服务员接收到顾客点菜请求" << endl;
		m_pCommand->order();
	}
	void cancelOrder()
	{
		cout << "服务员接收到顾客取消点菜请求" << endl;
		m_pCommand->cancelOrder();
	}
	void setCommand(Command *command)
	{
		m_pCommand = command;
	}
};

int main()
{
	// 创建厨师（接收者）
	Chef *chef = new Chef();
	// 创建点菜命令
	Command *orderCommand = new OrderCommand(chef);
	// 创建服务员（调用者）
	Waiter *waiter = new Waiter();
	// 设置命令
	waiter->setCommand(orderCommand);
	// 服务员接收到点菜请求
	waiter->takeOrder();
	// 服务员接收到取消点菜请求
	waiter->cancelOrder();

	system("pause");
	return 0;
}

运行结果：

在这里插入图片描述

实例 2：电视机遥控器

电视机是请求的接收者，遥控器是请求的发送者，遥控器上有一些按钮，不同的按钮对应电视机的不同操作。抽象命令角色由一个命令接口来扮演，有三个具体的命令类实现了抽象命令接口，这三个具体命令类分别代表三种操作：打开电视机、关闭电视机和切换频道。显然，电视机遥控器就是一个典型的命令模式应用实例。

UML 类图：

在这里插入图片描述

时序图：

在这里插入图片描述

模式扩展

宏命令又称为组合命令，它是命令模式和组合模式联用的产物。

宏命令也是一个具体命令，不过它包含了对其他命令对象的引用，在调用宏命令的execute()方法时，将递归调用它所包含的每个成员命令的execute()方法，一个宏命令的成员对象可以是简单命令，还可以继续是宏命令。执行一个宏命令将执行多个具体命令，从而实现对命令的批处理。

参考

https://design-patterns.readthedocs.io/zh-cn/latest/behavioral_patterns/command.html
https://blog.csdn.net/weixin_45433817/article/details/131465270
https://www.runoob.com/design-pattern/command-pattern.html
https://blog.csdn.net/weixin_45433817/article/details/131037102