...

Package httputil

import "net/http/httputil"
概览
索引

概览 ▾

Package httputil provides HTTP utility functions, complementing the more common ones in the net/http package.

变量

var (
    ErrPersistEOF = &http.ProtocolError{ErrorString: "persistent connection closed"}
    ErrClosed     = &http.ProtocolError{ErrorString: "connection closed by user"}
    ErrPipeline   = &http.ProtocolError{ErrorString: "pipeline error"}
)
var ErrLineTooLong = internal.ErrLineTooLong

ErrLineTooLong is returned when reading malformed chunked data with lines that are too long.

func DumpRequest

func DumpRequest(req *http.Request, body bool) (dump []byte, err error)

DumpRequest返回req的传输结构,可选的包括请求的消息体,调试使用。 DumpRequest在语义上是非操作性的,但是为了获取出消息体,它会将消息体读取到内存中, 并且改变req.Body内存的一个拷贝映射。使用的是req的http.Request.Write属性的文档细节。

func DumpRequestOut

func DumpRequestOut(req *http.Request, body bool) ([]byte, error)

DumpRequestOut和DumpRequest一样,但是包含了header,这个header有标准的http.Transport, 比如User-Agent。

func DumpResponse

func DumpResponse(resp *http.Response, body bool) (dump []byte, err error)

DumpResponse和DumpRequest一样,但是它取出的是一个response。

func NewChunkedReader

func NewChunkedReader(r io.Reader) io.Reader

NewChunkedReader returns a new chunkedReader that translates the data read from r out of HTTP "chunked" format before returning it. The chunkedReader returns io.EOF when the final 0-length chunk is read.

NewChunkedReader is not needed by normal applications. The http package automatically decodes chunking when reading response bodies.

func NewChunkedWriter

func NewChunkedWriter(w io.Writer) io.WriteCloser

NewChunkedWriter returns a new chunkedWriter that translates writes into HTTP "chunked" format before writing them to w. Closing the returned chunkedWriter sends the final 0-length chunk that marks the end of the stream.

NewChunkedWriter is not needed by normal applications. The http package adds chunking automatically if handlers don't set a Content-Length header. Using NewChunkedWriter inside a handler would result in double chunking or chunking with a Content-Length length, both of which are wrong.

type ClientConn

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

ClientConn从还保持着HTTP keepalive的底层连接发送请求,并且接收header。 ClientConn支持调用Hijack来劫持连接用于获取底层网络连接的控制来处理net.Conn。

ServerConn 是低级而老旧的,应用应当采用 net/http 中的 Client 或 Transport 来代替。

func NewClientConn

func NewClientConn(c net.Conn, r *bufio.Reader) *ClientConn

NewClientConn返回一个新的ClientConnd对c进行读取和写入。如果r非空,则使用缓存对c进行读取。

ServerConn 是低级而老旧的,应用应当采用 net/http 中的 Client 或 Transport 来代替。

func NewProxyClientConn

func NewProxyClientConn(c net.Conn, r *bufio.Reader) *ClientConn

NewProxyClientConn像NewClientConn一样,不同的是使用Request的WriteProxy方法对请求进行写操作。

新代码不应使用 NewProxyClientConn。见 net/http 中的 Client 或 Transport。

func (*ClientConn) Close

func (cc *ClientConn) Close() error

Close调用Hijack并且关闭底层的连接

func (*ClientConn) Do

func (cc *ClientConn) Do(req *http.Request) (resp *http.Response, err error)

Do是一个写请求和读回复很方便的方法。

func (*ClientConn) Hijack

func (cc *ClientConn) Hijack() (c net.Conn, r *bufio.Reader)

Hijack将ClientConn单独分离出来,并且返回底层的连接,以及可能有一些未读数据的缓存的读取器。 Hijack会在读取获取到keep-alive结束信号之前被调用。在Read或者Write进行中不可以调用Hijack。

func (*ClientConn) Pending

func (cc *ClientConn) Pending() int

Pending返回已经被发送出去但是却没有获取到应答的请求数。

func (*ClientConn) Read

func (cc *ClientConn) Read(req *http.Request) (resp *http.Response, err error)

Read读取连接上的下个请求。回复有可能和ErrPersistEOF一起返回,如果返回了这个错误, 则代表远端的请求是最后被服务的请求了。Read可以和Write并发调用,但是却不能和其他Read并发调用。

func (*ClientConn) Write

func (cc *ClientConn) Write(req *http.Request) (err error)

Write负责写请求。如果HTTP长连接已经被关闭了,ErrPersistEOF错误就会被抛出。如果req.Close设置为true, 在通知请求和对应的服务之后,长连接就会被关闭了。ErrUnexpectedEOF则表示TCP连接被远端关闭。 在考虑到关闭连接的时候必须考虑到这种情况。

type ReverseProxy

type ReverseProxy struct {

    // Director是一个回调函数,它能将请求变成一个新的真实传递的请求。
    // 它的响应会原封不动拷贝并传输到最原始的客户端。
    Director func(*http.Request)

    // Transport用来操作代理请求。
    // 如果为空,默认使用http.DefaultTransport。
    Transport http.RoundTripper

    // FlushInterval代表客户端拷贝回复消息体的刷新间隔时间。
    // 如果设置为zero,则不进行定期的刷新。
    FlushInterval time.Duration

    // ErrorLog specifies an optional logger for errors
    // that occur when attempting to proxy the request.
    // If nil, logging goes to os.Stderr via the log package's
    // standard logger.
    ErrorLog *log.Logger
}

ReverseProxy是一个HTTP处理器,它接收进来的请求,然后把请求发送给另外一个服务,并把回复返回给客户端。

func NewSingleHostReverseProxy

func NewSingleHostReverseProxy(target *url.URL) *ReverseProxy

NewSingleHostReverseProxy返回一个新的ReverseProxy,它会重写URL的scheme,host 和基本的目标路径。如果目标路径是“/base”并且进入的请求的路径是“/dir”, 那么最终请求的目标路径就会变成/base/dir。

func (*ReverseProxy) ServeHTTP

func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request)

type ServerConn

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

ServerConn 在底层连接之上读取请求,发送回复,直到HTTP keepalive出现了结束命令。 ServerConn 允许靠调用Hijack来对底层连接进行劫持,从而得到连接的控制权。 ServerConn 支持管道连接,例如,当回复发送的时候,请求可以不需要进行同步(但是是在相同的顺序)。

ServerConn 是低级而老旧的,大部分应用都不需要它。具体参见 Server。

func NewServerConn

func NewServerConn(c net.Conn, r *bufio.Reader) *ServerConn

NewServerConn返回一个新的ServerConn来读取和写c。如果r非空,则使用缓存对c进行读取。

ServerConn 是低级而老旧的,大部分应用都不需要它。具体参见 Server。

func (*ServerConn) Close

func (sc *ServerConn) Close() error

Close调用Hijack,并且关闭底层的连接。

func (*ServerConn) Hijack

func (sc *ServerConn) Hijack() (c net.Conn, r *bufio.Reader)

Hijack将ServerConn单独分离出来,并且返回底层的连接,以及可能有一些未读数据的缓存的读取器。 Hijack会在读取获取到keep-alive结束信号之前被调用。在Read或者Write进行中不可以调用Hijack。

func (*ServerConn) Pending

func (sc *ServerConn) Pending() int

Pending返回已经连接上但未应答的请求数。

func (*ServerConn) Read

func (sc *ServerConn) Read() (req *http.Request, err error)

Read返回连接上的下个请求。如果确认了没有更多请求之后,将会返回ErrPersistEOF。(例如,在HTTP/1.0 的第一个请求之后,或者在HTTP/1.1的Connection:close之后)

func (*ServerConn) Write

func (sc *ServerConn) Write(req *http.Request, resp *http.Response) error

Write为请求进行回复。为了要更好的关闭连接,该函数将Response.Close设置为true。 直到它返回一个错误之前,Write都可以被调用,并且应该要忽略任何读取端的错误。