在 Golang 高效的多包最佳实践中使用记录器/配置

Question

我有以下项目结构：

myGithubProject/
    |---- cmd
      |----- command
        |----- hello.go
    |---- internal
        |----- template
           |----- template.go
        |----- log
          |----- logger.go
    main.go

和log处于template同一级别（在内部包下） 在logger.go我使用logrus一些配置作为记录器时，我想使用包logger.go 内的对象template。我应该如何以干净的方式做到这一点？

import logger目前我在我的文件中使用它template.go，

在包下，internal我有6更多packages需要这个的东西logger。他们每个人都依赖于它。（在log包装上），有没有很好的去处理它？

更新：

如果我有更多需要传递的东西（比如记录器），这里的方法/模式是什么？也许使用dependency injection？interface？其他清洁方法...

我需要一些最佳实践的完整示例，我如何在文件logger内部hello.go以及template.go.

这是我的项目

cliProject/main.go

package main

import (

    "cliProject/cmd"

    "cliProject/internal/logs"

)

func main() {

    cmd.Execute()

    logs.Logger.Error("starting")

}

**cliProject/cmd/root.go**

package cmd

import (

    "fmt"

    "github.com/spf13/cobra"

)

var rootCmd = &cobra.Command{

    Use:   "cliProject",

    Short: "A brief description of your application",

}

func Execute() {

    if err := rootCmd.Execute(); err != nil {

        fmt.Println(err)

    }

}

**cliProject/cmd/serve.go**

package cmd

import (

    "cliProject/internal/logs"

    "fmt"

    "github.com/spf13/cobra"

)

// serveCmd represents the serve command

var serveCmd = &cobra.Command{

    Use:   "serve",

    Short: "A brief description of your command",

    Run: func(cmd *cobra.Command, args []string) {

        fmt.Println("serve called")

        startServe()

        stoppingServe()

    },

}

func init() {

    rootCmd.AddCommand(serveCmd)

    serveCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")

}

func startServe() {

    logs.Logger.Error("starting from function serve")

}

func stoppingServe() {

    logs.Logger.Error("stoping from function serve")

}

**cliProject/cmd/start.go**

package cmd

import (

    "cliProject/internal/logs"

    "github.com/spf13/cobra"

)

这是它的样子

Answer 1

在内部包下，我还有 6 个需要这个记录器的包。他们每个人都依赖于它。（在日志包上），去处理它有什么好处吗？一个好的一般原则是尊重应用程序的选择（是否记录或不记录）而不是设置策略。让目录中的 Go pkgsinternal成为支持包只会error在出现问题时返回不会记录（控制台或其他方式）惯于panic让您的应用程序（您cmd目录中的包）决定在发生错误时的适当行为（日志/正常关闭/恢复到 100% 完整性）这将通过仅在特定层进行日志记录来简化开发。注意：记得给应用程序提供足够的上下文来确定操作内部/流程/process.gopackage processimport (    "errors")var (    ErrNotFound = errors.New("Not Found")    ErrConnFail = errors.New("Connection Failed"))// function Process is a dummy function that returns error for certain arguments receivedfunc Process(i int) error {    switch i {    case 6:        return ErrNotFound    case 7:        return ErrConnFail    default:        return nil    }}cmd/servi/main.gopackage mainimport (    "log"    p "../../internal/process")func main() {    // sample: generic logging on any failure    err := p.Process(6)    if err != nil {        log.Println("FAIL", err)    }    // sample: this application decides how to handle error based on context    err = p.Process(7)    if err != nil {        switch err {        case p.ErrNotFound:            log.Println("DOESN'T EXIST. TRY ANOTHER")        case p.ErrConnFail:            log.Println("UNABLE TO CONNECT; WILL RETRY LATER")        }    }}如果我有更多需要传递的东西（比如记录器），这里的方法/模式是什么依赖注入始终是一个不错的首选。仅当最简单的实施方式不够时才考虑其他方式。下面的代码使用依赖注入和一流的函数传递将template和打包在一起。logger内部/日志/logger.gopackage loggerimport (    "github.com/sirupsen/logrus"    "github.com/x-cray/logrus-prefixed-formatter"    "os")var Logger *logrus.Loggerfunc NewLogger() *logrus.Logger {    var level logrus.Level    level = LogLevel("info")    logger := &logrus.Logger{        Out:   os.Stdout,        Level: level,        Formatter: &prefixed.TextFormatter{            DisableColors:   true,            TimestampFormat: "2009-06-03 11:04:075",        },    }    Logger = logger    return Logger}func LogLevel(lvl string) logrus.Level {    switch lvl {    case "info":        return logrus.InfoLevel    case "error":        return logrus.ErrorLevel    default:        panic("Not supported")    }}内部/模板/template.gopackage templateimport (    "fmt"    "github.com/sirupsen/logrus")type Template struct {    Name   string    logger *logrus.Logger}// factory function New accepts a logging function and some datafunc New(logger *logrus.Logger, data string) *Template {    return &Template{data, logger}}// dummy function DoSomething should do something and log using the given loggerfunc (t *Template) DoSomething() {    t.logger.Info(fmt.Sprintf("%s, %s", t.Name, "did something"))}命令/servi2/main.gopackage mainimport (    "../../internal/logs"    "../../internal/template")func main() {    // wire our template and logger together    loggingFunc := logger.NewLogger()    t := template.New(loggingFunc, "Penguin Template")    // use the stuff we've set up    t.DoSomething()}希望这可以帮助。干杯，

Answer 2

有几种可能性，每种可能性都有自己的权衡。显式传递依赖项传入具有所有依赖项的上下文将结构用于方法的上下文使用全局包并导入它们在不同的情况下都有自己的位置，并且都有不同的权衡：这非常清楚，但可能会变得非常混乱，并使您的函数因大量依赖而变得混乱。如果那是你的事，它使测试很容易模拟。这是我最不喜欢的选项，因为它一开始很诱人，但很快就变成了一个混合了许多不相关问题的上帝对象。避免。这在许多情况下非常有用，例如许多人以这种方式访问数据库。如果需要，也很容易模拟。这允许您设置/共享依赖项而无需在使用时更改代码 - 基本上以比传入显式参数更简洁的方式反转控制。这具有清晰性和正交性的优点。它将要求您为测试与生产添加单独的设置，在使用之前将包初始化为正确的状态。由于这个原因，有些人不喜欢它。只要使用非常简单的签名，我更喜欢将包全局方法用于日志记录之类的东西。我不倾向于测试日志输出，或者经常更改记录器。考虑你真正需要从日志中得到什么，以及是否最好只使用内置的日志包，也许可以尝试其中一种方法，看看哪种方法适合你。为简洁起见，伪代码示例：// 1. Pass in dependencies explicitlyfunc MyFunc(log LoggerInterface, param, param)// 2. Pass in a context with all dependenciesfunc MyFunc(c *ContextInterface, param, param)// 3. Use a struct for context to methodsfunc (controller *MyController) MyFunc(param, param) {   controller.Logger.Printf("myfunc: doing foo:%s to bar:%s",foo, bar) }// 4. Use a package global and importpackage log var DefaultLogger PrintfLoggerfunc Printf(format, args) {DefaultLogger.Printf(format, args)}// usage: import "xxx/log"log.Printf("myfunc: doing foo:%s to bar:%s",foo, bar) 我更喜欢这个选项 4 用于日志记录和配置，甚至数据库访问，因为它是明确的、灵活的，并且允许轻松切换另一个记录器——只需更改导入，无需更改接口。不过，最佳计算取决于具体情况——如果您正在编写一个广泛使用的库，您可能更愿意允许在结构级别设置记录器。我通常需要在应用程序启动时使用显式设置进行设置，并且始终避免使用 init 函数，因为它们令人困惑且难以测试。

Answer 3

我总是明确地将 a 传递*logrus.Logger给需要它的函数（或偶尔是对象）。这避免了奇怪的依赖循环，明确表明日志记录是这个函数所做的事情的一部分，并且更容易在别处重用该函数或模块。初始日志对象是在我的主函数中创建和配置的（可能在一些命令行参数处理之后）。