Golang函数式选项(Functional Options)模式

本篇博客的视频教程首发于 Youtube：科技小飞哥，加入 电报粉丝群 获得最新视频更新和问题解答。

概览

最近阅读源码的时候看到一段不错的代码，但是当时却不是非常理解为什么这么写。我们先来看一下源代码：

type User struct {
	ID     string
	Name   string
	Age    int
	Email  string
	Phone  string
	Gender string
}

type Option func(*User)

func WithAge(age int) Option {
	return func(u *User) {
		u.Age = age
	}
}

func WithEmail(email string) Option {
	return func(u *User) {
		u.Email = email
	}
}

func WithPhone(phone string) Option {
	return func(u *User) {
		u.Phone = phone
	}
}

func WithGender(gender string) Option {
	return func(u *User) {
		u.Gender = gender
	}
}

func NewUser(id string, name string, options ...func(*User)) (*User, error) {
	user := User{
		ID:     id,
		Name:   name,
		Age:    0,
		Email:  "",
		Phone:  "",
		Gender: "female",
	}
	for _, option := range options {
		option(&user)
	}
	//...
	return &user, nil
}

func main() {
	user, err := NewUser("1", "Ada", WithAge(18), WithPhone("123456"))
	if err != nil {
		fmt.Printf("NewUser: err:%v", err)
	}
	fmt.Printf("NewUser Success")
}

当时呢，也不是很明白 NewUser 这个构造函数为什么要这么写，后来查看了资料才知道了这是一种设计模式–函数式选项(functional options)模式。

什么是函数式选项模式，为什么要这么写，这个编程模式解决了什么问题呢？

其实就是为了解决动态灵活的配置不同的参数的问题。

假如我们有一个需求：在网站注册账号，有很多可选的选项，可填可不填。会根据你填的信息初始化你的 User 对象。

重载函数

如果你有 C++ 或者 Java 的编程基础，你的第一反应应该是函数重载。

但是因为 Golang 语言不像 C++ 一样支持重载函数，所以，你得用不同的函数名来应对不同的配置选项。

像这样：

func NewUserDefault(id string, name string) (*User, error) {
  return &User{ID: id, Name: name}, nil
}

func NewUserWithPhone(id string, name string, phone string) (*User, error) {
  return &User{ID: id, Name: name, Phone: phone}, nil
}

func NewUserWithEmail(id string, name string, email string) (*User, error) {
  return &User{ID: id, Name: name, Email: email}, nil
}

如果一共只有两三个参数的情况下，比较简单，但是更多的选项的组合就代码看起来很乱了。

配置化

这个时候我们可能会想到，配置化。把所有可选的参数放到一个Config的struct中。

type Config struct {
    Age    int
    Email  string
    Phone  string
    Gender string
}

然后把Config放到User的struct中。

type User struct {
    ID   string
    Name string
    Conf *Config
}

于是，我们只需要一个 NewUser() 的函数了，在使用前需要构造 Config 对象。

func NewUser(id string, name string, conf *Config) (*User, error) {
    //...
}
//Using the default configuratrion
user, _ := NewUser("1", "Ada", nil)

conf := Config{Age:18, Phone: "123456"}
user2, _ := NewUser("2", "Bob", &conf)

这段代码看起来算是不错了，很多时候我使用的一些开源库也是这么写的。通过引入一个Config对象来解决多个参数的组合的问题。

Builder模式

有些经常使用Java的同学会想到Builder模式。

于是就可以以如下的方式来使用了:

user := new(UserBuilder).Create("1", "Ada").
  age(18).
  phone("123456").
  gender("female").
  Build()

需要引入一个抽象的UserBuilder对象，来包装User对象，最终Build一个User对象返回。

函数式选项模式

函数式选项模式 首先需要定义一个函数类型：

`1`	`type Option func(*User)`

然后，我们定义一组返回函数的函数：

func WithAge(age int) Option {
	return func(u *User) {
		u.Age = age
	}
}

func WithEmail(email string) Option {
	return func(u *User) {
		u.Email = email
	}
}

func WithPhone(phone string) Option {
	return func(u *User) {
		u.Phone = phone
	}
}

func WithGender(gender string) Option {
	return func(u *User) {
		u.Gender = gender
	}
}

这个模式和Builder模式的区别是，Builder模式返回的是 * User 对象，Functional Options 返回的是函数类型 func(* User)。

上面这组代码传入一个参数，然后返回一个函数，返回的这个函数会设置自己的 User 参数。

这样我们就方便在 NewUser 里面统一初始化。循环对我们的函数类型执行调用操作。 option(&user)

func NewUser(id string, name string, options ...func(*User)) (*User, error) {
	user := User{
		ID:     id,
		Name:   name,
		Age:    0,
		Email:  "",
		Phone:  "",
		Gender: "female",
	}
	for _, option := range options {
		option(&user)
	}
	//...
	return &user, nil
}

调用方式如下：

1
2

user1, err := NewUser("1", "Ada")
user2, err := NewUser("2", "Bob", WithPhone("123456"), WithGender("male"))

这个看起来比较整洁和优雅，对外的接口只有一个NewUser。

相比于Builder模式，不需要引入一个Builder对象。

对比配置化的模式，也不需要引入一个新的Config。

总结

Golang 由于语言本身的特性，不支持函数重载，函数式选项 的编程模式在一定程度上解决了其他语言需要通过函数重载解决的问题。 函数式选项 编程有以下优点：

优点：

任意顺序传递参数
支持默认值
向后兼容性
很容易维护和扩展

看了这么多，是不是想马上上手重构你之前的代码了。

虽然 函数式选项 编程模式有很多优点，但是设计模式的存在都是为了弥补语言特性的缺陷的一种手段。它是为了解决代码扩展性的问题，往往是通过增加抽象牺牲了简单性，切勿过度使用。有些简单的配置，就不需要设计的这么通用了。

函数式选项模式的使用场景有哪些呢： 我们一般用来配置一些基础的服务配置，比如MySQL，Redis，Kafka的配置，很多可选参数，可以方便动态灵活的配置想要配置的参数。

<全文完>