Go子包调用父包回调函数如何避免循环依赖？

针对你遇到的循环依赖问题，有几种简单的实现方式，核心思路是让日志子包不直接依赖主包的类型：

方案1：使用any类型适配回调 #

把日志子包的回调类型改为接收any类型参数，子包无需知晓CleanupParams的具体定义，仅负责在需要时调用回调并传入保存的参数即可。

修改日志子包代码：

package MyPackage/logs

// 定义通用回调类型，参数为any
type LogCallback func(any)

func SetupLogs(callback LogCallback, cleanupParams any) {
    go LogLoop(callback, cleanupParams)
}

func LogLoop(callback LogCallback, cleanupParams any) {
    defer callback(cleanupParams)
    
    for {
        // 日志循环逻辑，panic时defer会触发回调
    }
}

主包调用时，通过匿名函数做类型断言保证安全：

package MyPackage

import . "MyPackage/logs"

func main() {
    cleanupParams := &CleanupParams{/* 初始化参数 */}
    SetupLogs(func(p any) {
        if params, ok := p.(*CleanupParams); ok {
            Cleanup(params)
        }
    }, cleanupParams)
}

type CleanupParams struct {
    // 参数结构定义
}

func Cleanup(params *CleanupParams) {
    // 清理逻辑
}

如果不需要额外安全校验，也可以直接传递Cleanup函数——Go允许func(*CleanupParams)隐式转换为func(any)，但类型断言能避免潜在的类型不匹配问题。

方案2：定义无类型依赖的回调接口 #

在日志子包里定义仅包含回调方法的接口，主包通过类型实现该接口（无需显式声明，方法匹配即可），完全消除类型依赖。

日志子包代码：

package MyPackage/logs

// 定义回调接口
type Cleaner interface {
    Cleanup()
}

func SetupLogs(cleaner Cleaner) {
    go LogLoop(cleaner)
}

func LogLoop(cleaner Cleaner) {
    defer cleaner.Cleanup()
    
    for {
        // 日志循环逻辑
    }
}

主包代码：

package MyPackage

import . "MyPackage/logs"

type CleanupParams struct {
    // 参数结构定义
}

// 让CleanupParams实现Cleaner接口
func (p *CleanupParams) Cleanup() {
    // 原Cleanup逻辑写在这里
}

func main() {
    cleanupParams := &CleanupParams{/* 初始化参数 */}
    SetupLogs(cleanupParams)
}

这种方式贴合Go的鸭子类型思想，代码结构更清晰。

方案3：提取公共类型到独立包 #

如果允许调整项目结构，可将CleanupParams提取到独立的公共包（比如MyPackage/common），主包和日志子包都引用该公共包，从根源上避免循环依赖。

公共包MyPackage/common代码：

package common

type CleanupParams struct {
    // 参数结构定义
}

主包代码：

package MyPackage

import (
    "MyPackage/logs"
    "MyPackage/common"
)

func main() {
    cleanupParams := &common.CleanupParams{/* 初始化参数 */}
    logs.SetupLogs(Cleanup, cleanupParams)
}

func Cleanup(params *common.CleanupParams) {
    // 清理逻辑
}

日志子包代码：

package MyPackage/logs

import "MyPackage/common"

type LogCallback func(*common.CleanupParams)

func SetupLogs(callback LogCallback, cleanupParams *common.CleanupParams) {
    go LogLoop(callback, cleanupParams)
}

func LogLoop(callback LogCallback, cleanupParams *common.CleanupParams) {
    defer callback(cleanupParams)
    
    for {
        // 日志循环逻辑
    }
}

这种方式类型安全性最高，适合长期维护的项目。

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