go: Command Pattern

geovindu

发布于 2026-06-18 15:37:00

1260

项目结构：

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Command Pattern 命令模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/26 12:55
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : jeweler.go
*/
package receiver
 
import "fmt"
 
// Jeweler 珠宝工匠（接收者）：职责单一，只实现首饰加工逻辑
type Jeweler struct {
    name string
}
 
func NewJeweler(name string) *Jeweler {
    return &Jeweler{name: name}
}
 
// ========== 具体业务操作 ==========
func (j *Jeweler) PolishRing() error {
    fmt.Printf("[%s] 执行：戒指抛光完成 ✨\n", j.name)
    return nil
}
 
func (j *Jeweler) InlayDiamond() error {
    fmt.Printf("[%s] 执行：钻石镶嵌完成 💎\n", j.name)
    return nil
}
 
func (j *Jeweler) CleanNecklace() error {
    fmt.Printf("[%s] 执行：项链清洗完成 🧼\n", j.name)
    return nil
}
 
// ========== 撤销操作 ==========
func (j *Jeweler) UndoPolishRing() error {
    fmt.Printf("[%s] 撤销：戒指抛光已回滚 ❌\n", j.name)
    return nil
}
 
func (j *Jeweler) UndoInlayDiamond() error {
    fmt.Printf("[%s] 撤销：钻石镶嵌已回滚 ❌\n", j.name)
    return nil
}
 
func (j *Jeweler) UndoCleanNecklace() error {
    fmt.Printf("[%s] 撤销：项链清洗已回滚 ❌\n", j.name)
    return nil
}

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Command Pattern 命令模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/26 12:55
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : workbench.go
*/
package invoker
 
import (
    "errors"
    "godesginpattern/command/command"
)
 
// Workbench 工作台（调用者）：职责单一，仅负责执行/撤销/记录命令
type Workbench struct {
    commandHistory []command.Command // 命令历史（可扩展存入DB）
}
 
func NewWorkbench() *Workbench {
    return &Workbench{
        commandHistory: make([]command.Command, 0),
    }
}
 
// ExecuteCommand 执行命令
func (w *Workbench) ExecuteCommand(cmd command.Command) error {
    if cmd == nil {
        return errors.New("命令不能为空")
    }
 
    // 执行命令
    if err := cmd.Execute(); err != nil {
        return err
    }
 
    // 记录历史
    w.commandHistory = append(w.commandHistory, cmd)
    return nil
}
 
// UndoLastCommand 撤销上一个命令
func (w *Workbench) UndoLastCommand() error {
    if len(w.commandHistory) == 0 {
        return errors.New("无操作可撤销")
    }
 
    // 取出最后一条命令
    lastIdx := len(w.commandHistory) - 1
    lastCmd := w.commandHistory[lastIdx]
 
    // 撤销
    if err := lastCmd.Undo(); err != nil {
        return err
    }
 
    // 移除历史
    w.commandHistory = w.commandHistory[:lastIdx]
    return nil
}
 
// GetHistory 获取命令历史（用于日志、审计）
func (w *Workbench) GetHistory() []command.Command {
    return w.commandHistory
}

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Command Pattern 命令模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/26 12:56
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : clean.go
*/
package command
 
import "godesginpattern/command/receiver"
 
type CleanNecklaceCommand struct {
    jeweler *receiver.Jeweler
}
 
func NewCleanNecklaceCommand(j *receiver.Jeweler) *CleanNecklaceCommand {
    return &CleanNecklaceCommand{jeweler: j}
}
 
func (c *CleanNecklaceCommand) Execute() error {
    return c.jeweler.CleanNecklace()
}
 
func (c *CleanNecklaceCommand) Undo() error {
    return c.jeweler.UndoCleanNecklace()
}
 
func (c *CleanNecklaceCommand) Name() string {
    return "CleanNecklaceCommand"
}
 
 
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Command Pattern 命令模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/26 12:56
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : command.go
*/
package command
 
// Command 命令接口（抽象层）：企业级必须定义标准契约
type Command interface {
    Execute() error
    Undo() error
    Name() string // 用于日志、追踪、可观测性
}
 
 
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Command Pattern 命令模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/26 12:56
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : inlay.go
*/
package command
 
import "godesginpattern/command/receiver"
 
type InlayDiamondCommand struct {
    jeweler *receiver.Jeweler
}
 
func NewInlayDiamondCommand(j *receiver.Jeweler) *InlayDiamondCommand {
    return &InlayDiamondCommand{jeweler: j}
}
 
func (i *InlayDiamondCommand) Execute() error {
    return i.jeweler.InlayDiamond()
}
 
func (i *InlayDiamondCommand) Undo() error {
    return i.jeweler.UndoInlayDiamond()
}
 
func (i *InlayDiamondCommand) Name() string {
    return "InlayDiamondCommand"
}
 
 
/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Command Pattern 命令模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/26 12:56
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : polish.go
*/
package command
 
import "godesginpattern/command/receiver"
 
// PolishRingCommand 抛光戒指命令
type PolishRingCommand struct {
    jeweler *receiver.Jeweler
}
 
func NewPolishRingCommand(j *receiver.Jeweler) *PolishRingCommand {
    return &PolishRingCommand{jeweler: j}
}
 
func (p *PolishRingCommand) Execute() error {
    return p.jeweler.PolishRing()
}
 
func (p *PolishRingCommand) Undo() error {
    return p.jeweler.UndoPolishRing()
}
 
func (p *PolishRingCommand) Name() string {
    return "PolishRingCommand"
}

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Command Pattern 命令模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/26 12:57
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : jewelry_service.go
*/
package service
 
import (
    "fmt"
    "godesginpattern/command/command"
    "godesginpattern/command/invoker"
)
 
// JewelryService 业务服务：职责单一，编排业务流程
type JewelryService struct {
    workbench *invoker.Workbench
    polishCmd command.Command
    inlayCmd  command.Command
    cleanCmd  command.Command
}
 
func NewJewelryService(
    workbench *invoker.Workbench,
    polishCmd command.Command,
    inlayCmd command.Command,
    cleanCmd command.Command,
) *JewelryService {
    return &JewelryService{
        workbench: workbench,
        polishCmd: polishCmd,
        inlayCmd:  inlayCmd,
        cleanCmd:  cleanCmd,
    }
}
 
// RunBusinessFlow 执行完整业务流程
func (s *JewelryService) RunBusinessFlow() {
    fmt.Println("========== 企业级珠宝加工系统启动 ==========\n")
 
    // 执行命令
    _ = s.workbench.ExecuteCommand(s.polishCmd)
    _ = s.workbench.ExecuteCommand(s.inlayCmd)
    _ = s.workbench.ExecuteCommand(s.cleanCmd)
 
    fmt.Println("\n========== 开始撤销操作 ==========")
    _ = s.workbench.UndoLastCommand()
    _ = s.workbench.UndoLastCommand()
    _ = s.workbench.UndoLastCommand()
    _ = s.workbench.UndoLastCommand()
}

调用：

/*
# 版权所有  2026 ©涂聚文有限公司™ ®
# 许可信息查看：言語成了邀功盡責的功臣，還需要行爲每日來值班嗎
# 描述：Command Pattern 命令模式
# Author    : geovindu,Geovin Du 涂聚文.
# IDE       : goLang 2024.3.6 go 26.2
# os        : windows 10
# database  : mysql 9.0 sql server 2019, postgreSQL 17.0  Oracle 21c Neo4j
# Datetime  : 2026/4/26 15:09
# User      :  geovindu
# Product   : GoLand
# Project   : godesginpattern
# File      : commandbll.go
 
Command/
├── cmd/                  # 启动入口
│   └── main.go           # 程序主入口
├── internal/             # 内部业务包（对外不可暴露）
│   ├── receiver/         # 接收者：真正执行业务（工匠）
│   │   └── jeweler.go
│   ├── command/          # 命令层：抽象命令 + 具体命令
│   │   ├── command.go    # 命令接口
│   │   ├── polish.go     # 抛光命令
│   │   ├── inlay.go      # 镶嵌命令
│   │   └── clean.go      # 清洗命令
│   ├── invoker/          # 调用者：工作台/命令执行器
│   │   └── workbench.go
│   └── service/          # 业务服务层（可选，复杂业务使用）
│       └── jewelry_service.go
├── go.mod                # Go 模块
└── go.sum
*/
package bll
 
import (
    "godesginpattern/command/command"
    "godesginpattern/command/invoker"
    "godesginpattern/command/receiver"
    "godesginpattern/command/service"
)
 
func CommandMain() {
    // 1. 创建接收者（工匠）
    jeweler := receiver.NewJeweler("首席工匠 - 张师傅")
 
    // 2. 创建命令（依赖注入接收者）
    polishCmd := command.NewPolishRingCommand(jeweler)
    inlayCmd := command.NewInlayDiamondCommand(jeweler)
    cleanCmd := command.NewCleanNecklaceCommand(jeweler)
 
    // 3. 创建调用者（工作台）
    workbench := invoker.NewWorkbench()
 
    // 4. 创建业务服务（组装依赖）
    appService := service.NewJewelryService(workbench, polishCmd, inlayCmd, cleanCmd)
 
    // 5. 执行业务流程
    appService.RunBusinessFlow()
}

输出：