设计模式就某些编码场景下的最佳实践，用来解决常见的软件设计问题。Go 语言不是面向对象语言，但是可以使用结构体、接口等类型实现面向对象语言的特性，想要弄懂设计模式，要熟练的使用 Go 语言接口类型 和结构体类型
设计模式总体上分为创建型、结构型和行为型 3 类、共 25 种经典设计方案，在 Go 项目开发中常见的有 6 种
下面详细说
创建型
创建型设计模式提供了一种 在创建对象的同时隐藏创建逻辑 的方式，而不是使用 new 运算符直接实例化对象
这种类型的设计模式有单例模式和工厂模式，工厂模式包括简单工厂模式、抽象工厂模式和工厂方法模式三种，这种设计模式在 Go 项目开发种比较常用
单例模式
单例模式是最简单的一个模式。在 Go 中，单例模式指的就是全局只有一个实例，而且只被初始化一次，比较适合 全局共享一个示例，并且只需要被初始化一次 的场景，比如数据库实例、全局配置、全局任务池等
单例模式又分为饿汉方式和懒汉方式，饿汉方式是全局的单例实例在包被加载时创建，懒汉方式是全局的单例实例在第一次被使用时创建
饿汉方式的单例模式：
type singleton struct{}
var ins *singleton = &singleton{}
func GetInsOr() *singleton {
return ins
}
在包被导入时，实例会直接初始化，如果初始化耗时，会导致程序加载时间变长
懒汉方式是开源项目中使用最多的，它的缺点是非并发安全，在实际使用时需要加锁，一个简单的实现：
type singleton struct{}
var ins *singleton
func GetInsOr() *singleton {
if ins == nil {
ins = &singleton{}
}
return ins
}
可以看到，在调用 GetInsOr() 函数时，如果 ins 为 nil，就会创建一个 ins 实例，如果不加锁，就会有多个实例创建
可以对实例加锁，保证并发安全：
import "sync"
type singleton struct{}
var ins *singleton
var mu sync.Mutex
func GetInsOr() *singleton {
if ins == nil {
mu.Lock()
if ins == nil {
ins = &singleton{}
}
mu.Unlock()
}
return ins
}
要注意加锁后需要再判断是否已经创建好实例。这样就保证了并发安全
除了饿汉方式和懒汉方式，在 Go 开发中还有一种更优雅的实现方式，比较推荐使用：
import "sync"
type singleton struct{}
var ins *singleton
var once sync.Once
func GetInsOr() *singleton {
once.Do(func() {
ins = &singleton{}
})
return ins
}
sync.Once 是一个结构体，它提供的 Do 方法可以确保 ins 实例全局只被创建一次，还可以确保在并发场景下，只有一个线程能执行这个函数，Do 方法的参数只能是一个没有参数和返回值的匿名函数，用于做一些初始化操作
工厂模式
工厂模式是面向对象编程中的常用模式，在 Go 中，可以把结构体理解为类，比如：
type Person struct {
Name string
Age int
}
func (p Person) Greet() {
fmt.Println("111")
}
Person 结构体实现了 Greet 方法，有了 Person 结构体，就可以通过简单工厂模式、抽象工厂模式、工厂方法模式这三种方式来创建一个 Person 实例
简单工厂模式是最常用、最简单的，它就是接收一些参数，然后返回 Person 实例：
type Person struct {
Name string
Age int
}
func (p Person) Greet() {
fmt.Println("111")
}
func NewPerson(name string, age int) *Person {
return &Person {
Name: name,
Age: age,
}
}
和 p := &Person{} 这种创建方式相比，简单工厂模式可以确保创建的实例具有需要的参数，进而保证实例的方法可以按预期执行，比如通过 NewPerson 方法创建的 Person 实例，可以确保实例的 name 和 age 属性被设置
抽象工厂模式和简单工厂模式的唯一区别，就是返回的是接口而不是结构体
通过返回接口，可以在 不公开内部实现的情况下，让调用者使用提供好的各种功能，比如：
type Person interface {
Greet()
}
type person struct {
name string
age int
}
func (p person) Greet() {
fmt.Println("111")
}
func NewPerson(name string, age int) Person {
return person {
name: name,
age: age,
}
}
注意接口名是开头大写的 Person，而结构体是开头小写的 person，在 Go 中，开头小写的结构体是不能被导出的，在上面的例子中，只能通过 NewPerson 函数去生成接口类型的实例，这样就隐藏了 person 结构体的内部实现细节
通过返回接口类型，还可以实现多个工厂函数，来实现返回不同的接口实现：
type Doer interface {
Do(req *http.Request) (*http.Response, error)
}
func NewHTTPClient() Doer {
return &http.Client{}
}
// mock 的 HTTP 连接 用于模拟外部连接
type mockHTTPClient struct{}
func (*mockHTTPClient) Do(req *http.Request) (*http.Response, error) {
// 假设 httptest.NewRecorder 是实现好的方法
// 用于返回一个新的 request 实例
res := httptest.NewRecorder()
return res.Result, nil
}
func NewMockHTTPClient() Doer {
return &mockHTTPClient{}
}
NewHTTPClient 和 NewMockHTTPClient 都返回了同一个接口类型 Doer，这使得两者可以互相使用，如果想测试一段调用了 Doer 接口的 Do 方法的代码时，就可以使用 Mock 出来的 HTTP 客户端，避免调用外部接口带来的失败，只专注于测试想测试的代码片段
比如现在想测试下面这段代码：
func QueryUser(doer Doer) error {
req, err := http.NewRequest("Get", "http://iam.api.marmotedu.com:8080/v1/secrets", nil)
if err != nil {
return err
}
_, err := doer.Do(req)
if err != nil {
return err
}
// 处理一些其他逻辑
// ...
return nil
}
给这段代码编写测试用例为：
func TestQueryUser(t *testing.T) {
doer := NewMockHTTPClient()
if err := QueryUser(doer); err != nil {
t.Errof(QueryUser failed, err: %v", err)
}
}
这个测试用例忽略了请求外部的 http://iam.api.marmotedu.com:8080/v1/secrets 带来的错误，只专注于核心业务逻辑
另外，在使用简单工厂模式和抽象工厂模式返回实例对象时，都可以返回指针，比如：
简单工厂模式：
return &Person {
Name: name,
Age: age
}
抽象工厂模式：
return &person {
Name: name,
Age: age
}
但是在实际开发中，推荐使用非指针的实例，因为使用工厂模式是想通过创建实例，来调用其提供的方法，而不是对实例做更改，如果要对实例进行更改，可以给实例实现 SetXXX 方法，返回非指针的实例，可以避免属性被意外修改
在简单工厂模式中，依赖于唯一的工厂对象，如果需要创建一个实例，就要向工厂中传入一个参数，如果工厂函数要根据传入的参数值返回不同类型的实例，如果要创建一种新的实例，就需要在工厂中修改函数，这会导致耦合度过高，这时候就可以使用 工厂方法模式
在工厂方法模式中，依赖工厂函数，通过工厂函数来创建多种工厂，把实例创建从 由一个对象负责所有具体实例的实例化，变成一群子实例负责对具体实例的实例化，从而将过程解耦
比如：
type Person struct {
name string
age int
}
func NewPersonFactory(age int) func(name string) Person {
return func(name string) Person {
return Person {
name: name,
age: age,
}
}
}
NewPersonFactory函数返回了一个闭包函数，使用时可以创建具有默认年龄的工厂：
newBaby := NewPersonFactory(1)
baby := newBaby("john")
newTeenager := NewPersonFactory(16)
teen := newTeenager("jill")
结构型模式
结构型模式关注 类和对象的组合，这一类型中有策略模式和模板模式
策略模式
策略模式定义了一组算法，将每个算法封装起来，并且使它们之间可以互换
在项目开发中，经常要根据不同的场景，采取不同的措施，也就是不同的策略。比如要对 a、b 这两个整数进行运算，根据条件的不同，需要执行不同的计算方式，就可以把所有操作封装在同一个函数中，通过 if ... else ... 来调用不同的计算方式，这种方式称之为硬编码
在实际应用中，随着功能和体验的不断增长，经常需要增加/修改策略，这样就需要不断修改已有的代码，这不仅会让这个函数越来越难维护，还可能因为修改带来一些 bug，为了解耦，就需要使用策略模式，定义一些独立的类来封装不同的算法，每一个类封装一个具体的算法
比如：
// 策略类
type IStrategy interface {
do(int, int) int
}
// 策略实现：加
type add struct{}
func (*add) do(a, b int) int {
return a + b
}
// 策略实现：减
type reduce struct{}
func (*reduce) do(a, b int) int {
return a - b
}
// 具体策略的执行者
type Operator struct {
strategy IStrategy
}
// 设置策略
func (op *Operator) setStrategy(strategy IStrategy) {
op.strategy = strategy
}
// 调用策略中的方法
func (op *Operator) calculate(a, b int) int {
return op.strategy.do(a, b)
}
在这段代码中，定义了策略接口 ISstrategy，还定义了 add 和 reduce 这两种策略，最后定义了一个策略执行者，可以设置不同的策略并执行，比如：
func TestStrategy(t *testing.T) {
op := Operator{}
// 设置策略为 加
op.setStrategy(&add{})
result := op.calculate(1, 2)
fmt.Println("add:", result)
op.setStrategy(&reduce{})
result = operator.calculate(2, 1)
fmt.Println("reduce:", result)
}
这样就可以随意更换策略，而不影响 Operator 的所有实现
模板模式
模板模式定义一个操作中算法的骨架，将一些步骤延迟到子类中，这种方法可以让子类在不改变一个算法结构的情况下，能重新定义该算法的某些特定步骤
实现上，模板模式将一个类中的公用方法放在抽象类中实现，不能公共使用的方法作为抽象方法，强制子类去实现。这样就做到了将一个类作为一个模板，让开发者去填充需要填充的地方
比如：
type Cooker interface {
fire()
cooke()
outfire()
}
// 类似于一个抽象类
type CookMenu struct{}
func (CookMenu) fire() {
fmt.Println("开火")
}
// 做菜，交给具体的子类实现
func (CookMenu) cooke() {
}
func (CookMenu) outfire() {
fmt.Println("关火")
}
// 封装具体步骤
func doCook(cook Cooker) {
cook.fire()
cook.cooke()
cook.outfire()
}
type XiHongShi struct {
CookMenu
}
func (*XiHongShi) cooke() {
fmt.Println("做西红柿")
}
type ChaoJiDan struct {
CookMenu
}
func (ChaoJiDan) cooke() {
fmt.Println("做炒鸡蛋")
}
在上面这段代码中，把通用的开火和关火交给了抽象父类实现，子类通过结构体嵌套的方式继承了通用方法，再自己实现对应的 cooke() 方法。对应的测试用例为：
func TestTemplate(t *testing.T) {
// 做西红柿
xihongshi := &XiHongShi{}
doCook(xihongshi)
// 做炒鸡蛋
chaojidan := &ChaoJiDan{}
doCook(chaojidan)
}
行为型模式
行为型模式关注 对象之间的通信，这一类的设计模式中，有代理模式和选项模式
代理模式
代理模式可以为另一个对象提供一个替身或占位符，用来控制对这个对象的访问
比如：
type Seller interface {
sell(name string)
}
// 火车站
type Station struct {
stock int // 库存
}
func (station *Station) sell(name string) {
if station.stock > 0 {
station.stock--
fmt.Printf("代理点中：%s买了一张票,剩余：%d \n", name, station.stock)
} else {
fmt.Println("票已售空")
}
}
// 火车代理点
type StationProxy struct {
station *Station // 持有一个火车站对象
}
func (proxy *StationProxy) sell(name string) {
// 增加一些其他逻辑，比如权限校验
if proxy.station.stock > 0 {
proxy.station.stock--
fmt.Printf("代理点中：%s买了一张票,剩余：%d \n", name, proxy.station.stock)
} else {
fmt.Println("票已售空")
}
}
在这段代码中，StationProxy代理了 Station，代理类中持有被代理类对象，且和被代理类实现了统一接口。代理类主要是为了增加一种控制机制，在 StationProxy 实现的 sell 方法中，可以增加一些其他的逻辑
选项模式
选项模式是 Go 项目开发中经常用到的模式，比如 grpc/grpc-go的 NewServer 函数，uber-go/zap 包的 New 函数，都用到了选项模式
使用选项模式可以创建一个带有默认值的 struct 变量，并选择性的修改其中一些参数的值
Go 语言中不支持给参数设置默认值，为了既能够创建带默认值的实例，又能创建自定义参数的实例，不使用选项模式，一般有两种写法。
第一种方法是，分别创建两个用来创建实例的函数，一个可以创建带默认值的实例，一个可以定制化参数创建实例
const (
defaultTimeout = 10
defaultCaching = false
)
type Connection struct {
addr string
cache bool
timeout time.Duration
}
// 创建一个连接对象 需要路径参数
func NewConnect(addr string) (*Connection, error) {
return &Connection{
addr: addr,
cache: defaultCaching,
timeout: defaultTimeout,
}, nil
}
// 创建一个连接对象，需要路径参数和一些配置参数
func NewConnectWithOptions(addr string, cache bool, timeout time.Duration) (*Connection, error) {
return &Connection{
addr: addr,
cache: cache,
timeout: timeout,
}, nil
}
这种写法创建一个 Connection 实例，却要实现两个不同的函数，很麻烦，如果 Connection 结构体又增加了新属性，那么也要再编写一个带有这个新属性的构造方法
另一种写法是创建一个带默认值的选项，并用该选项创建实例：
const (
defaultTimeout = 10
defaultCaching = false
)
type Connection struct {
addr string
cache bool
timeout time.Duration
}
type ConnectionOptions struct {
Caching bool
Timeout time.Duration
}
// 默认选项
func NewDefaultOptions() *ConnectionOptions {
return &ConnectionOptions{
Caching: defaultCaching,
Timeout: defaultTimeout,
}
}
// 传入选项结构体和地址
func NewConnect(addr string, opts *ConnectionOptions) (*Connection, error) {
return &Connection{
addr: addr,
cache: opts.Caching,
timeout: opts.Timeout,
}, nil
}
使用这种方式，虽然只需要一个函数来创建实例，但是调用 NewConnect 函数创建实例时，每次都要先创建一个 ConnectionOptions 结构体，操作起来比较麻烦
上面两种都有各自的缺点，使用选项模式可以更优雅的解决：
const (
defaultTimeout = 10
defaultCaching = false
)
type Connection struct {
addr string
cache bool
timeout time.Duration
}
// 配置选项
type options struct {
timeout time.Duration
caching bool
}
// 接口类型 要实现 apply 方法
type Option interface {
apply(*options)
}
// 函数类型起别名 类型是参数为 *options 返回为空的函数
type optionFunc func(*options)
func (f optionFunc) apply(o *options) {
f(o)
}
func WithTimeout(t time.Duration) Option {
// 把参数为 *options 返回为空的函数类型转换为 optionFunc 类型
return optionFunc(func(o *options) {
o.timeout = t
})
}
func WithCaching(cache bool) Option {
return optionFunc(func(o *options) {
o.caching = cache
})
}
// 创建一个连接对象 ... 表示可以有多个 Option 接口类型的参数
func NewConnect(addr string, ops ...Option) (*Connection, error) {
options := options {
timeout: defaultTimeout,
caching: defaultCaching
}
for _, o := range ops {
o.apply(&options)
}
return &Connection{
addr: addr,
cache: options.caching,
timeout: options.timeout,
}, nil
}
在这段代码中，首先定义了 options 结构体，它带有 timeout、caching 两个属性。接下来通过 NewConnect 创建连接，NewConnect 函数首先创建了一个带有默认值的 options 结构体，然后通过传入的 Option 参数，去修改 options 结构体，最后完成创建
在调用时，传入 WithXXX 格式的函数即可完成配置，因为函数返回值是 optionFunc 类型，而 optionFunc 类型又实现了 Option 接口，这就实现了动态设置 options 结构体变量的属性
选项模式有很多有点，例如：支持传递多个参数，在参数发生变化时保持兼容性，支持任意顺序传递参数，支持默认值，方便扩展等等
但是，为了实现选项模式，要增加很多代码，在开发中，要根据实际场景选择是否使用选项模式
选项模式适用的场景有：
-
结构体参数很多，创建结构体时期望创建一个携带默认值的结构体变量，并选择性修改其中一些参数值
-
结构体参数经常变动，变动时又不想修改创建实例的函数，比如：结构体新增一个 retry 参数，但是又不想在 NewConnect 入参列表中添加
retry int这样的参数声明
如果结构体参数比较少，要慎重考虑要不要采用选项模式
总结
设计模式，是业界沉淀下来的针对特定场景的最佳解决方案，Go 项目常见的有 6 种设计模式，每种设计模式解决某一类场景
汇总成一张表：
参考：
设计模式 | 菜鸟教程 (runoob.com)
Go 语言项目开发实战 -11.Go常用设计模式
