大多数行为在net/http
可以被嘲笑、扩展或改变。虽然http.Client http://golang.org/pkg/net/http/#Client是一个实现 HTTP 客户端语义的具体类型,它的所有字段都是导出的并且可以自定义。
The Client.Transport http://golang.org/pkg/net/http/#Client特别是,可以替换字段以使客户端执行任何操作,从使用自定义协议(例如 ftp:// 或 file://)到直接连接到本地处理程序(不生成 HTTP 协议字节或通过网络发送任何内容) 。
客户端功能,例如http.Get http://golang.org/pkg/net/http/#Get,全部利用导出的http.DefaultClient
包变量(您可以修改),因此利用这些便利函数的代码不会not例如,必须更改为调用自定义 Client 变量上的方法。请注意,虽然在公开可用的库中修改全局行为是不合理的,但在应用程序和测试(包括库测试)中这样做非常有用。
http://play.golang.org/p/afljO086iB http://play.golang.org/p/afljO086iB包含一个自定义的http.RoundTripper
重写请求 URL,以便将其路由到本地托管httptest.Server
,另一个例子直接将请求传递给http.Handler
,以及一个自定义http.ResponseWriter
实施,以创建一个http.Response
。第二种方法不像第一种方法那么勤奋(它没有填写响应值中那么多的字段),但效率更高,并且应该足够兼容,可以与大多数处理程序和客户端调用者一起使用。
上面链接的代码也包含在下面:
package main
import (
"fmt"
"io"
"log"
"net/http"
"net/http/httptest"
"net/url"
"os"
"path"
"strings"
)
func Handler(w http.ResponseWriter, r *http.Request) {
fmt.Fprintf(w, "hello %s\n", path.Base(r.URL.Path))
}
func main() {
s := httptest.NewServer(http.HandlerFunc(Handler))
u, err := url.Parse(s.URL)
if err != nil {
log.Fatalln("failed to parse httptest.Server URL:", err)
}
http.DefaultClient.Transport = RewriteTransport{URL: u}
resp, err := http.Get("https://google.com/path-one")
if err != nil {
log.Fatalln("failed to send first request:", err)
}
fmt.Println("[First Response]")
resp.Write(os.Stdout)
fmt.Print("\n", strings.Repeat("-", 80), "\n\n")
http.DefaultClient.Transport = HandlerTransport{http.HandlerFunc(Handler)}
resp, err = http.Get("https://google.com/path-two")
if err != nil {
log.Fatalln("failed to send second request:", err)
}
fmt.Println("[Second Response]")
resp.Write(os.Stdout)
}
// RewriteTransport is an http.RoundTripper that rewrites requests
// using the provided URL's Scheme and Host, and its Path as a prefix.
// The Opaque field is untouched.
// If Transport is nil, http.DefaultTransport is used
type RewriteTransport struct {
Transport http.RoundTripper
URL *url.URL
}
func (t RewriteTransport) RoundTrip(req *http.Request) (*http.Response, error) {
// note that url.URL.ResolveReference doesn't work here
// since t.u is an absolute url
req.URL.Scheme = t.URL.Scheme
req.URL.Host = t.URL.Host
req.URL.Path = path.Join(t.URL.Path, req.URL.Path)
rt := t.Transport
if rt == nil {
rt = http.DefaultTransport
}
return rt.RoundTrip(req)
}
type HandlerTransport struct{ h http.Handler }
func (t HandlerTransport) RoundTrip(req *http.Request) (*http.Response, error) {
r, w := io.Pipe()
resp := &http.Response{
Proto: "HTTP/1.1",
ProtoMajor: 1,
ProtoMinor: 1,
Header: make(http.Header),
Body: r,
Request: req,
}
ready := make(chan struct{})
prw := &pipeResponseWriter{r, w, resp, ready}
go func() {
defer w.Close()
t.h.ServeHTTP(prw, req)
}()
<-ready
return resp, nil
}
type pipeResponseWriter struct {
r *io.PipeReader
w *io.PipeWriter
resp *http.Response
ready chan<- struct{}
}
func (w *pipeResponseWriter) Header() http.Header {
return w.resp.Header
}
func (w *pipeResponseWriter) Write(p []byte) (int, error) {
if w.ready != nil {
w.WriteHeader(http.StatusOK)
}
return w.w.Write(p)
}
func (w *pipeResponseWriter) WriteHeader(status int) {
if w.ready == nil {
// already called
return
}
w.resp.StatusCode = status
w.resp.Status = fmt.Sprintf("%d %s", status, http.StatusText(status))
close(w.ready)
w.ready = nil
}