客户端请求

httplib 库主要用来模拟客户端发送 HTTP 请求，类似于 Curl 工具，支持 JQuery 类似的链式操作。使用起来相当的方便；通过如下方式进行安装：

  1. go get github.com/beego/beego/v2/client/httplib

在beego-example下的httplib包中有对应的例子。

如何使用

首先导入包

  1. import (
  2.     "github.com/beego/beego/v2/client/httplib"
  3. )

然后初始化请求方法，返回对象

  1. req := httplib.Get("http://beego.me/")

然后我们就可以获取数据了

  1. str, err := req.String()
  2. if err != nil {
  3.     t.Fatal(err)
  4. }
  5. fmt.Println(str)

支持的方法对象

httplib 包里面支持如下的方法返回 request 对象：

  • Get(url string)
  • Post(url string)
  • Put(url string)
  • Delete(url string)
  • Head(url string)

支持 debug 输出

可以根据上面五个方法返回的对象进行调试信息的输出：

  1. req.Debug(true)

这样就可以看到请求数据的详细输出

  1. httplib.Get("http://beego.me/").Debug(true).Response()
  3. //输出数据如下
  4. GET / HTTP/0.0
  5. Host: beego.me
  6. User-Agent: beegoServer

支持 HTTPS 请求

如果请求的网站是 HTTPS 的，那么我们就需要设置 client 的 TLS 信息，如下所示：

  1. req.SetTLSClientConfig(&tls.Config{InsecureSkipVerify: true})

关于如何设置这些信息请访问： http://gowalker.org/crypto/tls#Config

支持超时设置

通过如下接口可以设置请求的超时时间和数据读取时间：

  1. req.SetTimeout(connectTimeout, readWriteTimeout)

以上方法都是针对 request 对象的，所以你第一步必须是返回 request 对象，然后链式操作，类似这样的代码：

  1. httplib.Get("http://beego.me/").SetTimeout(100 * time.Second, 30 * time.Second).Response()

设置请求参数

对于 Put 或者 Post 请求，需要发送参数，那么可以通过 Param 发送 k/v 数据，如下所示：

  1. req := httplib.Post("http://beego.me/")
  2. req.Param("username","astaxie")
  3. req.Param("password","123456")

发送大片的数据

有时候需要上传文件之类的模拟，那么如何发送这个文件数据呢？可以通过 Body 函数来操作，举例如下：

  1. req := httplib.Post("http://beego.me/")
  2. bt,err:=ioutil.ReadFile("hello.txt")
  3. if err!=nil{
  4.     log.Fatal("read file err:",err)
  5. }
  6. req.Body(bt)

设置 header 信息

除了请求参数之外，我们有些时候需要模拟一些头信息，例如

  1. Accept-Encoding:gzip,deflate,sdch
  2. Host:beego.me
  3. User-Agent:Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.57 Safari/537.36

可以通过 Header 函数来设置，如下所示：

  1. req := httplib.Post("http://beego.me/")
  2. req.Header("Accept-Encoding","gzip,deflate,sdch")
  3. req.Header("Host","beego.me")
  4. req.Header("User-Agent","Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/31.0.1650.57 Safari/537.36")

设置 transport

http请求的传输由http.RoundTrip承载，因此我们可以实现接口以实现链接的控制。通过设置，我们可以实现长连接，如下所示:

  1. var tp http.RoundTripper = &http.Transport{
  2.     DialContext: (&net.Dialer{
  3.         Timeout:   30 * time.Second,
  4.         KeepAlive: 30 * time.Second,
  5.         DualStack: true,
  6.     }).DialContext,
  7.     MaxIdleConns:          100,
  8.     IdleConnTimeout:       90 * time.Second,
  9.     ExpectContinueTimeout: 1 * time.Second,
  10. }
  12. req := httplib.Post("http://beego.me/")
  13. req.SetTransport(tp)

httplib支持文件直接上传接口

PostFile 第一个参数是 form 表单的字段名,第二个是需要发送的文件名或者文件路径

  1. b:=httplib.Post("http://beego.me/")
  2. b.Param("username","astaxie")
  3. b.Param("password","123456")
  4. b.PostFile("uploadfile1", "httplib.pdf")
  5. b.PostFile("uploadfile2", "httplib.txt")
  6. str, err := b.String()
  7. if err != nil {
  8.     t.Fatal(err)
  9. }

获取返回结果

上面这些都是在发送请求之前的设置，接下来我们开始发送请求，然后如何来获取数据呢？主要有如下几种方式：

  • 返回 Response 对象，req.Response() 方法

    这个是 http.Response 对象，用户可以自己读取 body 的数据等。

  • 返回 bytes,req.Bytes() 方法

    直接返回请求 URL 返回的内容

  • 返回 string，req.String() 方法

    直接返回请求 URL 返回的内容

  • 保存为文件，req.ToFile(filename) 方法

    返回结果保存到文件名为 filename 的文件中

  • 解析为 JSON 结构，req.ToJSON(&result) 方法

    返回结构直接解析为 JSON 格式，解析到 result 对象中

  • 解析为 XML 结构，req.ToXml(&result) 方法

    返回结构直接解析为 XML 格式，解析到 result 对象中

Filter

httplib上设计了单独的filter机制，以允许用户可以扩展一些AOP的功能，例如日志，追踪。

我们有两个关键定义：

  1. type FilterChain func(next Filter) Filter
  3. type Filter func(ctx context.Context, req *BeegoHTTPRequest) (*http.Response, error)

Filter是指，我们希望把Filter组织成一个链式。这是典型的Filter-Chain设计模式的应用。

所以，在设计自己的Filter的时候，我们需要显式的调用next(...)。

这是一个简单的例子：

  1. func myFilter(next httplib.Filter) httplib.Filter {
  2.     return func(ctx context.Context, req *httplib.BeegoHTTPRequest) (*http.Response, error) {
  3.         r := req.GetRequest()
  4.         logs.Info("hello, here is the filter: ", r.URL)
  5.         // Never forget invoke this. Or the request will not be sent
  6.         return next(ctx, req)
  7.     }
  8. }

那么我们怎么添加到请求里面呢？有两种方法，一种是全局设置：

  1.     httplib.SetDefaultSetting(httplib.BeegoHTTPSettings{
  3.         FilterChains: []httplib.FilterChain{
  4.             myFilter,
  5.         },
  7.         UserAgent:        "beegoServer",
  8.         ConnectTimeout:   60 * time.Second,
  9.         ReadWriteTimeout: 60 * time.Second,
  10.         Gzip:             true,
  11.         DumpBody:         true,
  12.     })

另外一种是针对特定请求设置：

  1. req.AddFilters(myFilter)

针对单一请求的设置将不会影响别的请求。下面我们看提供的两个Filter。

Prometheus Filter

这是用于支持Prometheus框架的。

使用非常简单：

  1.     builder := prometheus.FilterChainBuilder{
  2.         AppName: "My-test",
  3.         ServerName: "User-server-1",
  4.         RunMode: "dev",
  5.     }
  6.     req := httplib.Get("http://beego.me/")
  7.     // only work for this request, or using SetDefaultSetting to support all requests
  8.     req.AddFilters(builder.FilterChain)
  10.     resp, err := req.Response()
  11.     if err != nil {
  12.         logs.Error("could not get response: ", err)
  13.     } else {
  14.         logs.Info(resp)
  15.     }

注意的是，如果没有开启我们的admin服务，那么你需要额外暴露prometheus的端口。

可以参考admin下如何暴露prometheus端口，或者参阅promethues的文档。

Opentracing Filter

  1.     builder := opentracing.FilterChainBuilder{}
  2.     req := httplib.Get("http://beego.me/")
  3.     // only work for this request, or using SetDefaultSetting to support all requests
  4.     req.AddFilters(builder.FilterChain)
  6.     resp, err := req.Response()
  7.     if err != nil {
  8.         logs.Error("could not get response: ", err)
  9.     } else {
  10.         logs.Info(resp)
  11.     }

使用这个Filter，也别忘记设置Opentracing的真正实现。一般来说，推荐使用zipkin。市面上大部分框架都会适配Opentracing的API，但是不一定有golang的客户端。