本文主要介绍了Go语言中函数式选项模式及该设计模式在实际编程中的应用。

为什么需要函数式选项模式？

最近看go-micro/options.go源码的时候，发现了一段关于服务注册的代码如下：

  1. type Options struct {
  2.     Broker    broker.Broker
  3.     Cmd       cmd.Cmd
  4.     Client    client.Client
  5.     Server    server.Server
  6.     Registry  registry.Registry
  7.     Transport transport.Transport
  8.     // Before and After funcs
  9.     BeforeStart []func() error
  10.     BeforeStop  []func() error
  11.     AfterStart  []func() error
  12.     AfterStop   []func() error
  13.     // Other options for implementations of the interface
  14.     // can be stored in a context
  15.     Context context.Context
  16. }
  17. func newOptions(opts ...Option) Options {
  18.     opt := Options{
  19.         Broker:    broker.DefaultBroker,
  20.         Cmd:       cmd.DefaultCmd,
  21.         Client:    client.DefaultClient,
  22.         Server:    server.DefaultServer,
  23.         Registry:  registry.DefaultRegistry,
  24.         Transport: transport.DefaultTransport,
  25.         Context:   context.Background(),
  26.     }
  27.     for _, o := range opts {
  28.         o(&opt)
  29.     }
  30.     return opt
  31. }

当时呢，也不是很明白newOptions这个构造函数为什么要这么写，但是后面在微信群里看到有人也再发类似的代码问为什么要这么写，后来在群里讨论的时候才知道了这是一种设计模式–函数式选项模式。
可能大家看到现在也不是很明白我说的问题到底是什么，我把它简单提炼一下。
我们现在有一个结构体，定义如下：

  1. type Option struct {
  2.     A string
  3.     B string
  4.     C int
  5. }

现在我们需要为其编写一个构造函数，我们可能会写成下面这种方式：

  1. func newOption(a, b string, c int) *Option {
  2.     return &Option{
  3.         A: a,
  4.         B: b,
  5.         C: c,
  6.     }
  7. }

上面的代码很好理解，也是我们一直在写的。有什么问题吗？
我们现在来思考以下两个问题：

  1. 我们可能需要为Option的字段指定默认值
  2. Option的字段成员可能会发生变更

    选项模式

    我们先定义一个OptionFunc的函数类型
    1. type OptionFunc func(*Option)
    然后利用闭包为每个字段编写一个设置值的With函数：
    1. func WithA(a string) OptionFunc {
    2.  return func(o *Option) {
    3.      o.A = a
    4.  }
    5. }
    6. func WithB(b string) OptionFunc {
    7.  return func(o *Option) {
    8.      o.B = b
    9.  }
    10. }
    11. func WithC(c int) OptionFunc {
    12.  return func(o *Option) {
    13.      o.C = c
    14.  }
    15. }
    然后，我们定义一个默认的Option如下：
    1. var (
    2.  defaultOption = &Option{
    3.      A: "A",
    4.      B: "B",
    5.      C: 100,
    6.  }
    7. )
    最后编写我们新版的构造函数如下：
    1. func newOption2(opts ...OptionFunc) (opt *Option) {
    2.  opt = defaultOption
    3.  for _, o := range opts {
    4.      o(opt)
    5.  }
    6.  return
    7. }
    测试一下：
    1. func main() {
    2.  x := newOption("nazha", "小王子", 10)
    3.  fmt.Println(x)
    4.  x = newOption2()
    5.  fmt.Println(x)
    6.  x = newOption2(
    7.      WithA("沙河娜扎"),
    8.      WithC(250),
    9.  )
    10.  fmt.Println(x)
    11. }
    输出：
    1. &{nazha 小王子 10}
    2. &{A B 100}
    3. &{沙河娜扎 B 250}
    这样一个使用函数式选项设计模式的构造函数就实现了。这样默认值也有了，以后再要为Option添加新的字段也不会影响之前的代码。
    推荐阅读:
    Go 函数式选项模式