处理重定向错误时使用Go ReverseProxy：无效地读取关闭的正文上的http

小伙伴们对Golang编程感兴趣吗？是否正在学习相关知识点？如果是，那么本文《处理重定向错误时使用Go ReverseProxy：无效地读取关闭的正文上的http》，就很适合你，本篇文章讲解的知识点主要包括。在之后的文章中也会多多分享相关知识点，希望对大家的知识积累有所帮助！

这是我的代码，当源服务器返回302时，反向代理将修改请求并再次提供服务，但如果请求带有正文，则会打印错误：http：无效读取关闭的正文

proxy = httputil.NewSingleHostReverseProxy(url)
        proxy.ErrorLog = proxyLogger
        proxy.ModifyResponse = func(response *http.Response) error {
            if response.StatusCode > 300 && response.StatusCode < 400 {
                location, err := response.Location()
                if err != nil {
                    return err
                }
                return &RedirectErr{location: location}
            }
            return nil
        }
        var rewindBody func(r *http.Request)

        proxy.Director = func(request *http.Request) {
            if redirect := request.Header.Get("redirect"); redirect != "" {
                request.Header.Del("redirect")
                u, _ := urlpkg.Parse(redirect)
                rewriteRequestURL(request, u)
                return
            }
            rewriteRequestURL(request, url)
        }
        proxy.ErrorHandler = func(writer http.ResponseWriter, request *http.Request, err error) {
            var redirect *RedirectErr
            if redirect, ok = err.(*RedirectErr); !ok {
                proxy.ErrorLog.Printf("http: proxy error: %v", err)
                writer.WriteHeader(http.StatusBadGateway)
            } else {
                request.Header.Set("redirect", redirect.location.String())
                proxy.ServeHTTP(writer, request)
                return
            }
        }

我尝试使用 fakeclosereadcloser，但出现了新错误：“错误：net/http: http/1.x 传输连接损坏：http: contentlength=75 且正文长度为 0”

正确答案

最后，我解决了这个问题。我们需要确保请求主体不关闭。 并在第二次运输前将机身倒回。

// after transport, the request body will close,
// so if we need redirect it, we have to wrap the body and ensure that it won't be close
// we will handle it after we finished.
// see this issue: https://github.com/flynn/flynn/issues/872
type fakeCloseReadCloser struct {
    io.ReadCloser
}

func (w *fakeCloseReadCloser) Close() error {
    return nil
}

func (w *fakeCloseReadCloser) RealClose() error {
    if w.ReadCloser == nil {
        return nil
    }
    return w.ReadCloser.Close()
}

type Proxy struct {
    *httputil.ReverseProxy
}

func (p *Proxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
    req.Body = &fakeCloseReadCloser{req.Body}
    // The body can only be read once, so we use this func to make the body available on the second forwarding
    if req.Body != nil {
        bodyBytes, _ := io.ReadAll(req.Body)
        _ = req.Body.(*fakeCloseReadCloser).RealClose()
        req.Body = &fakeCloseReadCloser{io.NopCloser(bytes.NewBuffer(bodyBytes))}
        req.GetBody = func() (io.ReadCloser, error) {
            body := io.NopCloser(bytes.NewBuffer(bodyBytes))
            return body, nil
        }
    }

    p.ReverseProxy.ServeHTTP(rw, req)
    _ = req.Body.(*fakeCloseReadCloser).RealClose()
}

// Get returns a proxy for the given shard.
func (pp *ProxyPool) Get(url *urlpkg.URL) *Proxy {
    pp.mutex.Lock()
    defer pp.mutex.Unlock()

    p, ok := pp.pool[url.String()]
    if !ok {
        // When the original target server returns 302,
        // proxy.ModifyResponse will return a customized redirect error containing location,
        // proxy.ErrorHandler catches the error and modifies the request,
        // adds a "redirect" header field to it, and Serve it again.
        // At this point proxy.Director will detect the "redirect" field in the request header
        // and send the request to the final target server.
        rp := httputil.NewSingleHostReverseProxy(url)
        px := &Proxy{ReverseProxy: rp}

        px.ErrorLog = proxyLogger
        px.ModifyResponse = func(response *http.Response) error {
            if response.StatusCode > 300 && response.StatusCode < 400 {
                location, err := response.Location()
                if err != nil {
                    return err
                }
                return &RedirectErr{location: location}
            }

            return nil
        }

        px.Director = func(request *http.Request) {
            if redirect := request.Header.Get("redirect"); redirect != "" {
                request.Header.Del("redirect")
                u, _ := urlpkg.Parse(redirect)
                // rewind
                if request.GetBody != nil {
                    b, _ := request.GetBody()
                    request.Body = b
                }
                rewriteRequestURL(request, u)
                return
            }

            rewriteRequestURL(request, url)
        }
        px.ErrorHandler = func(writer http.ResponseWriter, request *http.Request, err error) {
            var redirect *RedirectErr
            if redirect, ok = err.(*RedirectErr); !ok {
                p.ErrorLog.Printf("http: proxy error: %v", err)
                writer.WriteHeader(http.StatusBadGateway)
            } else {
                request.Header.Set("redirect", redirect.location.String())
                px.ReverseProxy.ServeHTTP(writer, request)
                return
            }
        }

        pp.pool[url.Host] = px
        p = px
    }

    return p
}

到这里，我们也就讲完了《处理重定向错误时使用Go ReverseProxy：无效地读取关闭的正文上的http》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！