go|go 自定义http.Client - 动态修改请求Body go自定义http.Client-动态修改请求

前言在对接Alexa Smart Home时，有的请求Payload中需要传入Access Token，但是这个Token是由OAuth2 Client管理的，封装Payload时并不知道Access Token。
所以使用自定义RoundTripper，在请求前取出Header里的token，修改body，实现动态修改payload。
原理 go中可以使用http.DefaultClient进行http请求，也可以自己创建http.Client，传入自定义Transport可以实现对request的处理。
http.Client

// A Client is an HTTP client. Its zero value (DefaultClient) is a // usable client that uses DefaultTransport. // // The Client's Transport typically has internal state (cached TCP // connections), so Clients should be reused instead of created as // needed. Clients are safe for concurrent use by multiple goroutines. // // A Client is higher-level than a RoundTripper (such as Transport) // and additionally handles HTTP details such as cookies and // redirects. // // When following redirects, the Client will forward all headers set on the // initial Request except: // // ? when forwarding sensitive headers like "Authorization", // "WWW-Authenticate", and "Cookie" to untrusted targets. // These headers will be ignored when following a redirect to a domain // that is not a subdomain match or exact match of the initial domain. // For example, a redirect from "foo.com" to either "foo.com" or "sub.foo.com" // will forward the sensitive headers, but a redirect to "bar.com" will not. // // ? when forwarding the "Cookie" header with a non-nil cookie Jar. // Since each redirect may mutate the state of the cookie jar, // a redirect may possibly alter a cookie set in the initial request. // When forwarding the "Cookie" header, any mutated cookies will be omitted, // with the expectation that the Jar will insert those mutated cookies // with the updated values (assuming the origin matches). // If Jar is nil, the initial cookies are forwarded without change. // 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 cancellation instead of implementing CancelRequest. Timeout time.Duration }

http.RoundTripper

// RoundTripper is an interface representing the ability to execute a // single HTTP transaction, obtaining the Response for a given Request. // // A RoundTripper must be safe for concurrent use by multiple // goroutines. type RoundTripper interface { // RoundTrip executes a single HTTP transaction, returning // a Response for the provided Request. // // RoundTrip should not attempt to interpret the response. In // particular, RoundTrip must return err == nil if it obtained // a response, regardless of the response's HTTP status code. // A non-nil err should be reserved for failure to obtain a // response. Similarly, RoundTrip should not attempt to // handle higher-level protocol details such as redirects, // authentication, or cookies. // // RoundTrip should not modify the request, except for // consuming and closing the Request's Body. RoundTrip may // read fields of the request in a separate goroutine. Callers // should not mutate or reuse the request until the Response's // Body has been closed. // // RoundTrip must always close the body, including on errors, // but depending on the implementation may do so in a separate // goroutine even after RoundTrip returns. This means that // callers wanting to reuse the body for subsequent requests // must arrange to wait for the Close call before doing so. // // The Request's URL and Header fields must be initialized. RoundTrip(*Request) (*Response, error) }

实现我们先写一个server，打印出访问的payload信息。

package mainimport ( "fmt" "io/ioutil" "net/http" )func main() { mux := http.NewServeMux() mux.HandleFunc("/", func(rw http.ResponseWriter, r *http.Request) { req, err := ioutil.ReadAll(r.Body) if err != nil { rw.WriteHeader(500) rw.Write([]byte(err.Error())) return } fmt.Println(string(req)) }) if err := http.ListenAndServe(":8000", mux); err != nil { panic(err) } }

如果使用默认的DefaultClient，只会打印出我们传入的payload。

package mainimport ( "fmt" "io/ioutil" "net/http" "strings" "github.com/google/uuid" )func main(){ id := uuid.NewString() req, _ := http.NewRequest("GET", "http://localhost:8000", strings.NewReader(fmt.Sprintf(`{"id":"%s"}`, id))) req.Header.Add("Authorization", fmt.Sprintf("Bearer token%s", id)) resp, err := http.DefaultClient.Do(req) if err != nil { panic(err) } fmt.Println(resp) }()

结果：

{"id":"912733ce-4e17-4209-ad9e-71159fd37845"} &{200 OK 200 HTTP/1.1 1 1 map[Content-Length:[0] Date:[Sun, 28 Nov 2021 06:48:50 GMT]] {} 0 [] false false map[] 0xc000194000 }

使用自定义Transport

package mainimport ( "bytes" "encoding/json" "io/ioutil" "net/http" "strings" )type customTransport struct { }func (t *customTransport) RoundTrip(req *http.Request) (*http.Response, error) { token := req.Header.Get("Authorization") if len(token) != 0 && strings.HasPrefix(token, "Bearer ") { token = token[7:] var bodyBytes []byte if req.Body != nil { bodyBytes, _ = ioutil.ReadAll(req.Body) } var payload map[string]interface{} if err := json.Unmarshal(bodyBytes, &payload); err != nil { return nil, err } else { payload["token"] = token if bodyBytes, err := json.Marshal(payload); err != nil { return nil, err } else { req.ContentLength = int64(len(bodyBytes)) req.Body = ioutil.NopCloser(bytes.NewBuffer(bodyBytes)) } } } resp, err := http.DefaultTransport.RoundTrip(req) if err != nil { return nil, err } return resp, nil }

使用自定义Client

package mainimport ( "fmt" "io/ioutil" "net/http" "strings" "github.com/google/uuid" )func main(){ id := uuid.NewString() req, _ := http.NewRequest("GET", "http://localhost:8000", strings.NewReader(fmt.Sprintf(`{"id":"%s"}`, id))) req.Header.Add("Authorization", fmt.Sprintf("Bearer token%s", id)) client := &http.Client{ Transport: &customTransport{}, } resp, err := client.Do(req) if err != nil { panic(err) } fmt.Println(resp) }()

最终结果：

{"id":"ebcceb4b-1979-457b-bf49-9255ceb77322","token":"tokenebcceb4b-1979-457b-bf49-9255ceb77322"} &{200 OK 200 HTTP/1.1 1 1 map[Content-Length:[0] Date:[Sun, 28 Nov 2021 06:49:25 GMT]] {} 0 [] false false map[] 0xc000140000 }

总结我们可以使用http.DefaultClient完成大部分http请求，但是如果我们需要实现一些自定义逻辑时，可以传入http.Client中对应自定义的部分，实现自定义逻辑。
【go|go 自定义http.Client - 动态修改请求Body】本文中通过修改Transport，读取请求Header，并修改请求Body，动态修改请求Payload。