## builder 模式

```go
// 需要配置的结构体
type Server struct {
    Addr     string
    Port     int
    Protocol string
    Timeout  time.Duration
    MaxConns int
    TLS      *tls.Config
}

//使用一个builder类来做包装
type ServerBuilder struct {
    Server
}

func (sb *ServerBuilder) Create(addr string, port int) *ServerBuilder {
    sb.Server.Addr = addr
    sb.Server.Port = port
    //其它代码设置其它成员的默认值
    return sb
}

func (sb *ServerBuilder) WithProtocol(protocol string) *ServerBuilder {
    sb.Server.Protocol = protocol
    return sb
}

func (sb *ServerBuilder) WithMaxConn( maxconn int) *ServerBuilder {
    sb.Server.MaxConns = maxconn
    return sb
}

func (sb *ServerBuilder) WithTimeOut( timeout time.Duration) *ServerBuilder {
    sb.Server.Timeout = timeout
    return sb
}

func (sb *ServerBuilder) WithTLS( tls *tls.Config) *ServerBuilder {
    sb.Server.TLS = tls
    return sb
}

func (sb *ServerBuilder) Build() (Server) {
    return  sb.Server
}


sb := ServerBuilder{}
server, err := sb.Create("127.0.0.1", 8080).
    WithProtocol("udp").
    WithMaxConn(1024).
    WithTimeOut(30*time.Second).
    Build()
```

## Functional Options (利用高阶函数/闭包)

```go
// 需要配置的结构体
type Server struct {
    Addr     string
    Port     int
    Protocol string
    Timeout  time.Duration
    MaxConns int
    TLS      *tls.Config
}

// 先定义一个函数类型
type Option func(*Server)

// 使用函数式的方式定义一组如下的函数
// 返回的这个函数会设置自己的 Server 参数
func Protocol(p string) Option {
    return func(s *Server) {
        s.Protocol = p
    }
}
func Timeout(timeout time.Duration) Option {
    return func(s *Server) {
        s.Timeout = timeout
    }
}
func MaxConns(maxconns int) Option {
    return func(s *Server) {
        s.MaxConns = maxconns
    }
}
func TLS(tls *tls.Config) Option {
    return func(s *Server) {
        s.TLS = tls
    }
}

// 使用一个for-loop来设置我们的 Server 对象
func NewServer(addr string, port int, options ...func(*Server)) (*Server, error) {
    srv := Server{
        Addr:     addr,
        Port:     port,
        Protocol: "tcp",
        Timeout:  30 * time.Second,
        MaxConns: 1000,
        TLS:      nil,
    }
    for _, option := range options {
        option(&srv)
    }
    //...
    return &srv, nil
}

// 创建 Server 对象
s1, _ := NewServer("localhost", 1024)
s2, _ := NewServer("localhost", 2048, Protocol("udp"))
s3, _ := NewServer("0.0.0.0", 8080, Timeout(300*time.Second), MaxConns(1000))
```

## Functional Options (UBER)

```go
// 需要配置的结构体
type options struct {
    cache  bool
    logger *zap.Logger
}

// 定义接口
type Option interface {
    apply(*options)
}

// 定义配置选项类型
type cacheOption bool
func (c cacheOption) apply(opts *options) {
    opts.cache = bool(c)
}
func WithCache(c bool) Option {
    return cacheOption(c)
}

// 定义配置选项类型
type loggerOption struct {
    Log *zap.Logger
}
func (l loggerOption) apply(opts *options) {
    opts.logger = l.Log
}
func WithLogger(log *zap.Logger) Option {
    return loggerOption{Log: log}
}

// Open creates a connection.
func Open(
    addr string,
    opts ...Option,
) (*Connection, error) {
    options := options{
        cache:  defaultCache,
        logger: zap.NewNop(),
    }

    for _, o := range opts {
        o.apply(&options)
    }

    // ...
}

// 使用
c, _ := Open("localhost", WithCache(true), WithLogger(&zap.NewNop()))
```


Options 配置选项