那些遇到过的问题

在多包中使用logger / configs的最佳做法可提高Golang的生产力

6 dependency-injection interface go

我有以下项目结构：

myGithubProject/
    |---- cmd
      |----- command
        |----- hello.go
    |---- internal
        |----- template
           |----- template.go
        |----- log
          |----- logger.go
    main.go
Run Code Online (Sandbox Code Playgroud)

在log与template处于同一水平（在内部封装）在logger.go使用即时通讯logrus与一些配置沙子记录我想用logger.go 的内部对象template包。我应该如何以一种干净的方式做到这一点？

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

而在internal包装下，我6还有更多packages需要它的地方logger。他们每个人都依赖它。（在log包装上）有什么好处理的吗？

更新：

如果我还有更多需要传递的内容（例如logger），这里的方法/模式是什么？也许使用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"
)

// startCmd represents the start command
var startCmd = &cobra.Command{
    Use:   "start",
    Short: "Start command",
    Run: func(cmd *cobra.Command, args []string) {
        // Print the logs via logger from internal
        logs.Logger.Println("start called inline")
        // example of many functions which should use the logs...
        start()
        stopping()

    },
}

func init() {
    logs.NewLogger()
    rootCmd.AddCommand(startCmd)
    startCmd.Flags().BoolP("toggle", "t", false, "Help message for toggle")
}

func start() {
    logs.Logger.Error("starting from function start")
}

func stopping() {
    logs.Logger.Error("stoping from function start")
}


**cliProject/internal/logs/logger.go**

package logs

import (
    "github.com/sirupsen/logrus"
    "github.com/x-cray/logrus-prefixed-formatter"
    "os"
)

var Logger *logrus.Logger

func 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")
    }
}
Run Code Online (Sandbox Code Playgroud)

这就是它的样子

在此处输入图片说明

jon*_*sam 6

在内部包下，我还有 6 个需要这个记录器的包。他们每个人都依赖于它。（在日志包上），有没有好的处理方法？

一个好的一般原则是尊重应用程序的选择（是否登录）而不是设置策略。

  1. 让你去PKGSinternal目录是支持包是

    • 只会error在出现问题时返回
    • 不会登录（控制台或其他方式）
    • 惯于 panic

  2. 让您的应用程序（您cmd目录中的包）决定发生错误时的适当行为（日志/正常关闭/恢复到 100% 完整性）

这将通过仅在特定层进行日志记录来简化开发。注意：记得给应用程序提供足够的上下文来确定操作

内部/流程/流程.go

package process

import (
    "errors"
)

var (
    ErrNotFound = errors.New("Not Found")
    ErrConnFail = errors.New("Connection Failed")
)

// function Process is a dummy function that returns error for certain arguments received
func Process(i int) error {
    switch i {
    case 6:
        return ErrNotFound
    case 7:
        return ErrConnFail
    default:
        return nil
    }
}
Run Code Online (Sandbox Code Playgroud)

cmd/servi/main.go

package main

import (
    "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")
        }
    }
}
Run Code Online (Sandbox Code Playgroud)

万一我需要传递更多的东西（比如记录器）这里的方法/模式是什么

依赖注入始终是一个不错的首选。只有在最简单的实现不够时才考虑其他。

下面的代码使用依赖注入和一流的函数传递将template和logger包“连接”在一起。

内部/日志/logger.go

package logger

import (
    "github.com/sirupsen/logrus"
    "github.com/x-cray/logrus-prefixed-formatter"
    "os"
)

var Logger *logrus.Logger

func 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")
    }
}
Run Code Online (Sandbox Code Playgroud)

内部/模板/template.go

package template

import (
    "fmt"
    "github.com/sirupsen/logrus"
)

type Template struct {
    Name   string
    logger *logrus.Logger
}

// factory function New accepts a logging function and some data
func New(logger *logrus.Logger, data string) *Template {
    return &Template{data, logger}
}

// dummy function DoSomething should do something and log using the given logger
func (t *Template) DoSomething() {
    t.logger.Info(fmt.Sprintf("%s, %s", t.Name, "did something"))
}
Run Code Online (Sandbox Code Playgroud)

cmd/servi2/main.go

package main

import (
    "../../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()
}
Run Code Online (Sandbox Code Playgroud)

希望这可以帮助。干杯，

Ken*_*ant 5

有几种可能性，每种都有自己的权衡。

\n\n
    \n
  1. 显式传递依赖项
    2. \n
  2. 传递包含所有依赖项的上下文
    3. \n
  3. 使用结构作为方法的上下文
    4. \n
  4. 使用全局包并导入
    5. \n
\n\n

它们在不同的情况下都有自己的位置，并且都有不同的权衡：

\n\n
    \n
  1. 这非常清楚，但可能会变得非常混乱，并且由于大量依赖项而使您的函数变得混乱。如果你喜欢的话，它会让测试变得很容易模拟。
    2. \n
  2. 这是我最不喜欢的选择，因为它一开始很诱人，但很快就成长为一个混合了许多不相关问题的神物。避免。
    3. \n
  3. 这在许多情况下非常有用，例如许多人以这种方式访问​​数据库。如果需要的话也很容易模拟。这允许您设置/共享依赖项，而无需在使用时更改代码 - 基本上以比传递显式参数更简洁的方式反转控制。
    4. \n
  4. 这具有清晰性和正交性的优点。它将要求您为测试和生产添加单独的设置，在使用之前将包初始化到正确的状态。由于这个原因，有些人不喜欢它。
    5. \n
\n\n

我更喜欢使用包全局方法来处理诸如日志记录之类的事情，只要使用非常简单的签名即可。我不\xe2\x80\x99t倾向于测试日志输出，或经常更改记录器。考虑您真正需要从日志中获得什么，以及使用内置日志包是否最好，也许可以尝试其中一种方法来看看哪一种适合您。

\n\n

为了简洁起见，伪代码示例：

\n\n
// 1. Pass in dependencies explicitly\nfunc MyFunc(log LoggerInterface, param, param)\n\n\n// 2. Pass in a context with all dependencies\n\nfunc MyFunc(c *ContextInterface, param, param)\n\n// 3. Use a struct for context to methods\n\nfunc (controller *MyController) MyFunc(param, param) {\n   controller.Logger.Printf("myfunc: doing foo:%s to bar:%s",foo, bar) \n}\n\n// 4. Use a package global and import\n\npackage log \n\nvar DefaultLogger PrintfLogger\n\nfunc Printf(format, args) {DefaultLogger.Printf(format, args)}\n\n// usage: \n\nimport "xxx/log"\n\nlog.Printf("myfunc: doing foo:%s to bar:%s",foo, bar) \n
Run Code Online (Sandbox Code Playgroud)\n\n

我更喜欢用这个选项 4 进行日志记录和配置，甚至是数据库访问，因为它是明确的、灵活的，并且允许轻松切换另一个记录器 - 只需更改导入，无需更改接口。不过，计算哪个最好取决于具体情况 - 如果您正在编写一个广泛使用的库，您可能更愿意允许在结构级别设置记录器。

\n\n

我通常需要在应用程序启动时进行显式设置，并且始终避免使用 init 函数，因为它们令人困惑且难以测试。

\n

归档时间：

查看次数：

1649 次

最近记录：

6 年，5 月 前
如何使用"内部"包？ 23
更多相关链接
相关归档
os.MkDir和os.MkDirAll权限值？ 50
去数组初始化 36
在Go中实例化类型的首选方法 12
在域类中注入grails服务的问题 5
Golang非结构类型指针接收器 4
Guice的实例方法 2
接口及其实现的包/目录结构 2
我们可以在Interface中有成员变量吗？ 1
在构造函数中使用多个接口作为参数的依赖注入 1
获取异常：InvalidOperationException：无法解析 Booking.Repositories.DriverRepository 类型的服务 0
难疑归档
撤消尚未推送的Git合并 3695
如何更新GitHub分叉存储库？ 3390
仅存储使用Git更改的多个文件中的一个文件？ 2895
如何以MS Word保留格式和语法高亮显示代码片段？ 1877
.gitignore和.gitkeep有什么区别？ 1776
动态创建元素的事件绑定？ 1677
在上传图像之前预览图像 1476
计算C#中的相对时间 1461
我如何开始使用Node.js 1264
如何将div中的绝对定位元素居中？ 1034