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)
// ...

为了控制HTTP客户头部,重定向策略,和其他设置,创建一个客户:

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)

为了控制代理,TLS配置,keep-alives,压缩,其他设置,创建一个Transport

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

Clients和Transports都是goruoutine并发安全的,为了高效应该只创建一次和重复利用 ListenAndServe开始一个HTTP服务器通过给定的地址和处理器,处理器通常是nil,意味着使用DefaultServeMux，Handle和HandleFunc添加处理器到DefaultServeMux.

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())

从Go 1.6开始,包http透明的支持HTTP/2协议,当使用HTTPS. 程序必须禁用HTTP/2通过设置Transport.TLSNextProto(对于客户)或Server.TLSNextProto(对于服务器)到non-nil,一个空map,或者,如下的GODEBUG环境变量目前被支持.

GODEBUG=http2client=0 # disable HTTP/2 client support
GODEBUG=http2server=0 # disable HTTP/2 server support
GODEBUG=http2debug=1 # enable verbose HTTP/2 debug logs
GODEBUG=http2debug=2 # even more verbose, with frame dumps

GODEBUG环境变量不被Go API兼容性覆盖,请先调查问题在禁用HTTP/2之前. 包http的Transport和Server都自动启用HTTP/2支持为了简单的配置,为了启用HTTP/2更复杂的配置去使用更低层的特征,或者使用Go更新版本的包http2,直接导入”golang.org/x/net/http2”,使用其ConfigureTransport和或ConfigureServer函数,手动的配置”golang.org/x/net/http2”包优先于net/http内建的HTTP/2支持

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

公有的HTTP方法. 除非另外注释,否则这些被定义于RFC 7231，4.3节

const (
    StatusContinue = 100 // RFC 7231, 6.2.1
    StatusSwitchingProtocols = 101 // RFC 7321, 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
    StatusNoAuthoritativeInfo = 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
    StatusMovePermanently = 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
    StatusProxyAutRequired = 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
)

向IANA注册HTTP状态码.

const DefaultMaxHeaderBytes = 1 << 20 // 1MB

DefaultMaxHeaderBytes是http请求头部最大的合法的大小,这个可以通过Server.MaxHeaderBytes重新设置.

const DefaultMaxIdleConnsPerHost = 2

DefaultMaxIdleConnsPerHost是Transport.MaxIdleConnsPerHost的默认值

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

TimeFormat是时间格式用于当在HTTP头部产生，它和RFC1113很像,但是这里使用GMT作为时区.时间被格式化必须使用UTC格式生成正确的格式. 为了解析时间格式,查看ParseTime.

const TrailerPrefix = "Trailer: "

TrailerPrefix是一个幻数前缀,对于ResponseWriter.Header映射键值,如果存在,表明映射入口实际上为了响应追踪,而不是响应的头部,前缀被剔除在ServeHTTP调用完成，且值被发送给追踪器. 此机制只适用于在写入标头之前未知的预告,如果追踪点集合固定或者熟知在头部写入之前,首选GO的锚点机制:

https://golang,org/pkg/net/http/#ResponseWriter
https://golang.org/pkg/net/http/#example_ResponseWriter_trailers

var (
    // ErrNotSupported是由推送者的Push方法返回的,实现表明
    // HTTP/2的Push支持不被提供
    ErrNotSupported = &ProtocolError{"feature not supported"}
    // 已废弃:包net/http任何操作都不会返回
    // ErrUnexpectedTrailer，不应该再把返回的错误和其比较
    ErrUnexpectedTrailer = &ProtocolError{"trailer 
    header without chunked transfer encoding"}
    // ErrMissingBoundary是由Request.MultipartReader
    // 返回当请求的Content-Type不包含"boundary"参数
    ErrMissingBoundary = &ProtocolError{"no 
    multipart boundary param in Content-Type"}
    // ErrNoMultipart是由Request.MultipartReader
    // 返回当请求的Content-Type不是multipart/form-data
    ErrNoMultipart = &ProtocolError{"request 
    Content-Type isn't multipart/form-data"}
    // 已废弃:ErrHeaderTooLong不再由net/http包中任何操作
    // 返回,所以不应该再把返回的错误与其比较
    ErrHeaderTooLong = &ProtocolError{"header too 
    long"}
    // 已废弃: ErrShortBody不再由net/http包中任何操作
    // 返回,所以不应该再把返回的错误与其比较
    ErrShortBody = &ProtocolError{"entity body too 
    short"}
    // 已废弃: ErrMissingContentLength不再由net/http包
    // 中任何操作返回，所以不应该再把返回的错误与其比较
    ErrMissingContentLength = &ProtocolError
    {"missing ContentLength in HEAD response"}
)

var (
    // ErrBodyNotAllowed是由ResponseWriter.Write返回
    // 当HTTP方法或者响应码不允许一个body
    ErrBodyNotAllowed = errors.New("http: request 
    method or response status code does not allow body")
    // ErrHijacked是由ResponseWriter.Write返回
    // 当底层的连接已经被劫持使用Hijacker接口,未写入的连接将
    // 会没有副作用的返回ErrHijacked
    ErrHijacked = errors.New("http: connection has 
    been hijacked")
    // ErrContentLength是由ResponseWriter调用返回
    // 当一个处理器设置Content-Length响应头部通过一个
    // 声明的大小而企图写入超过声明的大小
    ErrContentLength = errors.New("http: wrote more 
    than the declared Content-Length")
    // 已废弃:ErrWriteAfterFlush已不再由net/http任何方法
    // 返回，调用者不应该再比较错误变量
    ErrWriteAfterFlush = errors.New("unused")
)

Errors使用通过HTTP Server

var (
    // ServerContextKey是一个context key,它能够被
    // Context.Value使用访问服务器由开始的处理器.
    // 相关联的值类型属于*Server
    ServerContextKey = &contextKey{"http-server"}
    // LocalAddrContextKey是一个context key,它能够
    // 被Context.Value使用访问本地地址访问的连接
    // 相关联的值类型属于*net.Addr
    LocalAddrContextKey = &contextKey{"local-addr"}
)

var DefaultClient = &Client{}

DefaultClient是一个默认的客户,被用于Get,Head,Post.

var DefaultServeMux = &defaultServerMux

DefaultServeMux是由Serve使用的默认的ServeMux

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

ErrAbortHandler是一个哨兵值为了中止一个处理器,当任何panic从ServeHTTP中止到客户端的响应,ErrAbortHandler的panic还会记录栈的跟踪到服务器的错误日志.

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

ErrBodyReadAfterClose在读取request或者response的Body部分在主体已经关闭.这典型的发生读取主体在一个HTTP处理器在ResponseWriter上调用WriteHeader或Write.

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

ErrHandlerTimeout是由ResponseWriter的Write调用超时返回

var ErrLineTooLong = internal.ErrLineTooLong

ErrLineTooLong是由读取请求或响应主体的异常编码返回.

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

ErrMissingFile是由FormFile返回当提供的文件字段在请求中不存在或者不是一个文件字段

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

ErrNoLocation是由Response.Location返回当Location头部不存在

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

ErrServeClosed是由Server的Serve,ServeTLS,ListenAndServe,ListenAndServeTLS在调用Shutdown或Close之后调用返回

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

ErrSkipAltProtocol是一个哨兵错误值通过Transport.RegisterProtocol定义

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

ErrUseLastResponse能够被返回通过Client.CheckRedirect用于控制重定向是如何被处理的,如果被返回,下次请求将不会被发送且最近的响应将会返回和它的未关闭的主体.

var NoBody = noBody{}

NoBody是一个io.ReadCloser且没有字节,Read总是返回EOF,Close总是返回nil,它能够被用于外部客户请求为了明确地表明请求零字节,另一种方法是将Request.Body设为nil

type Request struct {
    // Method指定HTTP的方法(GET, POST, PUT, ..etc)
    // 对于客户端请求,客户端请求意味着GET
    //
    // Go的HTTP客户端不支持CONNECT方法,查看Transport文档
    // 更多细节
    Method string
    // URL指定被请求的URI(对于服务器的请求)或者访问的URL
    // (对于客户端的请求)
    //
    // 对于服务端请求,URI从URL解析在Request-Line提供,
    // 储存在RequestURI,对于大多数请求,Path和RawQuery其他
    // 以外字段将为空(See RFC 7230, Section 5.3)
    //
    // 对于客户端请求，URL的Host指定要连接的服务器,而
    // Request的Host字段可选的要发送的Host头部值
    // 在HTTP请求中
    URL *url.URL
    // 协议版本对于服务器进入的请求
    //
    // 对于客户的请求,这些字段将被忽视,HTTP客户码总是
    // 使用HTTP/1.1或者HTTP/2
    // 查看Transport文档更多细节
    Proto string // "HTTP/1.0"
    ProtoMajor int // 1
    ProtoMinor int // 0
    // Header包含了请求头部字段,被服务器接收的或者被客户端
    // 发送的
    //
    // 如果服务器接收到请求通过下面的头部行,
    //
    // Host: example.com
    // accept-encoding: gzip, deflate
    // Accept-Language: en-us
    // fOO: Bar
    // foo: two
    //
    // then
    // Header = map[string][]string {
    //  "Accept-Encoding": {"gzip", "deflate"},
    //  "Accept-Language": {"enus"},
    //  "FOO": {"Bar", "two"}
    // }
    //
    // 对于进入的请求,Host的header将被提升为Request.Host
    // 字段且被从Header map中移除.
    // HTTP定义头部名字是大小写不敏感的.请求解析实现这个通过
    // CanonicalHeaderKey使得首字符和任何跟连字符的大写其
    // 余的小写
    //
    // 对于客户端的请求，某些头部Content-Length
    // 和Connection都自动写入当被需要并且头部的值可能被忽略.
    // 查看Request,Write方法文档.
    Header Header
    // Body是请求的主体
    //
    // 对于客户端的请求,一个nil body意味着请求没有主体
    // ,比如一个GET请求,HTTP的客户端的Transport
    // 负责调用Close方法.
    //
    // 对于服务器的请求,请求的主体总是非空的但是将会
    // 立即返回EOF当没有主体存在
    // 服务器将会关闭请求主体,ServeHTTP处理器必须如此
    Body io.ReadCloser
    // GetBody定义了一个函数可选的返回新的Body的副本
    // 它被用于客户请求当一个重定向要求读取主体超过一次
    // GetBody仍要求设置主体.
    //
    // 对于服务端的请求,它是无用的.
    GetBody func() (io.ReadCloser, error)
    // ContentLength记录相关联内容的长度
    // 当值是-1，表明长度是未知的
    // 当值>=0，表明可能给出的字节数可能读取自Body
    //
    // 对于客户端请求,值为0且主体部分非空仍被视为未知
    ContentLength int64
    // TransferEncoding列出传输编码,从最外层到
    // 最内层,空列表意味着"identity"编码
    // TransferEncoding通常被忽视,chunk encoding自动被
    // 添加和移除有必要的,当发送和接收请求.
    TransferEncoding []string
    // Close表明是否关闭连接在回复这个请求(对于服务器)
    // 或者在发送这个请求后和读取响应时(对于客户端)
    //
    // 对于服务端请求,HTTP服务器自动处理这个,这个字段
    // 不被处理器需要
    // 对于客户端请求,设置这个字段阻止重复利用到相同服务器
    // 的TCP连接，仿佛Transport.DisableKeepAlives被设置
    Close bool
    // 对于服务器请求，Host指定URL寻求的主机
    // 对于RFC 7230,Section 5.4,这个是“Host”头部的值
    // 或者URL本身给出的主机名,它可能是"host:port"的格式
    // 对于国际域名,Host可能使用Punycode(域名代码)或者
    // Unicode形式，使用golang.org/x/net/idna去转换
    // 两者需要的格式
    // 为了阻止DNS重新绑定攻击,服务器处理器应该验证Host头部
    // 值的权威性
    // 被包含的ServeMux支持注册的模板指定特定的host name
    // 因此保护它已注册的处理器
    //
    // 对于客户的请求,Host可选的重写发送的Host头部
    // 如果为空,请求的Write方法将会使用URL.Host的值
    // Host可能包含国际域名
    Host string
    // Form包含解析过的表单数据,同时包含URL字段
    // 的请求参数和PATCH,POST,PUT的表单数据
    // 这个只有在ParseForm被调用后才会提供
    // HTTP客户端忽视Form而是使用Body
    Form url.Values
    // PostForm包含解析的数据从PATCH,POST,PUT
    // 的主体参数
    //
    // 这个字段只有在调用ParseForm被调用后才提供
    // HTTP客户忽视PostForm而是使用Body
    PostForm url.Values
    // MultipartForm是解析过的多部分表单,包含上传的文件
    // 这个字段只有在ParseMultipartForm被调用后才可提供
    // HTTP客户端忽视MultipartForm而是使用Body
    MultipartForm *multipart.Form
    // Trailer指定附加的头部在请求主体后被发送
    //
    // 对于服务器的请求,Trailer映射原来只包含锚点的键和nil 
    // values(客户端声明的锚点它之后将会发送),当处理器从
    // Body读取，它必须不引用Trailer,当读取Body返回EOF,
    // Trailer能够再次被读取，将会包含非空值,如果曾经被
    // 客户发送
    //
    // 对于客户端的请求,Trailer必须被初始化包含之后发送
    // 的Trailer keys的map,这些值必须为nil或者最终的值
    // ContentLength必须为-1或0,为了发送被分块的请求
    // 在HTTP请求被发送后,map的值能够被更新,当请求的主体
    // 被读.当主体返回EOF,调用者必须不能修改Trailer
    // 少数的HTTP客户，服务器,代理支持HTTP trailers
    Trailer Header
    // RemoteAddr允许HTTP服务器和其他软件记录被发送请求网络
    // 的地址,通常用于日志.这个字段不是由ReadRequest填充
    // 且含有未定义的格式. 该包中的HTTP Server在触发处理器
    // 前设置RemoteAddr为"IP:port"
    // 这个字段被HTTP客户端忽视
    RemoteAddr string
    // RequestURI是Request-Line未被修改的request-target
    // (RFC 7230 3.1.1)当由客户端发送给服务端.通常应该
    // 使用URL字段
    // 在HTTP 客户端设置这个字段是错误.
    RequestURI string
    // TLS允许HTTP服务器和其他软件记录接收到的请求
    // 关于TLS连接的信息.这个字段不是由ReadRequest
    // 填充。该包中的HTTP Server设置该字段对于
    // TLS-enabled 连接会在处理器触发前设置
    //
    // 这个字段被HTTP客户端忽视
    TLS *tls.ConnectionState
    // Cancel是一个可选的通道它的关闭表明客户端
    // 的请求被视为已取消.不是所有的RoundTripper
    // 实现可能支持Cancel
    //
    // 对于服务端的请求,这个字段是不可用的.
    // 已废弃: 设置Request的context而是通过
    // NewRequestWithContext,如果Request的
    // Cancel字段和context字段都设置,不确定
    // Cancel是否被遵守.
    Cancel <-chan struct{}
    // Response是重定向的响应造成该请求被创建
    // 这个字段只有在客户重定向时被填充.
    Response *Response
    // contains filtered or unexported fields
}

对于Request呈现一个HTTP服务端接收的或者被客户端接收的. 这个字段的语义客户端和服务端略有不同.

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) BasicAuth() (usename, password string, ok bool)

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

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

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

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

func (r *Request) FormFiles(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(io.Writer) error

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

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

type Response struct {
    Status string // eg. "OK 200"
    StatusCode int // eg. 200
    Proto string // eg. "HTTP/1.1"
    ProtoMajor int // eg. 1
    ProtoMinor int // eg. 1
    Header Header
    Body io.ReadCloser
    ContentLength int64
    TransferEncoding []string
    Close bool
    Uncompressed bool
    Trailer Header
    Request *Request
    TLS *tls.ConnectionState
}

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

301(Move Permanently)
302(Found)
303(See Other)
307(Temporary Redirect)
309(Permanently Redirect)

如果这里有太多重定向或者发生HTTP协议错误将会返回错误.一个non-2xx响应不会造成一个错误.任何返回的错误类型将是*url.Error.这个*url.Error的值的Timeout方法可以调查是否是由请求超时或被取消. 当err是nil,resp总是包含一个非空的resp.Body,调用者应该关闭它当它读取完毕. Get是一个DefaultClient.Get的封装.为了使得请求是定制的,使用NewRequest和DefaultClient.Do.

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

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

Head是DefaultClient.Head的封装.

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同样是Handlers能够设置HTTP锚点的机制.
    // 在调用WriteHeader(or Write)之后改变header map
    // 没有作用,除非修改的头部都是锚点.
    //
    // 这里有两种方法设置Trailers,首选的方式是在头部前置
    // 声明设置"Trailer"头部键值的名字,在这种情况下,这些
    // header map的键被认为似乎它们是trailers,查看示例.
    // 第二种方法,对于trailers,键值不被Handler所知直到在第
    // 一次写入之后,是通过header map键值的前缀
    // TrailerPrefix进行设置，查看TrailerPrefix
    //
    // 为了取代自动设置的响应头部(比如"Date"),设置它们
    // 的值为nil
    Header() Header
    // Write数据到连接作为HTTP答复的一部分.
    // 如果WriteHeader至今未调用,Write会在写入数据
    // 之前调用WriteHeader(http.StatusOK).
    // 如果写入行不包含Content-Type行,Write添加一个
    // Content-Type设置为传递的写入的数据最初的512 byte
    // 检测到的类型.此外,如果写入的数据大小在较少的KB之下
    // 且没有调用Flush，Content-Length自动添加.
    //
    // 取决于HTTP协议版本和客户,调用Write或者WriteHeader
    // 可能会阻止未来在Request.Body读取.对于HTTP/1.x,
    // handler应该在写入响应之前可以读取所有需要的请求主体
    // 一旦头部已经被刷新(由于一个明确的Flusher,调用Flush
    // 或者写入足够多的数据触发刷新),请求主体可能不能使用.
    // 对于HTTP/2请求,GO HTTP服务器允许handler继续读取
    // 请求主体,尽管同时正在写入响应.但是,这样的行为不被所有
    // 的HTTP/2客户支持.如果可能最大化兼容性,Handlers应该
    // 在写入之前读取.
    Write([]byte) (int, error)
    // WriteHeader通过提供的状态码发送HTTP响应头部.
    //
    // 如果WriteHeader不被明确地调用,第一次调用Write将会
    // 隐含地调用WriteHeader(http.StatusOK).因此明确的
    // WriteHeader主要用于发送错误代码.
    //
    // 提供的状态码必须是合理的HTTP 1xx-5xx状态码.
    //只有一个头部能被写入.Go目前不支持用户自定义 1xx提示
    // 头部,通过100-continue响应头部的例外
    // Server自动发送当Request,Body被读取.
    WriteHeader(statusCode int)
}

一个ResponseWriter接口用于HTTP handler构造一个HTTP响应. 在Handler.ServeHTTP方法返回后,ResponseWriter可能不被使用.

type ServeMux struct {
    // contains filtered or unexported fields
}

ServeMux是一个HTTP请求多路复用器,它匹配每个入口请求的URL针对一个列表已注册的模式和调用最接近的匹配URL的处理器调用. 模式名称是固定的,比如”/favicon.ico”或有根子树”/images/“(注意斜杠).较长的模式优先于较短的模式,以至于如果handlers同时被注册用于”/images/“和”/images/thumbnails/“,之后的handlers将会调用路径”/images/thumbnails/“开始和开始接受”/images/“子树的形式.注意以斜杠结束的模式会命名有根的子树,模式”/“将会匹配所有其他注册模式不匹配的，不仅仅是URL的路径是”/“. 如果一个子树已经被注册并且一个请求被接收以一个没有尾部斜杠的该子树名称命名的请求,ServeMux重定向该请求到子树根(增加尾部的斜杠),这个行为能够被覆盖通过一个路径单独的注册,不带斜杠.比如,注册”/images/“导致ServeMux重定向一个”/images”请求到”/images/“,除非”/images”已经被单独注册. 模式可能可选的由主机名开始，强制URL只匹配那个主机,指定主机模式优先于普通的模式,因此handlers可能注册用于两种模式”/codesearch”和”codesearch.google.com/“而不是接受”http://www.google.com/"的请求,ServeMux还负责清理URL请求路径和Host头部.去掉端口号和重定向任何请求包含.或..元素或者重复的斜杠到等效项,更简洁的URL.

func NewServeMux() *ServeMux

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

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

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

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

type Server struct {
    // TCP地址，如果为空，":http"
    Addr string
    // 如果http.DefaultServeMux为nil,触发的handler
    Handler Handler
    // TLSConfig可选的为ServeTLS和ListenAndServeTLS
    // 提供TLS配置.注意这个值是通过ServeTLS和
    // ListenAndServeTLS复制,因此它不可能修改配置通过
    // 方法比如tls.Config.SetSessionTicketKeys.为了
    // 使用SetSessionTicketKeys,使用Server.Serve和一个
    // TLS Listener.
    TLSConfig *tls.Config
    // ReadTimeout是最大的时间段对于读取完整的请求,包括
    // 请求主体.
    //
    // 因为ReadTimeout没有让Handlers作接收请求主体截止时间
    // 或上传速率的决策,大多数用户更倾向使用
    // ReadTimeoutHeader，同时使用两个是合理的.
    ReadTimeout time.Duration
    // ReadHeaderTimeout是允许读取请求头部允许的时间,
    // 在读取头部和Handler能够决定导致读取主体缓慢的原因
    // 之后连接的读取截止时间.如果ReadHeaderTimeout是零
    // ,将使用ReadTimeout的值.如果都为零,这将没超时.
    ReadHeaderTimeout time.Duration
    // WriteTimeout是写入响应超时最大的时间段,无论何时
    // 新请求的头部被读,它将被重置.比如ReadTimeout,它没有
    // 在每个请求的基础上做决策.
    WriteTimeout time.Duration
    // IdleTimeout是在keep-alive激活的状态下,等待下次请求的
    // 的最多时间.如果IdleTimeout为0,将使用ReadTimeout
    // 如果同时为0,则将不会超时.
    IdleTimeout time.Duration
    // MaxHeaderBytes控制服务器解析和读取请求头部
    // 键和值的最大的字节数,包括请求行.它不会限制请求
    // 主体,如果它的值为0,将会使用DefaultMaxHeaderBytes
    MaxHeaderBytes int
    // TLSNextProto可选的指定一个函数掌管被提供的TLS连接
    // 的所有权,当出现一个NPN/ALPN协议升级.键值是协商的名称
    // ,Handler参数应该被用来HTTP请求并且将会初始化Request
    // 的TLS和RemoteAddr,如果没有被设置.当函数返回时,连接将
    // 自动关闭,如果TLSNextProto非空,HTTP/2将不会被自动激活
    TLSNextProto map[string]func(*Server, *tls.Conn, Handler)
    // ConnState指定一个回调函数当一个客户连接改变了状态,查看
    // type ConnState和一些常量更多细节.
    ConnState func(net.Conn, ConnState)
    // ErrorLog可选的指定一个记录错误连接接受,Handler的不正常的行为
    // 底层文件系统错误的日志器,如果为nil,日志记录将由log包中标准
    // 日志器完成.
    ErrorLog *log.Logger
    // BaseContext可选的指定函数返回对于服务器进入的请求基本的context
    // ,被提供的Listener是指定的开始接受请求的Listener.
    // 如果BaseContext为nil,将会使用context.Background()
    // 如果BaseContext非空,将会返回一个非空的context.
    BaseContext func(net.Listener) context.Context
    // ConnContext可选的用于一个新连接c的context,被提供的ctx从
    // BaseContext派生并且拥有一个ServerContextKey值.
    ConnContext func(ctx context.Context, c net.Conn) context.Context
    // contains filtered or unexported fields
}

func (srv *Server) Close() error

func (srv *Server) ListenAndServe() error

func 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

type Client struct {
    // Transport指定每个HTTP请求的机制
    // 如果为nil,使用DefaultTransport
    Transport RoundTripper
    // CheckRedirect指定处理重定向的策略
    // 如果CheckRedirect非空,客户跟随重定向前
    // 将会调用它,参数req,via都是即将来临的请求
    // 并且请求都早已发出,更旧的优先.如果
    // CheckRedirect返回错误,Client的Get方法
    // 将会返回以前的Response(它的主体已关闭)和
    // CheckRedirect的错误(被url.Error封装)
    // 而不是请求 Request req的问题.
    // 作为一个特例,CheckRedirect返回ErrUseLastResponse
    // ,然后最近的Response被返回且其主体未关闭,随同一个nil error
    CheckRedirect func(req *Request, via []*Request) 
    // Jar指定cookie jar
    //
    // Jar用于向每个出站的请求插入cookie,并且被更新
    // 通过入站的响应,Jar被每个跟随的重定向的客户协商.
    //
    // 如果Jar为nil,Cookie只会在请求明确设置时被发送
    Jar CookieJar
    // Timeout指定该客户发出请求的时间限制,超时包括连接时间
    // ,任何重定向和读取响应主体,定时器任会运行在Get,Head,Post
    // 或者Do返回,将会中断读取Response.Body.
    //
    // Timeout为0,意味着不会超时.
    // 
    // 客户取消请求到底层的Transport,即使Request的Context
    // 已经结束
    // 为了兼容性,Client将会使用废弃的CancelRequest方法在
    // Transport如果找到的话,新的RoundTripper应该使用
    // 请求Context的取消,而不是CancelRequest的实现.
    Timeout time.Duration
}

func (c *Client) CloseIdleConnections()

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

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

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

错误被返回如果Client的CheckRedirect调用失败或者HTTP协议错误,一个non-2xx的响应不会返回错误,任何返回的错误将为*url.Error类型,url.Error值的Timeout方法可以调查请求是超时或被取消.当err是nil,resp总是包含非空的resp.Body,调用必须在读取完Body关闭它. 为了定制化请求的头部,使用NewRequest和Client.Do.

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

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

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

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

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) 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 Cookie struct {
    Name string
    Value string
    Path string //可选的
    Domain string //可选的
    Expires time.Time //可选的
    RawExpires string // 只用于读取cookie
    MaxAge int
    Secure bool
    HttpOnly bool
    SameSite SameSite //Go 1.11
    Raw string
    Unparsed []string // 原始文本未解析的键值对
}

func (c *Cookie) String() string

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

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 ProxyFunc(fixedURL *url.URL) func (*Request) (*url.URL, error)

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