設計模式學習-使用go實現建造者模式

2021 年 11 月 6 日
筆記
設計模式

建造者模式

建造者模式

定義

Builder 模式，中文翻譯為建造者模式或者構建者模式，也有人叫它生成器模式。

建造者模式（Builder Pattern）使用多個簡單的對象一步一步構建成一個複雜的對象。這種類型的設計模式屬於創建型模式，它提供了一種創建對象的最佳方式。

一個 Builder 類會一步一步構造最終的對象。該 Builder 類是獨立於其他對象的。

看了定義還是暈暈的，這裡來個栗子

這裡按照設計模式之美中的資源池的例子來進行討論

假設有這樣一道設計面試題：我們需要定義一個資源池配置類ResourcePoolConfig。這裡的資源池，你可以簡單理解為執行緒池、連接池、對象池等。在這個資源池配置類中，有以下幾個成員變數，也就是可配置項。現在，請你編寫程式碼實現這個ResourcePoolConfig類。

成員變數	解釋	是否必填	默認值
name	資源名稱	是	沒有
maxTotal	最大資源數量	否	10
maxIdle	最大空閑資源數量	否	10
minIdle	最小空閑資源數量	否	1

很簡單，來看下程式碼實現

const (
	defaultMaxTotal = 10
	defaultMaxIdle  = 10
	defaultMinIdle  = 1
)

// ResourcePoolConfig ...
type ResourcePoolConfig struct {
	name     string
	maxTotal int
	maxIdle  int
	minIdle  int
}

func NewResourcePoolConfig(name string, maxTotal, maxIdle, minIdle *int) (*ResourcePoolConfig, error) {
	rc := &ResourcePoolConfig{
		maxTotal: defaultMaxTotal,
		maxIdle:  defaultMaxIdle,
		minIdle:  defaultMinIdle,
	}
	if name == "" {
		return nil, errors.New("name is empty")
	}
	rc.name = name

	if maxTotal != nil {
		if *maxTotal <= 0 {
			return nil, errors.New("maxTotal should be positive")
		}
		rc.maxTotal = *maxTotal
	}

	if maxIdle != nil {
		if *maxIdle <= 0 {
			return nil, errors.New("maxIdle should not be negative")
		}
		rc.maxIdle = *maxIdle
	}

	if minIdle != nil {
		if *minIdle <= 0 {
			return nil, errors.New("minIdle should not be negative")
		}
		rc.minIdle = *minIdle
	}

	return rc, nil
}

我們接著討論，如果需要傳入的參數過多，我們可以使用 set() 函數來給成員變數賦值，以替代冗長的構造函數。

const (
	defaultMaxTotal = 10
	defaultMaxIdle  = 10
	defaultMinIdle  = 1
)

// ResourcePoolConfig ...
type ResourcePoolConfig struct {
	name     string
	maxTotal int
	maxIdle  int
	minIdle  int
}

func NewResourcePoolConfigSet(name string) (*ResourcePoolConfig, error) {
	if name == "" {
		return nil, errors.New("name is empty")
	}

	return &ResourcePoolConfig{
		maxTotal: defaultMaxTotal,
		maxIdle:  defaultMaxIdle,
		minIdle:  defaultMinIdle,
		name:     name,
	}, nil
}

// SetMinIdle ...
func (rc *ResourcePoolConfig) SetMinIdle(minIdle int) error {
	if minIdle < 0 {
		return fmt.Errorf("min idle cannot < 0, input: %d", minIdle)
	}
	rc.minIdle = minIdle
	return nil
}

// SetMaxIdle ...
func (rc *ResourcePoolConfig) SetMaxIdle(maxIdle int) error {
	if maxIdle < 0 {
		return fmt.Errorf("max idle cannot < 0, input: %d", maxIdle)
	}
	rc.maxIdle = maxIdle
	return nil
}

// SetMaxTotal ...
func (rc *ResourcePoolConfig) SetMaxTotal(maxTotal int) error {
	if maxTotal <= 0 {
		return fmt.Errorf("max total cannot <= 0, input: %d", maxTotal)
	}
	rc.maxTotal = maxTotal
	return nil
}

到這裡，我們還是沒有用上建造者模式，我們來接著分析上面的栗子

1、上面的 name 欄位是必填的，如果必填欄位很多，那麼我們的函數中又會出現參數很長的情況。當然必填項是不能放在set中設置的，因為如果對應的set沒加，我們不能判斷該參數必填的邏輯。

2、比如依賴關係，比如，如果用戶設置了maxTotal、maxIdle、minIdle其中一個，就必須顯式地設置另外兩個；或者配置項之間有一定的約束條件，比如，maxIdle和minIdle要小於等於maxTotal。所以我們就需要一開始就知道所有的參數，才能進行對應校驗。

3、如果我們希望ResourcePoolConfig類對象是不可變對象，也就是說，對象在創建好之後，就不能再修改內部的屬性值。要實現這個功能，我們就不能在ResourcePoolConfig類中暴露set()方法。

這時候建造者模式就登場了

const (
	defaultMaxTotal = 10
	defaultMaxIdle  = 10
	defaultMinIdle  = 1
)

// ResourcePoolConfig ...
type ResourcePoolConfig struct {
	name     string
	maxTotal int
	maxIdle  int
	minIdle  int
}

// ResourcePoolConfigBuilder ...
type ResourcePoolConfigBuilder struct {
	name     string
	maxTotal int
	maxIdle  int
	minIdle  int
}

// SetName ...
func (rb *ResourcePoolConfigBuilder) SetName(name string) error {
	if name == "" {
		return fmt.Errorf("name can not be empty")
	}
	rb.name = name
	return nil
}

// SetMinIdle ...
func (rb *ResourcePoolConfigBuilder) SetMinIdle(minIdle int) error {
	if minIdle < 0 {
		return fmt.Errorf("max total cannot < 0, input: %d", minIdle)
	}
	rb.minIdle = minIdle
	return nil
}

// SetMaxIdle ...
func (rb *ResourcePoolConfigBuilder) SetMaxIdle(maxIdle int) error {
	if maxIdle < 0 {
		return fmt.Errorf("max total cannot < 0, input: %d", maxIdle)
	}
	rb.maxIdle = maxIdle
	return nil
}

// SetMaxTotal ...
func (rb *ResourcePoolConfigBuilder) SetMaxTotal(maxTotal int) error {
	if maxTotal <= 0 {
		return fmt.Errorf("max total cannot <= 0, input: %d", maxTotal)
	}
	rb.maxTotal = maxTotal
	return nil
}

// Build ...
func (rb *ResourcePoolConfigBuilder) Build() (*ResourcePoolConfig, error) {
	if rb.name == "" {
		return nil, errors.New("name can not be empty")
	}

	// 設置默認值
	if rb.minIdle == 0 {
		rb.minIdle = defaultMinIdle
	}

	if rb.maxIdle == 0 {
		rb.maxIdle = defaultMaxIdle
	}

	if rb.maxTotal == 0 {
		rb.maxTotal = defaultMaxTotal
	}

	if rb.maxTotal < rb.maxIdle {
		return nil, fmt.Errorf("max total(%d) cannot < max idle(%d)", rb.maxTotal, rb.maxIdle)
	}

	if rb.minIdle > rb.maxIdle {
		return nil, fmt.Errorf("max idle(%d) cannot < min idle(%d)", rb.maxIdle, rb.minIdle)
	}

	return &ResourcePoolConfig{
		name:     rb.name,
		maxTotal: rb.maxTotal,
		maxIdle:  rb.maxIdle,
		minIdle:  rb.minIdle,
	}, nil
}

建造者模式，避免了無效狀態的存在，因為是設置構建者的變數，構建的變數符合條件之後，一次性的創建對象，這樣創建的對象就一直處於有效狀態了。

不過 go 中函數傳值可以這樣使用，一般公共庫的時候都會選擇這中方式，方便後期的擴展

const (
	defaultMaxTotal = 10
	defaultMaxIdle  = 10
	defaultMinIdle  = 1
)

// ResourcePoolConfig ...
type ResourcePoolConfig struct {
	name     string
	maxTotal int
	maxIdle  int
	minIdle  int
}

type Param func(*ResourcePoolConfig)

func NewResourcePoolConfigOption(name string, param ...Param) (*ResourcePoolConfig, error) {
	if name == "" {
		return nil, errors.New("name is empty")
	}
	ps := &ResourcePoolConfig{
		maxIdle:  defaultMinIdle,
		minIdle:  defaultMinIdle,
		maxTotal: defaultMaxTotal,
		name:     name,
	}

	for _, p := range param {
		p(ps)
	}

	if ps.maxTotal < 0 || ps.maxIdle < 0 || ps.minIdle < 0 {
		return nil, fmt.Errorf("args err, option: %v", ps)
	}

	if ps.maxTotal < ps.maxIdle || ps.minIdle > ps.maxIdle {
		return nil, fmt.Errorf("args err, option: %v", ps)
	}

	return ps, nil
}

func MaxTotal(maxTotal int) Param {
	return func(o *ResourcePoolConfig) {
		o.maxTotal = maxTotal
	}
}

func MaxIdle(maxIdle int) Param {
	return func(o *ResourcePoolConfig) {
		o.maxIdle = maxIdle
	}
}

func MinIdle(minIdle int) Param {
	return func(o *ResourcePoolConfig) {
		o.minIdle = minIdle
	}
}

相比於建造者模式，這種方式更其輕便，但是建造者模式也有有點，對於複雜參數的檢驗支援的更好

適用範圍

1、類的必填屬性放到構造函數中，強制創建對象的時候就設置。然後參數比較多，並且有必填校驗

2、類的屬性之間有一定的依賴關係或者約束條件

3、希望創建不可變對象

總結下就是

1、需要生成的對象具有複雜的內部結構。

2、需要生成的對象內部屬性本身相互依賴。

與工廠模式的區別

工廠模式：工廠模式是用來創建不同但是相關類型的對象（繼承同一父類或者介面的一組子類），由給定的參數來決定創建哪種類型的對象

建造者模式：建造者模式是用來創建一種類型的複雜對象，通過設置不同的可選參數，「訂製化」地創建不同的對象。

來個栗子：

顧客走進一家餐館點餐，我們利用工廠模式，根據用戶不同的選擇，來製作不同的食物，比如披薩、漢堡、沙拉。對於披薩來說，用戶又有各種配料可以訂製，比如乳酪、西紅柿、起司，我們通過建造者模式根據用戶選擇的不同配料來製作披薩。

優點

1、建造者獨立，易擴展。

2、便於控制細節風險。

缺點

1、產品必須有共同點，範圍有限制。

2、如內部變化複雜，會有很多的建造類。

參考

【文中涉及到的程式碼】//github.com/boilingfrog/design-pattern-learning/tree/master/建造者模式
【大話設計模式】//book.douban.com/subject/2334288/
【極客時間】//time.geekbang.org/column/intro/100039001
【建造者模式】//www.runoob.com/design-pattern/builder-pattern.html
【Go設計模式03-建造者模式】//lailin.xyz/post/builder.html
【建造者模式】//boilingfrog.github.io/2021/11/06/使用go實現建造者模式/

Tags: 設計模式