经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » 设计模式 » 查看文章
【命令设计模式详解】C/Java/JS/Go/Python/TS不同语言实现
来源：cnblogs　　作者：刀法如飞　　时间：2023/3/31 8:58:48　　对本文有异议

简介

命令模式（Command Pattern）是一种数据驱动的设计模式，也是一种行为型设计模式。这种模式的请求以命令的形式包裹在对象中，并传给调用对象。调用对象再寻找合适的对象，并把该命令传给相应的处理者。即把请求或操作封装成单个对象，并使其可以被参数化和延迟执行，这种方式将命令和执行者进行了有效解耦。

如果你需要通过操作来参数化对象，可使用命令模式。如果你想要将操作放入队列中、操作的执行或者远程执行操作， 可使用命令模式。如果你想要实现操作回滚功能，可使用命令模式。

作用

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

实现步骤

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

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.      */
  6.  
  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.    */
  9.  
  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>
  6.  
  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"
  3.  
  4. // 购买命令，操作receiver，实现了抽象命令类
  5.  
  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"
  31.  
  32. // 出售命令，操作receiver，实现了抽象命令类
  33.  
  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"
  3.  
  4. /*
  5. 命令调用类，通过关联命令来实行命令的调用
  6. 在命令模式中，Invoker（调用者）是一个可选的组件，
  7. 它负责将Command对象传递给Receiver，
  8. 并调用Command对象的execute方法来执行命令。
  9. Invoker在实现命令模式时可以有多种实现方式。
  10. */
  11.  
  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"
  3.  
  4. /* 命令模式真正的执行类，不直接对外，通过command来调用 */
  5.  
  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"
  2.  
  3. int main(void)
  4. {
  5.     printf("test start:\r\n");
  6.     /*
  7.      * 命令模式是一种行为设计模式，它将请求或操作封装成单个对象，并使其可以被参数化和延迟执行。
  8.      * 在命令模式中，客户端通过一个命令执行者invoker，去执行某个命令command
  9.      * 而命令则调用了业务类receiver的具体动作，从而完成真正的执行
  10.      * 这种方式将命令和执行者进行了有效解耦。
  11.      */
  12.  
  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

原文链接：https://www.cnblogs.com/letjs/p/17273541.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

设计模式热门文章

  • java设计模式-装饰者模式详解
  • 设计模式之迭代器与组合模式（四）
  • asp.net Core 中AuthorizationHandler 实现自定义授权
  • 高校宿舍管理系统详细需求分析说明书
  • 依赖注入与控制反转
  • 设计模式-工厂方法模式 实战演习 代码实现 - Code-CHAN
  • 报刊订阅管理系统的设计与实现
  • 深入浅出设计模式 PDF下载高清完整扫描原版
  • TypeScript实现设计模式——生成器模式
  • 小账本软件设计之数据库设计模式构建

    • 设计模式推荐文章

  • 设计模式：代理模式详解
  • 设计模式之工厂模式（学习笔记）
  • Java设计模式总结
  • Java面试题：Spring框架除了IOC和AOP，还有哪些好玩的设计模式？
  • 什么是设计模式？
  • 设计模式学习（一）单例模式的几种实现方式
  • 我们在SqlSugar开发框架中，用到的一些设计模式
  • 3分钟看懂设计模式01：策略模式
  • 设计模式浅析(三) &#183;装饰者模式
  • GOF23--23种设计模式（一）

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号