【Go-选项模式】

选项模式（Option Pattern），也叫函数式选项（Functional Options），在 Go 语言中非常流行

1. 什么是选项模式？为什么需要它？

想象一下，你正在编写一个创建配置对象的函数。最初，这个配置对象可能很简单，只有一两个字段。比如：

type Server struct {
    Host string
    Port int
}

func NewServer(host string, port int) *Server {
    return &Server{
        Host: host,
        Port: port,
    }
}

这看起来很简单，但如果你的 Server 结构体变得越来越复杂呢？比如需要添加超时时间、TLS 配置、读写缓冲区大小等字段。你的 NewServer 函数签名就会变成这样：

// 😱 函数签名变得很长，难以阅读和使用
func NewServer(host string, port int, timeout time.Duration, tlsEnabled bool, readBufferSize int, writeBufferSize int, ...) *Server {
    // ...
}

这带来了几个问题：

1. 参数过多：函数签名变得非常长，调用时需要记住每个参数的位置和含义。
2. 默认值问题：如果某些参数是可选的，你不得不传入一些零值（如 0、""、nil），这使得调用代码不直观。
3. 扩展性差：如果未来需要新增一个配置项，你必须修改 NewServer 函数的签名，这会破坏所有调用者的代码。

选项模式就是为了解决这些问题而生的。它通过将每个配置项封装成一个函数，然后将这些函数作为可变参数传递给构造函数，从而优雅地解决了这些痛点。

2. 选项模式的核心思想和实现步骤

选项模式的核心是高阶函数（Higher-Order Function），即一个函数可以接收另一个函数作为参数，或者返回一个函数。

核心步骤：

1. 定义配置结构体：首先，定义你想要配置的结构体，它包含所有可配置的字段。
2. 定义选项函数类型：创建一个函数类型，它接受一个指向配置结构体的指针作为参数，并对其进行修改。这是整个模式的关键。
3. 创建选项函数：为每个可配置的字段编写一个返回选项函数的函数。
4. 编写构造函数：编写一个构造函数，它接受可变参数的选项函数，并依次执行它们来配置对象。

示例代码（以 Server 为例）：

步骤1：定义配置结构体

// server.go

import "time"

// Server 结构体，包含所有可配置的字段
type Server struct {
    Host    string
    Port    int
    Timeout time.Duration
    TLS     bool
}

步骤2：定义选项函数类型

这是一个函数签名，它定义了所有选项函数的“形状”。

// Option 是一个函数类型，它接受一个 *Server 指针并对其进行修改
type Option func(*Server)

步骤3：创建选项函数

为每个配置项创建返回 Option 类型函数的函数。

// WithPort 返回一个设置端口的 Option 函数
func WithPort(port int) Option {
    return func(s *Server) {
        s.Port = port
    }
}

// WithTimeout 返回一个设置超时的 Option 函数
func WithTimeout(timeout time.Duration) Option {
    return func(s *Server) {
        s.Timeout = timeout
    }
}

// WithTLS 返回一个设置 TLS 的 Option 函数
func WithTLS(enabled bool) Option {
    return func(s *Server) {
        s.TLS = enabled
    }
}

关键点：WithPort(8080) 这行代码并没有直接修改 Server 对象，它只是创建并返回了一个 func(*Server) 函数。这个返回的函数才真正包含了设置端口的逻辑。

步骤4：编写构造函数

这是整个模式的入口，它负责将所有选项应用到新创建的对象上。

// NewServer 使用选项模式创建 Server 实例
func NewServer(opts ...Option) *Server {
    // 1. 设置默认值
    s := &Server{
        Host:    "localhost",
        Port:    8080,
        Timeout: 30 * time.Second,
        TLS:     false,
    }

    // 2. 遍历并应用所有传入的选项
    for _, opt := range opts {
        opt(s) // 在这里执行每个选项函数，修改 s 对象
    }

    // 3. 返回配置好的对象
    return s
}

3. 如何使用选项模式？

使用起来非常简单，可读性极高：

package main

import (
    "fmt"
    "time"
)

// ... (将上面的代码复制到这里) ...

func main() {
    // 使用默认配置
    defaultServer := NewServer()
    fmt.Printf("默认服务器配置: %+v\n", defaultServer)
    // 输出: 默认服务器配置: {Host:localhost Port:8080 Timeout:30s TLS:false}

    fmt.Println("---")

    // 自定义端口和超时
    customServer := NewServer(
        WithPort(9090),
        WithTimeout(10 * time.Second),
    )
    fmt.Printf("自定义服务器配置: %+v\n", customServer)
    // 输出: 自定义服务器配置: {Host:localhost Port:9090 Timeout:10s TLS:false}

    fmt.Println("---")

    // 自定义所有配置
    secureServer := NewServer(
        WithPort(443),
        WithTimeout(5 * time.Second),
        WithTLS(true),
    )
    fmt.Printf("安全服务器配置: %+v\n", secureServer)
    // 输出: 安全服务器配置: {Host:localhost Port:443 Timeout:5s TLS:true}
}

4. 选项模式的优点总结

5. 选项模式的应用场景

• 配置类对象：像你的 ListOptions 和我们这里的 Server。
• 客户端 SDK：例如数据库驱动、HTTP 客户端等，允许用户灵活配置连接参数。
• 中间件：为中间件提供可定制的选项，如超时、日志级别等。