数据绑定 #

一、数据绑定概述 #

1.1 什么是数据绑定 #

数据绑定是将请求数据自动解析到Go结构体的过程。

1.2 绑定类型 #

方法	用途	数据来源
BodyParser	解析请求体	Body
QueryParser	解析查询参数	URL Query
ParamsParser	解析路径参数	URL Path
CookieParser	解析Cookie	Cookie
ReqHeaderParser	解析请求头	Header

二、BodyParser #

2.1 JSON绑定 #

type User struct {
    Name  string `json:"name"`
    Email string `json:"email"`
    Age   int    `json:"age"`
}

app.Post("/users", func(c *fiber.Ctx) error {
    var user User
    if err := c.BodyParser(&user); err != nil {
        return c.Status(400).JSON(fiber.Map{
            "error": "Invalid JSON",
        })
    }
    return c.JSON(user)
})

2.2 表单绑定 #

type LoginForm struct {
    Username string `form:"username"`
    Password string `form:"password"`
    Remember bool   `form:"remember"`
}

app.Post("/login", func(c *fiber.Ctx) error {
    var form LoginForm
    if err := c.BodyParser(&form); err != nil {
        return c.Status(400).JSON(fiber.Map{
            "error": "Invalid form data",
        })
    }
    return c.JSON(form)
})

2.3 XML绑定 #

type UserXML struct {
    XMLName xml.Name `xml:"user"`
    Name    string   `xml:"name"`
    Email   string   `xml:"email"`
}

app.Post("/xml", func(c *fiber.Ctx) error {
    var user UserXML
    if err := c.BodyParser(&user); err != nil {
        return c.Status(400).JSON(fiber.Map{
            "error": "Invalid XML",
        })
    }
    return c.JSON(user)
})

2.4 多部分表单绑定 #

type UploadForm struct {
    Name        string `form:"name"`
    Description string `form:"description"`
}

app.Post("/upload", func(c *fiber.Ctx) error {
    var form UploadForm
    if err := c.BodyParser(&form); err != nil {
        return c.Status(400).JSON(fiber.Map{
            "error": "Invalid form data",
        })
    }
    
    // 获取文件
    file, _ := c.FormFile("file")
    
    return c.JSON(fiber.Map{
        "name":        form.Name,
        "description": form.Description,
        "filename":    file.Filename,
    })
})

三、QueryParser #

3.1 基本查询绑定 #

type SearchQuery struct {
    Q      string `query:"q"`
    Page   int    `query:"page"`
    Limit  int    `query:"limit"`
    Sort   string `query:"sort"`
    Order  string `query:"order"`
}

app.Get("/search", func(c *fiber.Ctx) error {
    var query SearchQuery
    if err := c.QueryParser(&query); err != nil {
        return c.Status(400).JSON(fiber.Map{
            "error": "Invalid query parameters",
        })
    }
    return c.JSON(query)
})

3.2 带默认值 #

func parseQuery(c *fiber.Ctx) (*SearchQuery, error) {
    query := &SearchQuery{
        Page:  1,
        Limit: 10,
        Sort:  "id",
        Order: "asc",
    }
    
    if err := c.QueryParser(query); err != nil {
        return nil, err
    }
    
    return query, nil
}

app.Get("/users", func(c *fiber.Ctx) error {
    query, err := parseQuery(c)
    if err != nil {
        return c.Status(400).JSON(fiber.Map{
            "error": err.Error(),
        })
    }
    return c.JSON(query)
})

四、ParamsParser #

4.1 路径参数绑定 #

type UserParams struct {
    ID string `params:"id"`
}

app.Get("/users/:id", func(c *fiber.Ctx) error {
    var params UserParams
    if err := c.ParamsParser(&params); err != nil {
        return c.Status(400).JSON(fiber.Map{
            "error": "Invalid parameters",
        })
    }
    return c.JSON(fiber.Map{"id": params.ID})
})

4.2 多个路径参数 #

type PostParams struct {
    UserID string `params:"userId"`
    PostID string `params:"postId"`
}

app.Get("/users/:userId/posts/:postId", func(c *fiber.Ctx) error {
    var params PostParams
    if err := c.ParamsParser(&params); err != nil {
        return c.Status(400).JSON(fiber.Map{
            "error": "Invalid parameters",
        })
    }
    return c.JSON(params)
})

五、CookieParser #

5.1 Cookie绑定 #

type SessionCookie struct {
    Session string `cookie:"session"`
    Token   string `cookie:"token"`
}

app.Get("/session", func(c *fiber.Ctx) error {
    var cookies SessionCookie
    if err := c.CookieParser(&cookies); err != nil {
        return c.Status(400).JSON(fiber.Map{
            "error": "Invalid cookies",
        })
    }
    return c.JSON(cookies)
})

六、ReqHeaderParser #

6.1 请求头绑定 #

type Headers struct {
    ContentType   string `reqHeader:"Content-Type"`
    Authorization string `reqHeader:"Authorization"`
    UserAgent     string `reqHeader:"User-Agent"`
}

app.Post("/headers", func(c *fiber.Ctx) error {
    var headers Headers
    if err := c.ReqHeaderParser(&headers); err != nil {
        return c.Status(400).JSON(fiber.Map{
            "error": "Invalid headers",
        })
    }
    return c.JSON(headers)
})

七、组合绑定 #

7.1 多来源绑定 #

type PostRequest struct {
    // 路径参数
    UserID string `params:"userId"`
    
    // 查询参数
    Draft bool `query:"draft"`
    
    // 请求体
    Title   string   `json:"title"`
    Content string   `json:"content"`
    Tags    []string `json:"tags"`
}

app.Post("/users/:userId/posts", func(c *fiber.Ctx) error {
    var req PostRequest
    
    // 解析路径参数
    if err := c.ParamsParser(&req); err != nil {
        return err
    }
    
    // 解析查询参数
    if err := c.QueryParser(&req); err != nil {
        return err
    }
    
    // 解析请求体
    if err := c.BodyParser(&req); err != nil {
        return err
    }
    
    return c.JSON(req)
})

7.2 绑定辅助函数 #

func BindRequest(c *fiber.Ctx, req interface{}) error {
    // 解析路径参数
    if err := c.ParamsParser(req); err != nil {
        return err
    }
    
    // 解析查询参数
    if err := c.QueryParser(req); err != nil {
        return err
    }
    
    // 解析请求体
    if c.Method() != fiber.MethodGet {
        if err := c.BodyParser(req); err != nil {
            return err
        }
    }
    
    return nil
}

// 使用
app.Post("/users/:id", func(c *fiber.Ctx) error {
    var req CreateUserRequest
    if err := BindRequest(c, &req); err != nil {
        return c.Status(400).JSON(fiber.Map{
            "error": err.Error(),
        })
    }
    return c.JSON(req)
})

八、标签参考 #

8.1 绑定标签 #

标签	用途	示例
json	JSON字段	`json:"name"`
xml	XML字段	`xml:"name"`
form	表单字段	`form:"name"`
query	查询参数	`query:"page"`
params	路径参数	`params:"id"`
cookie	Cookie	`cookie:"session"`
reqHeader	请求头	`reqHeader:"Authorization"`

8.2 标签选项 #

type User struct {
    Name  string `json:"name"`                      // 字段名
    Email string `json:"email,omitempty"`           // 空值忽略
    Age   int    `json:"age,string"`                // 类型转换
    Pass  string `json:"-"`                         // 忽略字段
}

九、总结 #

9.1 绑定方法汇总 #

方法	用途
BodyParser	请求体绑定
QueryParser	查询参数绑定
ParamsParser	路径参数绑定
CookieParser	Cookie绑定
ReqHeaderParser	请求头绑定

9.2 下一步 #

现在你已经掌握了数据绑定，接下来让我们学习数据验证，了解如何验证请求数据！