一個菜鳥的設計模式之旅，文章可能會有不對的地方，懇請大佬指出錯誤，
編程旅途是漫長遙遠的，在不同時刻有不同的感悟，本文會一直更新下去，
程式介紹
本程式實作收銀員對顧客收銀時可以采用不同的促銷策略，支持原價，按折扣促銷，滿多少返利多少三種策略，使用策略模式與簡單工廠模式，簡單工廠使用依賴注入方法，通過組態檔 config.json 能夠動態實體化物件，
PS C:\Users\小能喵喵喵\Desktop\設計模式\策略模式_簡單工廠_反射> go run .
商品數量 10
單價 100
當前商品總額￥700
--------------------------------
商品數量 30
單價 50
當前商品總額￥1700
--------------------------------
商品數量 -1
顧客需要支付￥1700
程式代碼
typeRegister.go
package main
import (
"errors"
"reflect"
"runtime"
)
var TypeReg = make(TypeRegister)
func init() {
TypeReg.Set(Discount{})
TypeReg.Set(MoneyOff{})
TypeReg.Set(Normal{})
runtime.GC()
}
type TypeRegister map[string]reflect.Type
func (t TypeRegister) Set(i interface{}) {
t[reflect.TypeOf(i).Name()] = reflect.TypeOf(i)
}
func (t TypeRegister) Get(name string) (interface{}, error) {
if typ, ok := t[name]; ok {
return reflect.New(typ).Interface(), nil // ^ 新建物件獲取指標并以空介面型別回傳
}
return nil, errors.New("no one")
}
- 維護一個
TypeRegister字典結構是為了實作依賴注入，什么是依賴注入？
var TypeReg = make(TypeRegister)
首先介紹一種設計思想，控制反轉，正常情況下，對函式或方法的呼叫是呼叫方主動的行為，呼叫方清楚地知道被調的函式名是什么，引數有哪些型別直接主動呼叫，包括物件的初始化也是顯式直接初始化，控制反轉就是將主動行為變為間接行為，呼叫方需要通過框架代碼進行間接呼叫和初始化，
這樣的好處就是能夠解耦呼叫方和被調方，呼叫者的代碼不用寫死，可以讓控制反轉的框架代碼讀取配置，動態構建物件，依賴注入是實作控制反轉的一種方法，通過注入引數或實體的方式實作控制反轉，通常這兩者是同一個東西，
golang沒有java的class.forName動態生成類實體的方法，需要自行維護一套型別注冊字典，該字典型別有添加類和生成類實體兩大方法，init函式會在main函式之前運行，在函式體創建各個型別的實體來進行注冊，使字典保存各個型別的類名和對應的reflect.Type結構，reflect.Type通過的New函式創建一個新的實體并回傳它的指標，這樣我們可以實作依賴注入，控制反轉（通過外部的 config.json 組態檔，動態生成實體）
- 為什么要回傳空介面型別？
return reflect.New(typ).Interface(), nil
New出來的是reflect.Value型別，不是原有的具體型別，轉換成空介面，該介面內部存放具體型別實體，可以使用介面型別查詢去還原為具體型別，
jsonConfig.go
package main
// 加載 config.json 檔案并創建維護策略實體的背景關系實體物件
// by 小能喵喵喵 2022年9月8日
import (
"encoding/json"
"io/ioutil"
"log"
"strings"
)
const (
configPath = "./config.json" // 組態檔絕對路徑
)
type Config struct {
Promotion string `json:"promotion"` // 從json字串轉換成結構體
}
func loadConfig() (c Context) {
config := getConfig(configPath)
params := strings.Split(config.Promotion, " ")
c.set(params[0], params[1:]) // 動態生成結構體實體并呼叫實體的config函式填入引數
return
}
func getConfig(path string) Config {
f, err := ioutil.ReadFile(path)
if err != nil {
log.Fatal("Error when opening file: ", err)
}
var config Config
err = json.Unmarshal(f, &config)
if err != nil {
log.Fatal("Error during Unmarshal(): ", err)
}
return config
}
strategy.go
package main
import (
"math"
"strconv"
)
// ^ 策略介面定義所有支持的演算法的公共介面
type IStrategy interface {
acceptCash(money float64) float64
config(args []string)
}
type Normal struct{}
type Discount struct {
Percent float64
}
type MoneyOff struct {
Threshold float64
Back float64
}
func (d Normal) acceptCash(money float64) float64 {
return money
}
func (d *Normal) config(args []string) {}
func (d Discount) acceptCash(money float64) float64 {
return money * d.Percent
}
func (d *Discount) config(args []string) {
d.Percent = GetFloat(args[0])
}
func (m MoneyOff) acceptCash(money float64) float64 {
if money >= m.Threshold {
money -= math.Floor(money/m.Threshold) * m.Back
}
return money
}
func (m *MoneyOff) config(args []string) {
m.Threshold = GetFloat(args[0])
m.Back = GetFloat(args[1])
}
// ^ 字串轉float64
func GetFloat(s string) float64 {
f, _ := strconv.ParseFloat(s, 64)
return f
}
/* -------------------------------------------------------------------------- */
// ^ 背景關系物件用于生成策略實體
type Context struct {
strategy IStrategy
}
// ^ 依賴注入生成策略實體
func (c *Context) set(str string, args []string) {
var strategy IStrategy
s, err := TypeReg.Get(str)
if err != nil {
return
}
strategy = s.(IStrategy)
strategy.config(args)
c.strategy = strategy
}
// ^ 背景關系執行策略
func (c *Context) cal(f float64) float64 {
if c.strategy == nil {
return f
}
return c.strategy.acceptCash(f)
}
main.go
package main
// 策略模式_簡單工廠_反射
// by 小能喵喵喵 2022年9月8日
import (
"fmt"
"strings"
)
var (
cost float64
quantity int
price float64
)
func main() {
c := loadConfig()
for {
fmt.Print("商品數量 ")
fmt.Scanln(&quantity)
if quantity <= 0 {
break
}
fmt.Print("單價 ")
fmt.Scanln(&price)
// ^ 使用策略
cost += c.cal(price * float64(quantity))
fmt.Printf("當前商品總額￥%v\n", cost)
fmt.Println(strings.Repeat("-", 32))
}
fmt.Printf("顧客需要支付￥%v\n", cost)
}
config.json
{
"promotion": "MoneyOff 300 100"
}
可以改成 Normal，也可以改成 Discount 0.5 打五折
Console
PS C:\Users\小能喵喵喵\Desktop\設計模式\策略模式_簡單工廠_反射> go run .
商品數量 10
單價 100
當前商品總額￥700
--------------------------------
商品數量 30
單價 50
當前商品總額￥1700
--------------------------------
商品數量 -1
顧客需要支付￥1700
思考總結
什么是策略模式
一個類的行為或其演算法可以在運行時更改，這種型別的設計模式屬于行為型模式，
策略模式：定義了演算法家族，分別封裝起來，讓它們之間可以相互替換，此模式讓演算法的變化，不會影響到使用演算法的客戶，
可能有點抽象，晦澀難懂，用自己的話來說就是
策略模式（白話文）：完成一件事有多種方法，比如刷碗可以人工刷也可以機器刷，做的都是刷碗的作業，把各個方法封裝到類里面去，每個類都能完成同樣的作業，我們可以抽象出行為共性，即介面，介面內有這個公共方法，各個子類實作這個介面，客戶端（使用方）宣告一個介面接收一個具體的子類方法實體，然后呼叫宣告介面的公共方法（里氏替換原則），如果未來需要添加新的方法，只需要添加子類，原來的客戶端不會受到影響（開放-封閉原則），如果需要修改原來的方法，只需要修改客戶端new實體的地方（最小的改動），
使用策略模式能夠降低具體演算法與使用者之間耦合程度，封裝的演算法完成的是同一份作業，只是實作不同，這些演算法隨時都可能相互替換的，策略模式封裝了變化點，雖然嚴格定義上策略模式是用來封裝演算法的，但實踐中可以用來封裝任何型別的規則（需要在不同時間應用不同的業務規劃），
完成一個作業有多個方法，如果不用策略模式，而是直接在單個類中使用方法，如果每個方法的執行有一定的條件要求，那么肯定會導致方法在這個類的堆積（大量的switch，if判斷），這既不靈活，也不好維護，如果有了新的方法，拓展了子類，卻還要修改客戶端的判斷，這顯然違背了開放-封閉原則，
通過里氏代換原則，子類必須能夠替換父類而不影響代碼的正常運行；迪米特法則，如果兩個類不直接通信，盡量讓兩個類之間保持松耦合，策略模式的設計，客戶端使用context物件，該物件維護了一個策略實體，實際上變數宣告的是抽象父類或抽象介面（里氏代換原則），用戶通過context物件呼叫具體策略的方法，而不再通過各個分支判斷new出具體策略實體呼叫方法，
基本策略模式優點
- 封裝了變化點，消除客戶端繁雜的條件陳述句，
- 符合里氏代換原則、迪米特法則，
- 提供了統一介面方法，每個子類都是一個策略，方便進行單元測驗，
基本策略模式缺點
- 選擇策略的職責依舊是客戶端承擔，將選擇的策略轉給Context物件，可以實作依賴注入，
- Context用switch來判斷生成哪個子類實體，每添加一個子類就要修改Context，違反了
開放-封閉原則，可以用反射解決，
策略模式為什么要context
有人說為啥要 context ，干脆在客戶端宣告介面然后new具體策略不就行了？既然要context肯定有它設計的原因，我認為主要有兩點
- 可以在context做一些必要作業，難不成你客戶端每次new具體策略前都要寫一遍額外作業的重復代碼？
- context用于實作簡單工廠模式，將客戶端判斷分支的邏輯遷移到context中去，那么每次擴展策略類，只要修改context了，而這個判斷分支的邏輯也能進一步用反射優化，通過反射動態實體化物件，去除分支判斷（具體可以看上面的例子）
什么是簡單工廠
簡單工廠模式屬于創建型模式的一種，創建型模式隱藏了這些類的實體是如何被創建和放在一起，整個系統關于這些物件所知道的是由抽象類所定義的介面，
案例程式中Context使用了改進后的簡單工廠，客戶端呼叫set函式，使用了反射技術和依賴注入，Context可以動態生成實體物件，
簡單工廠模式優點
- 工廠類包含必要邏輯判斷，根據客戶端的選擇條件動態實體化相關的類，對于客戶端來說，去除了與具體產品的依賴，
簡單工廠模式缺點
- 不符合
開放-封閉原則，每一次更改都要更改工廠類，
擴展應用場景
參考資料
- 《Go語言核心編程》李文塔
- 《Go語言高級編程》柴樹彬、曹春輝
- 《大話設計模式》程杰
- 策略模式 | 菜鳥教程 (runoob.com)
轉載請註明出處，本文鏈接：https://www.uj5u.com/ruanti/506059.html
標籤：設計模式