概念

命令模式（Command Pattern）请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令

具体实现

3种对象：

1. 真实操作对象，以及命令

2. 命令对象， 实现命令对象接口

3. 直接操作对象， 聚合了命令对象

3 操作命令的对象-> 2命令（实现了Command接口） -> 1真实对象的操作

实现

1. 定义一个Command接口， 接口有一个Execute方法
2. 定一个或者多个需要操作的对象， 对象有真实的操作方法
3. 给每一个对象的真实操作定一个操作命令结构体，结构体实现Command接口， 在实现接口中调用真实操作。
4. 定义一个操作结构体， 可以传入命令结构体， 通过命令结构体操作命令最终执行到真实操作。

使用场景

"行为请求者"与"行为实现者"解耦

优点

• 解耦合

将操作对象和真实操作对象解耦

• 易扩展

方便添加新的命令

缺点

• 导致命令类太多

命令模式对比策略模式

对于一些相似的设计模式的区分，我们应该关注设计意图，应用场景的不同，而不是只看解决方案这一部分，或者只关注代码实现。单看实现，一些设计模式确实很相似，比较难区分。

从设计意图区分：

策略模式不同的算法可以互相替换， 命令模式，算法不可以互相替换。

策略模式：不同的策略具有相同的目的、不同的实现、互相之间可以替换。

命令模式：不同的命令具有不同的目的，对应不同的处理逻辑，并且互相之间不可替换。

代码实现

package main

import (
    "fmt"
)

// *******需要封装成Command命令的真实操作*********
// 这些命令可以是任意操作， 每一个操作只需要定义一个新的Command命令
// 主板的真实需要的操作， 将被封装在一个一个Command命令当中
type MotherBoard struct{}

// Start ...
func (*MotherBoard) Start() {
    fmt.Print("system starting\n")
}

// Reboot ...
func (*MotherBoard) Reboot() {
    fmt.Print("system rebooting\n")
}

// ***************[图片上传失败...(image-dc3d3a-1691992355740)]*************

// 命令接口， 每一个新的命令都要实现这个接口
type Command interface {
    Execute()
}

// *******启动主板命令*********
// 实现了Command命令接口
type StartCommand struct {
    *MotherBoard
}

// NewStartCommand ...
func NewStartCommand(mb *MotherBoard) *StartCommand {
    return &StartCommand{
        MotherBoard: mb,
    }
}

// 执行启动主板命令
func (c *StartCommand) Execute() {
    c.Start()
}

// *****************************

// *******重启主板命令*********
// 实现了Command命令接口
type RebootCommand struct {
    *MotherBoard
}

// NewRebootCommand ...
func NewRebootCommand(mb *MotherBoard) *RebootCommand {
    return &RebootCommand{
        MotherBoard: mb,
    }
}

// 执行重启主板命令
func (c *RebootCommand) Execute() {
    c.Reboot()
}

// *****************************

// 命令调用者
type Box struct {
    Command
}

// 添加一个命令
func NewBox(commandButton Command) *Box {
    return &Box{Command: commandButton}
}

// Press
func (b *Box) Press() {
    b.Execute()
}

func main() {
    // 构建一个真实操作对象
    mb := &MotherBoard{}
    // 将对象操作封装成一个个命令
    startCommand := NewStartCommand(mb)
    rebootCommand := NewRebootCommand(mb)

    // 将命令给到需要使用的地方
    box1 := NewBox(startCommand)
    box2 := NewBox(rebootCommand)

    // 操作命令
    box1.Press()
    box2.Press()
}