编辑：

Question

我正在尝试使用builder patterns（从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等的计算相互独立，我们可以选择要创建的接口。

Answer 1

虽然感觉很笨重，但这是一种方法。

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可能返回1、2或1和2的组合。由于它可以返回多个彼此没有共同点的东西（一个红色标记），因此它返回一个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())
}

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

如何使用构建器模式来构建可动态实现接口的结构

编辑：

1 个答案: