请求输入依靠 ghttp.Request 对象实现,ghttp.Request继承了底层的http.Request对象。ghttp.Request包含一个与当前请求对应的返回输出对象Response,用于数据的返回处理。

相关方法: https://pkg.go.dev/github.com/gogf/gf/v2/net/ghttp#Request

简要说明

可以看到Request对象的参数获取方法非常丰富,常用方法如下:

常用方法描述
Get

常用方法,简化参数获取,GetRequest的别名。

GetQuery获取GET方式传递过来的参数,包括Query StringBody参数解析。
GetForm获取表单方式传递过来的参数,表单方式提交的参数Content-Type往往为application/x-www-form-urlencodedapplication/form-datamultipart/form-datamultipart/mixed等等。
GetRequest获取客户端提交的所有参数,按照参数优先级进行覆盖,不区分提交方式。
GetStruct将指定提交类型的所有请求参数绑定到指定的struct对象上,注意给定的参数为对象指针。绝大部分场景中往往使用Parse方法将请求数据转换为请求对象,具体详见后续章节。
GetBody/GetBodyString获取客户端提交的原始数据,该数据是客户端写入到body中的原始数据,与HTTP Method无关,例如客户端提交JSON/XML数据格式时可以通过该方法获取原始的提交数据。
GetJson自动将原始请求信息解析为gjson.Json对象指针返回,gjson.Json对象具体在 通用编解码-gjson 章节中介绍。
Exit用于请求流程退出控制,详见本章后续说明。

提交方式

GoFrame框架的参数获取不是通过HTTP Method来做区分,而是通过参数提交类型来区分。例如,分别通过HTTP Method: POST、INPUT、DELETE来提交表单参数,在服务端获取参数不是通过GetPost/GetInput/GetDelete的方式来获取,而是统一通过GetForm方法来获取表单参数,针对其他的HTTP Method也是如此。

GoFrame框架下,有以下几种提交类型:

提交类型描述
Router路由参数。来源于路由规则匹配。
Query

Query参数。URL中的Query String参数解析,如:http://127.0.0.1/index?id=1&name=john 中的id=1&name=john

Form

表单参数。最常见的提交方式,提交的Content-Type往往为:application/x-www-form-urlencodedmultipart/form-datamultipart/mixed

Body

内容参数。从Body中获取并解析得到的参数,JSON/XML请求往往使用这种方式提交。

Custom

自定义参数,往往在服务端的中间件、服务函数中通过SetParam/GetParam方法管理。

参数类型

获取的参数方法可以对指定键名的数据进行自动类型转换,例如:[http://127.0.0.1:8199/?amount=19.66](http://127.0.0.1:8199/?amount=19.66),通过Get(xxx).String()将会返回19.66的字符串类型,Get(xxx).Float32()/Get(xxx).Float64()将会分别返回float32float64类型的数值19.66。但是,Get(xxx).Int()/Get(xxx).Uint()将会返回19(如果参数为float类型的字符串,将会按照向下取整进行整型转换)。

聪明的您一定发现了,获取到的参数都是泛型变量,根据该泛型变量再根据需要调用对应的方法转换为对应的数据类型。

使用示例:

  1. package main
  2. import (
  3. "github.com/gogf/gf/v2/frame/g"
  4. "github.com/gogf/gf/v2/net/ghttp"
  5. )
  6. func main() {
  7. s := g.Server()
  8. s.BindHandler("/", func(r *ghttp.Request) {
  9. r.Response.Writeln(r.Get("amount").String())
  10. r.Response.Writeln(r.Get("amount").Int())
  11. r.Response.Writeln(r.Get("amount").Float32())
  12. })
  13. s.SetPort(8199)
  14. s.Run()
  15. }

执行后我们访问地址 http://127.0.0.1:8199/?amount=19.66 页面输出

  1. 19.66
  2. 19
  3. 19.66

参数优先级

我们考虑一种场景,当不同的提交方式中存在同名的参数名称会怎么样?在GoFrame框架下,我们根据不同的获取方法,将会按照不同的优先级进行获取,优先级高的方式提交的参数将会优先覆盖其他方式的同名参数。优先级规则如下:

  1. GetGetRequset方法:Router < Query < Body < Form < Custom,也就是说自定义参数的优先级最高,其次是Form表单参数,再次是Body提交参数,以此类推。例如,QueryForm中都提交了同样名称的参数id,参数值分别为12,那么Get("id")/GetForm("id")将会返回2,而GetQuery("id")将会返回1
  2. GetQuery方法:Query > Body,也就是说query string的参数将会覆盖Body中提交的同名参数。例如,QueryBody中都提交了同样名称的参数id,参数值分别为12,那么Get("id")将会返回2,而GetQuery("id")将会返回1
  3. GetForm方法:由于该类型的方法仅用于获取Form表单参数,因此没什么优先级的差别。

使用示例:

  1. package main
  2. import (
  3. "github.com/gogf/gf/v2/frame/g"
  4. "github.com/gogf/gf/v2/net/ghttp"
  5. )
  6. func main() {
  7. s := g.Server()
  8. s.BindHandler("/input", func(r *ghttp.Request) {
  9. r.Response.Writeln(r.Get("amount"))
  10. })
  11. s.BindHandler("/query", func(r *ghttp.Request) {
  12. r.Response.Writeln(r.GetQuery("amount"))
  13. })
  14. s.SetPort(8199)
  15. s.Run()
  16. }

执行后,我们通过curl工具进行测试:

  1. $ curl -d "amount=1" -X POST "http://127.0.0.1:8199/input?amount=100"
  2. 1
  3. $ curl -d "amount=1" -X POST "http://127.0.0.1:8199/query?amount=100"
  4. 100

可以看到,当我们访问/input路由时,该路由方法中采用了Get方法获取amount参数,按照同名优先级的规则返回了1,即body中传递的参数。而当我们通过/query路由访问时,该路由方法内部使用了GetQuery方法获取amount参数,因此获取到的是query string参数中的amount值,返回了100

大小写敏感

需要注意哦,参数名称是大小写敏感的哦,例如客户端提交的参数nameName是两个参数。 由于服务端默认是通过字符串名称获取参数,因此大小写敏感并不会产生什么问题,但是如果服务端接收的是一个API对象,那么可能需要注意一下。我们来看一个例子。

服务端:

  1. package main
  2. import (
  3. "context"
  4. "github.com/gogf/gf/v2/frame/g"
  5. "github.com/gogf/gf/v2/net/ghttp"
  6. )
  7. type Controller struct{}
  8. type PathReq struct {
  9. g.Meta `path:"/api/v1/*path" method:"post"`
  10. Path string
  11. }
  12. type PathRes struct {
  13. Path string
  14. }
  15. func (c *Controller) Path(ctx context.Context, req *PathReq) (res *PathRes, err error) {
  16. return &PathRes{Path: req.Path}, nil
  17. }
  18. func main() {
  19. s := g.Server()
  20. s.SetPort(8199)
  21. s.Use(ghttp.MiddlewareHandlerResponse)
  22. s.Group("/", func(group *ghttp.RouterGroup) {
  23. group.Bind(&Controller{})
  24. })
  25. s.Run()
  26. }

服务端的接口设计原意是定义一个路由参数path,并且通过API对象的Path属性来接收。

客户端:

  1. package main
  2. import (
  3. "fmt"
  4. "github.com/gogf/gf/v2/frame/g"
  5. "github.com/gogf/gf/v2/os/gctx"
  6. )
  7. func main() {
  8. var (
  9. ctx = gctx.New()
  10. client = g.Client()
  11. )
  12. client.SetPrefix("http://127.0.0.1:8199")
  13. for i := 0; i < 10; i++ {
  14. fmt.Println(client.PostContent(ctx, "/api/v1/user/info", `{"Path":"user/profile"}`))
  15. }
  16. }

根据我们的理解,客户端提交后,服务端应该会收到路由参数path的值为user/info。但是很奇怪,由于程序BUG,客户端提交的Body中同样提交了一个JSON,参数名称为Path,参数值为user/profile。那么这个时候服务端API对象中的属性Path将会是哪个值呢?

我们将客户端反复执行多次,发现输出的结果都是:

  1. {"code":0,"message":"","data":{"Path":"user/profile"}}
  2. {"code":0,"message":"","data":{"Path":"user/profile"}}
  3. {"code":0,"message":"","data":{"Path":"user/profile"}}
  4. {"code":0,"message":"","data":{"Path":"user/profile"}}
  5. {"code":0,"message":"","data":{"Path":"user/profile"}}
  6. {"code":0,"message":"","data":{"Path":"user/profile"}}
  7. {"code":0,"message":"","data":{"Path":"user/profile"}}
  8. {"code":0,"message":"","data":{"Path":"user/profile"}}
  9. {"code":0,"message":"","data":{"Path":"user/profile"}}
  10. {"code":0,"message":"","data":{"Path":"user/profile"}}

即参数都是Body中提交的值,而不是路由参数中的值。其实,由于参数大小写敏感的缘故,服务端这个时候接受到了两个参数,一个是路由参数path,一个是Body JSON提交的Path。服务端在转换API参数对象的时候,由于属性PathBody JSON中提交的Path更匹配,因此,使用的是Body JSON中的Path的值。

继续了解