参数获取

源码路径：github.com/gin-gonic/gin/context.go

URL

  1. func (c *Context) Param(key string) string

eg:

  1.     router.GET("/user/:id", func(c *gin.Context) {
  2. //         // a GET request to /user/john
  3.          id := c.Param("id") // id == "john"
  4.      })

query

  1. // It is shortcut for `c.Request.URL.Query().Get(key)`
  2. //     GET /path?id=1234&name=Manu&value=
  3. //        c.Query("id") == "1234"
  4. //        c.Query("name") == "Manu"
  5. //        c.Query("value") == ""
  6. //        c.Query("wtf") == ""
  7. func (c *Context) Query(key string) string {
  8.     value, _ := c.GetQuery(key)
  9.     return value
  10. }

其他方式query

  1. func (c *Context) QueryArray(key string) []string {
  2.     values, _ := c.GetQueryArray(key)
  3.     return values
  4. }
  6. func (c *Context) getQueryCache() {
  7.     if c.queryCache == nil {
  8.         c.queryCache = c.Request.URL.Query()
  9.     }
  10. }
  12. // GetQueryArray returns a slice of strings for a given query key, plus
  13. // a boolean value whether at least one value exists for the given key.
  14. func (c *Context) GetQueryArray(key string) ([]string, bool) {
  15.     c.getQueryCache()
  16.     if values, ok := c.queryCache[key]; ok && len(values) > 0 {
  17.         return values, true
  18.     }
  19.     return []string{}, false
  20. }
  22. // QueryMap returns a map for a given query key.
  23. func (c *Context) QueryMap(key string) map[string]string {
  24.     dicts, _ := c.GetQueryMap(key)
  25.     return dicts
  26. }
  28. // GetQueryMap returns a map for a given query key, plus a boolean value
  29. // whether at least one value exists for the given key.
  30. func (c *Context) GetQueryMap(key string) (map[string]string, bool) {
  31.     c.getQueryCache()
  32.     return c.get(c.queryCache, key)
  33. }

PostForm

  1. // PostForm returns the specified key from a POST urlencoded form or multipart form
  2. // when it exists, otherwise it returns an empty string `("")`.
  3. func (c *Context) PostForm(key string) string {
  4.     value, _ := c.GetPostForm(key)
  5.     return value
  6. }
  8. // DefaultPostForm returns the specified key from a POST urlencoded form or multipart form
  9. // when it exists, otherwise it returns the specified defaultValue string.
  10. // See: PostForm() and GetPostForm() for further information.
  11. func (c *Context) DefaultPostForm(key, defaultValue string) string {
  12.     if value, ok := c.GetPostForm(key); ok {
  13.         return value
  14.     }
  15.     return defaultValue
  16. }
  18. // GetPostForm is like PostForm(key). It returns the specified key from a POST urlencoded
  19. // form or multipart form when it exists `(value, true)` (even when the value is an empty string),
  20. // otherwise it returns ("", false).
  21. // For example, during a PATCH request to update the user's email:
  22. //     email=mail@example.com  -->  ("mail@example.com", true) := GetPostForm("email") // set email to "mail@example.com"
  23. //        email=                  -->  ("", true) := GetPostForm("email") // set email to ""
  24. //                             -->  ("", false) := GetPostForm("email") // do nothing with email
  25. func (c *Context) GetPostForm(key string) (string, bool) {
  26.     if values, ok := c.GetPostFormArray(key); ok {
  27.         return values[0], ok
  28.     }
  29.     return "", false
  30. }
  32. // PostFormArray returns a slice of strings for a given form key.
  33. // The length of the slice depends on the number of params with the given key.
  34. func (c *Context) PostFormArray(key string) []string {
  35.     values, _ := c.GetPostFormArray(key)
  36.     return values
  37. }
  39. func (c *Context) getFormCache() {
  40.     if c.formCache == nil {
  41.         c.formCache = make(url.Values)
  42.         req := c.Request
  43.         if err := req.ParseMultipartForm(c.engine.MaxMultipartMemory); err != nil {
  44.             if err != http.ErrNotMultipart {
  45.                 debugPrint("error on parse multipart form array: %v", err)
  46.             }
  47.         }
  48.         c.formCache = req.PostForm
  49.     }
  50. }
  52. // GetPostFormArray returns a slice of strings for a given form key, plus
  53. // a boolean value whether at least one value exists for the given key.
  54. func (c *Context) GetPostFormArray(key string) ([]string, bool) {
  55.     c.getFormCache()
  56.     if values := c.formCache[key]; len(values) > 0 {
  57.         return values, true
  58.     }
  59.     return []string{}, false
  60. }
  62. // PostFormMap returns a map for a given form key.
  63. func (c *Context) PostFormMap(key string) map[string]string {
  64.     dicts, _ := c.GetPostFormMap(key)
  65.     return dicts
  66. }
  68. // GetPostFormMap returns a map for a given form key, plus a boolean value
  69. // whether at least one value exists for the given key.
  70. func (c *Context) GetPostFormMap(key string) (map[string]string, bool) {
  71.     c.getFormCache()
  72.     return c.get(c.formCache, key)
  73. }
  75. // get is an internal method and returns a map which satisfy conditions.
  76. func (c *Context) get(m map[string][]string, key string) (map[string]string, bool) {
  77.     dicts := make(map[string]string)
  78.     exist := false
  79.     for k, v := range m {
  80.         if i := strings.IndexByte(k, '['); i >= 1 && k[0:i] == key {
  81.             if j := strings.IndexByte(k[i+1:], ']'); j >= 1 {
  82.                 exist = true
  83.                 dicts[k[i+1:][:j]] = v[0]
  84.             }
  85.         }
  86.     }
  87.     return dicts, exist
  88. }

上传

  1. // FormFile returns the first file for the provided form key.
  2. func (c *Context) FormFile(name string) (*multipart.FileHeader, error) {
  3.     if c.Request.MultipartForm == nil {
  4.         if err := c.Request.ParseMultipartForm(c.engine.MaxMultipartMemory); err != nil {
  5.             return nil, err
  6.         }
  7.     }
  8.     f, fh, err := c.Request.FormFile(name)
  9.     if err != nil {
  10.         return nil, err
  11.     }
  12.     f.Close()
  13.     return fh, err
  14. }
  16. // MultipartForm is the parsed multipart form, including file uploads.
  17. func (c *Context) MultipartForm() (*multipart.Form, error) {
  18.     err := c.Request.ParseMultipartForm(c.engine.MaxMultipartMemory)
  19.     return c.Request.MultipartForm, err
  20. }
  22. // SaveUploadedFile uploads the form file to specific dst.
  23. func (c *Context) SaveUploadedFile(file *multipart.FileHeader, dst string) error {
  24.     src, err := file.Open()
  25.     if err != nil {
  26.         return err
  27.     }
  28.     defer src.Close()
  30.     out, err := os.Create(dst)
  31.     if err != nil {
  32.         return err
  33.     }
  34.     defer out.Close()
  36.     _, err = io.Copy(out, src)
  37.     return err
  38. }

参数校验/binding

源码地址github.com/gin-gonic/gin/binding/binding.go
提供的默认的类型

  1. var (
  2.     JSON          = jsonBinding{}
  3.     XML           = xmlBinding{}
  4.     Form          = formBinding{}
  5.     Query         = queryBinding{}
  6.     FormPost      = formPostBinding{}
  7.     FormMultipart = formMultipartBinding{}
  8.     ProtoBuf      = protobufBinding{}
  9.     MsgPack       = msgpackBinding{}
  10.     YAML          = yamlBinding{}
  11.     Uri           = uriBinding{}
  12.     Header        = headerBinding{}
  13. )

定义需要实现的接口

  1. type Binding interface {
  2.     Name() string
  3.     Bind(*http.Request, interface{}) error
  4. }
  6. // BindingBody adds BindBody method to Binding. BindBody is similar with Bind,
  7. // but it reads the body from supplied bytes instead of req.Body.
  8. type BindingBody interface {
  9.     Binding
  10.     BindBody([]byte, interface{}) error
  11. }

例如json的实现类

  1. type jsonBinding struct{}
  3. func (jsonBinding) Name() string {
  4.     return "json"
  5. }
  7. func (jsonBinding) Bind(req *http.Request, obj interface{}) error {
  8.     if req == nil || req.Body == nil {
  9.         return fmt.Errorf("invalid request")
  10.     }
  11.     return decodeJSON(req.Body, obj)
  12. }
  14. func (jsonBinding) BindBody(body []byte, obj interface{}) error {
  15.     return decodeJSON(bytes.NewReader(body), obj)
  16. }
  18. func decodeJSON(r io.Reader, obj interface{}) error {
  19.     decoder := json.NewDecoder(r)
  20.     if EnableDecoderUseNumber {
  21.         decoder.UseNumber()
  22.     }
  23.     if EnableDecoderDisallowUnknownFields {
  24.         decoder.DisallowUnknownFields()
  25.     }
  26.     if err := decoder.Decode(obj); err != nil {
  27.         return err
  28.     }
  29.     return validate(obj)
  30. }

校验

  1. / Bind checks the Content-Type to select a binding engine automatically,
  2. // Depending the "Content-Type" header different bindings are used:
  3. //     "application/json" --> JSON binding
  4. //     "application/xml"  --> XML binding
  5. // otherwise --> returns an error.
  6. // It parses the request's body as JSON if Content-Type == "application/json" using JSON or XML as a JSON input.
  7. // It decodes the json payload into the struct specified as a pointer.
  8. // It writes a 400 error and sets Content-Type header "text/plain" in the response if input is not valid.
  9. func (c *Context) Bind(obj interface{}) error {
  10.     b := binding.Default(c.Request.Method, c.ContentType())
  11.     return c.MustBindWith(obj, b)
  12. }
  14. // BindJSON is a shortcut for c.MustBindWith(obj, binding.JSON).
  15. func (c *Context) BindJSON(obj interface{}) error {
  16.     return c.MustBindWith(obj, binding.JSON)
  17. }
  19. // MustBindWith binds the passed struct pointer using the specified binding engine.
  20. // It will abort the request with HTTP 400 if any error occurs.
  21. // See the binding package.
  22. func (c *Context) MustBindWith(obj interface{}, b binding.Binding) error {
  23.     if err := c.ShouldBindWith(obj, b); err != nil {
  24.         c.AbortWithError(http.StatusBadRequest, err).SetType(ErrorTypeBind) // nolint: errcheck
  25.         return err
  26.     }
  27.     return nil
  28. }
  29. // ShouldBindWith binds the passed struct pointer using the specified binding engine.
  30. // See the binding package.
  31. func (c *Context) ShouldBindWith(obj interface{}, b binding.Binding) error {
  32.     return b.Bind(c.Request, obj)
  33. }