【命令设计模式详解】C/Java/JS/Go/Python/TS不同语言实现

简介

命令模式（Command Pattern）是一种数据驱动的设计模式，也是一种行为型设计模式。这种模式的请求以命令的形式包裹在对象中，并传给调用对象。调用对象再寻找合适的对象，并把该命令传给相应的处理者。即把请求或操作封装成单个对象，并使其可以被参数化和延迟执行，这种方式将命令和执行者进行了有效解耦。
如果你需要通过操作来参数化对象，可使用命令模式。如果你想要将操作放入队列中、操作的执行或者远程执行操作， 可使用命令模式。如果你想要实现操作回滚功能，可使用命令模式。
作用

• 将不同命令按照抽象命令封装成不同的对象，将这些命令放到调用者里。
  
• 客户通过调用者执行命令再去调用接受者的动作，顺序为：客户调用方->调用者->命令对象->接受者。
  
• 同其他对象一样，命令也可以实现序列化，从而方便地写入文件或数据库中，实现延迟执行。
  

实现步骤

• 创建一个抽象命令接口，实现基本的命令方法。
  
• 创建多个具体命令类，实现抽象命令接口，以来命令接收者。
  
• 创建命令接收者，也就是具体业务类，接受命令并执行动作。
  
• 创建命令调用者，这是一个聚合命令的类，添加命令和执行命令。
  

UML

 
Java代码

基础命令接口

1. // Command.java 命令抽象接口
2. public interface Command {
3.    void execute();
4. }

复制代码

 
具体命令类，可以多个命令

1. // BuyCommand.java 购买命令，操作receiver，实现了抽象命令类
2. public class BuyCommand implements Command {
3.   private StockReceiver stockReceiver;
5.   public BuyCommand(StockReceiver stockReceiver) {
6.     this.stockReceiver = stockReceiver;
7.   }
9.   // 命令类调用执行者的实际动作
10.   public void execute() {
11.     System.out.println(this.getClass().getName() + "::execute() ");
12.     this.stockReceiver.buy();
13.   }
14. }
15. // SellCommand.java 出售命令，操作receiver，实现了抽象命令类
16. public class SellCommand implements Command {
17.   private StockReceiver stockReceiver;
19.   public SellCommand(StockReceiver stockReceiver) {
20.     this.stockReceiver = stockReceiver;
21.   }
23.   // 命令类调用执行者的实际动作
24.   public void execute() {
25.     System.out.println(this.getClass().getName() + "::execute() ");
26.     stockReceiver.sell();
27.   }
28. }

复制代码

 
命令调用类

1. // CommandInvoker.java 命令调用类，通过关联命令来执行命令的调用
2. public class CommandInvoker {
4.     private List<Command> commandList = new ArrayList<Command>();
6.     // 储存命令
7.     public void takeOrder(Command command) {
8.         System.out.println(this.getClass().getName() + "::takeOrder() " + command.getClass().getName());
9.         commandList.add(command);
10.     }
12.     // 统一执行
13.     public void executeOrders() {
14.         System.out.println(this.getClass().getName() + "::executeOrders() ");
15.         for (Command command : commandList) {
16.             command.execute();
17.         }
18.         commandList.clear();
19.     }
20. }

复制代码

 
命令接收执行类

1. // StockReceiver.java 命令模式真正的执行类，不直接对外，通过command来调用
2. public class StockReceiver {
4.    private String name;
5.    private int num;
7.    public StockReceiver(String name, int num) {
8.       this.name = name;
9.       this.num = num;
10.    }
12.    public void buy() {
13.       System.out.println(this.getClass().getName() + "::buy() [name=" + this.name + " num=" + this.num + "]");
14.    }
16.    public void sell() {
17.       System.out.println(this.getClass().getName() + "::sell() [name=" + this.name + " num=" + this.num + "]");
18.    }
20.    public void setName(String name) {
21.       this.setName(name);
22.    }
24.    public String getName() {
25.       return this.name;
26.    }
28.    public void setNum(int num) {
29.       this.num = num;
30.    }
32.    public int getNum() {
33.       return this.num;
34.    }
35. }

复制代码

 
测试调用

1.     /*
2.      * 命令模式是客户端通过一个命令执行者invoker，去执行某个命令command。
3.      * 而命令则调用了业务类receiver的具体动作，从而完成真正的执行。
4.      * 这种方式将命令和执行者进行了有效解耦。
5.      */
7.     // 先声明一个被操作对象，也就是接收者
8.     StockReceiver stock1 = new StockReceiver("Apple", 200);
10.     // 再声明具体的命令
11.     BuyCommand buyCommand = new BuyCommand(stock1);
12.     SellCommand sellCommand = new SellCommand(stock1);
14.     // 最后声明调用者，由调用者来执行具体命令
15.     CommandInvoker invoker = new CommandInvoker();
16.     invoker.takeOrder(buyCommand);
17.     invoker.takeOrder(sellCommand);
18.     invoker.executeOrders();
20.     // 再执行一只股票
21.     StockReceiver stock2 = new StockReceiver("Google", 100);
22.     BuyCommand buyCommand2 = new BuyCommand(stock2);
23.     invoker.takeOrder(buyCommand2);
24.     invoker.executeOrders();

复制代码

 
Go代码

基础命令接口

1. // Command.go 命令抽象接口
2. type Command interface {
3.   GetName() string
4.   SetStockReceiver(stockReceiver *StockReceiver)
5.   Execute()
6. }

复制代码

 
具体命令类，可以多个命令

1. // BuyCommand.go 购买命令，操作receiver，实现了抽象命令类
2. type BuyCommand struct {
3.   Name          string `default:"BuyCommand"`
4.   stockReceiver *StockReceiver
5. }
7. func (c *BuyCommand) GetName() string {
8.   return c.Name
9. }
11. func (c *BuyCommand) SetStockReceiver(stockReceiver *StockReceiver) {
12.   c.stockReceiver = stockReceiver
13. }
15. // 命令类调用执行者来自行真正的动作
16. func (c *BuyCommand) Execute() {
17.   fmt.Println("BuyCommand::Execute() ")
18.   c.stockReceiver.Buy()
19. }
20. // SellCommand.go 出售命令，操作receiver，实现了抽象命令类
21. type SellCommand struct {
22.   Name          string `default:"BuyCommand"`
23.   stockReceiver *StockReceiver
24. }
26. func (s *SellCommand) GetName() string {
27.   return s.Name
28. }
30. func (s *SellCommand) SetStockReceiver(stockReceiver *StockReceiver) {
31.   s.stockReceiver = stockReceiver
32. }
34. // 命令类调用执行者来自行真正的动作
35. func (s *SellCommand) Execute() {
36.   fmt.Println("SellCommand::Execute() ")
37.   s.stockReceiver.Sell()
38. }

复制代码

 
命令调用类

1. // CommandInvoker.go 命令调用类，通过关联命令来执行命令的调用
2. type CommandInvoker struct {
3.   Name        string
4.   commandList []Command
5. }
7. func (c *CommandInvoker) GetName() string {
8.   return c.Name
9. }
11. // 储存命令
12. func (c *CommandInvoker) TakeOrder(command Command) {
13.   fmt.Println("CommandInvoker::TakeOrder() " + command.GetName())
14.   c.commandList = append(c.commandList, command)
15. }
17. // 统一执行
18. func (c *CommandInvoker) ExecuteOrders() {
19.   fmt.Println("CommandInvoker::ExecuteOrders() ")
20.   for _, command := range c.commandList {
21.     command.Execute()
22.   }
23.   // 命令执行后清除
24.   c.commandList = c.commandList[:0]
25. }

复制代码

 
命令接收执行类

1. // StockReceiver.go 命令模式真正的执行类，不直接对外，通过command来调用
2. type StockReceiver struct {
3.   Name string
4.   Num  int
5. }
7. func (s *StockReceiver) Buy() {
8.   fmt.Println("StockReceiver::Buy() [Name=" +
9.     s.Name + " Num=" + strconv.Itoa(s.Num) + "]")
10. }
12. func (s *StockReceiver) Sell() {
13.   fmt.Println("StockReceiver::Sell() [Name=" +
14.     s.Name + " Num=" + strconv.Itoa(s.Num) + "]")
15. }

复制代码

 
测试调用

1. // main包下的main入口方法
2. func main() {
3.   fmt.Println("test start:")
4.   /*
5.    * 命令模式是客户端通过一个命令执行者invoker，去执行某个命令command
6.    * 而命令则调用了业务类receiver的具体动作，从而完成真正的执行
7.    * 这种方式将命令和执行者进行了有效解耦。
8.    */
10.   // 先声明一个被操作对象，也就是接收者
11.   var stock1 = &src.StockReceiver{
12.     Name: "Apple",
13.     Num:  200,
14.   }
16.   // 再声明具体的命令
17.   var buyCommand = &src.BuyCommand{
18.     Name: "buyCommand",
19.   }
20.   buyCommand.SetStockReceiver(stock1)
21.   var sellCommand = &src.SellCommand{
22.     Name: "sellCommand",
23.   }
24.   sellCommand.SetStockReceiver(stock1)
26.   // 最后声明调用者，由调用者来执行具体命令
27.   var invoker = &src.CommandInvoker{
28.     Name: "invoker",
29.   }
30.   invoker.TakeOrder(buyCommand)
31.   invoker.TakeOrder(sellCommand)
32.   invoker.ExecuteOrders()
34.   // 再执行一只股票
35.   var stock2 = &src.StockReceiver{
36.     Name: "Google",
37.     Num:  100,
38.   }
39.   var buyCommand2 = &src.BuyCommand{
40.     Name: "buyCommand2",
41.   }
42.   buyCommand2.SetStockReceiver(stock2)
43.   invoker.TakeOrder(buyCommand2)
44.   invoker.ExecuteOrders()
45. }

复制代码

 
C语言代码

基础对象定义

1. // func.h文件，基础命令结构体head
2. #include <stdio.h>
3. #include <stdlib.h>
4. #include <stdbool.h>
5. #include <string.h>
7. // 基础命令结构体
8. typedef struct Command
9. {
10.     char name[50];
11.     struct StockReceiver *stock_receiver;
12.     void (*set_stock_receiver)(struct Command *command, struct StockReceiver *);
13.     void (*execute)(struct Command *);
14. } Command;
16. // 接受者对象
17. typedef struct StockReceiver
18. {
19.     char name[50];
20.     int num;
21.     void (*buy)(struct StockReceiver *);
22.     void (*sell)(struct StockReceiver *);
23. } StockReceiver;
24. StockReceiver *stock_receiver_constructor(char *name, int num);
26. // 继承命令结构体
27. typedef struct BuyCommand
28. {
29.     char name[50];
30.     struct StockReceiver *stock_receiver;
31.     void (*set_stock_receiver)(struct BuyCommand *command, struct StockReceiver *);
32.     void (*execute)(struct Command *);
33. } BuyCommand;
34. BuyCommand *buy_command_constructor(char *name);
36. // 继承命令结构体
37. typedef struct SellCommand
38. {
39.     char name[50];
40.     struct StockReceiver *stock_receiver;
41.     void (*set_stock_receiver)(struct SellCommand *command, struct StockReceiver *);
42.     void (*execute)(struct Command *);
43. } SellCommand;
44. SellCommand *sell_command_constructor(char *name);
46. // 命令执行者
47. typedef struct CommandInvoker
48. {
49.     char name[50];
50.     void (*take_order)(struct CommandInvoker *invoker, Command *command);
51.     void (*execute_orders)(struct CommandInvoker *invoker);
52.     // 数组命令列表，记录待执行的命令对象
53.     struct Command **command_list;
54.     // 数组长度记录
55.     int command_list_size;
56.     // 若是柔性数组，则放在结构体最后，可以动态追加内容
57.     // struct Command *command_list[];
58. } CommandInvoker;
59. CommandInvoker *command_invoker_constructor(char *name);

复制代码

 
具体命令类，可以多个命令

1. // buy_command.c 购买命令，操作receiver，实现了抽象命令类
2. #include "func.h"
4. // 购买命令，操作receiver，实现了抽象命令类
6. void set_buy_stock_receiver(BuyCommand *command, StockReceiver *receiver)
7. {
8.   command->stock_receiver = receiver;
9. }
11. // 命令类调用执行者来自行真正的动作
12. void buy_command_execute(Command *command)
13. {
14.   printf("\r\n BuyCommand::execute() [command->name=%s]", command->name);
15.   command->stock_receiver->buy(command->stock_receiver);
16. }
18. // 创建Buy命令对象
19. BuyCommand *buy_command_constructor(char *name)
20. {
21.   Command *command = (Command *)malloc(sizeof(Command));
22.   strncpy(command->name, name, 50);
23.   command->execute = &buy_command_execute;
24.   // 转为BuyCommand
25.   BuyCommand *buy_command = (BuyCommand *)command;
26.   buy_command->set_stock_receiver = &set_buy_stock_receiver;
27.   return buy_command;
28. }
29. // sell_command.c 出售命令，操作receiver，实现了抽象命令类
30. #include "func.h"
32. // 出售命令，操作receiver，实现了抽象命令类
34. void set_sell_stock_receiver(SellCommand *command, StockReceiver *receiver) {
35.   command->stock_receiver = receiver;
36. }
38. // 命令类调用执行者来自行真正的动作
39. void sell_command_execute(Command *command) {
40.   printf("\r\n SellCommand::execute() [command->name=%s]", command->name);
41.   command->stock_receiver->sell(command->stock_receiver);
42. }
44. // 创建Sell命令对象
45. SellCommand *sell_command_constructor(char *name)
46. {
47.   Command *command = (Command *)malloc(sizeof(Command));
48.   strncpy(command->name, name, 50);
49.   command->execute = &sell_command_execute;
50.   // 转为SellCommand
51.   SellCommand *buy_command = (SellCommand *)command;
52.   buy_command->set_stock_receiver = &set_sell_stock_receiver;
53.   return buy_command;
54. }

复制代码

 
命令调用类

1. // command_invoker.c 命令调用类，通过关联命令来执行命令的调用
2. #include "func.h"
4. /*
5. 命令调用类，通过关联命令来实行命令的调用
6. 在命令模式中，Invoker（调用者）是一个可选的组件，
7. 它负责将Command对象传递给Receiver，
8. 并调用Command对象的execute方法来执行命令。
9. Invoker在实现命令模式时可以有多种实现方式。
10. */
12. void print_command_list(Command **list, int command_list_size)
13. {
14.   printf("\r\nThe current command_list:");
15.   for (int i = 0; i < command_list_size; i++)
16.   {
17.     printf("\r\n [i=%d, command->name=%s]", i, list[i]->name);
18.   }
19. }
21. // 把命令存储到调用者的命令列表
22. void invoker_take_order(CommandInvoker *invoker, Command *command)
23. {
24.   printf("\r\n CommandInvoker::take_order() [invoker->name=%s, command->name=%s, invoker->command_list_size=%d]", invoker->name, command->name, invoker->command_list_size);
26.   // 列表长度增加1位
27.   int new_command_list_size = invoker->command_list_size + 1;
29.   /* 如果采取柔性数组，则无需申请新空间和复制内容 */
30.   // 把原列表命令暂存下来
31.   Command **old_command_list = invoker->command_list;
32.   // 给命令列表申请新空间
33.   invoker->command_list = (Command **)calloc(new_command_list_size, sizeof(Command *));
34.   // 复制原有命令到命令列表，如果采取柔性数组则无需复制
35.   for (int i = 0; i < invoker->command_list_size; i++)
36.   {
37.     invoker->command_list[i] = old_command_list[i];
38.   }
39.   free(old_command_list);
41.   // 把新的命令添加列表最后
42.   invoker->command_list[new_command_list_size - 1] = command;
43.   invoker->command_list_size = new_command_list_size;
44.   
45.   // 打印当前有多少命令
46.   // print_command_list(invoker->command_list, invoker->command_list_size);
47. }
49. // 统一执行全部命令
50. void invoker_execute_orders(CommandInvoker *invoker)
51. {
52.   printf("\r\n CommandInvoker::execute_orders() ");
53.   int command_list_size = invoker->command_list_size;
54.   Command **command_list = invoker->command_list;
55.   for (int i = 0; i < command_list_size; i++)
56.   {
57.     Command *command = command_list[i];
58.     command->execute(command);
59.     command_list[i] = NULL;
60.   }
61.   // 命令执行完后清除命令列表
62.   invoker->command_list_size = 0;
63.   invoker->command_list = (Command **)calloc(0, sizeof(Command *));
64. }
66. // 初始化CommandInvoker命令对象
67. CommandInvoker *command_invoker_constructor(char *name)
68. {
69.   printf("\r\n command_invoker_constructor() [name=%s]", name);
70.   CommandInvoker *invoker = (CommandInvoker *)malloc(sizeof(CommandInvoker));
71.   strncpy(invoker->name, name, 50);
72.   invoker->command_list_size = 0;
73.   invoker->take_order = &invoker_take_order;
74.   invoker->execute_orders = &invoker_execute_orders;
75.   return invoker;
76. }

复制代码

 
命令接收执行类

1. // stock_receiver.c 命令模式真正的执行类，不直接对外，通过command来调用
2. #include "func.h"
4. /* 命令模式真正的执行类，不直接对外，通过command来调用 */
6. void stock_receiver_buy(StockReceiver *stock_receiver) {
7.   printf("\r\n StockReceiver::buy() [name=%s num=%d]", stock_receiver->name, stock_receiver->num);
8. }
10. void stock_receiver_sell(StockReceiver *stock_receiver) {
11.   printf("\r\n StockReceiver::sell() [name=%s num=%d]", stock_receiver->name, stock_receiver->num);
12. }
14. // 创建StockReceiver命令对象
15. StockReceiver *stock_receiver_constructor(char *name, int num)
16. {
17.   printf("\r\n stock_receiver_constructor() [name=%s, num=%d]", name, num);
18.   StockReceiver *receiver = (StockReceiver *)malloc(sizeof(StockReceiver));
19.   strncpy(receiver->name, name, 50);
20.   receiver->num = num;
21.   receiver->buy = &stock_receiver_buy;
22.   receiver->sell = &stock_receiver_sell;
23.   return receiver;
24. }

复制代码

 
测试调用

1. #include "../src/func.h"
3. int main(void)
4. {
5.     printf("test start:\r\n");
6.     /*
7.      * 命令模式是一种行为设计模式，它将请求或操作封装成单个对象，并使其可以被参数化和延迟执行。
8.      * 在命令模式中，客户端通过一个命令执行者invoker，去执行某个命令command
9.      * 而命令则调用了业务类receiver的具体动作，从而完成真正的执行
10.      * 这种方式将命令和执行者进行了有效解耦。
11.      */
13.     // 先声明一个被操作对象，也就是接收者
14.     StockReceiver *stocker_receiver1 = stock_receiver_constructor("Apple", 200);
16.     // 再声明具体的命令
17.     BuyCommand *buy_command = buy_command_constructor("buy_command");
18.     buy_command->set_stock_receiver(buy_command, stocker_receiver1);
20.     SellCommand *sell_command = sell_command_constructor("sell_command");
21.     sell_command->set_stock_receiver(sell_command, stocker_receiver1);
23.     // 最后声明调用者，由调用者来执行具体命令
24.     CommandInvoker *invoker = command_invoker_constructor("invoker");
25.     invoker->take_order(invoker, (Command *)buy_command);
26.     invoker->take_order(invoker, (Command *)sell_command);
27.     invoker->execute_orders(invoker);
29.     // 再执行一只股票，声明新的接受者
30.     StockReceiver *stock_receiver2 = stock_receiver_constructor("Google", 100);
31.     BuyCommand *buy_command2 = buy_command_constructor("buy_command2");
32.     // 这次只有buy命令
33.     buy_command2->set_stock_receiver(buy_command2, stock_receiver2);
34.     // 还用原来的invoker，或者新建invoker
35.     invoker->take_order(invoker, (Command *)buy_command2);
36.     invoker->execute_orders(invoker);
38.     return 0;
39. }

复制代码

 
更多语言版本

不同语言实现设计模式源码：https://github.com/microwind/design-pattern

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！