如何实现 Http Request Body 多次读取

建议点击 查看原文 查看最新内容。

原文链接: https://typonotes.com/posts/2024/01/02/http-request-multiple-times-read/

最近在使用 gin 的时候， 踩了一个重复读取的 Request.Body 的坑。

起因是 gin 的 gin.Context{} 提供了 c.Copy() 方法创建副本。 这个方法一直在用， 但不知道从什么时候开始， 一直认为这个方法是 深拷贝， 但 并不完全是 (T_T)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


// Copy returns a copy of the current context that can be safely used outside the request's scope.
// This has to be used when the context has to be passed to a goroutine.
func (c *Context) Copy() *Context {
	cp := Context{
		writermem: c.writermem,
		Request:   c.Request, // 指针， 也算引用类型。 没有实现完全复制
		Params:    c.Params,
		engine:    c.engine,
	}
	cp.writermem.ResponseWriter = nil
	cp.Writer = &cp.writermem
	cp.index = abortIndex
	cp.handlers = nil
	cp.Keys = map[string]interface{}{} // Keys 完全复制
	for k, v := range c.Keys {
		cp.Keys[k] = v
	}
	paramCopy := make([]Param, len(cp.Params)) // 切片， 完全复制
	copy(paramCopy, cp.Params) 
	cp.Params = paramCopy
	return &cp
}

1. gin 通过用一个全局变量保存

在 gin 中, 在读取了 request body 后， 通过 c.Set(BodyBytesKey, body) 放到了 gin.Context 中的 Keys。 这是一个 map， 上面说到了。

因此 在 gin 中通过中间变量实现类似效果。 虽然感觉上多次读取 Body ， 但实际 只读取了一次，

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

// ShouldBindBodyWith is similar with ShouldBindWith, but it stores the request
// body into the context, and reuse when it is called again.
//
// NOTE: This method reads the body before binding. So you should use
// ShouldBindWith for better performance if you need to call only once.
func (c *Context) ShouldBindBodyWith(obj any, bb binding.BindingBody) (err error) {
	var body []byte
	if cb, ok := c.Get(BodyBytesKey); ok {
		if cbb, ok := cb.([]byte); ok {
			body = cbb
		}
	}
	if body == nil {
		body, err = io.ReadAll(c.Request.Body)
		if err != nil {
			return err
		}
		// 将 Body 中的内容放到 gin.Context 中的 Keys 中
		c.Set(BodyBytesKey, body)
	}
	return bb.BindBody(body, obj)
}

参考文档: https://github.com/gin-gonic/gin/blob/v1.9.1/context.go#L744-L764

2. 再造一个 Request

另外一种方法， 就是在读取 Body 后， 重建一个 Requset 再把 Body 放进去。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// 读取老的
body, err := ioutil.ReadAll(r.Body)
if err != nil {
    // ...
}
url, _ := url.Parse(config.GetGameHost())

// 创建新的
r2 := r.Clone(r.Context())

// 将数据方进去
r.Body = ioutil.NopCloser(bytes.NewReader(body))
r2.Body = ioutil.NopCloser(bytes.NewReader(body))

r.ParseForm()

proxy := httputil.NewSingleHostReverseProxy(url)
proxy.ServeHTTP(w, r2)

参考文档: https://stackoverflow.com/q/62017146

注意 http.Request 有一个方法叫 Clone(), 但这也不是一个完全的深拷贝。 Body 没有复制。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// Clone returns a deep copy of r with its context changed to ctx.
// The provided ctx must be non-nil.
//
// For an outgoing client request, the context controls the entire
// lifetime of a request and its response: obtaining a connection,
// sending the request, and reading the response headers and body.
func (r *Request) Clone(ctx context.Context) *Request {
	if ctx == nil {
		panic("nil context")
	}
	r2 := new(Request)
	*r2 = *r
	r2.ctx = ctx
	r2.URL = cloneURL(r.URL)
	if r.Header != nil {
		r2.Header = r.Header.Clone()
	}
	if r.Trailer != nil {
		r2.Trailer = r.Trailer.Clone()
	}
	if s := r.TransferEncoding; s != nil {
		s2 := make([]string, len(s))
		copy(s2, s)
		r2.TransferEncoding = s2
	}
	r2.Form = cloneURLValues(r.Form)
	r2.PostForm = cloneURLValues(r.PostForm)
	r2.MultipartForm = cloneMultipartForm(r.MultipartForm)
	return r2
}