我正在尝试通过更好地定义接口(interface)和使用嵌入式结构来重用功能来清理我的代码库。在我的例子中，我有许多可以链接到各种对象的实体类型。我想定义捕获需求的接口(interface)和实现接口(interface)的结构，然后可以将其嵌入到实体中。

// All entities implement this interface
type Entity interface {
  Identifier()
  Type()
}

// Interface for entities that can link Foos
type FooLinker interface {
  LinkFoo()
}

type FooLinkerEntity struct {
  Foo []*Foo
}

func (f *FooLinkerEntity) LinkFoo() {
  // Issue: Need to access Identifier() and Type() here
  // but FooLinkerEntity doesn't implement Entity
}

// Interface for entities that can link Bars
type BarLinker interface {
  LinkBar()
}

type BarLinkerEntity struct {
  Bar []*Bar
}

func (b *BarLinkerEntity) LinkBar() {
  // Issues: Need to access Identifier() and Type() here
  // but BarLinkerEntity doesn't implement Entity
}

所以我的第一个想法是让 FooLinkerEntity 和 BarLinkerEntity 只实现 Entity 接口(interface)。

// Implementation of Entity interface
type EntityModel struct {
    Id string
    Object string
}

func (e *EntityModel) Identifier() { return e.Id }
func (e *EntityModel) Type() { return e.Type }

type FooLinkerEntity struct {
  EntityModel
  Foo []*Foo
}

type BarLinkerEntity struct {
  EntityModel
  Bar []*Bar
}

但是，对于可以链接 Foos 和 Bars 的任何类型，这最终会导致歧义错误。

// Baz.Identifier() is ambiguous between EntityModel, FooLinkerEntity,
// and BarLinkerEntity.
type Baz struct {
    EntityModel
    FooLinkerEntity
    BarLinkerEntity
}

构建此类代码的正确 Go 方法是什么？我是否只是在 LinkFoo() 和 LinkBar() 中进行类型断言以获取 Identifier() 和 Type()？有什么方法可以在编译时而不是运行时进行此检查？

最佳答案

Go 是 not (quite) an object oriented language : 它没有类并且它 does not have type inheritance ;但它在 struct 级别和 interface 级别都支持称为 embedding 的类似构造，并且它确实有 methods .

所以你应该停止思考 OOP 而开始思考组合。由于您在评论中说过 FooLinkerEntity 永远不会单独使用，这有助于我们以干净的方式实现您想要的。

我将使用新的名称和更少的功能来专注于问题和解决方案，这会导致代码更短，也更容易理解。

完整代码可以在Go Playground上查看和测试。 .

实体

简单的 Entity 及其实现如下所示:

type Entity interface {
    Id() int
}

type EntityImpl struct{ id int }

func (e *EntityImpl) Id() int { return e.id }

富和酒吧

在您的示例中，FooLinkerEntity 和 BarLinkerEntity 只是装饰器，因此它们不需要嵌入(扩展 在 OOP 中)Entity，它们的实现不需要嵌入 EntityImpl。但是，由于我们要使用 Entity.Id() 方法，因此我们需要一个 Entity 值，它可能是也可能不是 EntityImpl，但我们不要限制它们的实现。我们也可以选择嵌入它或使其成为“常规”结构字段，这并不重要(两者都有效):

type Foo interface {
    SayFoo()
}

type FooImpl struct {
    Entity
}

func (f *FooImpl) SayFoo() { fmt.Println("Foo", f.Id()) }

type Bar interface {
    SayBar()
}

type BarImpl struct {
    Entity
}

func (b *BarImpl) SayBar() { fmt.Println("Bar", b.Id()) }

使用 Foo 和 Bar:

f := FooImpl{&EntityImpl{1}}
f.SayFoo()
b := BarImpl{&EntityImpl{2}}
b.SayBar()

输出:

Foo 1
Bar 2

FooBar实体

现在让我们看一个“真实的”实体，它是一个 Entity(实现了 Entity)并且具有 Foo 和 栏:

type FooBarEntity interface {
    Entity
    Foo
    Bar
    SayFooBar()
}

type FooBarEntityImpl struct {
    *EntityImpl
    FooImpl
    BarImpl
}

func (x *FooBarEntityImpl) SayFooBar() {
    fmt.Println("FooBar", x.Id(), x.FooImpl.Id(), x.BarImpl.Id())
}

使用FooBarEntity:

e := &EntityImpl{3}
x := FooBarEntityImpl{e, FooImpl{e}, BarImpl{e}}
x.SayFoo()
x.SayBar()
x.SayFooBar()

输出:

Foo 3
Bar 3
FooBar 3 3 3

FooBarEntity 第 2 轮

如果 FooBarEntityImpl 不需要知道(不使用)Entity、Foo 和 Bar 实现(EntityImpl、FooImpl 和 BarImpl 在我们的例子中)，我们可以选择只嵌入接口(interface)而不嵌入实现(但是在这种情况下，我们不能调用 x.FooImpl.Id() 因为 Foo 没有实现 Entity - 这是一个实现细节我们最初声明我们不需要/不使用它):

type FooBarEntityImpl struct {
    Entity
    Foo
    Bar
}

func (x *FooBarEntityImpl) SayFooBar() { fmt.Println("FooBar", x.Id()) }

它的用法是一样的:

e := &EntityImpl{3}
x := FooBarEntityImpl{e, &FooImpl{e}, &BarImpl{e}}
x.SayFoo()
x.SayBar()
x.SayFooBar()

它的输出:

Foo 3
Bar 3
FooBar 3

在 Go Playground 上尝试这个变体.

FooBarEntity 创建

请注意，在创建 FooBarEntityImpl 时，Entity 的值将用于多个复合文字。由于我们只创建了一个Entity(EntityImpl)并且我们在所有地方都使用了它，所以在不同的实现类中只有一个id，只有“引用”传递给每个结构，而不是重复/副本。这也是预期/要求的用途。

由于 FooBarEntityImpl 的创建非常重要且容易出错，因此建议创建类似构造函数的函数:

func NewFooBarEntity(id int) FooBarEntity {
    e := &EntityImpl{id}
    return &FooBarEntityImpl{e, &FooImpl{e}, &BarImpl{e}}
}

请注意，工厂函数 NewFooBarEntity() 返回接口(interface)类型的值而不是实现类型(要遵循的良好做法)。

不导出实现类型，仅导出接口(interface)也是一个好习惯，因此实现名称将是 entityImpl、fooImpl、 barImpl, fooBarEntityImpl.

一些值得检查的相关问题

What is the idiomatic way in Go to create a complex hierarchy of structs?

is it possible to call overridden method from parent struct in golang?

Can embedded struct method have knowledge of parent/child?

Go embedded struct call child method instead parent method

关于oop - 确保嵌入式结构在不引入歧义的情况下实现接口(interface)，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/36710259/