實踐Go的命令模式

簡介

現在的軟件系統往往是分層設計。在業務層執行一次請求時，我們很清楚請求的上下文，包括，請求是做什么的、參數有哪些、請求的接收者是誰、返回值是怎樣的。相反，基礎設施層并不需要完全清楚業務上下文，它只需知道請求的接收者是誰即可，否則就耦合過深了。

因此，我們需要對請求進行抽象，將上下文信息封裝到請求對象里，這其實就是命令模式，而該請求對象就是 Command。

GoF 對命令模式（Command Pattern）的定義如下：

Encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations.

也即，命令模式可將請求轉換為一個包含與請求相關的所有信息的對象，它能將請求參數化、延遲執行、實現 Undo / Redo 操作等。

上述的請求是廣義上的概念，可以是網絡請求，也可以是函數調用，更通用地，指一個動作。

命令模式主要包含 3 種角色：

Command，命令，是對請求的抽象。具體的命令實現時，通常會引用 Receiver。
Invoker，請求的發起發起方，它并不清楚 Command 和 Receiver 的實現細節，只管調用命令的接口。
Receiver，請求的接收方。

命令模式，一方面，能夠使得 Invoker 與 Receiver 消除彼此之間的耦合，讓對象之間的調用關系更加靈活；另一方面，能夠很方便地實現延遲執行、Undo、Redo 等操作，因此被廣泛應用在軟件設計中。

UML 結構

場景上下文

在?簡單的分布式應用系統（示例代碼工程）中，db 模塊用來存儲服務注冊信息和系統監控數據。其中，服務注冊信息拆成了 profiles 和 regions 兩個表，在服務發現的業務邏輯中，通常需要同時操作兩個表，為了避免兩個表數據不一致的問題，db 模塊需要提供事務功能:

事務的核心功能之一是，當其中某個語句執行失敗時，之前已執行成功的語句能夠回滾，而使用命令模式能夠很方便地實現該功能。

代碼實現

// demo/db/transaction.go
package db
// Command 執行數據庫操作的命令接口
// 關鍵點1: 定義命令抽象接口
type Command interface {// 關鍵點2: 命令抽象接口中聲明執行命令的方法Exec() error // Exec 執行insert、update、delete命令// 關鍵點3: 如果有撤銷功能，則需要定義Undo方法Undo() // Undo 回滾命令setDb(db Db) // SetDb 設置關聯的數據庫
}
// Transaction Db事務實現，事務接口的調用順序為begin -> exec -> exec > ... -> commit
// 關鍵點4: 定義Invoker對象
type Transaction struct {name stringdb   Db// 關鍵點5: Invoker對象持有Command的引用cmds []Command
}
// Begin 開啟一個事務
func (t *Transaction) Begin() {t.cmds = make([]Command, 0)
}
// Exec 在事務中執行命令，先緩存到cmds隊列中，等commit時再執行
func (t *Transaction) Exec(cmd Command) error {if t.cmds == nil {return ErrTransactionNotBegin}cmd.setDb(t.db)t.cmds = append(t.cmds, cmd)return nil
}
// Commit 提交事務，執行隊列中的命令，如果有命令失敗，則回滾后返回錯誤
// 關鍵點6: 為Invoker對象定義Call方法，在方法內調用Command的執行方法Exec
func (t *Transaction) Commit() error {history := &cmdHistory{history: make([]Command, 0, len(t.cmds))}for _, cmd := range t.cmds {if err := cmd.Exec(); err != nil {history.rollback()return err}history.add(cmd)}return nil
}
// cmdHistory 命令執行歷史
type cmdHistory struct {history []Command
}
func (c *cmdHistory) add(cmd Command) {c.history = append(c.history, cmd)
}
// 關鍵點7: 在回滾方法中，調用已執行命令的Undo方法
func (c *cmdHistory) rollback() {for i := len(c.history) - 1; i >= 0; i-- {c.history[i].Undo()}
}
// InsertCmd 插入命令
// 關鍵點8: 定義具體的命令類，實現Command接口
type InsertCmd struct {// 關鍵點9: 命令通常持有接收者的引用，以便在執行方法中與接收者交互db         DbtableName stringprimaryKey interface{}newRecord interface{}
}
// 關鍵點10: 命令對象執行方法中，調用Receiver的Action方法，這里的Receiver為db對象，Action方法為Insert方法
func (i *InsertCmd) Exec() error {return i.db.Insert(i.tableName, i.primaryKey, i.newRecord)
}
func (i *InsertCmd) Undo() {i.db.Delete(i.tableName, i.primaryKey)
}
func (i *InsertCmd) setDb(db Db) {i.db = db
}
// UpdateCmd 更新命令
type UpdateCmd struct {...}
// DeleteCmd 刪除命令
type DeleteCmd struct {...}

客戶端可以這么使用：

func client() {transaction := db.CreateTransaction("register" + profile.Id)transaction.Begin()rcmd := db.NewUpdateCmd(regionTable).WithPrimaryKey(profile.Region.Id).WithRecord(profile.Region)transaction.Exec(rcmd)pcmd := db.NewUpdateCmd(profileTable).WithPrimaryKey(profile.Id).WithRecord(profile.ToTableRecord())transaction.Exec(pcmd)if err := transaction.Commit(); err != nil {return ... }return ...
}

總結實現命令模式的幾個關鍵點：

定義命令抽象接口，本例子中為 Command 接口。
在命令抽象接口中聲明執行命令的方法，本例子中為 Exec 方法。
如果要實現撤銷功能，還需要為命令對象定義 Undo 方法，在操作回滾時調用。
定義 Invoker 對象，本例子中為 Transaction 對象。
在 Invoker 對象持有 Command 的引用，本例子為 Command 的切片 cmds。
為 Invoker 對象定義 Call 方法，用于執行具體的命令，在方法內調用 Command 的執行方法，本例子中為 Transaction.Commit 方法。
如果要實現撤銷功能，還要在回滾方法中，調用已執行命令的 Undo 方法，本例子中為 cmdHistory.rollback 方法。
定義具體的命令類，實現 Command 接口，本例子中為 InsertCmd、UpdateCmd、DeleteCmd。
命令通常持有接收者的引用，以便在執行方法中與接收者交互。本例子中，Receiver 為 Db 對象。
最后，在命令對象執行方法中，調用 Receiver 的 Action 方法，本例子中， Receiver 的 Action 方法為 db.Insert 方法。

值得注意的是，本例子中 Transaction 對象在 Transaction.Exec 方法中只是將 Command 保存在隊列中，只有當調用 Transaction.Commit 方法時才延遲執行相應的命令。

擴展

os/exec 中的命令模式

Go 標準庫的 os/exec 包也用到了命令模式。

package main
import ("os/exec"
)
// 對應命令模式中的Invoker
func main() {cmd := exec.Command("sleep", "1")err := cmd.Run()
}

在上述例子中，我們通過 exec.Command 方法將一個 shell 命令轉換成一個命令對象?exec.Cmd，其中的 Cmd.Run() 方法即是命令執行方法；而 main() 函數，對應到命令模式中的 Invoker；Receiver 則是操作系統執行 shell 命令的具體進程，從 exec.Cmd 的源碼中可以看到：

// src/os/exec/exec.go
package exec
// 對應命令模式中的Command
type Cmd struct {...// 對應命令模式中的ReceiverProcess *os.Process...
}
// 對應命令模式中Command的執行方法
func (c *Cmd) Run() error {if err := c.Start(); err != nil {return err}return c.Wait()
}
func (c *Cmd) Start() error {...// Command與Receiver的交互c.Process, err = os.StartProcess(c.Path, c.argv(), &os.ProcAttr{...})...
}