• 设计模式：命令模式（C#、JAVA、JavaScript、C++、Python、Go、PHP）

    上一篇《代理模式》                                                                     下一篇《观察者模式》

    简介：

    命令模式，它是一种行为型设计模式，它尝试将请求或操作封装成对象，从而降低系统的耦合度，增加系统的可扩展性，并支持撤销、重做、事务等功能。

    在命令模式中，请求被封装为一个独立的对象，称为命令。命令对象包含请求的接收者和对接收者的操作。请求者通过调用命令对象的执行方法来发送请求，接收者则负责执行命令。

    命令模式包括以下角色：

    命令（Command）：封装了一次请求，包括请求的接收者和对接收者的操作。
    接收者（Receiver）：真正执行命令操作的对象。
    请求者（Invoker）：负责向命令对象发起请求，并将命令对象设置为接收者的命令。
    客户端（Client）：创建请求者、命令和接收者对象，并将它们组装起来。

    命令模式的使用场景：
    1、当系统的某项操作具备命令语义，且命令实现不稳定（变化）时，可以通过命令模式解耦请求与实现。使用抽象命令接口使请求方的代码架构稳定，封装接收方具体命令的实现细节。接收方与抽象命令呈现弱耦合（内部方法无需一致），具备良好的扩展性。
    2、当请求调用者需要与请求接收者解耦时，命令模式可以使调用者和接收者不直接交互。
    3、系统需要支持命令的撤销（Undo）操作和恢复（Redo）操作时，可以使用命令模式。
    4、系统需要在不同的时间指定请求、将请求排队和执行请求时，可以使用命令模式。
    5、系统需要执行一组操作时，命令模式可以定义宏命令来实现该功能。

    总之，命令模式适用于那些需要将请求和操作封装成对象，降低系统的耦合度，增加系统的可扩展性，并支持撤销、重做、事务等功能的情况。

    命令模式的创建步骤：
    1、定义接收者类（Receiver），包含执行命令所需要的具体操作。
    2、定义命令接口（Command），包含执行命令的方法。
    3、创建具体命令类（ConcreteCommand），实现命令接口，并接受接收者作为参数，实现具体命令。
    4、创建接收者类，接受具体命令作为参数，实现具体命令。
    5、创建请求者类（Invoker），包含执行命令的方法，该方法接受具体命令作为参数。
    6、在请求者类中调用具体命令的执行方法，将接收者作为参数传递给具体命令。
    7、在客户端中创建请求者对象和具体命令对象，并将它们组装起来。

    以上步骤是创建命令模式的基本步骤，可以根据具体情况进行适当的修改和扩展。

    命令模式的优点，主要包括：
    1、请求发送者和接收者解耦：通过引入中间件（抽象接口）降低系统的耦合度，请求发送者不直接与接收者交互，请求发送者只需要知道如何执行命令，而不需要了解命令的具体实现。
    2、支持撤销和重做：命令模式可以容易地实现撤销和重做操作，因为每个命令都可以实现自己的撤销和重做逻辑。
    3、事务支持：命令模式可以支持事务操作，即一系列命令的组合，如果其中一个命令执行失败，可以撤销整个事务。
    4、命令的参数化：命令模式可以将命令封装成对象，并使用参数来传递数据，从而方便地对命令进行定制和扩展。
    5、命令的队列化：命令模式可以较容易地设计一个命令队列，从而按照一定的顺序执行命令。
    6、降低类的耦合度：命令模式把请求一个操作的对象与知道怎么执行一个操作的对象分割开，可以让类的单一职责更明确，充分解耦。
    7、方便添加新命令：由于加进新的具体命令类不影响其它的类，因此增加新的具体命令类很容易。

    命令模式的缺点，主要包括：
    1、可能产生大量具体命令类：为了支持各种命令，需要定义大量的具体命令类，这会增加系统的复杂度和维护成本。
    2、请求调用者和接收者仍然存在一定的耦合：虽然命令模式使得请求调用者和接收者解耦，但它们仍然存在一定的耦合关系，因为请求调用者需要知道接收者的存在以及如何调用接收者的方法。
    3、实现复杂度较高：命令模式需要定义抽象命令接口和具体命令类，以及实现撤销和恢复等功能，实现起来较为复杂。
    4、对事务的支持可能不完整：虽然命令模式可以支持事务操作，但对于复杂的事务支持可能不完整，需要额外设计。

    示例：

    一、C#命令模式

    以下是一个示例，展示了如何在C#中实现命令模式：

    1. // 定义命令接口  
    2. public interface ICommand  
    3. {  
    4.     void Execute();  
    5.     void Undo();  
    6. }  
    7.   
    8. // 定义具体命令类  
    9. public class ConcreteCommand : ICommand  
    10. {  
    11.     private Receiver receiver;  
    12.   
    13.     public ConcreteCommand(Receiver receiver)  
    14.     {  
    15.         this.receiver = receiver;  
    16.     }  
    17.   
    18.     public void Execute()  
    19.     {  
    20.         receiver.Operation();  
    21.     }  
    22.   
    23.     public void Undo()  
    24.     {  
    25.         receiver.Undo();  
    26.     }  
    27. }  
    28.   
    29. // 定义接收者类  
    30. public class Receiver  
    31. {  
    32.     public void Operation()  
    33.     {  
    34.         // 执行操作  
    35.     }  
    36.   
    37.     public void Undo()  
    38.     {  
    39.         // 撤销操作  
    40.     }  
    41. }  
    42.   
    43. // 定义请求者类  
    44. public class Invoker  
    45. {  
    46.     private ICommand command;  
    47.   
    48.     public void SetCommand(ICommand command)  
    49.     {  
    50.         this.command = command;  
    51.     }  
    52.   
    53.     public void ExecuteCommand()  
    54.     {  
    55.         command.Execute();  
    56.     }  
    57. }

    在客户端代码中，可以创建具体命令对象和请求者对象，并将它们组装起来，然后通过请求者对象来执行命令。

    1. public class Client
    2. {
    3.     public void Test(){
    4.         Receiver receiver = new Receiver(); // 创建接收者对象  
    5.         ConcreteCommand command = new ConcreteCommand(receiver); // 创建具体命令对象，并传入接收者对象作为参数  
    6.         Invoker invoker = new Invoker(); // 创建请求者对象  
    7.         invoker.SetCommand(command); // 将具体命令对象设置给请求者对象作为属性使用、回调或引用，从而实现请求者和具体命令对象的解耦。这样客户端代码只需要与请求者对象交互即可执行命令。
    8.     }
    9. }

    二、java命令模式

    命令模式通常通过以下方式实现：

    1. interface Command {  
    2.     void execute();  
    3.     void undo();  
    4. }  
    5.   
    6. class ConcreteCommand implements Command {  
    7.     private Receiver receiver;  
    8.   
    9.     public ConcreteCommand(Receiver receiver) {  
    10.         this.receiver = receiver;  
    11.     }  
    12.   
    13.     @Override  
    14.     public void execute() {  
    15.         receiver.operation();  
    16.     }  
    17.   
    18.     @Override  
    19.     public void undo() {  
    20.         receiver.undo();  
    21.     }  
    22. }  
    23.   
    24. class Receiver {  
    25.     public void operation() {  
    26.         // 执行操作  
    27.     }  
    28.   
    29.     public void undo() {  
    30.         // 撤销操作  
    31.     }  
    32. }  
    33.   
    34. class Invoker {  
    35.     private Command command;  
    36.   
    37.     public void setCommand(Command command) {  
    38.         this.command = command;  
    39.     }  
    40.   
    41.     public void executeCommand() {  
    42.         command.execute();  
    43.     }  
    44. }
    45.  
    46. public class Demo {  
    47.     public static void main(String[] args) {  
    48.         Receiver receiver = new Receiver(); // 创建接收者对象  
    49.         ConcreteCommand command = new ConcreteCommand(receiver); // 创建具体命令对象，并传入接收者对象作为参数  
    50.         Invoker invoker = new Invoker(); // 创建请求者对象  
    51.         invoker.setCommand(command); // 将具体命令对象设置给请求者对象作为属性使用、回调或引用，从而实现请求者和具体命令对象的解耦。这样客户端代码只需要与请求者对象交互即可执行命令。
    52.     }
    53. }

    三、javascript命令模式

    在JavaScript中，命令实现方式如下：

    1. class Command {  
    2.   constructor(executor) {  
    3.     this.executor = executor;  
    4.   }  
    5.   
    6.   execute() {  
    7.     this.executor();  
    8.   }  
    9. }  
    10.   
    11. function executeCommand(command) {  
    12.   command.execute();  
    13. }  
    14.   
    15. function greet() {  
    16.   console.log('Hello, World!');  
    17. }  
    18.   
    19. const greetCommand = new Command(greet);  
    20. executeCommand(greetCommand); // 输出：Hello, World!

    在上面的代码中，我们定义了一个Command类，它接受一个执行器函数作为构造函数的参数。执行器函数是在Command对象被调用时执行的函数。我们还定义了一个executeCommand函数，它接受一个Command对象作为参数，并调用其execute方法来执行命令。最后，我们创建了一个greet函数作为执行器函数，并将其传递给Command构造函数来创建一个greetCommand对象。然后，我们调用executeCommand函数并将greetCommand对象作为参数传递给它，从而执行了greet函数。

    通过将函数或方法封装成对象，我们可以将其传递给其他函数或方法，以便在不同的上下文中使用。这种模式可以用于实现撤销操作、事务处理、日志记录等功能。

    四、C++命令模式

    以下是在C++中实现命令模式：

    1. class Command {  
    2. public:  
    3.     virtual ~Command() {}  
    4.     virtual void execute() = 0;  
    5.     virtual void undo() = 0;  
    6. };  
    7.   
    8. class ConcreteCommand : public Command {  
    9. public:  
    10.     ConcreteCommand(Receiver* receiver) : m_receiver(receiver) {}  
    11.     void execute() override {  
    12.         m_receiver->operation();  
    13.     }  
    14.     void undo() override {  
    15.         m_receiver->undo();  
    16.     }  
    17. private:  
    18.     Receiver* m_receiver;  
    19. };  
    20.   
    21. class Receiver {  
    22. public:  
    23.     void operation() {  
    24.         // 执行操作  
    25.     }  
    26.     void undo() {  
    27.         // 撤销操作  
    28.     }  
    29. };  
    30.   
    31. class Invoker {  
    32. public:  
    33.     Invoker(Receiver* receiver) : m_receiver(receiver) {}  
    34.     void setCommand(Command* command) {  
    35.         m_command = command;  
    36.     }  
    37.     void executeCommand() {  
    38.         m_command->execute();  
    39.     }  
    40.     void undoCommand() {  
    41.         m_command->undo();  
    42.     }  
    43. private:  
    44.     Command* m_command;  
    45.     Receiver* m_receiver;  
    46. };
    47.  
    48. int main() {
    49.     Receiver* receiver = new Receiver(); // 创建接收者对象  
    50.     ConcreteCommand* command = new ConcreteCommand(receiver); // 创建具体命令对象，并传入接收者对象作为参数  
    51.     Invoker* invoker = new Invoker(command); // 创建请求者对象，并将具体命令对象传递给请求者对象作为属性使用、回调或引用，从而实现请求者和具体命令对象的解耦。这样客户端代码只需要与请求者对象交互即可执行命令。
    52. }

    五、python命令模式

    以下是在python中实现命令模式：

    1. class Command:  
    2.     def execute(self):  
    3.         pass  
    4.       
    5.     def undo(self):  
    6.         pass  
    7.   
    8. class ConcreteCommand(Command):  
    9.     def __init__(self, receiver):  
    10.         self.receiver = receiver  
    11.       
    12.     def execute(self):  
    13.         self.receiver.operation()  
    14.       
    15.     def undo(self):  
    16.         self.receiver.undo()  
    17.   
    18. class Receiver:  
    19.     def operation(self):  
    20.         print("Operation executed")  
    21.       
    22.     def undo(self):  
    23.         print("Operation undone")  
    24.   
    25. class Invoker:  
    26.     def __init__(self):  
    27.         self.command = None  
    28.       
    29.     def set_command(self, command):  
    30.         self.command = command  
    31.       
    32.     def execute_command(self):  
    33.         self.command.execute()  
    34.   
    35. if __name__ == "__main__":  
    36.     receiver = Receiver()  
    37.     command = ConcreteCommand(receiver)  
    38.     invoker = Invoker()  
    39.     invoker.set_command(command)  
    40.     invoker.execute_command()  # Output: Operation executed

    六、go命令模式

    以下是一个示例，展示了如何在go中实现命令模式：

    1. type Command interface {  
    2.     Execute()  
    3.     Undo()  
    4. }  
    5.   
    6. type ConcreteCommand struct {  
    7.     receiver Receiver  
    8. }  
    9.   
    10. func (c *ConcreteCommand) Execute() {  
    11.     c.receiver.Operation()  
    12. }  
    13.   
    14. func (c *ConcreteCommand) Undo() {  
    15.     c.receiver.Undo()  
    16. }  
    17.   
    18. type Receiver struct {}  
    19.   
    20. func (r *Receiver) Operation() {  
    21.     fmt.Println("Operation executed")  
    22. }  
    23.   
    24. func (r *Receiver) Undo() {  
    25.     fmt.Println("Operation undone")  
    26. }  
    27.   
    28. type Invoker struct {  
    29.     command Command  
    30. }  
    31.   
    32. func (i *Invoker) SetCommand(cmd Command) {  
    33.     i.command = cmd  
    34. }  
    35.   
    36. func (i *Invoker) ExecuteCommand() {  
    37.     i.command.Execute()  
    38. }
    39. func main() {  
    40.     receiver := &Receiver{}   // 创建接收者对象  
    41.     command := &ConcreteCommand{receiver}   // 创建具体命令对象，并传入接收者对象作为参数  
    42.     invoker := &Invoker{}   // 创建调用者对象  
    43.     invoker.SetCommand(command)   // 将具体命令对象传递给调用者对象作为属性使用、回调或引用，从而实现请求者和具体命令对象的解耦。这样客户端代码只需要与调用者对象交互即可执行命令。
    44. }

    七、PHP命令模式

    以下是一个示例，展示了如何在PHP中实现命令模式：

    1. interface Command {  
    2.     public function execute();  
    3.     public function undo();  
    4. }  
    5.   
    6. class ConcreteCommand implements Command {  
    7.     private $receiver;  
    8.       
    9.     public function __construct(Receiver $receiver) {  
    10.         $this->receiver = $receiver;  
    11.     }  
    12.       
    13.     public function execute() {  
    14.         $this->receiver->operation();  
    15.     }  
    16.       
    17.     public function undo() {  
    18.         $this->receiver->undo();  
    19.     }  
    20. }  
    21.   
    22. class Receiver {  
    23.     public function operation() {  
    24.         echo "Operation executed";  
    25.     }  
    26.       
    27.     public function undo() {  
    28.         echo "Operation undone";  
    29.     }  
    30. }  
    31.   
    32. class Invoker {  
    33.     private $command;  
    34.       
    35.     public function setCommand(Command $command) {  
    36.         $this->command = $command;  
    37.     }  
    38.       
    39.     public function executeCommand() {  
    40.         $this->command->execute();  
    41.     }  
    42. }

    在客户端代码中，可以创建具体命令对象和调用者对象，并将它们组装起来。然后通过调用者对象来执行命令。例如：

    1. $receiver = new Receiver();   // 创建接收者对象  
    2. $command = new ConcreteCommand($receiver);   // 创建具体命令对象，并传入接收者对象作为参数  
    3. $invoker = new Invoker();   // 创建调用者对象  
    4. $invoker->setCommand($command);   // 将具体命令对象传递给调用者对象作为属性使用、回调或引用，从而实现请求者和具体命令对象的解耦。这样客户端代码只需要与调用者对象交互即可执行命令。


    《完结》

    上一篇《代理模式》                                                                     下一篇《观察者模式》​​​​​​​

  • 相关阅读:
    C/C++轻量级并发TCP服务器框架Zinx-游戏服务器开发003：架构搭建-需求分析及TCP通信方式的实现
    基于Vue3在线商城（Vue3+VueCLI+VueRouter+vuex+axios+Bootstrap）
    Java学习day07：面向对象三大特性之一：封装
    面经分享 | 某康安全开发工程师
    数据库的备份与恢复
    大数据学习技术栈及书籍推荐
    xss的绕过
    Java web应用性能分析之【jvisualvm远程连接云服务器】
    python导出数据到sqlite中
    mysql中EXPLAIN命令解析
  • 原文地址：https://blog.csdn.net/yetyrain/article/details/133969776