Go编程模式：详解函数式选项模式

大家好，我是 polarisxu。

Go 不是完全面向对象语言，有一些面向对象模式不太适合它。但经过这些年的发展，Go 有自己的一些模式。今天介绍一个常见的模式：函数式选项模式(Functional Options Pattern)。

01 什么是函数式选项模式

Go 语言没有构造函数，一般通过定义 New 函数来充当构造函数。然而，如果结构有较多字段，要初始化这些字段，有很多种方式，但有一种方式认为是最好的，这就是函数式选项模式(Functional Options Pattern)。

函数式选项模式是一种在 Go 中构造结构体的模式，它通过设计一组非常有表现力和灵活的 API 来帮助配置和初始化结构体。

在 Uber 的 Go 语言规范中提到了该模式：

Functional options 是一种模式，在该模式中，你可以声明一个不透明的 Option 类型，该类型在某些内部结构中记录信息。你接受这些可变数量的选项，并根据内部结构上的选项记录的完整信息进行操作。

将此模式用于构造函数和其他公共 API 中的可选参数，你预计这些参数需要扩展，尤其是在这些函数上已经有三个或更多参数的情况下。

02 一个示例

为了更好的理解该模式，我们通过一个例子来讲解。

定义一个 Server 结构体：

1. package main
2.  
3. type Server {
4. host string
5. port int
6. }
7.  
8. func New(host string, port int) *Server {
9. return &Server{host, port}
10. }
11.  
12. func (s *Server) Start() error {
13. }

如何使用呢?

1. package main
2.  
3. import (
4. "log"
5. "server"
6. )
7.  
8. func main() {
9. svr := New("localhost", 1234)
10. if err := svr.Start(); err != nil {
11. log.Fatal(err)
12. }
13. }

但如果要扩展 Server 的配置选项，如何做?通常有三种做法：

为每个不同的配置选项声明一个新的构造函数

定义一个新的 Config 结构体来保存配置信息

使用 Functional Option Pattern

做法 1：为每个不同的配置选项声明一个新的构造函数

这种做法是为不同选项定义专有的构造函数。假如上面的 Server 增加了两个字段：

1. type Server {
2.  
3. host string
4.  
5. port int
6.  
7. timeout time.Duration
8.  
9. maxConn int
10.  
11. }

一般来说，host 和 port 是必须的字段，而 timeout 和 maxConn 是可选的，所以，可以保留原来的构造函数，而这两个字段给默认值：

1. func New(host string, port int) *Server {
2.  
3. return &Server{host, port, time.Minute, 100}
4.  
5. }

然后针对 timeout 和 maxConn 额外提供两个构造函数：

1. func NewWithTimeout(host string, port int, timeout time.Duration) *Server {
2.  
3. return &Server{host, port, timeout}
4.  
5. }
6.  
7. func NewWithTimeoutAndMaxConn(host string, port int, timeout time.Duration, maxConn int) *Server {
8.  
9. return &Server{host, port, timeout, maxConn}
10.  
11. }

这种方式配置较少且不太会变化的情况，否则每次你需要为新配置创建新的构造函数。在 Go 语言标准库中，有这种方式的应用。比如 net 包中的 Dial 和 DialTimeout：

1. func Dial(network, address string) (Conn, error)
2.  
3. func DialTimeout(network, address string, timeout time.Duration) (Conn, error)

做法 2：使用专门的配置结构体

这种方式也是很常见的，特别是当配置选项很多时。通常可以创建一个 Config 结构体，其中包含 Server 的所有配置选项。这种做法，即使将来增加更多配置选项，也可以轻松的完成扩展，不会破坏 Server 的 API。

1. type Server {
2. cfg Config
3. }
4.  
5. type Config struct {
6. Host string
7. Port int
8. Timeout time.Duration
9. MaxConn int
10. }
11.  
12. func New(cfg Config) *Server {
13. return &Server{cfg}
14. }

在使用时，需要先构造 Config 实例，对这个实例，又回到了前面 Server 的问题上，因为增加或删除选项，需要对 Config 有较大的修改。如果将 Config 中的字段改为私有，可能需要定义 Config 的构造函数。。。

做法 3：使用 Functional Option Pattern

一个更好的解决方案是使用 Functional Option Pattern。

在这个模式中，我们定义一个 Option 函数类型：

1. type Option func(*Server)

Option 类型是一个函数类型，它接收一个参数：*Server。然后，Server 的构造函数接收一个 Option 类型的不定参数：

1. func New(options ...Option) *Server {
2.  
3. svr := &Server{}
4.  
5. for _, f := range options {
6.  
7. f(svr)
8.  
9. }
10.  
11. return svr
12.  
13. }

那选项如何起作用?需要定义一系列相关返回 Option 的函数：

1. func WithHost(host string) Option {
2.  
3. return func(s *Server) {
4.  
5. s.host = host
6.  
7. }
8.  
9. }
10.  
11. func WithPort(port int) Option {
12.  
13. return func(s *Server) {
14.  
15. s.port = port
16.  
17. }
18.  
19. }
20.  
21. func WithTimeout(timeout time.Duration) Option {
22.  
23. return func(s *Server) {
24.  
25. s.timeout = timeout
26.  
27. }
28.  
29. }
30.  
31. func WithMaxConn(maxConn int) Option {
32.  
33. return func(s *Server) {
34.  
35. s.maxConn = maxConn
36.  
37. }
38.  
39. }

针对这种模式，客户端类似这么使用：

1. package main
2.  
3. import (
4.  
5. "log"
6.  
7. "server"
8.  
9. )
10.  
11. func main() {
12.  
13. svr := New(
14.  
15. WithHost("localhost"),
16.  
17. WithPort(8080),
18.  
19. WithTimeout(time.Minute),
20.  
21. WithMaxConn(120),
22.  
23. )
24.  
25. if err := svr.Start(); err != nil {
26.  
27. log.Fatal(err)
28.  
29. }
30.  
31. }

将来增加选项，只需要增加对应的 WithXXX 函数即可。

这种模式，在第三方库中使用挺多，比如 github.com/gocolly/colly：

1. type Collector {
2.  
3. // 省略...
4.  
5. }
6.  
7. func NewCollector(options ...CollectorOption) *Collector
8.  
9. // 定义了一系列 CollectorOpiton
10.  
11. type CollectorOption{
12.  
13. // 省略...
14.  
15. }
16.  
17. func AllowURLRevisit() CollectorOption
18.  
19. func AllowedDomains(domains ...string) CollectorOption
20.  
21. ...

不过 Uber 的 Go 语言编程规范中提到该模式时，建议定义一个 Option 接口，而不是 Option 函数类型。该 Option 接口有一个未导出的方法，然后通过一个未导出的 options 结构来记录各选项。

Uber 的这个例子能看懂吗?

1. type options struct {
2. cache bool
3. logger *zap.Logger
4. }
5.  
6. type Option interface {
7. apply(*options)
8. }
9.  
10. type cacheOption bool
11.  
12. func (c cacheOption) apply(opts *options) {
13. opts.cache = bool(c)
14. }
15.  
16. func WithCache(c bool) Option {
17. return cacheOption(c)
18. }
19.  
20. type loggerOption struct {
21. Log *zap.Logger
22. }
23.  
24. func (l loggerOption) apply(opts *options) {
25. opts.logger = l.Log
26. }
27.  
28. func WithLogger(log *zap.Logger) Option {
29. return loggerOption{Log: log}
30. }
31.  
32. // Open creates a connection.
33. func Open(
34. addr string,
35. opts ...Option,
36. ) (*Connection, error) {
37. options := options{
38. cache: defaultCache,
39. logger: zap.NewNop(),
40. }
41.  
42. for _, o := range opts {
43. o.apply(&options)
44. }
45.  
46. // ...
47. }

03 总结

在实际项目中，当你要处理的选项比较多，或者处理不同来源的选项(来自文件、来自环境变量等)时，可以考虑试试函数式选项模式。

注意，在实际工作中，我们不应该教条的应用上面的模式，就像 Uber 中的例子，Open 函数并非只接受一个 Option 不定参数，因为 addr 参数是必须的。因此，函数式选项模式更多应该应用在那些配置较多，且有可选参数的情况。

参考文献

https://golang.cafe/blog/golang-functional-options-pattern.html

https://github.com/uber-go/guide/blob/master/style.md#functional-options

原文链接：https://mp.weixin.qq.com/s/B-HZu1oZGseaOuNUznjJFA