Golang学习条记_44——命令模式

Golang学习条记_41——观察者模式
Golang学习条记_42——迭代器模式
Golang学习条记_43——责任链模式

---

  

---

一、焦点概念

1. 界说

命令模式是一种行为型计划模式，通过将请求封装为独立对象实现调用者与实行者的解耦，支持请求的队列化、撤销重做和事务管理。其焦点特点包括：
• 请求对象化：将操纵抽象为可传递的命令对象
• 解耦调用链：调用者无需相识具体实行细节
• 操纵可编排：支持命令的组合与顺序控制
2. 解决的问题

• 体系紧耦合：消除行为请求者与实现者的直接依靠
• 操纵不可逆：缺乏标准化的撤销/重做机制
• 事务原子性：多步骤操纵无法保证团体实行
3. 焦点角色

角色作用Command界说实行操纵的统一接口（Execute/Undo）ConcreteCommand实现具体命令逻辑，绑定接收者对象Invoker触发命令实行，支持命令存储与调理Receiver实际实行业务操纵的对象Client组装命令对象与接收者的关系 4. 类图

1. @startuml
2. ' 命令模式类图
4. interface Command {
5.     +execute(): void
6. }
8. class Invoker {
9.     -command: Command
10.     +setCommand(command: Command): void
11.     +executeCommand(): void
12. }
14. class ConcreteCommand {
15.     -receiver: Receiver
16.     +execute(): void
17. }
19. class Receiver {
20.     +action(): void
21. }
23. ' 关系定义
24. Command <|.. ConcreteCommand
25. Invoker o--> Command
26. ConcreteCommand --> Receiver
27. Receiver <.. ConcreteCommand : <<create>>
29. note left of Command
30.   定义执行操作的接口
31. end note
33. note right of Receiver
34.   实际执行操作的对象
35. end note
36. @enduml

复制代码

二、特点分析

优点

• 解耦架构：彻底分离请求发起方与实行方
  
• 可扩展性：新增命令不影响现有体系
  
• 事务支持：支持多命令原子操纵与回滚
  

缺点

• 类膨胀：每个命令需独立类实现
  
• 实行开销：间接调用带来性能损耗
  
• 复杂度：需处理命令生命周期管理
  

三、实用场景

1. 事务管理体系

1. // 转账命令示例
2. type TransferCommand struct {
3.     from   *Account
4.     to     *Account
5.     amount int
6. }
8. func (t *TransferCommand) Execute() {
9.     t.from.Debit(t.amount)
10.     t.to.Credit(t.amount)
11. }
13. func (t *TransferCommand) Undo() {
14.     t.from.Credit(t.amount)
15.     t.to.Debit(t.amount)
16. }

复制代码

（实现资金划转与回滚，参考的撤销实现）
2. 多媒体遥控器

1. type TVPowerCommand struct {
2.     tv *Television
3. }
5. func (c *TVPowerCommand) Execute() {
6.     if c.tv.IsOn {
7.         c.tv.TurnOff()
8.     } else {
9.         c.tv.TurnOn()
10.     }
11. }

复制代码

3. 操纵审计体系

1. type AuditLog struct {
2.     commands []Command
3. }
5. func (a *AuditLog) Record(cmd Command) {
6.     a.commands = append(a.commands, cmd)
7.     cmd.Execute()
8. }

复制代码

四、Go语言实现示例

完整实现代码

1. package command_demo
3. import "fmt"
5. // Command 接口
6. type Command interface {
7.         Execute()
8. }
10. // Receiver 实现
11. type StockTrade struct{}
13. func (s *StockTrade) Buy() {
14.         fmt.Println("买入股票")
15. }
17. func (s *StockTrade) Sell() {
18.         fmt.Println("卖出股票")
19. }
21. // ConcreteCommand 具体命令
22. type BuyStock struct {
23.         stock *StockTrade
24. }
26. func (b *BuyStock) Execute() {
27.         b.stock.Buy()
28. }
30. type SellStock struct {
31.         stock *StockTrade
32. }
34. func (s *SellStock) Execute() {
35.         s.stock.Sell()
36. }
38. // Invoker 调用者
39. type Broker struct {
40.         orders []Command
41. }
43. func (b *Broker) TakeOrder(cmd Command) {
44.         b.orders = append(b.orders, cmd)
45. }
47. func (b *Broker) PlaceOrders() {
48.         for _, cmd := range b.orders {
49.                 cmd.Execute()
50.         }
51.         b.orders = nil
52. }
54. // 客户端代码
55. func Example() {
56.         stock := &StockTrade{}
57.         buy := &BuyStock{stock: stock}
58.         sell := &SellStock{stock: stock}
60.         broker := &Broker{}
61.         broker.TakeOrder(buy)
62.         broker.TakeOrder(sell)
64.         broker.PlaceOrders()
65. }

复制代码

实行结果

1. === RUN   TestExample
2. 买入股票
3. 卖出股票
4. --- PASS: TestExample (0.00s)
5. PASS

复制代码

五、高级应用

1. 宏命令体系

1. type MacroCommand struct {
2.         commands []Command
3. }
5. func (m *MacroCommand) Execute() {
6.         for _, cmd := range m.commands {
7.                 cmd.Execute()
8.         }
9. }
11. // 使用示例
12. macro := &MacroCommand{
13.         commands: []Command{
14.                 &SaveCommand{},
15.                 &CompileCommand{},
16.                 &DeployCommand{},
17.         },
18. }
19. macro.Execute()

复制代码

2. 异步命令队列

1. type AsyncInvoker struct {
2.         queue chan Command
3. }
5. func (a *AsyncInvoker) Start() {
6.         go func() {
7.                 for cmd := range a.queue {
8.                         cmd.Execute()
9.                 }
10.         }()
11. }
13. func (a *AsyncInvoker) Add(cmd Command) {
14.         a.queue <- cmd
15. }

复制代码

六、与其他模式对比

模式焦点区别典型应用场景计谋模式算法选择 vs 操纵封装付出方式选择职责链模式请求传递 vs 命令实行审批流程处理备忘录模式状态存储 vs 操纵记录编辑器撤销功能 七、实现发起

• 轻量化计划：使用闭包简化简朴命令
  1. func NewLightCmd(light *Light) Command {
  2.     return CommandFunc(light.Toggle)
  3. }

  复制代码
• 生命周期管理：实现Release()方法释放资源
  
• 批量操纵：采用组合模式实现命令聚集操纵
  
• 错误处理：增长Validate()预处理方法
  

八、典型应用

• 文本编辑器：实现编辑操纵撤销栈
  
• 智能家居：物联网设备控制中心
  
• 金融生意业务：多步骤生意业务事务管理
  
• 游戏开发：玩家操纵回放体系
  

通过命令模式，可以将分布式体系的操纵请求转化为可序列化对象，实现跨网络的操纵重放与审计。在Go语言中，联合channel特性可构建高性能命令管道，实用于实时生意业务体系等场景。发起对高频操纵命令采用对象池优化，克制重复创建开销。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。