我正在使用 Gin，https: //gin-gonic.github.io/gin/，用 Golang 构建一个简单的 RESTful JSON API。
路线是这样设置的：
func testRouteHandler(c *gin.Context) {
// do smth
}
func main() {
router := gin.Default()
router.GET("/test", testRouteHandler)
router.Run(":8080")
}
我的问题是如何将参数传递给 testRouteHandler 函数？例如，一个公共数据库连接可能是一个想要在路由之间重用的东西。
将它放在全局变量中是最好的方法吗？或者 Go 中有什么方法可以将额外的变量传递给 testRouteHandler 函数？Go 中的函数是否有可选参数？
PS。我刚刚开始学习围棋，所以我可能很明显地错过了一些东西:)
我会避免将“应用程序范围”依赖项（例如数据库连接池）填充到请求上下文中。您的两个“最简单”的选择是：
*sql.DB是线程安全的。gin.HandlerFunc例如
// SomeHandler returns a `func(*gin.Context)` to satisfy Gin's router methods
// db could turn into an 'Env' struct that encapsulates all of your
// app dependencies - e.g. DB, logger, env vars, etc.
func SomeHandler(db *sql.DB) gin.HandlerFunc {
fn := func(c *gin.Context) {
// Your handler code goes in here - e.g.
rows, err := db.Query(...)
c.String(200, results)
}
return gin.HandlerFunc(fn)
}
func main() {
db, err := sql.Open(...)
// handle the error
router := gin.Default()
router.GET("/test", SomeHandler(db))
router.Run(":8080")
}
使用我在评论中发布的链接，我创建了一个简单的示例。
package main
import (
"log"
"github.com/gin-gonic/gin"
"github.com/jinzhu/gorm"
_ "github.com/mattn/go-sqlite3"
)
// ApiMiddleware will add the db connection to the context
func ApiMiddleware(db gorm.DB) gin.HandlerFunc {
return func(c *gin.Context) {
c.Set("databaseConn", db)
c.Next()
}
}
func main() {
r := gin.New()
// In this example, I'll open the db connection here...
// In your code you would probably do it somewhere else
db, err := gorm.Open("sqlite3", "./example.db")
if err != nil {
log.Fatal(err)
}
r.Use(ApiMiddleware(db))
r.GET("/api", func(c *gin.Context) {
// Don't forget type assertion when getting the connection from context.
dbConn, ok := c.MustGet("databaseConn").(gorm.DB)
if !ok {
// handle error here...
}
// do your thing here...
})
r.Run(":8080")
}
这只是一个简单的 POC。但我相信这是一个开始。希望能帮助到你。
聚会迟到了，到目前为止，这是我的建议。将方法封装到带有私有/公共变量的对象中：
package main
import (
"log"
"github.com/gin-gonic/gin"
"github.com/jinzhu/gorm"
_ "github.com/mattn/go-sqlite3"
)
type HandlerA struct {
Db gorm.DB
}
func (this *HandlerA) Get(c *gin.Context) {
log.Info("[%#f]", this.Db)
// do your thing here...
}
func main() {
r := gin.New()
// Init, should be separate, but it's ok for this sample:
db, err := gorm.Open("sqlite3", "./example.db")
if err != nil {
log.Fatal(err)
}
Obj := new(HandlerA)
Obj.Db = db // Or init inside Object
r := gin.New()
Group := r.Group("api/v1/")
{
Group.GET("/storage", Obj.Get)
}
r.Run(":8080")
}
我喜欢 wildneuro 的例子，但会做一个单行来设置处理程序
package main
import (
"log"
"github.com/gin-gonic/gin"
"github.com/jinzhu/gorm"
_ "github.com/mattn/go-sqlite3"
)
type HandlerA struct {
Db gorm.DB
}
func (this *HandlerA) Get(c *gin.Context) {
log.Info("[%#f]", this.Db)
// do your thing here...
}
func main() {
r := gin.New()
// Init, should be separate, but it's ok for this sample:
db, err := gorm.Open("sqlite3", "./example.db")
if err != nil {
log.Fatal(err)
}
r := gin.New()
Group := r.Group("api/v1/")
{
Group.GET("/storage", (&HandlerA{Db: db}).Get)
}
r.Run(":8080")
}
处理程序闭包是一个不错的选择，但是当仅在该处理程序中使用参数时效果最好。
如果您有路由组或长处理程序链，在多个地方需要相同的参数，您应该将值设置到 Gin 上下文中。
您可以使用函数文字或返回的命名函数gin.HandlerFunc以干净的方式执行此操作。
将配置注入路由器组的示例：
中间件包：
func Configs(conf APIV1Config) gin.HandlerFunc {
return func(c *gin.Context) {
c.Set("configKey", conf) // key could be an unexported struct to ensure uniqueness
}
}
路由器：
conf := APIV1Config{/* some api configs */}
// makes conf available to all routes in this group
g := r.Group("/api/v1", middleware.Configs(conf))
{
// ... routes that all need API V1 configs
}
这也很容易进行单元测试。假设您测试单个处理程序，您可以将必要的值设置到模拟上下文中：
w := httptest.NewRecorder()
c, _ := gin.CreateTestContext(w)
c.Set("configKey", /* mock configs */)
apiV1FooHandler(c)
现在，对于应用程序范围的依赖项（数据库连接、远程客户端等），我同意将这些直接设置到 Gin 上下文中是一个糟糕的解决方案。
然后你应该做的是，使用上面概述的模式将提供者注入到 Gin 上下文中：
中间件包：
// provider could be an interface for easy mocking
func DBProvider(provider database.Provider) gin.HandlerFunc {
return func(c *gin.Context) {
c.Set("providerKey", provider)
}
}
路由器：
dbProvider := /* init provider with db connection */
r.Use(DBProvider(dbProvider)) // global middleware
// or
g := r.Group("/users", DBProvider(dbProvider)) // users group only
处理程序（您可以通过将这些上下文获取器放在一些辅助函数中来大大减少样板代码）：
// helper function
func GetDB(c *gin.Context) *sql.DB {
provider := c.MustGet("providerKey").(database.Provider)
return provider.GetConn()
}
func createUserHandler(c *gin.Context) {
db := GetDB(c) // same in all other handlers
// ...
}
好吧，我给你举了一个简单的例子。它应该工作。您可以根据需要扩展它
func main() {
router := gin.Default()
router.GET("/test/:id/:name", testRouteHandler)
router.Run(":8080")
}
func testRouteHandler(c *gin.Context) {
id := c.Params.ByName("id")
name := c.Params.ByName("name")
}
现在你必须调用你的处理程序如下 http://localhost:8080/test/1/myname
让我尝试详细解释，以免您感到困惑。
/books并且您的控制器是BooksControllerBooksController将尝试从数据库中获取书籍并返回响应。现在，您希望在您的内部有一个处理程序，BooksController以便您可以访问数据库。
我会做这样的事情。假设您使用的是 dynamoDB 并且 aws sdk 提供了*dynamodb.DynamoDB. 根据您的数据库，更改此变量。
type serviceConnection struct {
db *dynamoDB.DynamoDB
// You can have all services declared here
// which you want to use it in your controller
}
initDatabaseConnection可以将处理程序返回给 db，如下所示。db := initDatabaseConnection()-> 返回*dynamodb.DynamoDB
db为结构变量。conn := new(serviceConnection)
conn.db = db
r := gin.Default()
r.GET("/books", conn.BooksController)
如您所见， gin 处理程序是一个控制器方法，它将您的结构实例作为接收器。
serviceConnection现在，使用结构接收器创建一个控制器方法。func (conn *serviceConnection) BooksController(c *gin.Context) {
books := getBooks(conn.db)
}
正如您在此处看到的，您可以访问所有serviceConnection结构变量，并且可以在控制器中使用它们。