我正在尝试使用 builder patterns (从 Java 借来的)允许结构实现接口(interface)。例如，理想情况下我会喜欢这种代码模式:

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 实现的接口(interface)。

如何编写构建器 NewObject() 的函数定义，以便 Build() 方法返回一个可以(可能)实现 Oner 的结构 和 Twoer?

编辑:

这里是关于如何使用它的一些说明。我正在构建一个库，如果某些结构违反类型安全，则禁止将它们传递给函数。例如:

type Oner interface {
    One() int
}

type OneAndTwoer interface {
    Oner

    Two() int
}

type Library interface {
    DoSomethingWithOner(Oner)
    DoSomethingWithOneAndTwoer(Twoer)
}

虽然我们可以定义一个总是构造一个OneAndTwoer的函数，但我的限制是每当我们构造一个OneAndTwoer时，这比构造一个要花费更长的时间>一个

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 等的计算相互独立，我们可以挑选要创建的接口(interface)。

最佳答案

这里有一个方法，虽然感觉很笨重。

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())
}

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

关于go - 如何使用构建器模式构造动态实现接口(interface)的结构，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/56015613/