Question

我正在学习Go目前我正在编写一个小项目，其中包含一些报告到内部日志的探测器。我有一个基本的探针，我想创建扩展基本探针的新探针。

我希望将对象保存在数组/切片LoadedProbes中。

type LoadableProbe struct {
    Name   string
    Probe  Probe
    Active bool
}

var LoadableProbes []LoadableProbe

基本探针结构是：

type ProbeModule struct {
    version   VersionStruct
    name      string
    author    string
    log       []internals.ProbeLog
    lastcall  time.Time
    active    bool
}

func (m *ProbeModule) New(name string, jconf JsonConfig) {
    // read jsonConfig 
}
func (m *ProbeModule) Exec() bool {
    // do some stuff
    return true
}

func (m *ProbeModule) String() string {
    return m.name + " from " + m.author
}

func (m *ProbeModule) GetLogCount() int {
    return len(m.log)
}
[...]

我将这个基本结构用于其他探测器，例如：

type ShellProbe struct {
    ProbeModule
}

func (s *ShellProbe) New(name string, jconf JsonConfig) {
    s.ProbeModule.New(name, jconf)
    fmt.Println("Hello from the shell")
}

func (s *ShellProbe) Exec() bool {
    // do other stuff
    return true
}

在Init（）期间

我调用以下代码：

func init() {
    RegisterProbe("ShellProbe", ShellProbe{}, true)
}

func RegisterProbe(name string, probe Probe, state bool) {
    LoadableProbes = append(LoadableProbes, LoadableProbe{name, probe, state})
}

现在问题是我无法将Shellprobe类型添加到LoadableProbe结构中，该结构需要Probe结构。

我的想法是使用interface {}代替Loadable Probe结构中的Probe结构。但是当我调用Probe对象的New（）方法时：

for _, p := range probes.LoadableProbes {
    probe.Probe.New(probe.Name, jconf)
}

但是我得到了错误：p.Probe.New undefined（type interface {}是没有方法的接口）

我该如何解决这个问题？

Answer 1

如果在每种探测类型中都有公共数据字段，则可以考虑使用Probe作为定义基本数据字段和基本方法的具体基本类型，并使用新的ProbeInterface接口作为定义常见预期方法签名的抽象基类型，允许您传递/收集/管理不同的专用探测类型。

您可以将Probe嵌入到每个专用探测器类型中，并根据嵌入规则提升方法和字段。看起来您一般都熟悉嵌入，但如果您最近没有看过它，详细信息值得在the "Embedding" section of Effective Go进行审核。

您可以覆盖专用探针类型中的Probe方法，以执行特定于类型的代码。

它可能看起来像这样：

type ProbeInterface interface {
     New()
     Exec() bool
     // whatever other methods are common to all probes
}

type Probe struct {
    // whatever's in a probe
}

func (p *Probe) New() {
    // init stuff
}

func (p *Probe) Exec() bool {
    // exec stuff
    return true
}

// Probe's methods and fields are promoted to ShellProbe according to the rules of embedding
type ShellProbe struct {
    Probe
    // any specialized ShellProbe fields
}

// override Probe's Exec() method to have it do something ShellProbe specific.
func (sp *ShellProbe) Exec() bool {
    // do something ShellProbe-ish
    return true
}

type LoadableProbe struct {
    Name        string
    P           ProbeInterface
    Active      bool
}

func RegisterProbe(name string, probe ProbeInterface, state bool) {
    LoadableProbes = append(LoadableProbes, LoadableProbe{name, probe, state})
}

Answer 2

您的问题有不同的方法。

最直接的答案是：在调用任何方法之前，您需要将interface{}转换为具体类型。例如：

probe.Probe.(ShellProbe).New(...)

但这是一个非常令人困惑的API。

更好的方法可能是重新考虑整个API。使用您提供的有限信息很难做到这种级别的设计思维。

我不知道这是否适合您，但常见的模式是定义界面：

type Probe interface {
    New(string, JsonConfig)
    Exec() bool
    // ... etc
}

然后使所有探测类型实现接口。然后使用该界面而不是interface{}，正如您最初所做的那样：

type LoadableProbe struct {
    Name   string
    Probe  Probe
    Active bool
}

然后您的语法应该再次起作用，因为Probe接口包含New方法。

probe.Probe.New(...)

具有动态类型的结构

2 个答案: