在使用Golang创建复杂对象时，常用的两种模式是选项模式（Options pattern）和构建器模式（Builder pattern）。这两种模式各有优缺点，选择适合项目需求的模式取决于具体情况。

问题

假设我们想创建一个具有许多可选参数的复杂对象。一种方法是创建一个构造函数，该构造函数接受所有参数，并为可选参数提供默认值。然而，这种方法有一些缺点：

1. 很难记住参数的顺序。
2. 很难知道哪些参数是可选的，哪些是必需的。
3. 构造函数可能会变得很长，难以阅读。

解决方案：选项模式

选项模式可以用于创建具有许多可选参数的对象。在这种模式下，我们定义一个包含可选参数的结构体，并提供设置这些参数的方法。相比构建器模式，这种模式可以更简洁，并且适用于参数较少的对象。

示例

在Golang中，可以使用函数选项（functional options）来实现选项模式。函数选项是以结构体作为参数，并返回修改后的结构体的函数。以下是使用选项模式创建披萨对象的示例代码：

type Pizza struct {
    dough     string
    sauce     string
    cheese    string
    toppings  []string
}

type PizzaOptions struct {
    Dough     string
    Sauce     string
    Cheese    string
    Toppings  []string
}

type PizzaOption func(*PizzaOptions)

func WithDough(dough string) PizzaOption {
    return func(po *PizzaOptions) {
        po.Dough = dough
    }
}

func WithSauce(sauce string) PizzaOption {
    return func(po *PizzaOptions) {
        po.Sauce = sauce
    }
}

func WithCheese(cheese string) PizzaOption {
    return func(po *PizzaOptions) {
        po.Cheese = cheese
    }
}

func WithToppings(toppings []string) PizzaOption {
    return func(po *PizzaOptions) {
        po.Toppings = toppings
    }
}

func NewPizza(options ...PizzaOption) *Pizza {
    opts := &PizzaOptions{}
    for _, option := range options {
        option(opts)
    }
    pizza := &Pizza{
        dough: opts.Dough,
        sauce: opts.Sauce,
        cheese: opts.Cheese,
        toppings: opts.Toppings,
    }
    return pizza
}

在这个例子中，我们定义了Pizza结构体和PizzaOptions结构体，其中PizzaOptions是一个包含可选参数的结构体。然后，我们定义了一系列函数来设置每个选项，比如WithDough、WithSauce和WithToppings。这些函数返回一个PizzaOption，用于设置PizzaOptions结构体上对应的字段。最后，我们定义了一个NewPizza函数，它接受任意数量的PizzaOptions参数，并构造一个Pizza对象。

func main() {
   pizza := NewPizza(
      WithDough("Regular"),
      WithSauce("Tomato"),
      WithCheese("Mozzarella"),
      WithToppings([]string{"Pepperoni", "Olives", "Mushrooms"}),
   )

   println(pizza.dough)
   println(pizza.sauce)
   println(pizza.cheese)
   println(pizza.toppings)
}

Options模式可以是Builder模式的一个很好替代方案，用于创建具有许多可选参数的对象，特别是当对象的参数较少时。然而，对于具有许多参数的对象来说，Options模式可能变得笨拙，因为需要设置所有选项的函数数量可能会很大。

在Golang标准库中的使用

Options模式在Golang标准库中被用于创建诸如http.Request对象之类的对象，该对象具有许多可选参数。http.NewRequest函数接受方法、URL和可选的headers和body等参数，返回一个新的http.Request对象。headers和body是可选参数，可以使用函数选项来设置。

替代方案：Builder模式

Builder模式通过将复杂对象的构建与其表示分离，提供了对这些问题的解决方案。Builder模式涉及以下组件：

1. Builder接口，定义构建对象的步骤。
2. ConcreteBuilder结构体，实现Builder接口并提供构建对象的方法。
3. Director结构体，使用Builder来构建对象。

示例

以下是在Golang中使用Builder模式实现的示例，使用了文章中提到的pizza对象：

type Pizza struct {
    dough     string
    sauce     string
    cheese    string
    toppings  []string
}

type PizzaBuilder interface {
    SetDough(string) PizzaBuilder
    SetSauce(string) PizzaBuilder
    SetCheese(string) PizzaBuilder
    SetToppings([]string) PizzaBuilder
    Build() *Pizza
}

type ConcretePizzaBuilder struct {
    pizza *Pizza
}

func NewConcretePizzaBuilder() *ConcretePizzaBuilder {
    return &ConcretePizzaBuilder{pizza: &Pizza{}}
}

func (cpb *ConcretePizzaBuilder) SetDough(dough string) PizzaBuilder {
    cpb.pizza.dough = dough
    return cpb
}

func (cpb *ConcretePizzaBuilder) SetSauce(sauce string) PizzaBuilder {
    cpb.pizza.sauce = sauce
    return cpb
}

func (cpb *ConcretePizzaBuilder) SetCheese(cheese string) PizzaBuilder {
    cpb.pizza.cheese = cheese
    return cpb
}

func (cpb *ConcretePizzaBuilder) SetToppings(toppings []string) PizzaBuilder {
    cpb.pizza.toppings = toppings
    return cpb
}

func (cpb *ConcretePizzaBuilder) Build() *Pizza {
    return cpb.pizza
}

type Director struct {
    builder PizzaBuilder
}

func NewDirector(builder PizzaBuilder) *Director {
    return &Director{builder: builder}
}

func (d *Director) Construct() *Pizza {
    return d.builder.SetDough("Thin Crust").SetSauce("Tomato").SetCheese("Mozzarella").SetToppings([]string{"Mushrooms", "Olives", "Onions"}).Build()
}

在这个示例中，我们定义了Pizza结构体和PizzaBuilder接口。ConcretePizzaBuilder结构体实现了PizzaBuilder接口，并提供了构建Pizza对象的方法。Director结构体使用PizzaBuilder来构建Pizza对象。Director结构体并不是严格必需的，但它提供了一种简化构建Pizza对象过程的方式。

我们可以使用Director和ConcretePizzaBuilder来创建一个Pizza对象，如下所示：

builder := NewConcretePizzaBuilder()
director := NewDirector(builder)
pizza := director.Construct()

这将创建一个具有以下属性的Pizza对象：

• Dough: Thin Crust
• Sauce: Tomato
• Cheese: Mozzarella
• Toppings: Mushrooms, Olives, Onions

请注意，我们只需要指定要更改的属性。所有其他属性都被设置为默认值。这使得创建具有许多可选参数的复杂对象变得更容易，无需记住参数的顺序以及哪些参数是可选的，哪些是必需的。

在 Golang 标准库中的使用

构建器模式并未在 Golang 标准库中使用，但在 Golang 应用程序中，它是一种常用的模式，用于创建具有许多可选参数的复杂对象。Options 模式也被用作 Golang 应用程序中的替代方案，用于创建具有许多可选参数的对象。

结论

Options 模式是 Builder 模式的一种替代方案，可用于创建具有许多可选参数的对象。它比 Builder 模式更简洁，但对于具有许多参数的对象可能会变得笨重。在 Golang 中，可以使用函数选项来实现 Options 模式。

Builder 模式是一种强大的模式，可以用于创建具有许多可选参数的复杂对象。它将对象的构建与表示分离，并提供了一种使用相同构建过程创建同一对象的不同表示的方式。在 Golang 中，Builder 模式可用于轻松创建复杂对象。

参考资料

• "Design Patterns: Elements of Reusable Object-Oriented Software"（《设计模式：可复用面向对象软件的基础》）Erich Gamma、John Vlissides、Ralph Johnson、Richard Helm著

如果你喜欢我的文章，点赞，关注，转发！