相互依赖结构/接口嵌入咨询：提取公共结构体并处理双向方法调用

这种场景在Go里用接口解耦是最优雅的方案，刚好能完美解决你说的双向调用+公共逻辑提取需求。我给你梳理一套清晰的实现思路和代码示例：

我们通过接口定义契约来分离公共逻辑与特定逻辑，同时通过互相持有实例实现双向调用：

• 定义Specificer接口，约定特定结构体必须实现的方法（Name()、Format()）
• 定义Common结构体封装所有公共字段和方法（Start()、Process()、GetVerbosity()），并持有Specificer实例来调用特定逻辑
• 特定结构体持有Common（或其接口）的实例，用来调用公共方法

第一步：定义接口契约 #

先明确双方需要遵守的接口，让公共和特定部分只依赖接口而非具体实现：

// Specificer 特定结构体必须实现的接口，供Common调用
type Specificer interface {
    Name() string               // 返回特定结构体的标识字符串
    Format(processed string) string // 按需格式化处理后的结果
}

// Commoner 公共结构体必须实现的接口，供特定结构体调用
type Commoner interface {
    GetVerbosity() int // 获取公共的Verbosity配置
}

第二步：实现公共结构体Common #

把所有重复的逻辑和字段放到这里，通过Specificer接口调用特定逻辑：

import "fmt"

// Common 封装公共逻辑的核心结构体
type Common struct {
    Verbosity int       // 公共配置字段
    specific  Specificer // 持有特定部分的实例
}

// SetSpecific 给Common绑定对应的特定结构体实例
func (c *Common) SetSpecific(s Specificer) {
    c.specific = s
}

// Start 公共启动方法，串联整个工作流程
func (c *Common) Start() string {
    // 调用特定部分的Name()
    entityName := c.specific.Name()
    // 用公共逻辑处理结果
    processedResult := c.Process(entityName)
    // 根据Verbosity决定是否调用Format()
    if c.Verbosity > 2 {
        processedResult = c.specific.Format(processedResult)
    }
    return processedResult
}

// Process 公共处理逻辑，可根据需求扩展
func (c *Common) Process(input string) string {
    return fmt.Sprintf("[Common Process] input: %s | verbosity: %d", input, c.Verbosity)
}

// GetVerbosity 实现Commoner接口，供特定结构体调用
func (c *Common) GetVerbosity() int {
    return c.Verbosity
}

第三步：实现特定结构体 #

以StructA为例，其他结构体（StructB、StructC）只需复制这个结构，修改特定字段和方法实现即可：

// StructA 特定业务结构体A
type StructA struct {
    common     Commoner // 持有公共接口实例，调用公共方法
    CustomField string  // 结构体A的特定字段
}

// Name 实现Specificer接口，这里可以调用Common的方法
func (a *StructA) Name() string {
    return fmt.Sprintf("StructA | current verbosity: %d", a.common.GetVerbosity())
}

// Format 实现Specificer接口，添加A的特定格式化逻辑
func (a *StructA) Format(processed string) string {
    return fmt.Sprintf("[StructA Format] %s | custom data: %s", processed, a.CustomField)
}

第四步：使用示例 #

初始化并关联实例，验证整个流程：

func main() {
    // 1. 创建公共实例
    common := &Common{Verbosity: 3}
    // 2. 创建特定实例并绑定公共接口
    structA := &StructA{
        common:     common,
        CustomField: "sample data for A",
    }
    // 3. 给公共实例绑定特定实例
    common.SetSpecific(structA)

    // 4. 启动流程
    finalResult := common.Start()
    fmt.Println(finalResult)
}

运行后输出：

[StructA Format] [Common Process] input: StructA | current verbosity: 3 | verbosity: 3 | custom data: sample data for A

• 代码复用：公共逻辑完全抽离，避免3个结构体的重复代码
• 低耦合：公共和特定部分只依赖接口，新增/修改特定结构体不需要改动Common代码
• 双向调用清晰：通过互相持有接口实例实现双向调用，避免循环依赖问题
• 扩展性强：新增特定结构体只需要实现Specificer接口，快速接入现有流程

内容的提问来源于stack exchange，提问作者Eugene Lisitsky