详细内容请看源码说明，下文提供一个中间件样例来进行请求转发

type Client struct {

// Transport specifies the mechanism by which individual

// HTTP requests are made.

// If nil, DefaultTransport is used.

Transport RoundTripper

// CheckRedirect specifies the policy for handling redirects.

// If CheckRedirect is not nil, the client calls it before

// following an HTTP redirect. The arguments req and via are

// the upcoming request and the requests made already, oldest

// first. If CheckRedirect returns an error, the Client's Get

// method returns both the previous Response (with its Body

// closed) and CheckRedirect's error (wrapped in a url.Error)

// instead of issuing the Request req.

// As a special case, if CheckRedirect returns ErrUseLastResponse,

// then the most recent response is returned with its body

// unclosed, along with a nil error.

//

// If CheckRedirect is nil, the Client uses its default policy,

// which is to stop after 10 consecutive requests.

CheckRedirect func(req *Request, via []*Request) error

// Jar specifies the cookie jar.

//

// The Jar is used to insert relevant cookies into every

// outbound Request and is updated with the cookie values

// of every inbound Response. The Jar is consulted for every

// redirect that the Client follows.

//

// If Jar is nil, cookies are only sent if they are explicitly

// set on the Request.

Jar CookieJar

// Timeout specifies a time limit for requests made by this

// Client. The timeout includes connection time, any

// redirects, and reading the response body. The timer remains

// running after Get, Head, Post, or Do return and will

// interrupt reading of the Response.Body.

//

// A Timeout of zero means no timeout.

//

// The Client cancels requests to the underlying Transport

// as if the Request's Context ended.

//

// For compatibility, the Client will also use the deprecated

// CancelRequest method on Transport if found. New

// RoundTripper implementations should use the Request's Context

// for cancelation instead of implementing CancelRequest.

Timeout time.Duration

}

//中间件样例

http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

proxy := func(_ *http.Request) (*url.URL, error) {

return url.Parse("target ip:port")//127.0.0.1:8099

}

transport := &http.Transport{

Proxy: proxy,

DialContext: (&net.Dialer{

Timeout: 30 * time.Second,

KeepAlive: 30 * time.Second,

DualStack: true,

}).DialContext,

MaxIdleConns: 100,

IdleConnTimeout: 90 * time.Second,

TLSHandshakeTimeout: 10 * time.Second,

ExpectContinueTimeout: 1 * time.Second,

MaxIdleConnsPerHost: 100,

}

client := &http.Client{Transport: transport}

url := "http://" + r.RemoteAddr + r.RequestURI

req, err := http.NewRequest(r.Method, url, r.Body)

//注： 设置Request头部信息

for k, v := range r.Header {

for _, vv := range v {

req.Header.Add(k, vv)

}

}

resp, err := client.Do(req)

if err != nil {

return

}

defer resp.Body.Close()

//注： 设置Response头部信息

for k, v := range resp.Header {

for _, vv := range v {

w.Header().Add(k, vv)

}

}

data, _ := ioutil.ReadAll(resp.Body)

w.Write(data)

})