迷宫网

先来看个例子：

package main

import "fmt"

type cache struct {
    Name string `json:"mysqli"`
    Host string `json:"host:127.0.0.1"`
    Port int64  `json:"port:3306"`
    Note string
    pwd  string //私有
}

func main() {
    dbConf := cache{Name: "conn", Host: "127.0.0.1", Port: 3306, pwd: "123456"}
    fmt.Println(dbConf)
}

以上是最基础的构造cache方法，注意，cache中包含了pwd这样一个私有化属性，此时在其他的包构造该结构体时，是无法直接赋值的，那怎么办呢？首先想到的是用一个公共的方法来进行统一赋值，如下：

package main

import "fmt"

type cache struct {
    Name string `json:"mysqli"`
    Host string `json:"host:127.0.0.1"`
    Port int64  `json:"port:3306"`
    Note string
    pwd  string //私有
}

func SetCacheVale(name, host, note, pwd string, port int64) *cache {
    return &cache{
        Name: name,
        Host: host,
        Note: note,
        pwd:  pwd,
        Port: port,
    }
}

func main() {
    //dbConf := cache{Name: "conn", Host: "127.0.0.1", Port: 3306, pwd: "123456"}
    //fmt.Println(dbConf)
    dbConf := SetCacheVale("link1", "127.0.0.1", "", "123456", 3306)
    fmt.Println(dbConf)
}

以上通过SetCacheVale 进行结构体的属性赋值，这样做貌似没什么问题，但是如果后期需要对cache结构体扩充，则必然需要修改SetCacheVale这个方法的传参，而外部如果调用了该方法则必须跟着修改。那怎么办呢？把每个参数分别加一个set方法是否可行呢？接着再改一下

package main

import "fmt"

type cache struct {
    Name string `json:"mysqli"`
    Host string `json:"host:127.0.0.1"`
    Port int64  `json:"port:3306"`
    Note string
    pwd  string //私有
}


//设置必填属性
func setBaseVale(name, host string) *cache {
    return &cache{Name: name, Host: host}
}

//设置必填属性+非必填note
func setCacheWithNote(name, host, note string) *cache {
    return &cache{Name: name, Host: host, Note: note}
}

//设置必填属性+非必填port
func setCacheWithPort(name, host string, port int64) *cache {
    return &cache{Name: name, Host: host, Port: port}
}

func main() {
    //dbConf := cache{Name: "conn", Host: "127.0.0.1", Port: 3306, pwd: "123456"}
    //fmt.Println(dbConf)
    //dbConf := SetCacheVale("link1", "127.0.0.1", "", "123456", 3306)
    //fmt.Println(dbConf)
    dbConf := setCacheWithNote("link2", "127.0.0.1", "这是测试连接")
    fmt.Println(dbConf)
}

上面代码中，加入了3个方法，分别是设置基本属性，设置port,设置note。可对应不同的场景，缺点很明显，如果cache加入一个新的属性，则会add多种排列组合，虽然业务端不用修改代码，但是这样的实现不太优雅。下面就来进行重构。

package main

import "fmt"

type cache struct {
    Name string `json:"mysqli"`
    Host string `json:"host:127.0.0.1"`
    Port int64  `json:"port:3306"`
    Note string
    pwd  string //私有
}

//定义一个模版接口，需要实现call调用，传参为cache的结构体指针
type optInterface interface {
    call(*cache)
}

//抽出cache中的name,定义结构体
type SetName struct {
    name string
}

//name实现了接口，用来设置name
func (s SetName) call(c *cache) {
    c.Name = s.name
}

//SetName实现了optInterface中的方法，所以withName的类型和optInterface的类型相同
func withName(n string) optInterface {
    return SetName{name: n}
}

type SetHost struct {
    host string
}

func (s SetHost) call(c *cache) {
    c.Host = s.host
}

func withHost(h string) optInterface {
    return SetHost{host: h}
}

//定义一个公共函数入口,用来接收结构体，调用结构体的call方法
func ValOption(opts ...optInterface) *cache {
    o := &cache{}
    for _, opt := range opts {
        opt.call(o)
    }
    return o
}

func main() {
    dbConf := ValOption(withName("连接测试2"), withHost("127.0.0.2"))
    fmt.Println(dbConf)
}

上面的代码中，将cache的属性抽离，每个属性分别对应3个模块：

• 1.Set{field} 该模块是个结构体，对应cache字段
• 2.Set{field}.call(),该结构体方法接收者是上面对应的结构体，该方法实现了接口optInterface
• 3.with{field} ，该模块返回一个具体设置好的结构体。

除此之外，还需要一个公共的解析方法去解析具体结构体设置方法，在上述代码中，该方法名称为ValOption ，它接收类型为optInterface的组成的切片，返回一个cache指针。

关键说完之后，我们来分析一下重点：
1.为何要设计一个接口？并且还需要属性实现该方法？
原因是公共方法ValOption需要一个统一的参数类型，该接口的目的就是为了类型转换。假设不定义接口，每个参数的类型都不一样，则无法实现公共方法统一处理。

2.option设计模式的具体原则是什么？

• 1.对于cache中的每一个属性都定义一个属性struct,一个属性设置方法（返回结构体本身）和属性接口方法（接口方法传入cache结构体，内部实现结构体属性复写）
• 2.用一个公共入口函数去执行属性的接口方法（传入结构体）

3.option设计模式的好处是什么？
这种方式我们使用Option接口，该接口保存一个未导出的方法，在未导出的options结构上记录选项，这种模式为client端提供了更多的灵活性，针对每一个option可以做更细的custom function设计，更加清晰且不暴露cache的结构，也提高了单元测试的覆盖性，缺点是当cache结构发生变化时，也要同时维护option的结构，维护复杂性升高了。

end!