我正在尝试在 golang 上编写一个 restful api。对于 http 路由器，我使用 gin-gonic，与我使用 gorm 的数据库交互。 包主

import (
    "fmt"

    "github.com/gin-gonic/gin"
    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/postgres"
)

var db *gorm.DB

type Person struct {
    ID        uint   `json:"id"`
    FirstName string `json:"firstname"`
    LastName  string `json:"lastname"`
}

func main() {
    // NOTE: See we’re using = to assign the global var
    // instead of := which would assign it only in this function
    db, err := gorm.Open("postgres", fmt.Sprintf("host=localhost sslmode=disable user=postgres password="))
    if err != nil {
        fmt.Println(err)
    }
    defer db.Close()
    db.AutoMigrate(&Person{})
    r := gin.Default()
    r.GET("/people/", GetPeople)
    r.GET("/people/:id", GetPerson)
    r.POST("/people", CreatePerson)
    r.Run(":8080")
}
func CreatePerson(c *gin.Context) {
    var person Person
    c.BindJSON(&person)
    db.Create(&person)
    c.JSON(200, person)
}
func GetPerson(c *gin.Context) {
    id := c.Params.ByName("id")
    var person Person
    if err := db.Where("id = ?", id).First(&person).Error; err != nil {
        c.AbortWithStatus(404)
        fmt.Println(err)
    } else {
        c.JSON(200, person)
    }
}
func GetPeople(c *gin.Context) {
    var people []Person
    if err := db.Find(&people).Error; err != nil {
        c.AbortWithStatus(404)
        fmt.Println(err)
    } else {
        c.JSON(200, people)
    }
}

如何将代码拆分到多个文件中，以便单独的资源位于单独的文件中？如何在另一个文件中使用路由器和数据库？

更新

结构如下:

.
└── app
    ├── users.go
    ├── products.go
    └── main.go

我有两个问题:

1. db == nil products.go 和 users.go
2. 在不同的文件中重新声明函数(get，create ...)，这通过函数声明中的前缀解决，例如CreateUser，CreateProduct等，不过可能是把代码放到另外一个包里解决

ma​​in.go

package main

import (
    "fmt"

    "github.com/gin-gonic/gin"
    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/postgres"
)

var (
    db *gorm.DB
    r  *gin.Engine
)

func init() {
    db, err := gorm.Open("postgres", fmt.Sprintf("host=localhost sslmode=disable user=postgres password="))
    if err != nil {
        fmt.Println(err)
    }
    defer db.Close()

    r = gin.Default()
}

func main() {
    r.Run(":8080")
}

products.go

package main

import (
    "github.com/gin-gonic/gin"
    "github.com/jinzhu/gorm"
)

type Product struct {
    gorm.Model
    Code  string
    Price uint
}

func init() {
    db.AutoMigrate(&Product{}) // db -> nil

    r.GET("/products", get)
}

func get(c *gin.Context) {
    var product Product
    db.First(&product, 1)

    c.JSON(200, gin.H{
        "product": product,
    })
}

users.go

package main

import (
    "github.com/gin-gonic/gin"
    "github.com/jinzhu/gorm"
)

type User struct {
    gorm.Model
    Name string
}

func init() {
    db.AutoMigrate(&User{}) // db -> nil

    r.GET("/users", get)
}

// ./users.go:19: get redeclared in this block
// previous declaration at ./products.go:20    
func get(c *gin.Context) {
    var user User
    db.First(&user, 1)

    c.JSON(200, gin.H{
        "user": user,
    })
}

最佳答案

因为您的 db var 是在包级别定义的，所以它基本上是该包的全局变量，可以在该包中的任何文件中引用。

例如，在这样的项目中:

.
└── app
    ├── a.go
    ├── b.go
    ├── c.go
    └── main.go

如果 db 是在包级别的 main.go 中定义的，如您的示例，则文件 a.go、b.go 和 c.go 中的代码可以使用 db 。

反之亦然，在 a.go、b.go 和 c.go 中定义的任何资源处理程序都可以在 main.go 中引用。这意味着在这些文件中的每一个中，您都可以定义一个函数，它接受一个路由器，gin 路由器，并设置相应的处理程序，然后在 main.go 的主要函数中，您调用传递给路由器的那些函数 r.

更新

首先，您在 init 函数内部调用 defer db.Close()，这意味着在 init 返回后您的 db 立即关闭，这绝对是不是你想要的。在 main 中使用 defer db.Close() 很好，因为 main 在您的应用程序终止时终止，此时关闭数据库是有道理的，但是当 init 终止时您的应用程序甚至没有正常启动，main刚刚被执行，你仍然需要你的 db。

如果你想在每个文件中使用 init 函数来执行特定于该文件的初始化，你必须确保无论这些 init 函数依赖什么，都在它们被执行之前被初始化 .

在您的示例中，所有初始化函数都依赖于 db 和 r，因此您需要确保这两个不是 nil。我不确定在 Go 中，单个包中的多个 init 函数的执行顺序是什么，但我可以肯定的是包级变量表达式在执行 init 函数之前得到初始化。

所以你可以做的是使用函数调用来初始化两个包级变量，如下所示:

package main

import (
    "fmt"

    "github.com/gin-gonic/gin"
    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/postgres"
)

var (
    db = func() *gorm.DB {
        db, err := gorm.Open("postgres", fmt.Sprintf("host=localhost sslmode=disable user=postgres password="))
        if err != nil {
            // if you can't open a db connection you should stop the app,
            // no point in continuing if you can't do anything useful.
            panic(err)
        }
        return db
    }() // <- call the anon function to get the db.

    r = gin.Default()
)

func main() {
    // you can call defer db.Close() here but you don't really need to
    // because after main exists, that is, your app terminates, db
    // will be closed automatically.

    r.Run(":8080")
}

关于你的第二个问题，在 Go 中，init 是一个特例，我的意思是你可以在一个包内有多个 init 函数，甚至在单个文件。这不适用于您声明的任何其他标识符。

这意味着在包内，并在包级别声明，你只能有一个 db 标识符，一个 get 标识符，只有一个 User 标识符等。是否使用后缀，例如getUser 或 packages user.Get 完全由您决定。

请注意，您可以在另一个作用域中重新声明标识符，假设您在包级别有type User struct { ...，然后在中声明了一个函数同一个 pacakge 可以在其自己的范围内声明一个变量，如 var User = "whatever"，尽管这可能不是编译时的最佳想法。

详情请见: Package initialization

更新2

如果您想将代码拆分到多个包中，只需将文件放入单独的文件夹中，并确保文件顶部的 package 声明具有正确的包名称。

这是一个例子:

└── app/
    ├── main.go
    ├── product/
    │   ├── product.go
    │   └── product_test.go
    └── user/
        ├── user.go
        └── user_test.go

现在您的 app/user/user.go 代码可能看起来像这样。

package user

import (
    "github.com/gin-gonic/gin"
    "github.com/jinzhu/gorm"
)

var db *gorm.DB

type User struct {
    gorm.Model
    Name string
}

// custom and exported Init function, this will not be called automatically
// by the go runtime like the special `init` function and therefore must be called
// manually by the package that imports this one.
func Init(gormdb *gorm.DB, r *gin.Engine) {
    db = gormdb // set package global

    db.AutoMigrate(&User{})

    r.GET("/users", get)
}

func get(c *gin.Context) {
    var user User
    db.First(&user, 1)

    c.JSON(200, gin.H{
        "user": user,
    })
}

你的 app/product/product.go ...

package product

import (
    "github.com/gin-gonic/gin"
    "github.com/jinzhu/gorm"
)

var db *gorm.DB

type Product struct {
    gorm.Model
    Code  string
    Price uint
}

// custom and exported Init function, this will not be called automatically
// by the go runtime like the special `init` function and therefore must be called
// manually by the package that imports this one.
func Init(gormdb *gorm.DB, r *gin.Engine) {
    db = gormdb // set package global

    db.AutoMigrate(&Product{})

    r.GET("/products", get)
}

func get(c *gin.Context) {
    var product Product
    db.First(&product, 1)

    c.JSON(200, gin.H{
        "product": product,
    })
}

你的入口点在 app/main.go ...

package main

import (
    "fmt"

    // This assumes that the app/ folder lives directly in $GOPATH if that's
    // not the case the import won't work.
    "app/product"
    "app/user"

    "github.com/gin-gonic/gin"
    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/postgres"
)

func main() {
    db, err := gorm.Open("postgres", fmt.Sprintf("host=localhost sslmode=disable user=postgres password="))
    if err != nil {
        fmt.Println(err)
    }
    defer db.Close()

    r := gin.Default()

    // manually initialize imported packages
    user.Init(db, r)
    product.Init(db, r)

    r.Run(":8080")
}

关于go - 如何将我的资源拆分成多个文件，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/47115731/