更优雅的gin验证身体的方法

Question

是否有更优雅的方法使用json body和route id来验证go-gin

package controllers

import (
    "giin/inputs"
    "net/http"

    "github.com/gin-gonic/gin"
    "github.com/google/uuid"
)

func GetAccount(context *gin.Context) {

    // validate if `accountId` is valid `uuid``
    _, err := uuid.Parse(context.Param("accountId"))
    if err != nil {
        context.JSON(http.StatusBadRequest, gin.H{"message": err.Error()})
        return
    }

    // some logic here...

    context.JSON(http.StatusOK, gin.H{"message": "account received"})
}

func AddAccount(context *gin.Context) {

    // validate if `body` is valid `inputs.Account`
    var input inputs.Account
    if error := context.ShouldBindJSON(&input); error != nil {
        context.JSON(http.StatusBadRequest, error.Error())
        return
    }

    // some logic here...

    context.JSON(http.StatusOK, gin.H{"message": "account added"})
}

我创建了中间件，它能够检测accountId是否被通过，如果是的话，验证它，如果accountId不是uuid格式，返回坏请求，但是我不能对主体做同样的事情，因为AccountBodyMiddleware试图验证每个请求，有人能帮我吗？

而且，如果我能够验证任何类型的主体，而不是为每个json body创建新的中间件，那就太好了。

package main

import (
    "giin/controllers"
    "giin/inputs"
    "net/http"

    "github.com/gin-gonic/gin"
    "github.com/google/uuid"
)

func AccountIdMiddleware(c *gin.Context) {
    id := c.Param("accountId")
    if id == "" {
        c.Next()
        return
    }
    if _, err := uuid.Parse(id); err != nil {
        c.JSON(http.StatusBadRequest, "uuid not valid")
        c.Abort()
        return
    }
}

func AccountBodyMiddleware(c *gin.Context) {
    var input inputs.Account
    if error := c.ShouldBindJSON(&input); error != nil {
        c.JSON(http.StatusBadRequest, "body is not valid")
        c.Abort()
        return
    }
    c.Next()
}

func main() {
    r := gin.Default()
    r.Use(AccountIdMiddleware)
    r.Use(AccountBodyMiddleware)

    r.GET("/account/:accountId", controllers.GetAccount)
    r.POST("/account", controllers.AddAccount)
    r.Run(":5000")
}

Answer 1

在这里使用中间件肯定不是方法，你的直觉是正确的！使用FastAPI作为灵感，我通常为我拥有的每个请求/响应创建模型。然后，可以将这些模型绑定为查询、路径或主体模型。查询模型绑定的一个示例(只是为了向您展示您可以将它用于不仅仅是json post请求)：

type User struct {
    UserId            string                     `form:"user_id"`
    Name              string                     `form:"name"`
}

func (user *User) Validate() errors.RestError {
    if _, err := uuid.Parse(id); err != nil {
        return errors.BadRequestError("user_id not a valid uuid")
    }
    return nil
}

其中，错误只是一个包，您可以在本地定义，这样就可以通过以下方式直接返回验证错误：

func GetUser(c *gin.Context) {

    // Bind query model
    var q User
    if err := c.ShouldBindQuery(&q); err != nil {
        restError := errors.BadRequestError(err.Error())
        c.JSON(restError.Status, restError)
        return
    }

    // Validate request
    if err := q.Validate(); err != nil {
        c.JSON(err.Status, err)
        return
    }

    // Business logic goes here
}

好处是:通过这种方式，您还可以从高级别构建结构并调用内部验证函数。我认为这就是您试图通过使用中间件(组成验证)来完成的：

type UserId struct {
    Id string
}

func (userid *UserId) Validate() errors.RestError {
    if _, err := uuid.Parse(id); err != nil {
        return errors.BadRequestError("user_id not a valid uuid")
    }
    return nil
}

type User struct {
    UserId
    Name string 
}

func (user *User) Validate() errors.RestError {
    if err := user.UserId.Validate(); err != nil {
        return err
    }

    // Do some other validation
    
    return nil
}

额外奖励:如果您对后端路由设计软件深度指南感兴趣，在这里阅读更多关于后端路由设计和基于模型的验证的内容

作为参考，下面是一个错误结构示例：

type RestError struct {
    Message string `json:"message"`
    Status  int    `json:"status"`
    Error   string `json:"error"`
}

func BadRequestError(message string) *RestError {
    return &RestError{
        Message: message,
        Status:  http.StatusBadRequest,
        Error:   "Invalid Request",
    }
}