Golang Functional Options 来了解一下？

在开发或者学习源码过程中，不少人应该见过下面的代码片段

type Option func(opts *Options)

// 新建一个server，client，pool等
func NewXXX(name string, opts ...Option) {}

刚开始从java转go的时候，我看这些代码真的是看得一脸懵逼，看不懂这些option是什么，也不明白为什么需要它们的存在

直到后来，我才知道，这叫函数式选项（Functional Options）

函数式选项是Golang中实现简洁API的一种方式

在使用NewXXX函数构建struct的时候，struct中的属性并不都是必须的，这些非必须属性，在构建struct的过程中可以通过函数式选项的方式，实现更加简洁的API

假设需要实现一个协程池GPool，其中必备的属性有协程数量size，还有可选项：是否异步async，错误处理errorHandler，最大缓存任务数maxTaskNums，那么struct的设计应该如下

package pool

// Option 定义函数式选项
type Option func(options *Options)

// GPool 协程池
type GPool struct {
    size    int64 // 协程数量
    options *Options
}

type ErrorHandler func(err error)

// Options 将非必须的选项都放到这里
type Options struct {
    async    bool         // 是否支持异步提交任务
    handler  ErrorHandler // 任务执行出错时，回调该函数
    maxTasks int64        // 协程池所接受的最大缓存任务数
}

// NewGPool 新建协程池
func NewGPool(size int64, opts ...Option) *GPool {
    options := loadOpts(opts)
    return &GPool{
        size:    size,
        options: options,
    }
}

func loadOpts(opts []Option) *Options {
    options := &Options{}
    for _, opt := range opts {
        opt(options)
    }
    return options
}

func WithAsync(async bool) Option {
    return func(options *Options) {
        options.async = async
    }
}

func WithErrorHandler(handler ErrorHandler) Option {
    return func(options *Options) {
        options.handler = handler
    }
}

func WithMaxTasks(maxTasks int64) Option {
    return func(options *Options) {
        options.maxTasks = maxTasks
    }
}

如果需要创建一个协程池，协程数量为100，只需要这样写

p := pool.NewGPool(100)

如果需要创建一个协程池，协程数量为100并支持异步提交，只需要这样写

p := pool.NewGPool(100, pool.WithAsync(true))

如果需要穿件一个协程池，协程数量为100、支持异步提交，并且回调自定义错误处理，只需要这样写

p := pool.NewGPool(100,
    pool.WithAsync(true),
    pool.WithErrorHandler(func(err error) {
        // 处理任务执行过程中发生的error
    }),
)

这样的写法是不是感觉更加简洁？

如果不使用函数式选项，我们还可以怎么做？

第一种，直接构建struct，但是需要填写非常非常多的属性，对调用者并不友好

func NewGPool(size int64, async bool, handler ErrorHandler, maxTasks int64) *GPool {
    return &GPool{
        size:    size,
        options: &Options{
            async:    async,
            handler:  handler,
            maxTasks: maxTasks,
        },
    }
}

当struct中的属性变得越来越多时候，这长长的函数签名，对于调用者而言，简直是噩梦般的存在

第二种，使用建造者模式

func (builder *GPoolBuilder) Builder(size int64) *GPoolBuilder {
    return &GPoolBuilder{p: &GPool{
        size: size,
        options: &Options{},
    }}
}

func (builder *GPoolBuilder) WithAsync(async bool) *GPoolBuilder {
    builder.p.options.async = async
    return builder
}

func (builder *GPoolBuilder) Build() *GPool {
    return builder.p
}

调用者使用经构建者模式封装后的API，还是非常舒服的

    builder := GPoolBuilder{}
    p := builder.Builder(100).WithAsync(true).Build()

但是，却要额外维护一份属于builder的代码，虽然使用简洁，但是具备一定的维护成本！！

总的来看，函数式选项还是最佳的选择方案，开发者通过它能够构建简洁，友好的API。

本文由博客一文多发平台 OpenWrite 发布！