构建器模式是一种设计模式，它允许你使用不同的构建步骤来创建复杂对象。这种模式可以让你动态地添加或移除对象的属性，从而使其能够实现不同的接口。在 Java 中，构建器模式通过使用 Builder 接口和一个具体的 Builder 类来实现。Builder 接口定义了构建对象所需的步骤，而具体的 Builder 类则实现了这些步骤。通过使用构建器模式，你可以创建一个可以实现多个接口的结构体，从而提高代码的灵活性。

我正在尝试使用构建器模式（从 java 借用）来允许结构实现接口。例如，我理想地喜欢这个代码模式：

package main

import "fmt"

type oner interface {
    one() int
}

type twoer interface {
    two() int
}

func main() {
    s := newobject().
        withone(1).
        build()

    _, ok := s.(oner)
    fmt.println(ok) // prints true

    _, ok = s.(twoer)
    fmt.println(ok) // prints false

    t := newobject().
        withone(1).
        withtwo(2).
        build()

    _, ok = t.(oner)
    fmt.println(ok) // prints true

    _, ok = t.(twoer)
    fmt.println(ok) // prints true
}

如您所见，构建器的定义决定了 s 和 t 实现哪些接口。

如何编写构建器 newobject() 的函数定义，以便 build() 方法返回一个可以（可能）实现 oner 和 twoer 的结构？

编辑：

以下是有关如何使用它的一些说明。我正在构建一个库，禁止某些违反类型安全的结构被传递到函数中。例如：

type oner interface {
    one() int
}

type oneandtwoer interface {
    oner

    two() int
}

type library interface {
    dosomethingwithoner(oner)
    dosomethingwithoneandtwoer(twoer)
}

虽然我们可以定义一个始终构造 oneandtwoer 的函数，但我的限制是每当我们构造 oneandtwoer 时，这比仅仅构造 oner 需要更长的时间

func NewOneAndTwoer() OneAndTwoer {
    // Do some really really complicated logic which takes a lot of time
}

func NewOner() Oner {
    // Do simple logic
}

你可以想象，如果我们有 threer、fourer 等，这会变得非常笨拙，我们必须为所有可能的属性排列构造构造函数。

这就是构建器模式派上用场的地方。假设 one、two 等的计算彼此独立，我们可以选择要创建的接口。

解决方案

这里有一种方法，虽然感觉很笨拙。

package main

import (
  "fmt"
)

type fieldoner interface {
    fieldone() int
}

type fieldtwoer interface {
    fieldtwo() int
}

设置结构一和结构二分别实现 fieldoner 和 fieldtwoer。

type one struct {
    one int
}

func (f one) fieldone() int {
    return f.one
}

type two struct {
    two int
}

func (f two) fieldtwo() int {
    return f.two
}

创建 fieldbuilder，它可以存储这两个值以及是否已给定每个值，以及 withfieldone 和 withfieldtwo。

type fieldbuilder struct {
    one int
    has_one bool
    two int
    has_two bool
}

func newobject() fieldbuilder {
    return fieldbuilder{ has_one: false, has_two: false }
}

func (f fieldbuilder) withfieldone(one int) fieldbuilder {
    f.one = one
    f.has_one = true
    return f
}

func (f fieldbuilder) withfieldtwo(two int) fieldbuilder {
    f.two = two
    f.has_two = true
    return f
}

build 可能返回一、二或一和二的组合。由于它可以返回多个彼此之间没有任何共同点的内容（危险信号），因此它返回一个 interface{}。

func (f fieldbuilder) build() interface{} {
    switch {
    case f.has_one && f.has_two:
        return struct {
            one
            two
        }{
            one{one: f.one}, two{two: f.two},
        }
    case f.has_one:
        return one{ one: f.one }
    case f.has_two:
        return two{ two: f.two }
    }
    panic("should never be here")
}

因为 build 返回一个 interface{}，所以有必要对结果进行类型转换，以便实际使用它，这可能会破坏整个练习的要点。

func main() {
    s := NewObject().
        WithFieldOne(1).
        Build()

    s1, ok := s.(FieldOner)
    fmt.Println(s1.FieldOne())

    _, ok = s.(FieldTwoer)
    fmt.Println(ok) // Prints false

    t := NewObject().
        WithFieldOne(1).
        WithFieldTwo(2).
        Build()

    t1, ok := t.(FieldOner)
    fmt.Println(t1.FieldOne())

    t2, ok := t.(FieldTwoer)
    fmt.Println(t2.FieldTwo())
}

这并不能很好地扩展。两个接口需要三种情况。三个将需要六个。四个将需要十个。五个需要十五个......

今天关于《使用构建器模式创建可以动态实现接口的结构体》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！