douwen8424
douwen8424
2018-05-29 00:29
浏览 36
已采纳

Gin-Gonic中间件声明

I'm using Gin-Gonic and I'm creating a custom middleware. See: https://github.com/gin-gonic/gin#custom-middleware

Is there a reason why the middlewares in the doc are written as such:

func MyMiddleware() gin.HandlerFunc {
    return func (c *gin.Context) {
        // middleware
    }
}
r := gin.New()
r.Use(MyMiddleware())

When I could simply write it like this:

func MyMiddleware(c *gin.Context) {
    // middleware
}
r := gin.New()
r.Use(MyMiddleware)

Thanks for your help!

  • 点赞
  • 写回答
  • 关注问题
  • 收藏
  • 邀请回答

2条回答 默认 最新

  • dtvgo28624
    dtvgo28624 2018-05-29 02:31
    已采纳

    You can certainly just do this if you prefer it:

    func MyMiddleware(c *gin.Context) {
        // middleware
    }
    r := gin.New()
    r.Use(MyMiddleware)
    

    The most probably reason why it is suggested that you do this instead:

    func MyMiddleware() gin.HandlerFunc {
        return func (c *gin.Context) {
            // middleware
        }
    }
    r := gin.New()
    r.Use(MyMiddleware())
    

    is, so you can add parameters, the example used in here: https://github.com/gin-gonic/gin#custom-middleware is a logging middleware.:

    func Logger() gin.HandlerFunc {
        return func(c *gin.Context) {
            // code goes here
        }
    }
    

    It didn't have any params, but you can use custom logger like logrus inside your middleware by adding a param:

    You can have a logging middleware like this:

    func Logger(log *logrus.Logger) gin.HandlerFunc {
        return func(c *gin.Context) {
            // use logrus
            log.WithFields(log.Fields{
              "animal": "walrus",
            }).Info("A walrus appears")
    
        }
    }
    

    And use it like this:

    var log = logrus.New()
    r.Use(Logger(log))
    
    点赞 评论
  • dongyuan1983
    dongyuan1983 2018-05-29 02:34

    Yes, you can.

    Sometimes a middleware takes arguments. For example:

    MyMiddleware(foo string) gin.HandlerFunc {
    
        // preprocess with argument foo
    
        return func(c *gin.Context) {
            // do something related with foo...
        }
    }
    

    Take gin.BasicAuthForRealm for example. Before checking the authorization from HTTP requests, you must provide it the auth data.

    func BasicAuthForRealm(accounts Accounts, realm string) HandlerFunc {
        // ...
    }
    

    For middlewares taking no argument, I think they just want to keep them in same format.

    点赞 评论

相关推荐