如何解决Golang中的导入周期问题？

Question

我遇到了导入周期问题。 我读了一些博客，但没看懂。 这是我编写的示例代码。

文件1.go

package dir1

type Filo interface {
    File2(string) string
}

func File1(message string) string {
    var f Filo
    importFile2 := f.File2("file 2")
    return "Welcome to " + message + " and message from file 2: " + importFile2
}

文件2.go

package dir2

import "github.com/ibilalkayy/app/dir1"

func File2(message string) string {
    importFile1 := dir1.File1("file 1")
    return "Welcome to " + message + " and message from file 1: " + importFile1
}

主要.go

package main

import (
    "fmt"

    "github.com/ibilalkayy/app/dir1"
    "github.com/ibilalkayy/app/dir2"
)

func main() {
    fmt.Println("Hello world")
    first := dir1.File1("file 1")
    second := dir2.File2("file 2")
    fmt.Println(first)
    fmt.Println(second)
}

Answer 1

对导入周期的渴望通常表明设计存在问题。

有两种通用解决方案可以避免导入循环：

• 如果 2 个包如此紧密地联系在一起并且它们相互依赖，那么最好将它们（或核心功能）合并到一个 package 中。这可以避免导入周期。
• 或者，其中一个包应该使用一个接口，这样它就不会依赖于其他 package。这会创建 package 层的自然排序。

例如，由于导入循环，以下人为设计的示例将无法编译：

package main

import "example.com/base"
import "example.com/other"

func main() {
   f := &other.Foo{}
   _ = base.Process(f)
}

package base

import "example.com/other"

func Process(f *other.Foo) {
    for {
        if err := f.Frob(); err != nil {
            return err
        }
    }
}

package other

import "example.com/base"

type Foo int

func (f *foo) Frob(name string) error {
    if *f == 0 {
        return errors.New("completed")
    }
    *f--
    return base.Process(f)
}

这可以通过更改base以使用接口来解决：

package base

type Frobber interface {
    Frob(string) error
}

func Process(f Frobber) error {
    for {
        if err := f.Frob("some file"); err != nil {
            return err
        }
    }
}

这是有效的，因为*other.Foo可以传递给base.Process而无需base package 需要了解other package 的任何信息。

另一种选择是使用 function 变量：

// Given:
package other
import "example.com/base"
type Foo struct {}
func (f *Foo) Frob(name string) error

package base
import "example.com/other"
func Process(f *Foo) error

// Use this instead:
package base
func Process(fn func(string) error) error

// Which enables using:
package main
import "example.com/other"
func main() {
    f := &other.Foo{} // NOTE: This needs to be real an initialised.
    Process(f.Frob)
}

问题中的示例从根本上打破了导入周期之外的问题。 由于相互递归，它会用完堆栈空间。 忽略它，您可以使用无类型的func进行编译。 例如：

func File1(fn func(string) string) string {
    return "Welcome to message from file 2: " + fn("some file")
}

// Call with:

func something(name string) string {
   return "foo/" + name
}

dir1.File1(something)