我是 Go 的新手，我创建了一个按预期工作的应用程序。

我的应用程序结构如下:

myproj
   Gopkg.toml
   Gopkg.lock
   src
      server
         main.go
      utils
          file1.go
          logger.go
      handler
          handler1.go
          handler2.go

现在在 main.go 文件中，我创建了一个如下所示的记录器:

文件 server-> main.go

import (
      "handler"
      "utils"
      "github.com/sirupsen/logrus"
)

var logger                *logrus.Logger

fun init(){
    logger = utils.InitLogs()
} 


func main(){
  logger.info("my message")

  …

  handler.run()

} 

一切都按预期工作!

现在我想在 handler1&2 文件中使用记录器(来 self 本地项目中的 diff 包)

为此，我执行了以下步骤。 在处理程序 init 中记录器(与我在主文件中所做的完全一样)并且它正在工作

文件handler->handler1.go

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

var logger                *logrus.Logger

fun init(){
   //Init the logger again
    logger = utils.InitLogs()
} 
func run(){
   //here Im not using logger otherwise maybe I can move it as parameter…
} 

func build(){
  //Here Im using the logger
  logger.info("Hi") 
}

虽然这是有效的，但我已经创建了记录器的两个实例，第一个在main 和第二个在 handler1 上，我不确定哪个是最好的

My questions are:

1. 我想在 handler 类/模块中重用 logger，在 Go 中有更好的方法吗？

这是差异包(在我的本地项目中)，我不确定如果我不重新使用相同的记录器对象 main 方法，这是正确的方法...

1. (低优先级问题)我的项目结构适合 Go 吗？我用了this作为类似的引用... also this这有点不同

最佳答案

如果你想在你的项目中共享你的记录器实例，一种方法是将它作为一个全局变量从你的 utils 包中导出，正如 Armin 在他的回答中所建议的那样:

package utils

...

var Logger *logrus.Logger

func init() {
    Logger = InitLogs()
}

我敢打赌，通过将 InitLogs() 更改为 initLogs()

然后，在代码的其他地方，您可以导入 utils 并使用该记录器实例:

import "utils"

...
func something() {
    utils.Logger.Info("Hi")
}

或者，如果将所有配置保存在一个地方有意义，您可以将记录器指针声明为配置结构的一个字段，并将其与程序配置的其余部分(如果有的话)一起初始化。

例如，假设您的 utils 包中包含以下内容:

package utils

...

type MyAppConfig struct {
    // whatever config parameters your app needs,
    // like DB connections, etc.
    Logger *logrus.Logger
}

// pass in whatever configuration parameters you need,
// like DB URL, etc.
func InitConfig() (*MyAppConfig, error) {
   // set up other configuration

   config := &MyAppConfig{
       // other config
       Logger: InitLogs(),
   }

   return config, nil
}

func (c *MyAppConfig) DoSomethingImportant() {
    c.Logger.Info("Hello")
}

与此同时，您可以在其他任何地方使用它，例如在您的 CLI 界面中:

package main

import "utils"

...

func main() {
    // input, or CLI parameters...

    // pass in other CLI parameters, if any
    // (of course you'd have to change the function signature in
    // the previous file above)
    config, err := utils.NewConfig()
    if err != nil {
        // handle error
    }

    config.DoSomethingImportant()

    // or since Logger is exported:
    config.Logger.Info("hello")
}

如果你发现你最终需要配置很多全局的东西，比如你需要配置的 Logger，配置结构是更具可扩展性的 IMO 方法。作为一个额外的好处，使用配置类型比直接使用全局变量更容易在单元测试中进行依赖注入(inject)。

另一方面，如果您只需要担心一个全局记录器，那么配置结构可能就有点过分了，尤其是当您在设计测试时不需要检测它时。这是一个主观判断，具体取决于您的情况。

回答你的第二个问题......

项目布局

如果 /server 有一个带有命令的主包，将它移动到 cmd/server 下。

此外，以您目前的方式，依赖您的项目会让其他人感到困惑。由于您的存储库似乎从 src/ 开始，因此当其他人尝试导入您的 utils 包时，它看起来像这样:

文件结构:

 <top of someone else's GOPATH>/
   src/
     myproject/src/utils/
       ...

导入:

 import "myproject/src/utils"

... 实际上，由于您现在在代码中 import "utils"，我认为您的代码不会在其他人的 GOPATH 中编译，因为它们没有 $GOPATH/src/utils。

解决方案:您的存储库不应包含 src/。这个想法是您设置您的 $GOPATH 并将不同的存储库/包放入其中。例如(假设您将代码托管在 Github 上):

 <top of gopath>/
   src/
     github.com/you/myproject/  <---- your repo starts here
       cmd/server/
         main.go
       utils
         file1.go
         logger.go
       handler
         handler1.go
         handler2.go

这将使您的包对您和其他人来说是可导入的:

import "github.com/you/myproject/utils"

此外，此项目结构允许其他人将您的项目包含在他们的 $GOPATH 或他们的 vendor/ 中，可互换。

关于go - 从本地包中共享对象，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/47737242/