package http

import "net/http"

resp , err := http.Get("http://example.com/")
...
resp, err := http.Post("http://example.com/upload","image/jpeg",&buf)
...
resp, err := http.PostForm("http://example.com/form",
    url.Values{"Key":{"Value"}, "id":{"123"}})

resp, err := http.Get("http://example.com")
if err != nil {
    // handle error
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)

client := &http.Client{
    CheckRedirect: redirectPolicyFunc,
}

resp, err := client.Get("http://example.com")
// ...

req, err := http.NewRequest("GET","http://example.com",nil)
// ...
req.Header.Add("if-None-Match",`W/"wyzzy"`)
resp, err := client.Do(req)
// ...

tr := &http.Transport{
    MaxldleConns: 10,
    ldleConnTimeout: 30 * time.Second,
    DisableCompression: true,
}
client := &http.Client{Transport: tr}
resp, err := client.Get("https://example.com")

http.Handle("/foo"，fooHandler)

http.HandleFunc("/bar",func(w http.ResponseWriter, r *http.Request){
    fmt.Fprintf(w, "Hello,%q", html.EscapeString(r.URL, Path))
})

log.Fatal(http.ListenAndServe(":8080", nil))

s := &http.Server{
    Addr :              ":8080",
    Handler:            myHandler,
    ReadTimeout:    10 * time.Second,
    WriteTimeout:   10 * time.Second,
    MaxHeaderBytes: 1<< 20,
    }

log.Fatal(s.ListenAndServe())

GODEBUG=http2client=0 // 禁用HTTP/2客户端支持
GODEBUG=http2server=0 // 禁用HTTP/2服务端支持
GODEBUG=http2debug=1 // 启动详细的HTTP/2调试日志
GODEBUG=http2debug=2 // 更详细的日志，包含 frame dumps

const (
    MethodGet     = "GET"
    MethodHead    = "HEAD"
    MethodPost    = "POST"
    MethodPut     = "PUT"
    MethodPath    = "PATCH" // RFC 5789
    MethodDelete  = "DELETE"
    MethodConnect = "CONNECT"
    MethodOptions = "OPTIONS"
    MethodTrace   = "TRACE"
)

const (
    StatusContinue           = 100 // RFC 7231, 6.2.1
    StatusSwitchingProtocols = 101 // RFC 7231, 6.2.2
    StatusProcessing         = 102 // RFC 2518, 10.1
    StatusEarlyHints         = 103 // RFC 8297

    StatusOK                   = 200 // RFC 7231, 6.3.1
    StatusCreated              = 201 // RFC 7231, 6.3.2
    StatusAccepted             = 202 // RFC 7231, 6.3.3
    StatusNonAuthoritativeInfo = 203 // RFC 7231, 6.3.4
    StatusNoContent            = 204 // RFC 7231, 6.3.5
    StatusResetContent         = 205 // RFC 7231, 6.3.6
    StatusPartialContent       = 206 // RFC 7233, 4.1
    StatusMultiStatus          = 207 // RFC 4918, 11.1
    StatusAlreadyReported      = 208 // RFC 5842, 7.1
    StatusIMUsed               = 226 // RFC 3229, 10.4.1

    StatusMultipleChoices  = 300 // RFC 7231, 6.4.1
    StatusMovedPermanently = 301 // RFC 7231, 6.4.2
    StatusFound            = 302 // RFC 7231, 6.4.3
    StatusSeeOther         = 303 // RFC 7231, 6.4.4
    StatusNotModified      = 304 // RFC 7232, 4.1
    StatusUseProxy         = 305 // RFC 7231, 6.4.5

    StatusTemporaryRedirect = 307 // RFC 7231, 6.4.7
    StatusPermanentRedirect = 308 // RFC 7538, 3

    StatusBadRequest                   = 400 // RFC 7231, 6.5.1
    StatusUnauthorized                 = 401 // RFC 7235, 3.1
    StatusPaymentRequired              = 402 // RFC 7231, 6.5.2
    StatusForbidden                    = 403 // RFC 7231, 6.5.3
    StatusNotFound                     = 404 // RFC 7231, 6.5.4
    StatusMethodNotAllowed             = 405 // RFC 7231, 6.5.5
    StatusNotAcceptable                = 406 // RFC 7231, 6.5.6
    StatusProxyAuthRequired            = 407 // RFC 7235, 3.2
    StatusRequestTimeout               = 408 // RFC 7231, 6.5.7
    StatusConflict                     = 409 // RFC 7231, 6.5.8
    StatusGone                         = 410 // RFC 7231, 6.5.9
    StatusLengthRequired               = 411 // RFC 7231, 6.5.10
    StatusPreconditionFailed           = 412 // RFC 7232, 4.2
    StatusRequestEntityTooLarge        = 413 // RFC 7231, 6.5.11
    StatusRequestURITooLong            = 414 // RFC 7231, 6.5.12
    StatusUnsupportedMediaType         = 415 // RFC 7231, 6.5.13
    StatusRequestedRangeNotSatisfiable = 416 // RFC 7233, 4.4
    StatusExpectationFailed            = 417 // RFC 7231, 6.5.14
    StatusTeapot                       = 418 // RFC 7168, 2.3.3
    StatusMisdirectedRequest           = 421 // RFC 7540, 9.1.2
    StatusUnprocessableEntity          = 422 // RFC 4918, 11.2
    StatusLocked                       = 423 // RFC 4918, 11.3
    StatusFailedDependency             = 424 // RFC 4918, 11.4
    StatusTooEarly                     = 425 // RFC 8470, 5.2.
    StatusUpgradeRequired              = 426 // RFC 7231, 6.5.15
    StatusPreconditionRequired         = 428 // RFC 6585, 3
    StatusTooManyRequests              = 429 // RFC 6585, 4
    StatusRequestHeaderFieldsTooLarge  = 431 // RFC 6585, 5
    StatusUnavailableForLegalReasons   = 451 // RFC 7725, 3

    StatusInternalServerError           = 500 // RFC 7231, 6.6.1
    StatusNotImplemented                = 501 // RFC 7231, 6.6.2
    StatusBadGateway                    = 502 // RFC 7231, 6.6.3
    StatusServiceUnavailable            = 503 // RFC 7231, 6.6.4
    StatusGatewayTimeout                = 504 // RFC 7231, 6.6.5
    StatusHTTPVersionNotSupported       = 505 // RFC 7231, 6.6.6
    StatusVariantAlsoNegotiates         = 506 // RFC 2295, 8.1
    StatusInsufficientStorage           = 507 // RFC 4918, 11.5
    StatusLoopDetected                  = 508 // RFC 5842, 7.2
    StatusNotExtended                   = 510 // RFC 2774, 7
    StatusNetworkAuthenticationRequired = 511 // RFC 6585, 6
)

const DefaultMaxHeaderBytes = 1 << 20 // 1 MB

const DefaultMaxIdleConnsPerHost = 2

const TimeFormat = "Mon, 02 Jan 2006 15:04:05 GMT"

const TrailerPrefix = "Trailer:"

var (
    // ErrNotSupported 是由Pusher的Push方法返回的，表示不可获得对HTTP/2的支持
    ErrNotSupported = &ProtocolError{"feature not supported"}

    // 弃用
    // net/http包中的任何方法都不会再返回 ErrUnexpectedTrailer
    // 调用者不应该将错误与这个变量进行比较
    ErrUnexpectedTrailer = &ProtocolError{"trailer header without chunked transfer encoding"}

    // 当请求的 Content-Type 不包含一个“boundary”参数时，Request.MultipartReader 返回 ErrMissingBoundary
    ErrMissingBoundary = &ProtocolError{"no multipart boundary param in Content-Type"}

    // 当请求的 Content-Type 不是 multipart/form-data 时，Request.MultipartReader 返回 ErrNotMultipart
    ErrNotMultipart = &ProtocolError{"request Content-Type isn't multipart/form-data"}

    // 弃用
    // net/http包中的任何方法都不会再返回 ErrHeaderTooLong
    // 调用者不应该将错误与这个变量进行比较
    ErrHeaderTooLong = &ProtocolError{"header too long"}

    // 弃用
    // net/http包中的任何方法都不会再返回 ErrShortBody
    // 调用者不应该将错误与这个变量进行比较
    ErrShortBody = &ProtocolError{"entity body too short"}

    // 弃用
    // net/http包中的任何方法都不会再返回 ErrMissingContentLength
    // 调用者不应该将错误与这个变量进行比较
    ErrMissingContentLength = &ProtocolError{"missing ContentLength in HEAD response"}
)

var (
    // HTTP方法或响应代码不允许body时，ResponseWriter.Write调用返回ErrBodyNotAllowed
    ErrBodyNotAllowed = errors.New("http: request method or response status code does not allow body")

    // 当使用Hijacker接口时基础连接被劫持，ResponseWriter.Write 返回 ErrHijacked
    // 在被劫持的连接上进行零字节写入将返回ErrHijacked，而不会产生任何其他副作用
    ErrHijacked = errors.New("http: connection has been hijacked")

    // 当 Handler 为Content-Length响应头设置一个长度，然后尝试写入比声明更多的字节时，
    // ResponseWriter.Write调用返回ErrContentLength
    ErrContentLength = errors.New("http: wrote more than the declared Content-Length")

    // 弃用
    // net/http包中的任何方法都不会再返回 ErrWriteAfterFlush
    // 调用者不应该将错误与这个变量进行比较
    ErrWriteAfterFlush = errors.New("unused")
)

var (
    // ServerContextKey是 context key。可以在带有 Context.Value 的 HTTP handler 中
    // 使用它来访问启动 handler 的服务器，关联的值将是*Server类型
    ServerContextKey = &contextKey{"http-server"}

    // LocalAddrContextKey是context key。 可以在带有Context.Value的HTTP handler中使用它来访问连接的本地地址
    // 关联的值将为net.Addr类型。
    LocalAddrContextKey = &contextKey{"local-addr"}
)

var DefaultClient = &Client{}

var DefaultServeMux = &defaultServeMux

var ErrAbortHandler = errors.New("net/http: abort Handler")

var ErrBodyReadAfterClose = errors.New("http: invalid Read on closed Body")

var ErrHandlerTimeout = errors.New("http: Handler timeout")s

var ErrLineTooLong = internal.ErrLineTooLong

var ErrMissingFile = errors.New("http: no such file")

var ErrNoCookie = errors.New("http: named cookie not present")

var ErrNoLocation = errors.New("http: no Location header in response")

var ErrServerClosed = errors.New("http: Server closed")

var ErrSkipAltProtocol = errors.New("net/http: skip alternate protocol")

var ErrUseLastResponse = errors.New("net/http: use last response")

var NoBody = noBody{}

func CanonicalHeaderKey(s string) string

func DetectContentType(data []byte) string

func Error(w ResponseWriter, error string, code int)

func Handle(pattern string, handler Handler)

package main

import (
    "fmt"
    "log"
    "net/http"
    "sync"
)

type countHander struct{
    mu sync.Mutex // guards n
    n int
}

func (h *countHandler) ServeHTTP(w http.ResponseWriter, r *http.Request){
    h.mu.Lock()
    defer h.mu.Unlock()
    h.n++
    fmt.Fprintf(w, "count is %d\n", h.n)
}

func main(){
    http.Handle("/count",new(countHandler))
    log.Fatal(http.ListenAndServe(":8080",nil))
}

func HandleFunc(pattern string, handler func(ResponseWriter, *Request))

h1 := func(w http.ResponseWriter, _ *http.Request){
    io.WriteString(w, "Hello from a HandleFunc #1!\n")
}

h2 := func(w http.ResponseWriter, _ *http.Request){
    io.WriteString(w,"Hello from a HandleFunc #2!\n")
}

http.HandleFunc("/", h1)
http.HandleFunc("/endpoint", h2)

log.Fatal(http.ListenAndServe(":8080",nil))

func ListenAndServe(addr string, handler Handler) error

helloHandler := func(w http.ResponseWriter, req *http.Request){
    io.WriteString(w,"Hello,world!\n")
}

http.HandlerFunc("/hello",helloHandler)
log.Fatal(http.ListenAndServe(":8080",nil))

func ListenAndServeTLS(addr, certFile, keyFile string, handler Handler) error

http.HandlerFunc("/",func(w http.ResponseWriter, req *http.Request){
    io.WriteString(w,"Hello,TLS!\n")
})

// One can use generate_cert.go in crypto/tls to generate cert.pem and key.pem
log.Printf("About to listen on 8443. Go to https://127.0,0.1:8443/")
err := http.ListenAndServeTLS(":8443","cert.pem","key.pem",nil)
log.Fatal(err)

func MaxBytesReader(w ResponseWriter, r io.ReadCloser, n int64) io.ReadCloser

func NotFound(w ResponseWriter, r *Request)

func ParseHTTPVersion(vers string) (major, minor int, ok bool)

func ParseTime(text string) (t time.Time, err error)

func ProxyFromEnvironment(req *Request) (*url.URL, error)

func ProxyURL(fixedURL *url.URL) func(*Request) (*url.URL, error)

func Redirect(w ResponseWriter, r *Request, url string, code int)

func Serve(l net.Listener, handler Handler) error

func ServeContent(w ResponseWriter, req *Request, name string, modtime time.Time, content io.ReadSeeker)

func ServeFile(w ResponseWriter, r *Request, name string)

func ServeTLS(l net.Listener, handler Handler, certFile, keyFile string) error

func SetCookie(w ResponseWriter, cookie *Cookie)

func StatusText(code int) string

type Client struct {
    // Transport 指定发出单个HTTP请求的机制。
    // 如果为nil，则使用DefaultTransport。
    Transport RoundTripper

    // CheckRedirect指定用于处理重定向的策略。 如果CheckRedirect不为nil，则客户端将在执行 HTTP重定向之前调用它。
    // 参数req和via是即将到来的请求和已发出的请求，先到达的先发出。
    // 如果CheckRedirect返回错误，则客户端的Get方法将返回先前的Response（关闭该响应体）和CheckRedirect的错误（包装在url.Error中），而不是发出Request请求。
    // 作为一种特殊情况，如果CheckRedirect返回ErrUseLastResponse，则返回最近的响应，且其响应体未关闭，并返回nil错误。 
    // 如果CheckRedirect为nil，则客户端使用其默认策略，该策略将在连续10个请求后停止。
    CheckRedirect func(req *Request, via []*Request) error

    // Jar 指定cookie jar。Jar用于将相关cookie插入每个出站请求，并使用每个入站Response的cookie值进行更新。
    // 客户端遵循的每个重定向都会咨询Jar。 如果Jar为nil，则仅当在Request上显式设置cookie时，才发送cookie。
    Jar CookieJar

    // Timeout 指定此客户端发出的请求的时间限制。 超时包括连接时间，任何重定向和读取响应Body。
    // 在Get，Head，Post或Do返回之后，计时器保持运行状态，并且将中断Response.Body的读取。
    // Timeout为零表示没有超时。 客户端取消对基础传输的请求，就像请求的context结束一样。
    // 为了兼容性，如果找到，客户端还将在Transport上使用已经弃用的CancelRequest方法。
    // 新的RoundTripper实现应使用请求的context进行取消，而不是实现CancelRequest。
    Timeout time.Duration
}

func (c *Client) CloseIdleConnections()

func (c *Client) Do(req *Request) (*Response, error)

func (c *Client) Get(url string) (resp *Response, err error)

301 (Moved Permanently)
302 (Found)
303 (See Other)
307 (Temporary Redirect)
308 (Permanent Redirect)

func (c *Client) Head(url string) (resp *Response, err error)

301 (Moved Permanently)
302 (Found)
303 (See Other)
307 (Temporary Redirect)
308 (Permanent Redirect)

func (c *Client) Post(url, contentType string, body io.Reader) (resp *Response, err error)

func (c *Client) PostForm(url string, data url.Values) (resp *Response, err error)

type CloseNotifier interface {
    // 当客户端连接断开时，CloseNotify返回一个通道，该通道最多接收单个值（true）。
    // 在完全读取Request.Body之前，CloseNotify可能会等待通知。
    // handler返回后，不能保证该通道会收到一个值。
    // 如果协议是HTTP/1.1，并且在使用HTTP/1.1管道处理幂等请求（例如GET）时调用了CloseNotify，则后续管道请求的到来可能会导致在返回的通道上发送值。
    // 实际上，HTTP/1.1管道未在浏览器中启用，并且很不常见。 如果这是一个问题，请使用HTTP/2或仅对诸如POST之类的方法使用CloseNotify。
    CloseNotify() <-chan bool
}

type ConnState int

const (
    // StateNew表示一个新连接，该连接应立即发送请求。 连接从此状态开始，然后过渡到StateActive或StateClosed。
    StateNew ConnState = iota

    // StateActive表示已读取一个或多个请求字节的连接。 StateActive的Server.ConnState钩子在请求进入handler之前触发，直到请求被处理后才再次触发。
    // 处理请求后，状态将转换为StateClosed，StateHijacked或StateIdle。 对于HTTP / 2，StateActive在从零到一个活动请求的转换上触发，并且仅在所有活动请求完成后才转换。 
    // 这意味着ConnState不能用于执行每个请求的预处理工作； ConnState仅记录连接的整体状态。
    StateActive

    // StateIdle表示已完成处理请求并处于keep-alive状态的连接，正在等待新请求。 连接从StateIdle转换为StateActive或StateClosed。
    StateIdle

    // StateHijacked 表示被劫持的连接， 这是状态的终态，它不会过渡到StateClosed。
    StateHijacked

    // StateClosed表示已关闭的连接。 这是状态的终态， 被劫持的连接不会过渡到StateClosed。
    StateClosed
)

func (c ConnState) String() string

type Cookie struct {
    Name  string
    Value string

    Path       string    // optional
    Domain     string    // optional
    Expires    time.Time // optional
    RawExpires string    // for reading cookies only

    // MaxAge=0 means no 'Max-Age' attribute specified.
    // MaxAge<0 means delete cookie now, equivalently 'Max-Age: 0'
    // MaxAge>0 means Max-Age attribute present and given in seconds
    MaxAge   int
    Secure   bool
    HttpOnly bool
    SameSite SameSite
    Raw      string
    Unparsed []string // Raw text of unparsed attribute-value pairs
}

func (c *Cookie) String() string 

type CookieJar interface {
    // SetCookies在给定URL的回复中处理cookie的接收。
    // 它可能会或可能不会选择保存cookie，具体取决于jar的策略和实现。
    SetCookies(u *url.URL, cookies []*Cookie)

    // Cookies返回cookie，以发送对给定URL的请求。
    // 具体实现取决于标准的cookie使用限制，例如RFC 6265。
    Cookies(u *url.URL) []*Cookie
}

type Dir string

func (d Dir) Open(name string) (File, error)

type File interface {
    io.Closer
    io.Reader
    io.Seeker
    Readdir(count int) ([]os.FileInfo, error)
    Stat() (os.FileInfo, error)
}

type FileSystem interface {
    Open(name string) (File, error)
}

type Flusher interface {
    // Flush 刷新会将所有缓冲的数据发送到客户端。
    Flush()
}

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

func FileServer(root FileSystem) Handler

http.Handle("/", http.FileServer(http.Dir("/tmp")))

// 简单的静态Web服务器
log.Fatal(http.ListenAndServe(":8080", http.FileServer(http.Dir("/usr/share/doc"))))

package http_test

import (
    "log"
    "net/http"
    "os"
    "strings"
)

// containsDotFile报告name是否包含以句点开头的path元素。
// 假定name由正斜杠分隔，由http.FileSystem接口保证。
func containsDotFile(name string) bool {
    parts := strings.Split(name, "/")
    for _, part := range parts {
        if strings.HasPrefix(part, ".") {
            return true
        }
    }
    return false
}

// dotFileHidingFile是dotFileHidingFileSystem中的http.File使用。
// 它用于包装http.File的Readdir方法，以便我们可以从其输出中删除以句点开头的文件和目录。
type dotFileHidingFile struct {
    http.File
}

// Readdir是嵌入式File的Readdir方法的包装，可过滤掉名称中以句点开头的所有文件。
func (f dotFileHidingFile) Readdir(n int) (fis []os.FileInfo, err error) {
    files, err := f.File.Readdir(n)
    for _, file := range files { // 过滤点文件
        if !strings.HasPrefix(file.Name(), ".") {
            fis = append(fis, file)
        }
    }
    return
}

// dotFileHidingFileSystem是一个http.FileSystem，可隐藏隐藏的“点文件”，使其不再提供服务。
type dotFileHidingFileSystem struct {
    http.FileSystem
}

// Open是嵌入式FileSystem的Open方法的包装，
// 当name具有名称以其路径开头的文件或目录时，它将包装403权限错误。
func (fs dotFileHidingFileSystem) Open(name string) (http.File, error) {
    if containsDotFile(name) { // 如果是点文件, 返回 403
        return nil, os.ErrPermission
    }

    file, err := fs.FileSystem.Open(name)
    if err != nil {
        return nil, err
    }
    return dotFileHidingFile{file}, err
}

func ExampleFileServer_dotFileHiding() {
    fs := dotFileHidingFileSystem{http.Dir(".")}
    http.Handle("/", http.FileServer(fs))
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func NotFoundHandler() Handler

mux := http.NewServeMux()

// 创建示例handler以返回404
mux.Handle("/resources", http.NotFoundHandler())

// 创建示例handler以返回200
mux.Handle("/resources/people/", newPeopleHandler())

log.Fatal(http.ListenAndServe(":8080", mux))

func RedirectHandler(url string, code int) Handler

func StripPrefix(prefix string, h Handler) Handler

// 要在备用URL路径（/tmpfiles/）下为磁盘（/tmp）上的目录提供服务，请在FileServer看到之前使用StripPrefix修改请求URL的路径：
http.Handle("/tmpfiles/", http.StripPrefix("/tmpfiles/", http.FileServer(http.Dir("/tmp"))))

func TimeoutHandler(h Handler, dt time.Duration, msg string) Handler

type HandlerFunc func(ResponseWriter, *Request)

func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request)

type Header map[string][]string

func (h Header) Add(key, value string)

func (h Header) Clone() Header

func (h Header) Del(key string)

func (h Header) Get(key string) string

func (h Header) Set(key, value string)

func (h Header) Write(w io.Writer) error

func (h Header) WriteSubset(w io.Writer, exclude map[string]bool) error

type Hijacker interface {
    // Hijack使调用者可以接管连接。
    // 调用Hijack之后，HTTP服务器库将不会对该连接执行任何其他操作。

    // 管理和关闭连接成为调用者的责任。

    // 根据服务器的配置，返回的net.Conn可能已设置了读取或写入的期限。
    // 调用者有责任根据需要设置或清除这些截止时间。

    // 返回的bufio.Reader可能包含来自客户端的未处理的缓冲数据。

    // 调用Hijack之后，不得使用原始的Request.Body。
    // 原始请求的context仍然有效，并且直到该请求的ServeHTTP方法返回后才被取消。
    Hijack() (net.Conn, *bufio.ReadWriter, error)
}

http.HandleFunc("/hijack", func(w http.ResponseWriter, r *http.Request) {
    hj, ok := w.(http.Hijacker)
    if !ok {
        http.Error(w, "webserver doesn't support hijacking", http.StatusInternalServerError)
        return
    }
    conn, bufrw, err := hj.Hijack()
    if err != nil {
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    // 不要忘记关闭连接
    defer conn.Close()
    bufrw.WriteString("Now we're speaking raw TCP. Say hi: ")
    bufrw.Flush()
    s, err := bufrw.ReadString('\n')
    if err != nil {
        log.Printf("error reading string: %v", err)
        return
    }
    fmt.Fprintf(bufrw, "You said: %q\nBye.\n", s)
    bufrw.Flush()
})

type PushOptions struct {
    // Method为承诺的请求指定HTTP方法。
    // 如果设置，则必须为“ GET”或“ HEAD”。空表示“ GET”。
    Method string

    // Header指定其他承诺的请求Header。
    // 这不能包括HTTP/2伪Header字段，例如“:path”和“:scheme”，它们会自动添加。
    Header Header
}

type Pusher interface {
    // Push启动HTTP/2服务器来推送。 这将使用给定的目标和选项构造一个综合请求，
    // 将该请求序列化为PUSH_PROMISE帧，然后使用服务器的handler分派该请求。 
    // 如果opts为nil，则使用默认选项。

    // target必须是绝对路径（例如“ /path”）或包含有效host和与父请求相同的scheme的绝对URL。
    // 如果目标是路径，它将继承父请求的scheme和host。

    // HTTP/2规范不允许递归推送和交叉授权推送。
    // 推送可能会或可能不会检测到这些无效的推送； 但是，合格的客户端将检测并取消无效的推送。

    // 希望推送URL X的handler应在发送任何可能触发URL X请求的数据之前调用Push。
    // 这避免了客户端在收到X的PUSH_PROMISE之前发出X请求的竞争。

    // Push将在单独的goroutine中运行，从而使到达顺序不确定。 调用者需要实现任何所需的同步。

    // 如果客户端禁用了Push或底层连接不支持Push，则Push返回ErrNotSupported。
    Push(target string, opts *PushOptions) error
}

type Request struct {
    // Method指定HTTP方法（GET，POST，PUT等）。
    // 对于客户端请求，空字符串表示GET。

    // Go的HTTP客户端不支持使用CONNECT方法发送请求。 
    // 有关详细信息，请参见Transport文档。
    Method string

    // URL指定要请求的URI（对于服务端请求）或要访问的URL（对于客户端请求）。
    // 对于服务端请求，将从存储在RequestURI中的请求行上提供的URI解析URL。
    // 对于大多数请求，Path和RawQuery以外的其他字段将为空。 （请参阅RFC 7230，第5.3节）

    // 对于客户端请求，URL的host指定要连接的服务器，
    // 而请求的host字段则可选地指定要在HTTP请求中发送的hostHeader值。
    URL *url.URL

    // 传入服务器请求的协议版本。
    // 对于客户请求，将忽略这些字段。HTTP客户端代码始终使用HTTP/1.1或HTTP/2。
    // 有关详细信息，请参见Transport文档。
    Proto      string // "HTTP/1.0"
    ProtoMajor int    // 1
    ProtoMinor int    // 0

    // Header包含服务端接收或客户端发送的请求Header字段。

    // 如果服务端收到带有Header行的请求：
    // Host: example.com
    // accept-encoding: gzip, deflate
    // Accept-Language: en-us
    // fOO: Bar
    // foo: two

    //  Header = map[string][]string{
    //      "Accept-Encoding": {"gzip, deflate"},
    //      "Accept-Language": {"en-us"},
    //      "Foo": {"Bar", "two"},
    //  }

    // 对于传入的请求，Host Header被提升为Request.Host字段并从 Header映射中删除。

    // HTTP定义Header名称不区分大小写。 请求解析器通过使用CanonicalHeaderKey来实现此目的，
    // 使第一个字符以及连字符后的所有字符都变为大写，其余的都变为小写。

    // 对于客户端请求，某些header（例如Content-Length和Connection）会在需要时自动写入，
    // 并且Header中的值可能会被忽略。 请参阅文档中的Request.Write方法。
    Header Header

    // Body 是请求体。

    // 对于客户端请求，nil body表示该请求没有请求体，例如GET请求。
    // HTTP客户端的transport负责调用Close方法。

    // 对于服务端请求，请求体始终为non-nil，但在不存在请求体时将立即返回EOF。
    // 服务端将关闭请求体。 ServeHTTP handler不需要这么做。
    Body io.ReadCloser

    // GetBody定义了一个可选的func来返回Body的新副本。
    // 它用于当客户端请求重定向需要多次读取Body时。使用GetBody仍然需要设置Body。 

    // 对于服务端请求，它是不使用的。

    GetBody func() (io.ReadCloser, error)


    // ContentLength记录关联内容的长度。
    // 值-1表示长度未知。
    // 值>=0表示可以从请求体读取给定的字节数。
    // 对于客户请求，non-nil Body 的值为0也会被认为是未知。
    ContentLength int64

    // TransferEncoding列出从最外层到最内层的传输编码。
    // 空列表表示“identity”编码。 通常可以忽略TransferEncoding。
    // 发送和接收请求时，将根据需要自动添加和删除分块编码。
    TransferEncoding []string

    // Close 指示是在回复此请求后（对于服务器）还是在发送此请求并读取其响应（对于客户端）之后关闭连接。

    //  对于服务端请求，HTTP服务器会自动处理此请求，并且处理程序不需要此字段。
    // 对于客户端请求，设置此字段可防止在相同主机的请求之间重复使用TCP连接，
    // 就像设置了Transport.DisableKeepAlives一样。
    Close bool

    // 对于服务器请求，Host指定在其上搜索URL的host。
    //  根据RFC 7230，第5.4节，这是“host”Header的值或URL本身中提供的主机名。
    // 它的形式可能是“ host:port”。 对于国际域名，Host可以采用Punycode或Unicode形式。
    // 如果需要，请使用golang.org/x/net/idna将其转换为两种格式。

    // 为了防止DNS重新绑定攻击，服务器handler应验证主机Header是否具有其认为自己具有权威性的值。
    // 随附的ServeMux支持注册到特定host名的模式，从而保护其注册的handler。
    // 对于客户端请求，host可以选择覆盖要发送的主机头。 如果为空，则Request.Write方法使用URL.Host的值。 
    // 主机可能包含国际域名。
    Host string

    // 表单包含已解析的表单数据，包括URL字段的查询参数和PATCH，POST或PUT表单数据。
    // 该字段仅在调用ParseForm之后可用。 HTTP客户端会忽略Form，而使用Body。
    Form url.Values

    // PostForm包含从PATCH，POST或PUT Body参数解析的表单数据。
    // 该字段仅在调用ParseForm之后可用。 HTTP客户端会忽略PostForm并改用Body。
    PostForm url.Values

    // MultipartForm是已解析的多部分表单，包括文件上传。
    // 仅在调用ParseMultipartForm之后，此字段才可用。 HTTP客户端会忽略MultipartForm并改用Body。
    MultipartForm *multipart.Form

    // Trailer指定在请求体之后发送的其他Header。
    // 对于服务器请求，Trailer map 最初仅包含 Trailer 键，其值为nil。
    // （客户端声明它将稍后发送的Trailer。）handler从Body读取时，它不得引用 Trailer。
    // 从Body读取返回EOF后，Trailer可以再次读取，并且包含非null值（如果它们是由客户端发送的）。
    //  对于客户端请求，必须将Trailer初始化为包含Trailer key 的 map，以便以后发送。
    // 这些值可以为nil或它们的最终值。 ContentLength必须为0或-1，才能发送分块的请求。
    // 发送HTTP请求后，可以在读取请求体的同时更新map值。 一旦Body返回EOF，调用方就不得使Trailer发生改变。 
    // 很少有HTTP客户端，服务器或代理支持HTTP Trailer。
    Trailer Header

    // RemoteAddr允许HTTP服务器和其他软件记录发送请求的网络地址，通常用于日志记录。
    // ReadRequest不会填写此字段，并且没有定义的格式。
    // 在调用handler之前，此程序包中的HTTP服务器将RemoteAddr设置为“ IP:Port”地址。 HTTP客户端将忽略此字段。
    RemoteAddr string

    // RequestURI是客户端发送到服务器的请求行（RFC 7230，第3.1.1节）的未经修改的请求目标。
    // 通常应改用URL字段。 在HTTP客户端请求中设置此字段是错误的。
    RequestURI string

    // TLS允许HTTP服务器和其他软件记录有关在其上接收到请求的TLS连接的信息。ReadRequest不会填写此字段。
    // 此程序包中的HTTP服务器在调用handler之前为启用TLS的连接设置字段。
    // 否则，该字段将为零。 HTTP客户端会忽略此字段。
    TLS *tls.ConnectionState

    // Cancel是一个可选通道，当它关闭则表示客户端的请求应被视为已取消。 
    // 并非RoundTripper的所有实现都支持取消。
    // 对于服务器请求，此字段不适用。
    // 弃用：而是使用NewRequestWithContext设置请求的context。
    // 如果同时设置了请求的“cancel”字段和context，则不确定是否遵守“cancel”。
    Cancel <-chan struct{}

    // Response是导致创建此请求的重定向响应。仅在客户端重定向期间填充此字段。
    Response *Response
}

func NewRequest(method, url string, body io.Reader) (*Request, error)

func NewRequestWithContext(ctx context.Context, method, url string, body io.Reader) (*Request, error)

func ReadRequest(b *bufio.Reader) (*Request, error)

func (r *Request) AddCookie(c *Cookie)

func (r *Request) BasicAuth() (username, password string, ok bool)

func (r *Request) Clone(ctx context.Context) *Request

func (r *Request) Context() context.Context

func (r *Request) Cookie(name string) (*Cookie, error)

func (r *Request) Cookies() []*Cookie

func (r *Request) FormFile(key string) (multipart.File, *multipart.FileHeader, error)

func (r *Request) FormValue(key string) string

func (r *Request) MultipartReader() (*multipart.Reader, error)

func (r *Request) ParseForm() error

func (r *Request) ParseMultipartForm(maxMemory int64) error

func (r *Request) PostFormValue(key string) string

func (r *Request) ProtoAtLeast(major, minor int) bool

func (r *Request) Referer() string

func (r *Request) SetBasicAuth(username, password string)

func (r *Request) UserAgent() string

func (r *Request) WithContext(ctx context.Context) *Request

func (r *Request) Write(w io.Writer) error

Host
URL
Method (defaults to "GET")
Header
ContentLength
TransferEncoding
Body

func (r *Request) WriteProxy(w io.Writer) error

type Response struct {
    Status     string // e.g. "200 OK"
    StatusCode int    // e.g. 200
    Proto      string // e.g. "HTTP/1.0"
    ProtoMajor int    // e.g. 1
    ProtoMinor int    // e.g. 0

    // Header将header key映射到value。
    // 如果响应中的多个header具有相同的键，则可以使用逗号分隔符将它们连接在一起。
    // （RFC 7230第3.2.2节要求，多个header在语义上等效于逗号分隔的序列。）
    // 当header值被该结构中的其他字段（例如ContentLength，TransferEncoding，Trailer）复制时，
    // 这些字段值是权威的。

    // map中的key已规范化（请参见CanonicalHeaderKey）。
    Header Header

    // Body代表响应体。

    // 在读取“body”字段时，将按需流式传输响应体。 如果网络连接失败或服务器终止响应，则Body.Read调用将返回错误。

    // http 的Client 和Transport 保证即使在没有响应体的响应或长度为零的响应中，响应体也始终为非零。
    // 关闭响应体是调用者的责任。 如果未读取并关闭响应体，则默认的HTTP客户端的传输可能不会重用HTTP/1.x“keep-alive” TCP连接。

    // 如果服务器回复了“分块”传输编码，则响应体将自动分块。

    // 从Go 1.12开始，Body还将在成功的“101交换协议”响应上实现io.Writer，
    // 该响应由WebSocket和HTTP/2的“h2c”模式使用。
    Body io.ReadCloser

    // ContentLength记录关联内容的长度。 值-1表示长度未知。
    // 除非Request.Method为“HEAD”，否则值>=0表示可以从Body中读取给定的字节数。
    ContentLength int64

    // 包含从最外部到最内部的传输编码。 值为nil，表示使用“identity”编码，即不进行编码。
    TransferEncoding []string

    // Close记录在读取响应体后，header是否指示关闭连接。 该值是给客户的建议：ReadResponse和Response.Write都不会关闭连接。
    Close bool

    // Uncompressed报告响应是否已压缩发送，并已被http包解压缩。
    // 如果为true，则从Body读取将产生未压缩的内容，而不是从服务器实际设置的压缩内容，
    // ContentLength设置为-1，并且从responseHeader中删除“Content-Length”和“Content-Encoding”字段。
    // 要从服务器获取原始响应，请将Transport.DisableCompression设置为true。
    Uncompressed bool

    // Trailer将trailer键映射到与header相同格式的值。
    // Trailer最初仅包含nil值，服务器“Trailer”header值中指定的每个键对应一个值。这些值不会添加到Header中。
    // 不得在响应体上与Read调用同时访问Trailer。 在Body.Read返回io.EOF之后，Trailer将包含服务器发送的所有trailer值。
    Trailer Header
    // Request是为获取此响应而发送的请求。 请求体为零（已被消耗）。 仅针对客户端请求填充。
    Request *Request

    // TLS包含有关在其上接收到响应的TLS连接的信息。 对于未加密的响应，它为nil。
    // 指针在响应之间共享，不应修改。
    TLS *tls.ConnectionState
}

func Get(url string) (resp *Response, err error)

301 (Moved Permanently)
302 (Found)
303 (See Other)
307 (Temporary Redirect)
308 (Permanent Redirect)

res, err := http.Get("http://www.google.com/robots.txt")
if err != nil {
    log.Fatal(err)
}
robots, err := ioutil.ReadAll(res.Body)
res.Body.Close()
if err != nil {
    log.Fatal(err)
}
fmt.Printf("%s", robots)

func Head(url string) (resp *Response, err error)

301 (Moved Permanently)
302 (Found)
303 (See Other)
307 (Temporary Redirect)
308 (Permanent Redirect)

func Post(url, contentType string, body io.Reader) (resp *Response, err error)

func PostForm(url string, data url.Values) (resp *Response, err error)

func ReadResponse(r *bufio.Reader, req *Request) (*Response, error)

func (r *Response) Cookies() []*Cookie

func (r *Response) Location() (*url.URL, error)

func (r *Response) ProtoAtLeast(major, minor int) bool

func (r *Response) Write(w io.Writer) error

StatusCode
ProtoMajor
ProtoMinor
Request.Method
TransferEncoding
Trailer
Body
ContentLength
Header, values for non-canonical keys will have unpredictable behavior

type ResponseWriter interface {
    // Header返回将由WriteHeader发送的header map。header map也是handler可以用来设置HTTP trailer的机制。

    // 除非修改后的header是trailer，否则在调用WriteHeader（或Write）后更改header map无效。

    // 设置trailer有两种方法。 首选方法是在header中预先声明稍后将发送的trailer，
    // 方法是将“Trailer”header设置为稍后将出现的键的名称。
    // 在这种情况下，Header映射的那些键被视为trailer。参见示例。
    // 第二种方法是，对于直到第一次处理之后才被handler所知的trailer键，
    // 在Header映射键之前加上TrailerPrefix常量值。 请参阅TrailerPrefix。

    // 要取消自动响应header（例如“Date”），请设置它们的值为nil。
    Header() Header

    // Write将数据作为HTTP回复的一部分写入连接。

    // 如果尚未调用WriteHeader，则Write在写入数据之前会调用WriteHeader（http.StatusOK）。
    // 如果header不包含Content-Type行，则Write将Content-Type集添加到将初始512字节的写入数据传递到DetectContentType的结果中。
    // 此外，如果所有写入数据的总大小小于几KB，并且没有Flush调用，则会自动添加Content-Length header。
    // 根据HTTP协议版本和客户端，调用Write或WriteHeader可能会阻止将来对Request.Body进行读取。
    // 对于HTTP/1.x请求，handler应在写入响应之前读取所有需要的请求体数据。
    // 刷新header后（由于显式的Flusher.Flush调用或写入足够的数据以触发刷新），请求体可能不可用。
    // 对于HTTP/2请求，Go HTTP服务器允许handler在同时写入响应的同时继续读取请求体。
    // 但是，并非所有的HTTP/2客户端都支持这种行为。
    // 如果可能，handler应在写入之前先进行读取，以最大程度地实现兼容性。
    Write([]byte) (int, error)

    // WriteHeader发送带有提供的状态代码的HTTP响应头。 如果未显式调用WriteHeader，则对Write的第一次调用将触发一个隐式WriteHeader（http.StatusOK）。
    // 因此，对WriteHeader的显式调用主要用于发送错误代码。 提供的代码必须是有效的HTTP 1xx-5xx状态代码。 只能写入一个header。
    // Go当前不支持发送用户定义的1xx信息性header，但服务器会在读取Request.Body时自动发送的100-xx响应头，但不支持发送该header。
    WriteHeader(statusCode int)
}

mux := http.NewServeMux()
mux.HandleFunc("/sendstrailers", func(w http.ResponseWriter, req *http.Request) {
    // 在对WriteHeader或Write的任何调用之前，声明将在HTTP响应期间设置的Trailer。
    // 这三个header实际上是在Trailer中发送的。
    w.Header().Set("Trailer", "AtEnd1, AtEnd2")
    w.Header().Add("Trailer", "AtEnd3")

    w.Header().Set("Content-Type", "text/plain; charset=utf-8") // normal header
    w.WriteHeader(http.StatusOK)

    w.Header().Set("AtEnd1", "value 1")
    io.WriteString(w, "This HTTP response has both headers before this text and trailers at the end.\n")
    w.Header().Set("AtEnd2", "value 2")
    w.Header().Set("AtEnd3", "value 3") // These will appear as trailers.
})

type RoundTripper interface {
    // RoundTrip执行一个HTTP事务，为提供的请求返回响应。

    // RoundTrip不应尝试解释响应。
    // 特别是，如果RoundTrip获得响应，则必须返回err == nil，
    // 而不管响应的HTTP状态代码如何。如果失败，则应保留非null错误。
    // 同样，RoundTrip不应尝试处理更高级别的协议详细信息，例如重定向，身份验证或cookie。

    // 除了消费和关闭请求体之外，RoundTrip不应修改请求。 RoundTrip可以在单独的goroutine中读取请求的字段。
    // 在响应体关闭之前，调用者不应更改或重用请求。

    // RoundTrip必须要关闭响应体，包括发生错误时，但根据实现的不同，
    // 即使在RoundTrip返回之后，也可能在单独的goroutine中关闭它。
    // 这意味着希望重用响应体以用于后续请求的调用者必须安排在等待Close调用之后再这样做。

    // 请求的URL和Header字段必须初始化。
    RoundTrip(*Request) (*Response, error)
}

var DefaultTransport RoundTripper = &Transport{
    Proxy: ProxyFromEnvironment,
    DialContext: (&net.Dialer{
        Timeout:   30 * time.Second,
        KeepAlive: 30 * time.Second,
        DualStack: true,
    }).DialContext,
    ForceAttemptHTTP2:     true,
    MaxIdleConns:          100,
    IdleConnTimeout:       90 * time.Second,
    TLSHandshakeTimeout:   10 * time.Second,
    ExpectContinueTimeout: 1 * time.Second,
}

func NewFileTransport(fs FileSystem) RoundTripper

t := &http.Transport{}
t.RegisterProtocol("file", http.NewFileTransport(http.Dir("/")))
c := &http.Client{Transport: t}
res, err := c.Get("file:///etc/passwd")
...

type SameSite int

const (
    SameSiteDefaultMode SameSite = iota + 1
    SameSiteLaxMode
    SameSiteStrictMode
    SameSiteNoneMode
)

type ServeMux struct {
    mu    sync.RWMutex
    m     map[string]muxEntry
    es    []muxEntry // slice of entries sorted from longest to shortest.
    hosts bool       // whether any patterns contain hostnames
}

func NewServeMux() *ServeMux

func (mux *ServeMux) Handle(pattern string, handler Handler)

mux := http.NewServeMux()
mux.Handle("/api/", apiHandler{})
mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
    // “/”模式匹配所有内容，因此我们需要检查我们是否在root这里。
    if req.URL.Path != "/" {
        http.NotFound(w, req)
        return
    }
    fmt.Fprintf(w, "Welcome to the home page!")
})

func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request))

func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string)

func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request)

type Server struct {
    Addr    string  // 监听的TCP地址 , 如果为空，则为":http"
    Handler Handler // 要调用的处理程序，如果为空则为 http.DefaultServeMux

    // TLSConfig可选地提供TLS配置，以供ServeTLS和ListenAndServeTLS使用。
    // 请注意，此值由ServeTLS和ListenAndServeTLS克隆，
    // 因此无法使用tls.Config.SetSessionTicketKeys之类的方法修改配置。
    // 若要使用SetSessionTicketKeys，请改为将Server.Serve与TLS侦听器一起使用。
    TLSConfig *tls.Config

    // ReadTimeout是读取整个请求（包括请求体）的最大持续时间。
    // 由于ReadTimeout不允许处理程序根据每个请求体的可接受截止日期或上载速率做出每个请求的决定，
    // 因此大多数用户将更喜欢使用ReadHeaderTimeout。 两者都使用也是有效的。
    ReadTimeout time.Duration

    // ReadHeaderTimeout是允许读取请求头的时间量。
    // 读取请求体后，将重置连接的读取截止时间，并且Handler可以确定对Body而言太慢的速度。
    // 如果ReadHeaderTimeout为零，则使用ReadTimeout的值。 如果两者均为零，则没有超时。
    ReadHeaderTimeout time.Duration

    // WriteTimeout是写入响应超时之前的最大持续时间。
    // 每当读取新请求头时，都会将其重置。
    // 与ReadTimeout一样，它也不允许处理程序根据每个请求做出决策。
    WriteTimeout time.Duration

    // IdleTimeout是启用保持活动状态后等待下一个请求的最长时间。
    // 如果IdleTimeout为零，则使用ReadTimeout的值。 如果两者均为零，则没有超时。
    IdleTimeout time.Duration

    // MaxHeaderBytes控制服务器读取的最大字节数，以解析请求头的键和值（包括请求行）。
    // 它不限制请求体的大小。 如果为零，则使用DefaultMaxHeaderBytes。
    MaxHeaderBytes int

    // TLSNextProto可以选择指定一个函数，以在进行NPN/ALPN协议升级时接管所提供的TLS连接的所有权。
    // map的key是协商的协议名称。 Handler参数应用于处理HTTP请求，
    // 并将初始化请求的TLS和RemoteAddr（如果尚未设置）。 函数返回时，连接将自动关闭。
    // 如果TLSNextProto不为nil，则不会自动启用HTTP/2支持。
    TLSNextProto map[string]func(*Server, *tls.Conn, Handler)

    // ConnState指定一个可选的回调函数，当客户端连接更改状态时调用该函数。
    // 有关详细信息，请参见ConnState类型和关联的常量。
    ConnState func(net.Conn, ConnState)

    // ErrorLog指定一个可选的记录器，用于接收连接的错误，
    // 来自处理程序的意外行为以及潜在的FileSystem错误。
    // 如果为nil，则通过日志包的标准记录器完成记录。
    ErrorLog *log.Logger


    // BaseContext可以选择指定一个函数，该函数返回此服务器上传入请求的基本context。
    // 提供的侦听器是即将开始接收请求的特定侦听器。
    // 如果BaseContext为nil，则默认值为context.Background()。 如果为非nil，则它必须返回非nil Context。
    BaseContext func(net.Listener) context.Context

    // ConnContext可选地指定一个函数，该函数修改用于新连接的上下文c。
    // 提供的ctx派生自基本上下文，并且具有ServerContextKey值。
    ConnContext func(ctx context.Context, c net.Conn) context.Context

    disableKeepAlives int32     // accessed atomically.
    inShutdown        int32     // accessed atomically (non-zero means we're in Shutdown)
    nextProtoOnce     sync.Once // guards setupHTTP2_* init
    nextProtoErr      error     // result of http2.ConfigureServer if used

    mu         sync.Mutex
    listeners  map[*net.Listener]struct{}
    activeConn map[*conn]struct{}
    doneChan   chan struct{}
    onShutdown []func()
}

func (srv *Server) Close() error

func (srv *Server) ListenAndServe() error

func (srv *Server) ListenAndServeTLS(certFile, keyFile string) error

func (srv *Server) RegisterOnShutdown(f func())

func (srv *Server) Serve(l net.Listener) error

func (srv *Server) ServeTLS(l net.Listener, certFile, keyFile string) error

func (srv *Server) SetKeepAlivesEnabled(v bool)

func (srv *Server) Shutdown(ctx context.Context) error

var srv http.Server

idleConnsClosed := make(chan struct{})
go func() {
    sigint := make(chan os.Signal, 1)
    signal.Notify(sigint, os.Interrupt)
    <-sigint

    // We received an interrupt signal, shut down.
    if err := srv.Shutdown(context.Background()); err != nil {
        // Error from closing listeners, or context timeout:
        log.Printf("HTTP server Shutdown: %v", err)
    }
    close(idleConnsClosed)
}()

if err := srv.ListenAndServe(); err != http.ErrServerClosed {
    // Error starting or closing listener:
    log.Fatalf("HTTP server ListenAndServe: %v", err)
}

<-idleConnsClosed

type Transport struct {
    // Proxy指定一个函数来返回给定请求的代理。
    // 如果函数返回非零错误，则请求将中止并提供所提供的错误。
    // Proxy类型由URL scheme确定。 支持“http”，“ https”和“socks5”。
    //  如果scheme为空，则假定为“http”。 如果Proxy为nil或返回nil *URL，则不使用任何代理。
    Proxy func(*Request) (*url.URL, error)

    // DialContext指定用于创建未加密的TCP连接的拨号功能。
    // 如果DialContext为nil（并且下面弃用的Dial也为nil），则Transport使用程序包net进行调用。
    // DialContext与RoundTrip的调用同时运行。 当较早的连接在以后的DialContext完成之前变为空闲时，
    // 发起调用的RoundTrip调用可能会使用先前调用的连接结束。
    DialContext func(ctx context.Context, network, addr string) (net.Conn, error)

    // Dial指定用于创建未加密的TCP连接的拨号功能。 Dial与RoundTrip的调用同时运行。
    // 当较早的连接在之后的Dial完成之前变为空闲时，发起Dial的RoundTrip调用可能会使用先前调动的连接结束。
    // 弃用：改用DialContext，它允许Transport在不再需要调用时立即取消Dial。 
    // 如果两者都设置，则DialContext优先。
    Dial func(network, addr string) (net.Conn, error)

    // DialTLS指定用于为非代理HTTPS请求创建TLS连接的可选Dial功能。
    // 如果DialTLS为nil，则使用Dial和TLSClientConfig。
    // 如果设置了DialTLS，则Dial挂钩不用于HTTPS请求，并且TLSClientConfig和TLSHandshakeTimeout将被忽略。
    // 假定返回的net.Conn已通过TLS握手。
    DialTLS func(network, addr string) (net.Conn, error)

    // TLSClientConfig指定要与tls.Client一起使用的TLS配置。
    // 如果为nil，则使用默认配置。 如果为非nil，则默认情况下可能不会启用HTTP/2支持。
    TLSClientConfig *tls.Config

    // TLSHandshakeTimeout指定等待TLS握手的最长时间。 零表示没有超时。
    TLSHandshakeTimeout time.Duration

    // DisableKeepAlives（如果为true）将禁用HTTP keep-alives，并且仅将与服务器的连接用于单个HTTP请求。
    // 这与类似命名的TCP keep-alives。
    DisableKeepAlives bool

    // DisableCompression如果为true，则当请求不包含现有的Accept-Encoding值时，
    // 阻止Transport使用“Accept-Encoding:gzip”请求Header请求压缩。
    // 如果Transport请求gzip并获得gzip压缩的响应，则会在Response.Body中对其进行透明解码。
    // 但是，如果用户明确请求gzip，则不会自动将其解压缩。
    DisableCompression bool

    // MaxIdleConns控制所有主机之间的最大空闲（keep-alive）连接数。 零表示无限制。
    MaxIdleConns int

    // MaxIdleConnsPerHost（如果非零）控制最大空闲（keep-alive）连接以保留每个主机。
    // 如果为零，则使用DefaultMaxIdleConnsPerHost。
    MaxIdleConnsPerHost int

    // MaxConnsPerHost可以选择限制每个主机的连接总数，
    // 包括处于拨号，活动和空闲状态的连接。 超出限制时，拨号将阻塞。 零表示无限制。
    MaxConnsPerHost int

    // IdleConnTimeout是空闲（keep-alive）连接在关闭自身之前将保持空闲状态的最长时间。
    // 零表示无限制。
    IdleConnTimeout time.Duration

    // ResponseHeaderTimeout（如果非零）指定在完全写入请求（包括其Body（如果有））
    // 之后等待服务器的响应头的时间。 该时间不包括读取响应体的时间。
    ResponseHeaderTimeout time.Duration

    // ExpectContinueTimeout（如果非零）指定如果请求具有“Expect: 100-continue”header，
    // 则在完全写入请求头之后等待服务器的第一个响应头的时间。
    // 零表示没有超时，并导致请求体立即发送，而无需等待服务器批准。 此时间不包括发送请求头的时间。
    ExpectContinueTimeout time.Duration

    // TLSNextProto指定在TLS NPN/ALPN协议协商之后，Transport如何切换到备用协议（例如HTTP/2）。
    // 如果Transport使用非空协议名称调用TLS连接，并且TLSNextProto包含该键的映射条目（例如“ h2”），
    // 则将以请求的权限（例如“example.com”或“example .com:1234“）和TLS连接。
    // 该函数必须返回RoundTripper，然后再处理请求。 如果TLSNextProto不为nil，则不会自动启用HTTP/2支持。
    TLSNextProto map[string]func(authority string, c *tls.Conn) RoundTripper

    // ProxyConnectHeader可以选择指定在CONNECT请求期间发送给代理的header。
    ProxyConnectHeader Header

    // MaxResponseHeaderBytes指定对服务器的响应头中允许的响应字节数的限制。 零表示使用默认限制。
    MaxResponseHeaderBytes int64

    // WriteBufferSize指定在写入Transport时使用的写入缓冲区的大小。 如果为零，则使用默认值（当前为4KB）。
    WriteBufferSize int

    // ReadBufferSize指定从Transport读取时使用的读取缓冲区的大小。 如果为零，则使用默认值（当前为4KB）。
    ReadBufferSize int

    // 当提供非零Dial，DialTLS或DialContext函数或TLSClientConfig时，ForceAttemptHTTP2控制是否启用HTTP/2。
    // 默认情况下，保守地使用这些字段会禁用HTTP/2。要使用自定义Dial程序或TLS配置并仍尝试HTTP/2升级，
    // 请将其设置为true。
    ForceAttemptHTTP2 bool

    idleMu       sync.Mutex
    closeIdle    bool                                // user has requested to close all idle conns
    idleConn     map[connectMethodKey][]*persistConn // most recently used at end
    idleConnWait map[connectMethodKey]wantConnQueue  // waiting getConns
    idleLRU      connLRU

    reqMu       sync.Mutex
    reqCanceler map[*Request]func(error)

    altMu    sync.Mutex   // guards changing altProto only
    altProto atomic.Value // of nil or map[string]RoundTripper, key is URI scheme

    connsPerHostMu   sync.Mutex
    connsPerHost     map[connectMethodKey]int
    connsPerHostWait map[connectMethodKey]wantConnQueue // waiting getConns

}

func (t *Transport) Clone() *Transport

func (t *Transport) CloseIdleConnections()

func (t *Transport) RegisterProtocol(scheme string, rt RoundTripper)

func (t *Transport) RoundTrip(req *Request) (*Response, error)