go http put请求_【Go】优雅的读取http请求或响应的数据-续

最新推荐文章于 2022-06-14 23:45:09 发布
最新推荐文章于 2022-06-14 23:45:09 发布
阅读量477 收藏
点赞数
文章标签： go http put请求
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39713686/article/details/112098159
版权

338c0895d9db4b83400d9773b6268b69.png

原文链接：https://blog.thinkeridea.com/201902/go/you_ya_de_du_qu_http_qing_qiu_huo_xiang_ying_de_shu_ju_2.html

之前发布 【Go】优雅的读取http请求或响应的数据 文章，网友 “wxe” 咨询：“优化前后的请求耗时变化有多大”，之前只分析了内存分配，这篇文章用单元测试的方式分析优化前后的耗时情况，本文源码。

非常感谢 “wxe” 网友的提问，让我在测试过程中发现一个 json 序列化的问题。

之前我们优化了两个部分，json 与 ioutil.ReadAll， 先对比 ioutil.ReadAll, 这里测试的代码分成两个部分做对比，一部分单纯对比 ioutil.ReadAll 和 io.Copy + sync.Pool，另一部分增加 jsoniter.Unmarshal 来延迟 pool.Put(buffer) 的执行, 源码。

package iouitl_readall

import (
    "bytes"
    "io"
    "io/ioutil"
    "sync"

    jsoniter "github.com/json-iterator/go"
)

var pool = sync.Pool{
    New: func() interface{} {
        return bytes.NewBuffer(make([]byte, 4096))
    },
}

func IoCopyAndJson(r io.Reader) error {
    buffer := pool.Get().(*bytes.Buffer)
    buffer.Reset()
    defer pool.Put(buffer)

    res := Do(r)
    _, err := io.Copy(buffer, res)
    if err != nil {
        return err
    }

    m := map[string]string{}
    err = jsoniter.Unmarshal(buffer.Bytes(), &m)
    return err
}

func IouitlReadAllAndJson(r io.Reader) error {
    res := Do(r)
    data, err := ioutil.ReadAll(res)
    if err != nil {
        return err
    }

    m := map[string]string{}
    err = jsoniter.Unmarshal(data, &m)
    return err
}

func IoCopy(r io.Reader) error {
    buffer := pool.Get().(*bytes.Buffer)
    buffer.Reset()
    defer pool.Put(buffer)

    res := Do(r)
    _, err := io.Copy(buffer, res)
    if err != nil {
        return err
    }

    return err
}

func IouitlReadAll(r io.Reader) error {
    res := Do(r)
    data, err := ioutil.ReadAll(res)
    if err != nil {
        return err
    }
    _ = data
    return err
}

测试代码如下源码:

package iouitl_readall

import (
    "bytes"
    "testing"
)

var data = bytes.Repeat([]byte("ABCD"), 1000)

func BenchmarkIouitlReadAll(b *testing.B) {
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            err := IouitlReadAll(bytes.NewReader(data))
            if err != nil {
                b.Error(err.Error())
            }
        }
    })
}

func BenchmarkIoCopy(b *testing.B) {
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            err := IoCopy(bytes.NewReader(data))
            if err != nil {
                b.Error(err.Error())
            }
        }
    })
}

func BenchmarkIouitlReadAllAndJson(b *testing.B) {
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            err := IouitlReadAllAndJson(bytes.NewReader(data))
            if err != nil {
                b.Error(err.Error())
            }
        }
    })
}

func BenchmarkIoCopyAndJson(b *testing.B) {
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            err := IoCopyAndJson(bytes.NewReader(data))
            if err != nil {
                b.Error(err.Error())
            }
        }
    })
}

测试结果如下: 

goos: darwin
goarch: amd64
pkg: github.com/thinkeridea/example/iouitl_readall
BenchmarkIouitlReadAll-8              500000          2752 ns/op       14496 B/op          6 allocs/op
BenchmarkIoCopy-8                   20000000            65.2 ns/op        48 B/op          1 allocs/op
BenchmarkIouitlReadAllAndJson-8       100000         20022 ns/op       46542 B/op        616 allocs/op
BenchmarkIoCopyAndJson-8              100000         17615 ns/op       32102 B/op        611 allocs/op

结论：

可以发现 IoCopy 方法是 IouitlReadAll 方法效率的 40 倍，内存分配也很少，而 IoCopyAndJson 和 IouitlReadAllAndJson 的效率差异极小仅有 2407ns，大约是 1.13倍，不过内存分配还是少了很多的，为什么会这样呢，这就是 sync.Pool 的导致的，sync.Pool 每次获取使用时间越短，命中率就越高，就可以减少创建新的缓存，这样效率就会大大提高，而 jsoniter.Unmarshal 很耗时，就导致 sync.Pool 的命中率降低了，所以性能下降极其明显.

使用 io.Copy + sync.Pool 表面上执行效率不会有很大提升，但是会大幅度减少内存分配，从而可以减少 GC 的负担，在单元测试中我们并没有考虑 GC 的问题，而 GC 能带来的性能提升会更有优势。

在看一下 json 使用 sync.Pool 的效果吧 源码

package iouitl_readall

import (
    "bytes"
    "encoding/json"

    jsoniter "github.com/json-iterator/go"
)

func Json(r map[string]string) error {
    data, err := json.Marshal(r)
    if err != nil {
        return err
    }

    _ = data
    return nil
}

func JsonPool(r map[string]string) error {
    buffer := pool.Get().(*bytes.Buffer)
    buffer.Reset()
    defer pool.Put(buffer)

    e := json.NewEncoder(buffer)
    err := e.Encode(r)
    if err != nil {
        return err
    }

    return nil
}

func JsonIter(r map[string]string) error {
    data, err := jsoniter.Marshal(r)
    if err != nil {
        return err
    }

    _ = data
    return nil
}

func JsonIterPool(r map[string]string) error {
    buffer := pool.Get().(*bytes.Buffer)
    buffer.Reset()
    defer pool.Put(buffer)

    e := jsoniter.NewEncoder(buffer)
    err := e.Encode(r)
    if err != nil {
        return err
    }

    return nil
}

性能测试代码源码: 

package iouitl_readall

import (
    "strconv"
    "strings"
    "testing"
)

var request map[string]string

func init() {
    request = make(map[string]string, 100)
    for i := 0; i < 100; i++ {
        request["X"+strconv.Itoa(i)] = strings.Repeat("A", i/2)
    }
}
func BenchmarkJson(b *testing.B) {
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            err := Json(request)
            if err != nil {
                b.Error(err.Error())
            }
        }
    })
}

func BenchmarkJsonIter(b *testing.B) {
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            err := JsonIter(request)
            if err != nil {
                b.Error(err.Error())
            }
        }
    })
}

func BenchmarkJsonPool(b *testing.B) {
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            err := JsonPool(request)
            if err != nil {
                b.Error(err.Error())
            }
        }
    })
}

func BenchmarkJsonIterPool(b *testing.B) {
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            err := JsonIterPool(request)
            if err != nil {
                b.Error(err.Error())
            }
        }
    })
}

测试结果如下:

goos: darwin
goarch: amd64
pkg: github.com/thinkeridea/example/iouitl_readall
BenchmarkJson-8                       100000         13297 ns/op       13669 B/op        207 allocs/op
BenchmarkJsonPool-8                   100000         13310 ns/op       10218 B/op        206 allocs/op
BenchmarkJsonIter-8                   500000          2948 ns/op        3594 B/op          4 allocs/op
BenchmarkJsonIterPool-8               200000          6126 ns/op        6040 B/op        144 allocs/op
PASS
ok      github.com/thinkeridea/example/iouitl_readall   12.716s

这里使用了两个 json 包， 一个是标准库的，一个是 jsoniter (也是社区反馈效率最高的)，对比两个包使用 sync.Pool 和不使用之间的差异，发现标准库 json 包使用后内存有少量减少，但是运行效率稍微下降了，差异不是很大，jsoniter 包差异之所谓非常明显，发现使用 sync.Pool 之后不仅内存分配更多了，执行效率也大幅度下降，差了将近3倍有余。

是不是很奔溃，这是啥情况 jsoniter 本身就使用了 sync.Pool 作缓冲，我们使用 jsoniter.NewEncoder(buffer) 创建一个序列化实例，但是其内部并没有直接使用 io.Writer 而是先使用缓冲序列化数据，之后写入 io.Writer, 具体代码如下：

// Flush writes any buffered data to the underlying io.Writer.
func (stream *Stream) Flush() error {
    if stream.out == nil {
        return nil
    }
    if stream.Error != nil {
        return stream.Error
    }
    n, err := stream.out.Write(stream.buf)
    if err != nil {
        if stream.Error == nil {
            stream.Error = err
        }
        return err
    }
    stream.buf = stream.buf[n:]
    return nil
}

这样一来我们使用 buffer 做 json 序列化优化效果就大打折扣，甚至适得其反了。

再次感谢 “wxe” 网友的提问，这里没有使用实际的应用场景做性能测试，主要发现在性能测试中使用 http 服务会导致 connect: can't assign requested address 问题，所以测试用使用了函数模拟，如果有朋友有更好的测试方法欢迎一起交流。

转载：

本文作者： 戚银（thinkeridea）

本文链接： https://blog.thinkeridea.com/201902/go/you_ya_de_du_qu_http_qing_qiu_huo_xiang_ying_de_shu_ju_2.html

版权声明： 本博客所有文章除特别声明外，均采用 CC BY 4.0 CN协议 许可协议。转载请注明出处！

weixin_39713686
关注
【Go】优雅的读取http请求或响应的数据
weixin_33774615的博客
01-26 1929
原文链接：https://blog.thinkeridea.com/... 从 http.Request.Body 或 http.Response.Body 中读取数据方法或许很多，标准库中大多数使用 ioutil.ReadAll 方法一次读取所有数据，如果是 json 格式的数据还可以使用 json.NewDecoder 从 io.Re...
前后端分离开发，RESTful 接口应该这样设计
程序员闪充宝
02-22 165
点击上方蓝色字体，选择“标星公众号”优质文章，第一时间送达译者 |唐尤华https://dzone.com/refcardz/rest-foundations-restful前言RE...
Go语言经典库使用分析（三）| Gorilla Handlers 详细介绍
flysnow_org的博客
08-06 413
Go语言经典库使用分析，未完待续，欢迎扫码关注公众号flysnow_org或者网站http://www.flysnow.org/，第一时间看后续系列。觉得有帮助的话，顺手分享到朋友圈吧，...
Go | Go 发送 http 请求: post，get，put，delete请求示例代码
双鬼带单
02-07 2856
Go 发送 http 请求: post，get，put，delete请求示例代码 HTTP 请求方法 请求示例 GET POST kv 形式 PUT PATCH DELETE 源码参考 HTTP 请求方法 根据 HTTP 标准，HTTP 请求可以使用多种请求方法。 在日常开发中大多数会用到 5 种请求方法： GET、POST、PUT、PATCH 和 DELETE 方法 描述 GET 请求指定的页面信息，并返回实体主体。 POST 向指定资源提交数据进行处理请求（例.
Golang发送GET、POST、PUT、DELETE请求
懒人程序员的博客
04-12 3482
golang发送GET、POST、PUT、DELETE请求 package request import ( "compress/gzip" "fmt" "io" "io/ioutil" "net/http" "net/url" ) type Param map[string]interface{} type request struct { Url string Par...
go http put请求_MIT 6.824 Lecture2和Go的GPM模型
weixin_30135925的博客
12-27 227
Prerequisite for Lecture2课程要求通过该网站熟悉GO语言，有其它语言基础熟悉一下还是很快的。恕我见识短浅，第一次见到Go的设计颠覆三观orz。在课程之外，我也整理了一下Go的GPM模型，更有利于理解Go的从语言层面支持的多线程。西瓜学习：Go的GPM多线程调度​zhuanlan.zhihu.com使用Go的理由 Go有垃圾回收且类型安全(自动确定最后一个线程何时结束一个对象...
Golang 发送http请求时设置header的实现
12-20
首先，我们需要导入必要的包，包括`fmt`用于输出，`io/ioutil`用于读取响应体，`net/http`用于发起HTTP请求，以及`os`和`encoding/json`在某些情况下用于处理输入输出和JSON数据。 ```go import ( "fmt" "io/...
Go-request是Go中的一个简洁HTTP请求客户端
08-14
Go请求库，通常被称为`go-request`，是一个在Go语言中广泛使用的轻量级HTTP客户端。这个库的设计理念是提供简单、链式API，使得开发者能够方便地进行HTTP请求操作，比如GET、POST等。在Go这样的静态类型语言中，`go-...
Go-sling-一个GoHTTP客户端库用于创建和发送API请求
08-13
Go-sling是一个专门为Go语言开发者设计的HTTP客户端库，它为构建和发送API请求提供了便利。在Go语言中，标准库"net/http"虽然已经足够强大，但有时在处理复杂的HTTP请求，尤其是涉及到RESTful API调用时，使用sling...
go语言web开发框架学习系列二：Get、Post、Put等请求及数据返回格式
qfliweimin的博客
04-21 472
数据请求方式的分类 所有的项目中使用的请求都遵循HTTP协议标准，HTTP协议经过了1.0和1.1两个版本的发展。 HTTP1.0定义了三种请求方法： GET, POST 和 HEAD方法。 HTTP1.1新增了五种请求方法：OPTIONS, PUT, DELETE, TRACE 和 CONNECT 方法。 因此，我们可以说，HTTP协议一共定义了八种方法用来对Request-URI网络资源...
.interface文件怎么看啊_如何用Golang每秒读取16GB的文件
weixin_42114046的博客
12-15 144
当今世界，任何计算机系统每天都会生成大量日志或数据。 随着系统的发展，将调试数据存储到数据库中是不可行的，因为它们是不可变的，仅用于分析和故障排除。 因此，组织倾向于将其存储在驻留在本地磁盘存储中的文件中。我们将使用Golang从大小为16 GB的.txt或.log文件中提取日志，其中包含数百万行。上代码…！首先打开文件。 我们将对任何文件IO使用标准的Go os.File。f, err := o...
golang模拟curl命令发送http GET|POST|PUT|DELETE 请求
tower888的专栏
03-28 7561
package main import ( "flag" "fmt" "io/ioutil" "net/http" "strings" ) //模拟curl命令发送http GET|POST|PUT|DELETE 请求 func main() { url := flag.String("url", "http://ip:port/xxx", "request url") met...
go 通过http发送图片file内容
weixin_33815613的博客
02-07 1513
package main import ( "encoding/json" "fmt" "io/ioutil" "net/http" "net/url" "os" "bufio" "io" "mime/multipart" "net/smtp" ) ...
go从0开始1，安装包，get,post请求及params,body等参数获取
Velly_zheng的博客
01-29 2502
一，安装go环境 这个挺容易，不过要记得配置go参数 ~/.bash_profile(环境以mac为参照) 二，安装goland 这个也容易，不过网上基本上都收费，但也有破解的方法，自己找吧 三，安装包 由于原go的默认包地址在墙外，基本上没有VPN的话，下载失败，但也有解决办法 解决方式： 开启代理：export GO111MODULE=on 设置代理：export GOPROXY=https://goproxy.cn ...
go --- go-bin获取请求参数
my_miuye的博客
06-14 993
go-bin获取请求参数的各种方法。
golang中发送http请求的几种常见情况
diemoyi5954的博客
07-19 1253
整理一下golang中各种http的发送方式 最初的一些项目中，很多的地方都使用到了golang发送http请求，之后再对请求收到的结果进行一些处理，所用到的模式也比较固定，这里整理一下集中http的发送方式，先记录这么多，再一点一点添加。 最基本的场景 方式一 使用http.Newrequest 先生成http.client -> 再生成 http.request -> 之...
怎么用golang发送http请求
最新发布
02-21
如果要发送其他类型的 HTTP 请求，比如 POST、PUT 或 DELETE，可以使用 http 库中的其他函数，比如 Post、Put 和 Delete。这些函数的用法与 Get 类似，只是请求方法不同而已。 例如，下面的例子展示了如何发送一个 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值