http

package

v1.21.9 Latest Latest Go to latest Published: Dec 31, 2023 License: MIT Imports: 15 Imported by: 0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/shogo82148/std

Links

Open Source Insights

Documentation ¶

Rendered for

Overview ¶

Package http は HTTP クライアントとサーバーの実装を提供します。

Get、Head、Post、PostForm は HTTP (または HTTPS) リクエストを行います:

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 := io.ReadAll(resp.Body)
// ...

Clients and Transports ¶

HTTP クライアントヘッダー、リダイレクトポリシー、その他の設定を制御するには、Client を作成してください。

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-Alive、圧縮、その他の設定を制御するには、Transport を作成してください。

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

クライアントとトランスポートは、複数のゴルーチンによる同時使用に対して安全であり、効率的に使用するためには、1度だけ作成して再利用する必要があります。

Servers ¶

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

HTTP/2 ¶

Go 1.6 以降、HTTPS を使用する場合、http パッケージは HTTP/2 プロトコルの透過的なサポートを提供します。HTTP/2 を無効にする必要があるプログラムは、Transport.TLSNextProto (クライアント用) または Server.TLSNextProto (サーバー用) を nil でない空のマップに設定することで行えます。また、次の GODEBUG 設定が現在サポートされています。

GODEBUG=http2client=0  # HTTP/2 クライアントサポートを無効にする
GODEBUG=http2server=0  # HTTP/2 サーバーサポートを無効にする
GODEBUG=http2debug=1   # 詳細な HTTP/2 デバッグログを有効にする
GODEBUG=http2debug=2   # ... フレームダンプを含めて、より詳細なログを有効にする

HTTP/2 サポートを無効にする前に、問題がある場合は報告してください: https://golang.org/s/http2bug

http パッケージの Transport と Server は、単純な構成に対して自動的に HTTP/2 サポートを有効にします。より複雑な構成で HTTP/2 を有効にする、より低レベルの HTTP/2 機能を使用する、またはより新しいバージョンの Go の http2 パッケージを使用するには、直接 "golang.org/x/net/http2" をインポートし、その ConfigureTransport および/または ConfigureServer 関数を使用します。golang.org/x/net/http2 パッケージを使用して HTTP/2 を手動で設定する場合、net/http パッケージの組み込みの HTTP/2 サポートよりも優先されます。

Index ¶

Constants
Variables
func CanonicalHeaderKey(s string) string
func DetectContentType(data []byte) string
func Error(w ResponseWriter, error string, code int)
func Handle(pattern string, handler Handler)
func HandleFunc(pattern string, handler func(ResponseWriter, *Request))
func ListenAndServe(addr string, handler Handler) error
func ListenAndServeTLS(addr, certFile, keyFile string, handler Handler) error
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, ...)
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
- func (c *Client) CloseIdleConnections()
- func (c *Client) Do(req *Request) (*Response, error)
- func (c *Client) Get(url string) (resp *Response, err error)
- func (c *Client) Head(url string) (resp *Response, err error)
- 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 CloseNotifierdeprecated
type ConnState
- func (c ConnState) String() string
type Cookie
- func (c *Cookie) String() string
- func (c *Cookie) Valid() error
type CookieJar
type Dir
- func (d Dir) Open(name string) (File, error)
type File
type FileSystem
- func FS(fsys fs.FS) FileSystem
type Flusher
type Handler
- func AllowQuerySemicolons(h Handler) Handler
- func FileServer(root FileSystem) Handler
- func MaxBytesHandler(h Handler, n int64) Handler
- func NotFoundHandler() Handler
- func RedirectHandler(url string, code int) Handler
- func StripPrefix(prefix string, h Handler) Handler
- func TimeoutHandler(h Handler, dt time.Duration, msg string) Handler
type HandlerFunc
- func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request)
type Header
- 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) Values(key string) []string
- func (h Header) Write(w io.Writer) error
- func (h Header) WriteSubset(w io.Writer, exclude map[string]bool) error
type Hijacker
type MaxBytesError
- func (e *MaxBytesError) Error() string
type ProtocolErrordeprecated
- func (pe *ProtocolError) Error() string
- func (pe *ProtocolError) Is(err error) bool
type PushOptions
type Pusher
type Request
- 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
- func (r *Request) WriteProxy(w io.Writer) error
type Response
- func Get(url string) (resp *Response, err error)
- func Head(url string) (resp *Response, err error)
- 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
type ResponseController
- func NewResponseController(rw ResponseWriter) *ResponseController
- func (c *ResponseController) EnableFullDuplex() error
- func (c *ResponseController) Flush() error
- func (c *ResponseController) Hijack() (net.Conn, *bufio.ReadWriter, error)
- func (c *ResponseController) SetReadDeadline(deadline time.Time) error
- func (c *ResponseController) SetWriteDeadline(deadline time.Time) error
type ResponseWriter
type RoundTripper
- func NewFileTransport(fs FileSystem) RoundTripper
type SameSite
type ServeMux
- 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, pattern string)
- func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request)
type Server
- 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
type Transport
- func (t *Transport) CancelRequest(req *Request)deprecated
- 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)

Constants ¶

View Source

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

一般的なHTTPメソッド。

特に注記がない限り、これらはRFC 7231セクション4.3で定義されています。

View Source

const (
	StatusContinue           = 100
	StatusSwitchingProtocols = 101
	StatusProcessing         = 102
	StatusEarlyHints         = 103

	StatusOK                   = 200
	StatusCreated              = 201
	StatusAccepted             = 202
	StatusNonAuthoritativeInfo = 203
	StatusNoContent            = 204
	StatusResetContent         = 205
	StatusPartialContent       = 206
	StatusMultiStatus          = 207
	StatusAlreadyReported      = 208
	StatusIMUsed               = 226

	StatusMultipleChoices  = 300
	StatusMovedPermanently = 301
	StatusFound            = 302
	StatusSeeOther         = 303
	StatusNotModified      = 304
	StatusUseProxy         = 305

	StatusTemporaryRedirect = 307
	StatusPermanentRedirect = 308

	StatusBadRequest                   = 400
	StatusUnauthorized                 = 401
	StatusPaymentRequired              = 402
	StatusForbidden                    = 403
	StatusNotFound                     = 404
	StatusMethodNotAllowed             = 405
	StatusNotAcceptable                = 406
	StatusProxyAuthRequired            = 407
	StatusRequestTimeout               = 408
	StatusConflict                     = 409
	StatusGone                         = 410
	StatusLengthRequired               = 411
	StatusPreconditionFailed           = 412
	StatusRequestEntityTooLarge        = 413
	StatusRequestURITooLong            = 414
	StatusUnsupportedMediaType         = 415
	StatusRequestedRangeNotSatisfiable = 416
	StatusExpectationFailed            = 417
	StatusTeapot                       = 418
	StatusMisdirectedRequest           = 421
	StatusUnprocessableEntity          = 422
	StatusLocked                       = 423
	StatusFailedDependency             = 424
	StatusTooEarly                     = 425
	StatusUpgradeRequired              = 426
	StatusPreconditionRequired         = 428
	StatusTooManyRequests              = 429
	StatusRequestHeaderFieldsTooLarge  = 431
	StatusUnavailableForLegalReasons   = 451

	StatusInternalServerError           = 500
	StatusNotImplemented                = 501
	StatusBadGateway                    = 502
	StatusServiceUnavailable            = 503
	StatusGatewayTimeout                = 504
	StatusHTTPVersionNotSupported       = 505
	StatusVariantAlsoNegotiates         = 506
	StatusInsufficientStorage           = 507
	StatusLoopDetected                  = 508
	StatusNotExtended                   = 510
	StatusNetworkAuthenticationRequired = 511
)

IANAに登録されたHTTPステータスコード。詳細はこちらを参照してください：https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml

View Source

const DefaultMaxHeaderBytes = 1 << 20

DefaultMaxHeaderBytesは、HTTPリクエストのヘッダーの許容される最大サイズです。これは、Server.MaxHeaderBytesを設定することで上書きできます。

View Source

const DefaultMaxIdleConnsPerHost = 2

DefaultMaxIdleConnsPerHostは、TransportのMaxIdleConnsPerHostのデフォルト値です。

View Source

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

TimeFormatは、HTTPヘッダーで時間を生成するときに使用する時間形式です。 time.RFC1123のようですが、タイムゾーンとしてGMTがハードコードされています。フォーマットされる時間はUTCである必要があります。

この時間形式を解析するには、ParseTimeを参照してください。

View Source

const TrailerPrefix = "Trailer:"

TrailerPrefixは、ResponseWriter.Headerマップのキーに対するマジックプレフィックスで、存在する場合は、マップエントリが実際にはレスポンストレーラーであることを示します。プレフィックスは、ServeHTTP呼び出しが終了し、値がトレーラーに送信された後に削除されます。

このメカニズムは、ヘッダーが書き込まれる前には不明なトレーラーにのみ使用することができます。トレーラーのセットが固定されている場合、またはヘッダーが書き込まれる前に既知の場合、通常のGoトレーラーメカニズムが推奨されます。

https://pkg.go.dev/net/http#ResponseWriter
https://pkg.go.dev/net/http#example-ResponseWriter-Trailers

Variables ¶

View Source

var (
	// ErrNotSupportedは、機能がサポートされていないことを示します。
	//
	// ResponseControllerメソッドによって、ハンドラがメソッドをサポートしていないことを示すために返され、
	// Pusher実装のPushメソッドによって、HTTP/2 Pushサポートが利用できないことを示すために返されます。
	ErrNotSupported = &ProtocolError{"feature not supported"}

	// Deprecated: ErrUnexpectedTrailerは、net/httpパッケージの何も返さなくなりました。
	// 呼び出し元は、この変数とエラーを比較すべきではありません。
	ErrUnexpectedTrailer = &ProtocolError{"trailer header without chunked transfer encoding"}

	// ErrMissingBoundaryは、リクエストのContent-Typeに「boundary」パラメータが含まれていない場合に、Request.MultipartReaderによって返されます。
	ErrMissingBoundary = &ProtocolError{"no multipart boundary param in Content-Type"}

	/// ErrNotMultipartは、リクエストのContent-Typeがmultipart/form-dataでない場合、Request.MultipartReaderによって返されます。
	ErrNotMultipart = &ProtocolError{"request Content-Type isn't multipart/form-data"}

	// Deprecated: ErrHeaderTooLongは、net/httpパッケージの何も返さなくなりました。
	// 呼び出し元は、この変数とエラーを比較すべきではありません。
	ErrHeaderTooLong = &ProtocolError{"header too long"}

	// Deprecated: ErrShortBodyは、net/httpパッケージの何も返さなくなりました。
	// 呼び出し元は、この変数とエラーを比較すべきではありません。
	ErrShortBody = &ProtocolError{"entity body too short"}

	// Deprecated: ErrMissingContentLengthは、net/httpパッケージの何も返さなくなりました。
	// 呼び出し元は、この変数とエラーを比較すべきではありません。
	ErrMissingContentLength = &ProtocolError{"missing ContentLength in HEAD response"}
)

View Source

var (
	// ErrBodyNotAllowedは、HTTPメソッドまたはレスポンスコードがボディを許可しない場合に、ResponseWriter.Write呼び出しによって返されます。
	ErrBodyNotAllowed = errors.New("http: request method or response status code does not allow body")

	// ErrHijackedは、Hijackerインターフェースを使用して基礎となる接続がハイジャックされた場合に、ResponseWriter.Write呼び出しによって返されます。
	// ハイジャックされた接続でのゼロバイト書き込みは、他の副作用なしにErrHijackedを返します。
	ErrHijacked = errors.New("http: connection has been hijacked")

	// ErrContentLengthは、Handlerが宣言されたサイズを持つContent-Lengthレスポンスヘッダーを設定し、宣言されたバイト数よりも多くのバイトを書き込もうとした場合に、ResponseWriter.Write呼び出しによって返されます。
	ErrContentLength = errors.New("http: wrote more than the declared Content-Length")

	// Deprecated: ErrWriteAfterFlushは、net/httpパッケージの何も返さなくなったため、もはや返されません。
	// 呼び出し元は、この変数に対してエラーを比較するべきではありません。
	ErrWriteAfterFlush = errors.New("unused")
)

HTTPサーバーで使用されるエラー。

View Source

var (
	// ServerContextKeyは、コンテキストキーです。
	// HTTPハンドラーでContext.Valueと一緒に使用して、ハンドラーを開始したサーバーにアクセスできます。
	// 関連する値の型は*Serverです。
	ServerContextKey = &contextKey{"http-server"}

	// LocalAddrContextKeyは、コンテキストキーです。
	// HTTPハンドラーでContext.Valueと一緒に使用して、接続が到着したローカルアドレスにアクセスできます。
	// 関連する値の型はnet.Addrです。
	LocalAddrContextKey = &contextKey{"local-addr"}
)

View Source

var DefaultClient = &Client{}

DefaultClientはデフォルトのClientであり、Get、Head、およびPostに使用されます。

View Source

var DefaultServeMux = &defaultServeMux

DefaultServeMuxは、Serveによって使用されるデフォルトのServeMuxです。

View Source

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

ErrAbortHandlerは、ハンドラーを中止するためのセンチネルパニック値です。 ServeHTTPからのパニックはすべて、クライアントへの応答を中止しますが、 ErrAbortHandlerでパニックすると、サーバーのエラーログにスタックトレースを記録しないようにすることができます。

View Source

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

ErrBodyReadAfterCloseは、ボディが閉じられた後にRequestまたはResponseのボディを読み取る場合に返されます。これは通常、HTTPハンドラがResponseWriterのWriteHeaderまたはWriteを呼び出した後にボディが読み取られた場合に発生します。

View Source

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

ErrHandlerTimeoutは、タイムアウトしたハンドラ内のResponseWriter Write呼び出しで返されます。

View Source

var ErrLineTooLong = internal.ErrLineTooLong

ErrLineTooLongは、不正なチャンクエンコーディングでリクエストまたはレスポンスボディを読み取る場合に返されます。

View Source

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

ErrMissingFileは、FormFileが提供されたファイルフィールド名がリクエストに存在しないか、ファイルフィールドではない場合に返されます。

View Source

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

ErrNoCookieは、Cookieメソッドがクッキーを見つけられなかった場合にRequestによって返されます。

View Source

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

ErrNoLocationは、LocationメソッドがLocationヘッダーが存在しない場合に返されます。

View Source

var ErrSchemeMismatch = errors.New("http: server gave HTTP response to HTTPS client")

ErrSchemeMismatchは、サーバーがHTTPSクライアントにHTTPレスポンスを返した場合に返されます。

View Source

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

ErrServerClosedは、ShutdownまたはCloseの呼び出し後、ServerのServe、ServeTLS、ListenAndServe、およびListenAndServeTLSメソッドによって返されます。

View Source

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

ErrSkipAltProtocolは、Transport.RegisterProtocolによって定義されたセンチネルエラー値です。

View Source

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

ErrUseLastResponseは、Client.CheckRedirectフックによって返され、リダイレクトの処理方法を制御するために使用できます。これが返されると、次のリクエストは送信されず、最も最近のレスポンスがそのボディが閉じられていない状態で返されます。

View Source

var NoBody = noBody{}

NoBodyはバイトを持たないio.ReadCloserです。Readは常にEOFを返し、 Closeは常にnilを返します。これは、リクエストがゼロバイトであることを明示的に示すために、送信元クライアントのリクエストで使用することができます。ただし、代わりにRequest.Bodyをnilに設定することもできます。

Functions ¶

func CanonicalHeaderKey ¶

func CanonicalHeaderKey(s string) string

CanonicalHeaderKeyは、ヘッダーキーsの正規形式を返します。正規化により、最初の文字とハイフンに続く任意の文字が大文字に変換されます。それ以外の文字は小文字に変換されます。たとえば、「accept-encoding」の正規キーは「Accept-Encoding」です。 sにスペースまたは無効なヘッダーフィールドバイトが含まれている場合、変更せずに返されます。

func DetectContentType ¶

func DetectContentType(data []byte) string

DetectContentTypeは、指定されたデータのContent-Typeを決定するために https://mimesniff.spec.whatwg.org/ で説明されているアルゴリズムを実装します。データの最初の512バイトまでしか考慮しません。 DetectContentTypeは常に有効なMIMEタイプを返します。より具体的なMIMEタイプを決定できない場合は、"application/octet-stream"を返します。

func Error ¶

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

Errorは、指定されたエラーメッセージとHTTPコードでリクエストに応答します。それ以外に、リクエストを終了しません。呼び出し元は、wに対してさらに書き込みが行われないようにする必要があります。エラーメッセージはプレーンテキストである必要があります。

func Handle ¶

func Handle(pattern string, handler Handler)

Handleは、DefaultServeMuxに指定されたパターンのハンドラを登録します。 ServeMuxのドキュメントには、パターンがどのようにマッチするかが説明されています。

Example ¶

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

Output:

func HandleFunc ¶

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

HandleFuncは、DefaultServeMuxに指定されたパターンのハンドラ関数を登録します。 ServeMuxのドキュメントには、パターンがどのようにマッチするかが説明されています。

Example ¶

package main

import (
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net/http"
)

func main() {
	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))
}

Output:

func ListenAndServe ¶

func ListenAndServe(addr string, handler Handler) error

ListenAndServeは、TCPネットワークアドレスaddrでリッスンし、 Serveを呼び出して着信接続のリクエストを処理します。受け入れられた接続は、TCP keep-alivesを有効にするように構成されます。

ハンドラは通常nilであり、その場合はDefaultServeMuxが使用されます。

ListenAndServeは常に非nilのエラーを返します。

Example ¶

package main

import (
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net/http"
)

func main() {
	// Hello world, the web server

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

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

Output:

func ListenAndServeTLS ¶

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

ListenAndServeTLSは、ListenAndServeと同じように動作しますが、HTTPS接続が必要です。さらに、サーバーの証明書と対応する秘密鍵が含まれるファイルを提供する必要があります。証明書が認証局によって署名されている場合、certFileはサーバーの証明書、中間証明書、およびCAの証明書を連結したものである必要があります。

Example ¶

package main

import (
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net/http"
)

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

	// crypto/tls の generate_cert.go を使用して、cert.pem と 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)
}

Output:

func MaxBytesReader ¶

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

MaxBytesReaderは、io.LimitReaderに似ていますが、着信リクエストボディのサイズを制限するために使用されます。 io.LimitReaderとは異なり、MaxBytesReaderの結果はReadCloserであり、制限を超えたReadに対して *MaxBytesError 型の非nilエラーを返し、Closeメソッドが呼び出されたときに基になるリーダーを閉じます。

MaxBytesReaderは、クライアントが誤ってまたは悪意を持って大きなリクエストを送信してサーバーのリソースを浪費することを防止します。可能であれば、ResponseWriterに制限に達した後に接続を閉じるように指示します。

func NotFound ¶

func NotFound(w ResponseWriter, r *Request)

NotFoundは、HTTP 404 not foundエラーでリクエストに応答します。

func ParseHTTPVersion ¶

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

ParseHTTPVersionは、RFC 7230、セクション2.6に従ってHTTPバージョン文字列を解析します。 "HTTP/1.0"は(1, 0, true)を返します。注意："HTTP/2"のようにマイナーバージョンがない文字列は無効です。

func ParseTime ¶ added in v1.1.0

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

ParseTimeは、HTTP/1.1で許可されている3つのフォーマットのうちの1つ、TimeFormat、time.RFC850、およびtime.ANSICをそれぞれ試して、時間ヘッダー（Date：ヘッダーなど）を解析します。

func ProxyFromEnvironment ¶

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

ProxyFromEnvironmentは、環境変数HTTP_PROXY、HTTPS_PROXY、およびNO_PROXY（またはそれらの小文字バージョン）によって示されるように、指定されたリクエストに使用するプロキシのURLを返します。リクエストは、NO_PROXYによって除外されていない限り、スキームに一致する環境変数からプロキシを使用します。

環境値は、完全なURLまたは"host[:port]"のいずれかである場合があります。この場合、"http"スキームが想定されます。スキーム"http"、"https"、および"socks5"がサポートされています。値が異なる形式の場合は、エラーが返されます。

環境変数でプロキシが定義されていない場合、またはNO_PROXYによって指定されたリクエストにプロキシを使用しない場合、 nilのURLとnilのエラーが返されます。

特別な場合として、req.URL.Hostが"localhost"（ポート番号ありまたはなし）の場合、nilのURLとnilのエラーが返されます。

func ProxyURL ¶

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

ProxyURLは、常に同じURLを返すプロキシ関数（Transportで使用するため）を返します。

func Redirect ¶

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

Redirectは、リクエストに対してurlにリダイレクトする応答を返します。 urlは、リクエストパスに対する相対パスである場合があります。

提供されたコードは通常、StatusMovedPermanently、StatusFound、またはStatusSeeOtherの3xx範囲にあります。

Content-Typeヘッダーが設定されていない場合、Redirectはそれを"text/html; charset=utf-8"に設定し、小さなHTML本文を書き込みます。 Content-Typeヘッダーを任意の値、nilを含む任意の値に設定すると、その動作が無効になります。

func Serve ¶

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

Serveは、リスナーlに対して着信HTTP接続を受け入れ、それぞれに新しいサービスgoroutineを作成します。サービスgoroutineはリクエストを読み取り、その後handlerを呼び出して応答します。

handlerは通常nilであり、その場合はDefaultServeMuxが使用されます。

TLS Config.NextProtosで"h2"が設定された *tls.Conn 接続を返すリスナーがある場合、HTTP / 2サポートが有効になります。

Serveは常にnilでないエラーを返します。

func ServeContent ¶

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

ServeContentは、提供されたReadSeeker内のコンテンツを使用してリクエストに応答します。 ServeContentの主な利点は、Rangeリクエストを適切に処理し、MIMEタイプを設定し、If-Match、If-Unmodified-Since、If-None-Match、If-Modified-Since、およびIf-Rangeリクエストを処理することです。

応答のContent-Typeヘッダーが設定されていない場合、ServeContentはまず、名前のファイル拡張子からタイプを推測し、それでも失敗した場合は、コンテンツの最初のブロックを読み取ってDetectContentTypeに渡します。名前はそれ以外では使用されず、特に空であっても、応答に送信されません。

modtimeがゼロ時またはUnixエポックでない場合、ServeContentは応答のLast-Modifiedヘッダーに含めます。リクエストにIf-Modified-Sinceヘッダーが含まれている場合、ServeContentはmodtimeを使用して、コンテンツを送信する必要があるかどうかを決定します。

コンテンツのSeekメソッドは動作する必要があります。ServeContentは、コンテンツのサイズを決定するために、コンテンツの末尾にシークを使用します。

呼び出し元がRFC 7232、セクション2.3に従ってフォーマットされたwのETagヘッダーを設定している場合、ServeContentはそれを使用して、If-Match、If-None-Match、またはIf-Rangeを使用するリクエストを処理します。

*os.Fileはio.ReadSeekerインターフェースを実装していることに注意してください。

func ServeFile ¶

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

ServeFileは、指定された名前のファイルまたはディレクトリの内容でリクエストに応答します。

提供されたファイル名またはディレクトリ名が相対パスの場合、それは現在のディレクトリに対して相対的に解釈され、親ディレクトリに昇格することができます。提供された名前がユーザー入力から構築されている場合、ServeFileを呼び出す前にサニタイズする必要があります。

予防措置として、ServeFileはr.URL.Pathに".."パス要素が含まれているリクエストを拒否します。これは、r.URL.Pathをサニタイズせずにfilepath.Joinで安全でなく使用し、その結果をname引数として使用する可能性のある呼び出し元に対する保護です。

別の特殊なケースとして、ServeFileはr.URL.Pathが "/index.html"で終わる任意のリクエストを、最後の "index.html"なしで同じパスにリダイレクトします。そのようなリダイレクトを避けるためには、パスを変更するか、ServeContentを使用します。

それらの2つの特殊なケースの外では、ServeFileは r.URL.Pathを使用して提供するファイルやディレクトリを選択しません。名前引数で提供されたファイルやディレクトリのみが使用されます。

func ServeTLS ¶ added in v1.9.0

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

ServeTLSは、リスナーlに対して着信HTTPS接続を受け入れ、それぞれに新しいサービスgoroutineを作成します。サービスgoroutineはリクエストを読み取り、その後handlerを呼び出して応答します。

handlerは通常nilであり、その場合はDefaultServeMuxが使用されます。

さらに、サーバーの証明書と対応する秘密鍵を含むファイルを提供する必要があります。証明書が認証局によって署名されている場合、certFileはサーバーの証明書、中間証明書、およびCAの証明書を連結したものである必要があります。

ServeTLSは常にnilでないエラーを返します。

func SetCookie ¶

func SetCookie(w ResponseWriter, cookie *Cookie)

SetCookieは、提供されたResponseWriterのヘッダーにSet-Cookieヘッダーを追加します。提供されたクッキーには有効な名前が必要です。無効なクッキーは黙って破棄される場合があります。

func StatusText ¶

func StatusText(code int) string

StatusText は、HTTP ステータスコードのテキストを返します。コードが不明な場合は、空の文字列を返します。

Types ¶

type Client ¶

type Client struct {
	// Transportは個別のHTTPリクエストが行われるメカニズムを指定します。
	// nilの場合、DefaultTransportが使用されます。
	Transport RoundTripper

	// CheckRedirectはリダイレクトの処理ポリシーを指定します。
	// CheckRedirectがnilでない場合、クライアントはHTTPリダイレクトに従う前にそれを呼び出します。
	// 引数のreqとviaは、直前のリクエストとこれまでに行われたリクエストです。最も古いものから順に渡されます。
	// CheckRedirectがエラーを返す場合、ClientのGetメソッドはリクエストreqを発行せずに、
	// 前のResponse（そのBodyが閉じられている）とCheckRedirectのエラー（url.Errorでラップされたもの）の両方を返します。
	// 特別な場合として、CheckRedirectがErrUseLastResponseを返す場合、
	// 最新のレスポンスがそのBodyが閉じていない状態で返され、エラーはnilです。
	//
	// CheckRedirectがnilの場合、Clientはデフォルトのポリシーを使用します。
	// デフォルトのポリシーは、連続した10個のリクエストの後に停止することです。
	CheckRedirect func(req *Request, via []*Request) error

	// Jarはクッキージャーを指定します。
	//
	// Jarは、出力リクエストに関連するクッキーを挿入するために使用され、
	// すべての入力レスポンスのクッキー値で更新されます。
	// Jarは、クライアントがフォローするすべてのリダイレクトで参照されます。
	//
	// Jarがnilの場合、リクエストに明示的に設定されていない場合にのみクッキーが送信されます。
	Jar CookieJar

	// Timeoutは、このClientによって行われるリクエストのタイムアウト時間を指定します。
	// タイムアウトには、接続時間、リダイレクト、レスポンスボディの読み取りなどが含まれます。
	// Get、Head、Post、またはDoが返却された後でも、タイマーは実行し続け、
	// Response.Bodyの読み取りを中断します。
	//
	// Timeoutがゼロの場合は、タイムアウトはありません。
	//
	// Clientは、RequestのContextが終了した場合と同様に、
	// ベースとなるTransportへのリクエストをキャンセルします。
	//
	// 互換性のために、ClientはTransportにCancelRequestメソッドも使用しますが、
	// 新しいRoundTripperの実装はCancelRequestではなく、
	// リクエストのContextを使用してキャンセルするべきです。
	Timeout time.Duration
}

ClientはHTTPクライアントです。ゼロ値(DefaultClient)は、DefaultTransportを使用する使用可能なクライアントです。

ClientのTransportには通常、内部状態(キャッシュされたTCP接続など)があるため、必要に応じて作成するのではなく、再利用する必要があります。 Clientsは、複数のゴルーチンによる同時使用に対して安全です。

Clientは、RoundTripper(Transportなど)よりも高レベルであり、クッキーやリダイレクトなどのHTTPの詳細も処理します。

リダイレクトに従う場合、Clientは、初期リクエストに設定されたすべてのヘッダーを転送しますが、以下の場合は除外されます。

* 「Authorization」、「WWW-Authenticate」、「Cookie」などの機密性の高いヘッダーを、信頼できないターゲットに転送する場合。これらのヘッダーは、初期ドメインのサブドメインマッチまたは完全一致ではないドメインにリダイレクトする場合には無視されます。たとえば、「foo.com」から「foo.com」または「sub.foo.com」にリダイレクトする場合、機密性の高いヘッダーが転送されますが、「bar.com」にリダイレクトする場合は転送されません。

* 非nilのCookie Jarで「Cookie」ヘッダーを転送する場合。各リダイレクトは、Cookie Jarの状態を変更する可能性があるため、初期リクエストで設定されたCookieを変更する可能性があります。「Cookie」ヘッダーを転送する場合、変更されたCookieは省略され、Jarが更新された値でこれらの変更されたCookieを挿入することが期待されます(元の値が一致する場合)。 Jarがnilの場合、初期Cookieは変更せずに転送されます。

func (*Client) CloseIdleConnections ¶ added in v1.12.0

func (c *Client) CloseIdleConnections()

CloseIdleConnectionsは、以前は接続されていたが現在は"keep-alive"状態、つまりアイドル状態にあるTransport上のアイドル接続を閉じます。これは現在アクティブな接続を中断しません。

クライアントのTransportにCloseIdleConnectionsメソッドがない場合、このメソッドは何もしません。

func (*Client) Do ¶

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

DoはHTTPリクエストを送信し、クライアントの設定したポリシー（リダイレクト、クッキー、認証など）に従ってHTTPレスポンスを返します。

クライアントポリシー（CheckRedirectなど）によってトリガーされた場合、またはHTTP転送が失敗した場合（ネットワーク接続の問題など）、エラーが返されます。2xx以外のステータスコードはエラーを引き起こしません。

返されるエラーがnilの場合、Responseにはユーザーが閉じなければならない非nilのBodyが含まれます。BodyがEOFまで完全に読み取られずに閉じられない場合、クライアントの基本となるRoundTripper（通常はTransport）は、次の「keep-alive」リクエストのためにサーバーへの永続的なTCP接続を再利用できないかもしれません。

リクエストのBodyがnilでない場合、それは基本となるTransportによって閉じられます。エラーが発生した場合も同様です。

エラーが発生した場合、任意のResponseは無視できます。非nilのResponseと非nilのエラーは、CheckRedirectが失敗した場合にのみ返されます。その場合でも、返されたResponse.Bodyはすでに閉じられています。

通常、Doの代わりにGet、Post、またはPostFormが使用されます。

サーバーがリダイレクトを返すと、Clientは最初にCheckRedirect関数を使用してリダイレクトをフォローするかどうかを決定します。許可されると、301、302、または303のリダイレクトは、メソッドがGET（元のリクエストがHEADだった場合はHEAD）でボディがない後続のリクエストを引き起こします。307または308のリダイレクトは、Request.GetBody関数が定義されている場合、元のHTTPメソッドとボディを保持します。NewRequest関数は、一般的な標準ライブラリボディタイプのGetBodyを自動的に設定します。

すべての返されるエラーは*url.Error型です。url.ErrorのTimeoutメソッドは、リクエストがタイムアウトした場合にtrueを報告します。

func (*Client) Get ¶

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

Getは指定されたURLにGETを発行します。レスポンスが以下のリダイレクトコードのいずれかである場合、 Getはリダイレクトをフォローします。最大10回のリダイレクトが許可されます：

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

リダイレクトが多すぎる場合やHTTPプロトコルエラーがあった場合にエラーが返されます。 2xx以外のレスポンスはエラーを引き起こしません。返される任意のエラーは*url.Error型になります。 url.Error値のTimeoutメソッドは、リクエストがタイムアウトした場合にtrueを報告します。

errがnilの場合、respは常に非nilのresp.Bodyを含みます。読み取りが完了したら、呼び出し元はresp.Bodyを閉じる必要があります。

GetはDefaultClient.Getのラッパーです。

カスタムヘッダーでリクエストを行うには、NewRequestと DefaultClient.Doを使用します。

指定したcontext.Contextでリクエストを作成するには、NewRequestWithContextとDefaultClient.Doを使用します。

func (*Client) Head ¶

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

指定されたURLにHEADリクエストを送信します。もしレスポンスが以下のいずれかのリダイレクトコードである場合、 Headメソッドはリダイレクトに従う前にClientのCheckRedirect関数を呼び出すことがあります。

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

指定されたcontext.Contextを使用してリクエストを送信する場合は、NewRequestWithContextとClient.Doを使用してください。

func (*Client) Post ¶

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

Postは、指定されたURLにPOSTリクエストを送信します。

呼び出し元は、resp.Bodyの読み込みが完了したらresp.Bodyを閉じる必要があります。

提供されたBodyがio.Closerインターフェースを実装している場合、リクエストの後に閉じられます。

カスタムヘッダーを設定するには、NewRequestとClient.Doを使用します。

指定されたcontext.Contextでリクエストを作成するには、NewRequestWithContextとClient.Doを使用します。

リダイレクトの処理方法については、Client.Doメソッドのドキュメントを参照してください。

func (*Client) PostForm ¶

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

PostForm関数は、指定されたデータのキーと値のペアをリクエストボディにエンコードして、URLにPOSTリクエストを送信します。

Content-Typeヘッダーはapplication/x-www-form-urlencodedに設定されます。他のヘッダーを設定するには、NewRequestとClient.Doを使用します。

errがnilの場合、respは常に非nilのresp.Bodyを含みます。読み取り後、呼び出し元はresp.Bodyを閉じなければなりません。

リダイレクトの処理については、Client.Doメソッドのドキュメンテーションを参照してください。

指定したcontext.Contextでリクエストを作成するには、NewRequestWithContextとClient.Doを使用します。

type CloseNotifier deprecated added in v1.1.0

type CloseNotifier interface {
	// CloseNotifyは、クライアント接続が切断されたときに最大で
	// 一つの値（true）を受け取るチャネルを返します。
	//
	// CloseNotifyは、Request.Bodyが完全に読み取られるまで、
	// 通知を待つ場合があります。
	//
	// ハンドラが戻った後、チャネルが値を受け取ることが保証されていません。
	//
	// プロトコルがHTTP/1.1で、CloseNotifyが
	// 冪等なリクエスト（GETなど）の処理中に呼び出され、
	// HTTP/1.1のパイプラインが使用されている場合、
	// 続くパイプラインリクエストの到着により、
	// 返されたチャネルに値が送信される可能性があります。
	// 実際には、ブラウザではHTTP/1.1のパイプラインは有効になっておらず、
	// 野生ではあまり見られません。これが問題である場合は、
	// HTTP/2を使用するか、POSTなどのメソッドでのみCloseNotifyを使用します。
	CloseNotify() <-chan bool
}

CloseNotifierインターフェースは、基礎となる接続が切断されたときに検出できるResponseWriterによって実装されます。

このメカニズムは、レスポンスが準備される前にクライアントが切断された場合、サーバー上の長時間の操作をキャンセルするために使用できます。

Deprecated: CloseNotifierインターフェースは、Goのコンテキストパッケージより前に実装されました。新しいコードでは、Request.Contextを使用する必要があります。

type ConnState ¶ added in v1.3.0

type ConnState int

ConnStateは、サーバーへのクライアント接続の状態を表します。これは、オプションのServer.ConnStateフックによって使用されます。

const (
	// StateNewは、すぐにリクエストを送信することが期待される新しい接続を表します。
	// 接続はこの状態で開始し、StateActiveまたはStateClosedに移行します。
	StateNew ConnState = iota

	// StateActiveは、1バイト以上のリクエストを読み取った接続を表します。
	// StateActiveのServer.ConnStateフックは、リクエストがハンドラに入る前に発生し、
	// リクエストが処理されるまで再び発生しません。
	// リクエストが処理された後、状態はStateClosed、StateHijacked、またはStateIdleに移行します。
	// HTTP/2の場合、StateActiveはゼロから1つのアクティブなリクエストに移行するときに発生し、
	// すべてのアクティブなリクエストが完了するまでにしか移行しません。
	// つまり、ConnStateはリクエストごとの作業に使用できません。
	// ConnStateは接続の全体的な状態のみを示します。
	StateActive

	// StateIdleは、リクエストの処理が完了し、新しいリクエストを待機しているkeep-alive状態の接続を表します。
	// 接続はStateIdleからStateActiveまたはStateClosedに移行します。
	StateIdle

	// StateHijackedは、ハイジャックされた接続を表します。
	// これは終端状態です。StateClosedに移行しません。
	StateHijacked

	// StateClosedは、閉じられた接続を表します。
	// これは終端状態です。ハイジャックされた接続はStateClosedに移行しません。
	StateClosed
)

func (ConnState) String ¶ added in v1.3.0

func (c ConnState) String() string

type Cookie struct {
	Name  string
	Value string

	Path       string
	Domain     string
	Expires    time.Time
	RawExpires string

	// MaxAge=0は 'Max-Age'属性が指定されていないことを意味します。
	// MaxAge<0は今すぐクッキーを削除することを意味し、'Max-Age: 0'と同等です。
	// MaxAge>0はMax-Age属性が存在し、秒で指定されていることを意味します。
	MaxAge   int
	Secure   bool
	HttpOnly bool
	SameSite SameSite
	Raw      string
	Unparsed []string
}

Cookieは、HTTP応答のSet-CookieヘッダーまたはHTTPリクエストのCookieヘッダーで送信されるHTTPクッキーを表します。

詳細については、https://tools.ietf.org/html/rfc6265 を参照してください。

func (c *Cookie) String() string

Stringは、Cookieヘッダー（NameとValueのみが設定されている場合）またはSet-Cookie応答ヘッダー（他のフィールドが設定されている場合）で使用するためのクッキーのシリアル化を返します。 cがnilであるか、c.Nameが無効な場合、空の文字列が返されます。

func (c *Cookie) Valid() error

Validは、クッキーが有効かどうかを報告します。

type CookieJar ¶

type CookieJar interface {
	// SetCookiesは、指定されたURLの応答でのクッキーの受け取りを処理します。
	// ジャーのポリシーと実装により、クッキーを保存するかどうかを選択するかもしれませんし、しないかもしれません。
	SetCookies(u *url.URL, cookies []*Cookie)

	// Cookiesは、指定されたURLのリクエストで送信するクッキーを返します。
	// 標準的なクッキー使用制限（RFC 6265など）を尊重するかどうかは、実装次第です。
	Cookies(u *url.URL) []*Cookie
}

CookieJarは、HTTPリクエストでのCookieのストレージと使用を管理します。

CookieJarの実装は、複数のゴルーチンによる同時使用に対して安全である必要があります。

net/http/cookiejarパッケージはCookieJarの実装を提供します。

type Dir ¶

type Dir string

Dirは、特定のディレクトリツリーに制限されたネイティブファイルシステムを使用してFileSystemを実装します。

FileSystem.Openメソッドは'/'で区切られたパスを取りますが、Dirの文字列値はURLではなくネイティブファイルシステム上のファイル名であるため、filepath.Separatorで区切られます。これは必ずしも'/'ではありません。

Dirは、機密ファイルやディレクトリを公開する可能性があります。Dirは、ディレクトリツリーから外部を指すシンボリックリンクを追跡します。これは、ユーザーが任意のシンボリックリンクを作成できるディレクトリからサービスを提供する場合に特に危険です。Dirは、ピリオドで始まるファイルやディレクトリにもアクセスを許可します。これには、.gitのような機密ディレクトリや.htpasswdのような機密ファイルが含まれます。ピリオドで始まるファイルを除外するには、ファイル/ディレクトリをサーバーから削除するか、カスタムFileSystem実装を作成してください。

空のDirは"."として扱われます。

func (Dir) Open ¶

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

Openは、os.Openを使用して、ディレクトリdにルートされ、相対的なファイルを読み取るためにFileSystemを実装します。

type File ¶

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

FileSystemのOpenメソッドによって返され、FileServer実装によって提供されるファイルです。

メソッドは、 *os.File と同じ動作をする必要があります。

type FileSystem ¶

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

FileSystemは、名前付きファイルのコレクションへのアクセスを実装します。ファイルパスの要素は、ホストオペレーティングシステムの規約に関係なく、スラッシュ（'/'、U+002F）で区切られます。 FileSystemをHandlerに変換するには、FileServer関数を参照してください。

このインターフェースは、fs.FSインターフェースより前に存在しており、代わりに使用できます。 FSアダプター関数は、fs.FSをFileSystemに変換します。

func FS ¶ added in v1.16.0

func FS(fsys fs.FS) FileSystem

FSは、fsysをFileSystem実装に変換し、FileServerおよびNewFileTransportで使用するために使用されます。 fsysによって提供されるファイルは、io.Seekerを実装する必要があります。

type Flusher ¶

type Flusher interface {
	// Flush sends any buffered data to the client.
	Flush()
}

Flusherインターフェースは、HTTPハンドラーがバッファリングされたデータをクライアントにフラッシュすることを許可するResponseWriterによって実装されます。

デフォルトのHTTP/1.xおよびHTTP/2 ResponseWriter実装はFlusherをサポートしていますが、ResponseWriterラッパーはサポートしていない場合があります。ハンドラーは常にランタイムでこの機能をテストする必要があります。

FlushをサポートするResponseWriterであっても、クライアントがHTTPプロキシを介して接続されている場合、バッファリングされたデータがレスポンスが完了するまでクライアントに到達しない場合があります。

type Handler ¶

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

Handlerは、HTTPリクエストに応答します。

ServeHTTPは、応答ヘッダーとデータをResponseWriterに書き込んでから返す必要があります。返すことで、リクエストが完了したことを示します。 ServeHTTP呼び出しの完了後または同時に、ResponseWriterを使用するか、Request.Bodyから読み取ることは無効です。

HTTPクライアントソフトウェア、HTTPプロトコルバージョン、およびクライアントとGoサーバーの間の中間者によっては、 ResponseWriterに書き込んだ後にRequest.Bodyから読み取ることができない場合があります。慎重なハンドラーは、最初にRequest.Bodyを読み取り、その後に返信する必要があります。

ボディを読み取る以外の場合、ハンドラーは提供されたRequestを変更してはいけません。

ServeHTTPがパニックを起こすと、サーバー（ServeHTTPの呼び出し元）は、パニックの影響がアクティブなリクエストに限定されたと仮定します。サーバーはパニックを回復し、サーバーエラーログにスタックトレースを記録し、ネットワーク接続を閉じるか、HTTP/2 RST_STREAMを送信します。クライアントが中断された応答を見るが、サーバーがエラーをログに記録しないように、ErrAbortHandlerの値でパニックを発生させることで、ハンドラーを中止できます。

func AllowQuerySemicolons ¶ added in v1.17.0

func AllowQuerySemicolons(h Handler) Handler

AllowQuerySemicolonsは、URLクエリ内のエスケープされていないセミコロンをアンパサンドに変換し、ハンドラhを呼び出すハンドラを返します。

これにより、Go 1.17以前のクエリパラメータをセミコロンとアンパサンドの両方で分割する動作が復元されます（golang.org/issue/25192 を参照）。ただし、この動作は多くのプロキシと一致せず、不一致がセキュリティ上の問題を引き起こす可能性があります。

AllowQuerySemicolonsは、Request.ParseFormが呼び出される前に呼び出す必要があります。

func FileServer ¶

func FileServer(root FileSystem) Handler

FileServerは、ルートでルートされたファイルシステムの内容でHTTPリクエストを処理するハンドラーを返します。

特別な場合として、返されたファイルサーバーは、"/index.html"で終わるリクエストを、最後の"index.html"を除いた同じパスにリダイレクトします。

オペレーティングシステムのファイルシステム実装を使用するには、http.Dirを使用してください。

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

fs.FS実装を使用するには、http.FSを使用して変換してください。

http.Handle("/", http.FileServer(http.FS(fsys)))

Example ¶

package main

import (
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net/http"
)

func main() {
	// シンプルな静的 Web サーバー:
	log.Fatal(http.ListenAndServe(":8080", http.FileServer(http.Dir("/usr/share/doc"))))
}

Output:

Example (DotFileHiding) ¶

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

Output:

Example (StripPrefix) ¶

package main

import (
	"github.com/shogo82148/std/net/http"
)

func main() {
	// ディスク上のディレクトリ (/tmp) を別の URL パス (/tmpfiles/) の下で提供するには、
	// StripPrefix を使用して、FileServer がそれを見る前に
	// リクエスト URL のパスを変更します。
	http.Handle("/tmpfiles/", http.StripPrefix("/tmpfiles/", http.FileServer(http.Dir("/tmp"))))
}

Output:

func MaxBytesHandler ¶ added in v1.18.0

func MaxBytesHandler(h Handler, n int64) Handler

MaxBytesHandlerは、ResponseWriterとRequest.BodyをMaxBytesReaderでラップしてhを実行するハンドラを返します。

func NotFoundHandler ¶

func NotFoundHandler() Handler

NotFoundHandlerは、各リクエストに「404ページが見つかりません」という応答を返す単純なリクエストハンドラーを返します。

Example ¶

mux := http.NewServeMux()

// Create sample handler to returns 404
mux.Handle("/resources", http.NotFoundHandler())

// Create sample handler that returns 200
mux.Handle("/resources/people/", newPeopleHandler())

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

Output:

func RedirectHandler ¶

func RedirectHandler(url string, code int) Handler

RedirectHandlerは、受信した各リクエストを、指定されたステータスコードを使用して、指定されたURLにリダイレクトするリクエストハンドラーを返します。

提供されたコードは通常、StatusMovedPermanently、StatusFound、またはStatusSeeOtherの3xx範囲にあります。

func StripPrefix ¶

func StripPrefix(prefix string, h Handler) Handler

StripPrefixは、リクエストURLのPath（および設定されている場合はRawPath）から指定された接頭辞を削除し、ハンドラーhを呼び出してHTTPリクエストを処理するハンドラーを返します。 prefixで始まらないパスのリクエストには、HTTP 404 not foundエラーで応答します。接頭辞は完全に一致する必要があります。リクエストの接頭辞にエスケープされた文字が含まれている場合、応答もHTTP 404 not foundエラーになります。

Example ¶

package main

import (
	"github.com/shogo82148/std/net/http"
)

func main() {
	// ディスク上のディレクトリ (/tmp) を別の URL パス (/tmpfiles/) の下で提供するには、
	// StripPrefix を使用して、FileServer がそれを見る前に
	// リクエスト URL のパスを変更します。
	http.Handle("/tmpfiles/", http.StripPrefix("/tmpfiles/", http.FileServer(http.Dir("/tmp"))))
}

Output:

func TimeoutHandler ¶

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

ListenAndServeTLSは、TCPネットワークアドレスsrv.Addrでリッスンし、 ServeTLSを呼び出して着信TLS接続のリクエストを処理します。受け入れられた接続は、TCP keep-alivesを有効にするように構成されます。

サーバーのTLSConfig.CertificatesまたはTLSConfig.GetCertificateがどちらも設定されていない場合、サーバーの証明書と対応する秘密鍵が含まれるファイルを提供する必要があります。証明書が認証局によって署名されている場合、certFileはサーバーの証明書、中間証明書、およびCAの証明書を連結したものである必要があります。

srv.Addrが空白の場合、":https"が使用されます。

ListenAndServeTLSは常に非nilのエラーを返します。ShutdownまたはCloseの後、返されるエラーはErrServerClosedです。

type HandlerFunc ¶

type HandlerFunc func(ResponseWriter, *Request)

HandlerFunc型は、HTTPハンドラーとして通常の関数を使用できるようにするためのアダプタです。 fが適切なシグネチャを持つ関数である場合、HandlerFunc(f)はfを呼び出すHandlerです。

func (HandlerFunc) ServeHTTP ¶

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

ServeHTTPは、f(w, r) を呼び出します。

type Header ¶

type Header map[string][]string

キーは、CanonicalHeaderKeyが返すように正規化された形式である必要があります。

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

Addは、ヘッダーにキーと値のペアを追加します。キーに関連付けられた既存の値に追加します。キーは大文字小文字を区別せず、CanonicalHeaderKeyによって正規化されます。

func (h Header) Clone() Header

Cloneは、hのコピーを返します。hがnilの場合はnilを返します。

func (h Header) Del(key string)

Delは、キーに関連付けられた値を削除します。キーは大文字小文字を区別せず、CanonicalHeaderKeyによって正規化されます。

func (h Header) Get(key string) string

Getは、指定されたキーに関連付けられた最初の値を取得します。キーに関連付けられた値がない場合、Getは""を返します。大文字小文字を区別せず、textproto.CanonicalMIMEHeaderKeyが提供されたキーを正規化することに注意してください。 Getは、すべてのキーが正規形式で格納されていると想定しています。非正規のキーを使用するには、直接マップにアクセスしてください。

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

Setは、キーに関連付けられたヘッダーエントリを単一の要素値に設定します。キーに関連付けられた既存の値を置き換えます。キーは大文字小文字を区別せず、textproto.CanonicalMIMEHeaderKeyによって正規化されます。非正規のキーを使用するには、直接マップに割り当ててください。

func (h Header) Values(key string) []string

Valuesは、指定されたキーに関連付けられたすべての値を返します。大文字小文字を区別せず、textproto.CanonicalMIMEHeaderKeyが提供されたキーを正規化することに注意してください。非正規のキーを使用するには、直接マップにアクセスしてください。返されるスライスはコピーではありません。

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

Writeは、ワイヤーフォーマットでヘッダーを書き込みます。

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

WriteSubsetはワイヤーフォーマットでヘッダーを書き込みます。 excludeがnilでない場合、exclude[key] == trueのキーは書き込まれません。 excludeマップをチェックする前にキーは正規化されません。

type Hijacker ¶

type Hijacker interface {
	// Hijackは、呼び出し元が接続を引き継ぐことを可能にします。
	// Hijackの呼び出し後、HTTPサーバーライブラリは
	// その接続に対して何も行いません。
	//
	// 接続の管理とクローズは、呼び出し元の責任となります。
	//
	// 返されるnet.Connは、サーバーの設定により、
	// すでに設定されている読み取りまたは書き込みの期限を持つ可能性があります。
	// それらの期限を必要に応じて設定またはクリアするのは、呼び出し元の責任です。
	//
	// 返されるbufio.Readerには、クライアントからの未処理のバッファリングされた
	// データが含まれている可能性があります。
	//
	// Hijackの呼び出し後、元のRequest.Bodyは使用してはなりません。
	// 元のRequestのContextは有効であり、RequestのServeHTTPメソッドが
	// 戻るまでキャンセルされません。
	Hijack() (net.Conn, *bufio.ReadWriter, error)
}

Hijackerインターフェースは、HTTPハンドラーが接続を引き継ぐことを許可するResponseWriterによって実装されます。

HTTP/1.x接続のデフォルトResponseWriterはHijackerをサポートしていますが、HTTP/2接続は意図的にサポートしていません。 ResponseWriterラッパーもHijackerをサポートしていない場合があります。ハンドラーは常にランタイムでこの機能をテストする必要があります。

Example ¶

package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net/http"
)

func main() {
	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()
	})
}

Output:

type MaxBytesError ¶ added in v1.19.0

type MaxBytesError struct {
	Limit int64
}

MaxBytesErrorは、MaxBytesReaderの読み取り制限を超えた場合にMaxBytesReaderによって返されます。

func (*MaxBytesError) Error ¶ added in v1.19.0

func (e *MaxBytesError) Error() string

type ProtocolError deprecated

type ProtocolError struct {
	ErrorString string
}

ProtocolErrorは、HTTPプロトコルエラーを表します。

Deprecated: httpパッケージのすべてのプロトコルエラーに関連するエラーがProtocolError型ではありません。

func (*ProtocolError) Error ¶

func (pe *ProtocolError) Error() string

func (*ProtocolError) Is ¶ added in v1.21.0

func (pe *ProtocolError) Is(err error) bool

Isは、http.ErrNotSupportedがerrors.ErrUnsupportedに一致するようにします。

type PushOptions ¶ added in v1.8.0

type PushOptions struct {

	// Methodは要求されたリクエストのHTTPメソッドを指定します。
	// 設定する場合、"GET"または"HEAD"でなければなりません。空は"GET"を意味します。
	Method string

	// Headerは追加の約束されたリクエストヘッダーを指定します。これには":path"や":scheme"などのHTTP/2疑似ヘッダーフィールドは含めることができませんが、これらは自動的に追加されます。
	Header Header
}

PushOptionsは、Pusher.Pushのオプションを記述します。

type Pusher ¶ added in v1.8.0

type Pusher interface {
	// Pushは、HTTP/2サーバープッシュを開始します。これは、指定されたターゲットとオプションを使用して合成リクエストを構築し、
	// そのリクエストをPUSH_PROMISEフレームにシリアライズし、そのリクエストをサーバーのリクエストハンドラを使用してディスパッチします。
	// optsがnilの場合、デフォルトのオプションが使用されます。
	//
	// ターゲットは、絶対パス（"/path"のような）または親リクエストと同じスキームと有効なホストを含む絶対URLでなければなりません。
	// ターゲットがパスの場合、親リクエストのスキームとホストを継承します。
	//
	// HTTP/2の仕様では、再帰的なプッシュとクロスオーソリティプッシュが禁止されています。
	// Pushはこれらの無効なプッシュを検出するかもしれませんし、検出しないかもしれません。しかし、無効な
	// プッシュは、準拠しているクライアントによって検出され、キャンセルされます。
	//
	// URL Xをプッシュしたいハンドラは、URL Xのリクエストをトリガーする可能性のあるデータを送信する前にPushを呼び出すべきです。
	// これにより、クライアントがXのPUSH_PROMISEを受信する前にXのリクエストを発行するというレース条件を回避します。
	//
	// Pushは別のゴルーチンで実行されるため、到着の順序は非決定的です。
	// 必要な同期は呼び出し元によって実装する必要があります。
	//
	// Pushは、クライアントがプッシュを無効にした場合、または基本となる接続でプッシュがサポートされていない場合、ErrNotSupportedを返します。
	Push(target string, opts *PushOptions) error
}

Pusherは、HTTP/2サーバープッシュをサポートするResponseWritersによって実装されるインターフェースです。詳細については、 https://tools.ietf.org/html/rfc7540#section-8.2 を参照してください。

type Request ¶

type Request struct {
	// Methodは、HTTPメソッド（GET、POST、PUTなど）を指定します。
	// クライアントリクエストの場合、空の文字列はGETを意味します。
	//
	// GoのHTTPクライアントは、CONNECTメソッドでリクエストを送信することをサポートしていません。
	// 詳細については、Transportのドキュメントを参照してください。
	Method string

	// URLは、サーバーリクエストの場合に要求されるURI（URI）を指定するか、
	// クライアントリクエストの場合にアクセスするURLを指定します。
	//
	// サーバーリクエストの場合、URLはRequestURIに格納されたRequest-Lineで指定されたURIから解析されます。
	// ほとんどのリクエストでは、PathとRawQuery以外のフィールドは空になります。 （RFC 7230、セクション5.3を参照）
	//
	// クライアントリクエストの場合、URLのHostは接続するサーバーを指定し、
	// RequestのHostフィールドはHTTPリクエストで送信するHostヘッダー値をオプションで指定します。
	URL *url.URL

	// サーバーリクエストのプロトコルバージョン。
	//
	// クライアントリクエストの場合、これらのフィールドは無視されます。
	// HTTPクライアントコードは常にHTTP/1.1またはHTTP/2を使用します。
	// 詳細については、Transportのドキュメントを参照してください。
	Proto      string
	ProtoMajor int
	ProtoMinor int

	// 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ヘッダーはRequest.Hostフィールドに昇格し、Headerマップから削除されます。
	//
	// HTTPは、ヘッダー名が大文字小文字を区別しないことを定義しています。リクエストパーサーは、CanonicalHeaderKeyを使用してこれを実装し、ハイフンの後に続く最初の文字と任意の文字を大文字にし、残りを小文字にします。
	//
	// クライアントリクエストの場合、Content-LengthやConnectionなどの特定のヘッダーは必要に応じて自動的に書き込まれ、Headerの値は無視される場合があります。Request.Writeメソッドのドキュメントを参照してください。
	Header Header

	// Bodyは、リクエストの本文です。
	//
	// クライアントリクエストの場合、nilのBodyは、GETリクエストなど、リクエストに本文がないことを意味します。
	// HTTPクライアントのTransportは、Closeメソッドを呼び出す責任があります。
	//
	// サーバーリクエストの場合、Request Bodyは常にnilではありませんが、本文が存在しない場合はすぐにEOFが返されます。
	// サーバーはリクエストボディを閉じます。ServeHTTPハンドラーは閉じる必要はありません。
	//
	// Bodyは、ReadがCloseと同時に呼び出されることを許可する必要があります。
	// 特に、Closeを呼び出すと、入力を待機しているReadがブロックされている場合は、それを解除する必要があります。
	Body io.ReadCloser

	// GetBodyは、Bodyの新しいコピーを返すオプションの関数を定義します。
	// リダイレクトにより、Bodyを複数回読み取る必要がある場合にクライアントリクエストで使用されます。
	// GetBodyの使用には、Bodyを設定する必要があります。
	//
	// サーバーリクエストの場合、使用されません。
	GetBody func() (io.ReadCloser, error)

	// ContentLengthは、関連するコンテンツの長さを記録します。
	// 値-1は、長さが不明であることを示します。
	// 値が0以上の場合、Bodyから指定されたバイト数を読み取ることができます。
	//
	// クライアントリクエストの場合、Bodyがnilでない場合、値0は不明として扱われます。
	ContentLength int64

	// TransferEncodingは、最も外側から最も内側までの転送エンコーディングをリストします。
	// 空のリストは「identity」エンコーディングを示します。
	// TransferEncodingは通常無視できます。チャンクエンコーディングは、
	// リクエストの送信と受信時に必要に応じて自動的に追加および削除されます。
	TransferEncoding []string

	// Closeは、このリクエストに応答した後（サーバーの場合）またはこのリクエストを送信してその応答を読み取った後（クライアントの場合）に接続を閉じるかどうかを示します。
	//
	// サーバーリクエストの場合、HTTPサーバーがこれを自動的に処理し、このフィールドはHandlersによって必要ではありません。
	//
	// クライアントリクエストの場合、このフィールドを設定すると、 Transport.DisableKeepAlives が設定された場合と同様に、同じホストへのリクエスト間でTCP接続の再利用が防止されます。
	Close bool

	// サーバーリクエストの場合、HostはURLが要求されるホストを指定します。
	// HTTP/1（RFC 7230、セクション5.4による）の場合、これは「Host」ヘッダーの値またはURL自体で指定されたホスト名のいずれかです。
	// HTTP/2の場合、これは「:authority」疑似ヘッダーフィールドの値です。
	// 形式は「host:port」にすることができます。
	// 国際ドメイン名の場合、HostはPunycodeまたはUnicode形式である場合があります。
	// 必要に応じて、golang.org/x/net/idna を使用してどちらの形式にも変換できます。
	// DNSリバインディング攻撃を防ぐために、サーバーハンドラーは、Hostヘッダーがハンドラー自身が権限を持つ値であることを検証する必要があります。
	// 含まれるServeMuxは、特定のホスト名に登録されたパターンをサポートし、その登録されたハンドラーを保護します。
	//
	// クライアントリクエストの場合、HostはオプションでHostヘッダーを上書きして送信します。
	// 空の場合、Request.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値が含まれます。
	// （クライアントは、後で送信するトレーラーを宣言します。）
	// ハンドラーがBodyから読み取っている間、Trailerに参照しないでください。
	// Bodyからの読み取りがEOFを返した後、Trailerを再度読み取ると、クライアントが送信した場合は非nil値が含まれます。
	//
	// クライアントリクエストの場合、Trailerは、後で送信するトレーラーキーを含むマップで初期化する必要があります。
	// 値はnilまたは最終値である場合があります。ContentLengthは0または-1である必要があります。
	// HTTPリクエストが送信された後、マップの値は、リクエストボディが読み取られている間に更新できます。
	// ボディがEOFを返した後、呼び出し元はTrailerを変更してはいけません。
	//
	// 少数のHTTPクライアント、サーバー、またはプロキシがHTTPトレーラーをサポートしています。
	Trailer Header

	// RemoteAddrは、HTTPサーバーやその他のソフトウェアが、通常はログ記録のためにリクエストを送信したネットワークアドレスを記録できるようにします。
	// このフィールドはReadRequestによって入力されず、定義された形式はありません。
	// このパッケージのHTTPサーバーは、ハンドラーを呼び出す前にRemoteAddrを「IP:port」アドレスに設定します。
	// このフィールドはHTTPクライアントによって無視されます。
	RemoteAddr string

	// RequestURIは、クライアントがサーバーに送信したRequest-Line（RFC 7230、セクション3.1.1）の変更されていないリクエストターゲットです。
	// 通常、URLフィールドを代わりに使用する必要があります。
	// HTTPクライアントリクエストでこのフィールドを設定することはエラーです。
	RequestURI string

	// TLSは、HTTPサーバーやその他のソフトウェアが、リクエストを受信したTLS接続に関する情報を記録できるようにします。
	// このフィールドはReadRequestによって入力されず、定義された形式はありません。
	// このパッケージのHTTPサーバーは、ハンドラーを呼び出す前にTLS有効な接続のためにこのフィールドを設定します。
	// それ以外の場合は、このフィールドをnilのままにします。
	// このフィールドはHTTPクライアントによって無視されます。
	TLS *tls.ConnectionState

	// Cancelは、クライアントリクエストがキャンセルされたと見なす必要があることを示すチャネルのオプションです。
	// RoundTripperのすべての実装がCancelをサポートしているわけではありません。
	//
	// サーバーリクエストの場合、このフィールドは適用されません。
	//
	// Deprecated: NewRequestWithContextでRequestのコンテキストを設定してください。
	// RequestのCancelフィールドとコンテキストの両方が設定されている場合、Cancelが尊重されるかどうかは未定義です。
	Cancel <-chan struct{}

	// Responseは、このリクエストが作成されたクライアントリダイレクト中にのみ設定されるリダイレクトレスポンスです。
	Response *Response
	// contains filtered or unexported fields
}

Requestは、サーバーによって受信されたHTTPリクエストまたはクライアントによって送信されるHTTPリクエストを表します。

フィールドの意味は、クライアントとサーバーの使用方法でわずかに異なります。以下のフィールドに関する注意事項に加えて、Request.WriteおよびRoundTripperのドキュメントを参照してください。

func NewRequest ¶

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

NewRequestWithContextは、context.Backgroundを使用してNewRequestWithContextをラップします。

func NewRequestWithContext ¶ added in v1.13.0

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

NewRequestWithContextは、メソッド、URL、およびオプションのボディが与えられた場合に新しいRequestを返します。

提供されたボディがio.Closerでもある場合、返されたRequest.Bodyはbodyに設定され、ClientメソッドDo、Post、およびPostForm、およびTransport.RoundTripによって閉じられます。

NewRequestWithContextは、Client.Do または Transport.RoundTrip で使用するためのRequestを返します。 Server Handlerをテストするためのリクエストを作成するには、net/http/httptestパッケージのNewRequest関数を使用するか、 ReadRequestを使用するか、またはRequestフィールドを手動で更新します。送信元のクライアントリクエストの場合、コンテキストはリクエストとその応答の全寿命を制御します：接続の取得、リクエストの送信、および応答ヘッダーとボディの読み取り。入力リクエストフィールドと出力リクエストフィールドの違いについては、Requestタイプのドキュメントを参照してください。

bodyが *bytes.Buffer、 *bytes.Reader、または *strings.Readerの場合、返されたリクエストのContentLengthはその正確な値に設定されます（-1の代わりに）、 GetBodyが作成されます（307および308のリダイレクトがボディを再生できるように）、およびContentLengthが0の場合はBodyがNoBodyに設定されます。

func ReadRequest ¶

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

ReadRequestは、bから受信したリクエストを読み取り、解析します。

ReadRequestは、低レベルの関数であり、特殊なアプリケーションにのみ使用する必要があります。ほとんどのコードは、Serverを使用してリクエストを読み取り、Handlerインターフェイスを介して処理する必要があります。 ReadRequestは、HTTP / 1.xリクエストのみをサポートしています。 HTTP / 2の場合は、golang.org/x/net/http2を使用してください。

func (*Request) AddCookie ¶

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

AddCookieは、リクエストにクッキーを追加します。RFC 6265セクション5.4に従い、 AddCookieは1つ以上のCookieヘッダーフィールドを添付しません。つまり、すべてのクッキーが、セミコロンで区切られた同じ行に書き込まれます。 AddCookieは、cの名前と値をサニタイズするだけで、すでにリクエストに存在するCookieヘッダーをサニタイズしません。

func (*Request) BasicAuth ¶ added in v1.4.0

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

BasicAuthは、リクエストがHTTP Basic認証を使用する場合、リクエストのAuthorizationヘッダーで提供されるユーザー名とパスワードを返します。 RFC 2617、セクション2を参照してください。

func (*Request) Clone ¶ added in v1.13.0

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

Cloneは、そのコンテキストをctxに変更したrのディープコピーを返します。提供されたctxはnilであってはなりません。

出力クライアントリクエストの場合、コンテキストはリクエストとそのレスポンスのライフタイム全体を制御します：接続の取得、リクエストの送信、レスポンスヘッダーとボディの読み取り。

新しいコンテキストを持つリクエストを作成するには、NewRequestWithContextを使用します。コンテキストを変更せずに新しいリクエストを作成するには、Request.WithContextを使用します。

func (*Request) Context ¶ added in v1.7.0

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

Contextは、リクエストのコンテキストを返します。コンテキストを変更するには、CloneまたはWithContextを使用してください。

返されるコンテキストは常にnilではありません。デフォルトでは、バックグラウンドコンテキストになります。

出力クライアントリクエストの場合、コンテキストはキャンセルを制御します。

入力サーバーリクエストの場合、クライアントの接続が閉じられたとき、リクエストがキャンセルされたとき（HTTP/2で）、またはServeHTTPメソッドが返されたときに、コンテキストがキャンセルされます。

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

Cookieは、リクエストで提供された名前付きクッキーを返します。クッキーが見つからない場合はErrNoCookieを返します。複数のクッキーが指定された名前に一致する場合、1つのクッキーのみが返されます。

func (*Request) Cookies ¶

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

Cookiesは、リクエストで送信されたHTTPクッキーを解析して返します。

func (*Request) FormFile ¶

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

FormFileは、指定されたフォームキーの最初のファイルを返します。必要に応じて、FormFileはParseMultipartFormおよびParseFormを呼び出します。

func (*Request) FormValue ¶

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

FormValueは、クエリの名前付きコンポーネントの最初の値を返します。 POSTおよびPUTボディパラメータは、URLクエリ文字列値より優先されます。 FormValueは必要に応じてParseMultipartFormおよびParseFormを呼び出し、これらの関数によって返されたエラーを無視します。キーが存在しない場合、FormValueは空の文字列を返します。同じキーの複数の値にアクセスするには、ParseFormを呼び出して、その後Request.Formを直接調べます。

func (*Request) MultipartReader ¶

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

MultipartReaderは、これがmultipart/form-dataまたはmultipart/mixed POSTリクエストである場合、MIMEマルチパートリーダーを返します。それ以外の場合はnilとエラーを返します。リクエストボディをストリームとして処理するために、ParseMultipartFormの代わりにこの関数を使用してください。

func (*Request) ParseForm ¶

func (r *Request) ParseForm() error

ParseFormはr.Formとr.PostFormを埋めます。

すべてのリクエストに対して、ParseFormはURLから生のクエリを解析し、r.Formを更新します。

POST、PUT、およびPATCHリクエストの場合、それはまた、リクエストボディを読み取り、フォームとして解析し、その結果をr.PostFormとr.Formの両方に入れます。リクエストボディのパラメータは、r.FormのURLクエリ文字列値より優先されます。

リクエストボディのサイズがすでにMaxBytesReaderによって制限されていない場合、サイズは10MBに制限されます。

他のHTTPメソッド、またはContent-Typeがapplication/x-www-form-urlencodedでない場合、リクエストボディは読み取られず、r.PostFormはnilでない空の値に初期化されます。

ParseMultipartFormは自動的にParseFormを呼び出します。 ParseFormは冪等です。

func (*Request) ParseMultipartForm ¶

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

ParseMultipartFormは、リクエストボディをmultipart/form-dataとして解析します。リクエストボディ全体が解析され、そのファイルパーツの最大maxMemoryバイトがメモリに格納され、残りは一時ファイルに格納されます。 ParseMultipartFormは必要に応じてParseFormを呼び出します。 ParseFormがエラーを返した場合、ParseMultipartFormはそれを返しますが、リクエストボディの解析を続けます。 ParseMultipartFormを1回呼び出した後、以降の呼び出しは効果がありません。

func (*Request) PostFormValue ¶ added in v1.1.0

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

PostFormValueは、POST、PATCH、またはPUTリクエストボディの名前付きコンポーネントの最初の値を返します。 URLクエリパラメータは無視されます。 PostFormValueは必要に応じてParseMultipartFormおよびParseFormを呼び出し、これらの関数によって返されたエラーを無視します。キーが存在しない場合、PostFormValueは空の文字列を返します。

func (*Request) ProtoAtLeast ¶

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

ProtoAtLeastは、リクエストで使用されるHTTPプロトコルがmajor.minor以上であるかどうかを報告します。

func (*Request) Referer ¶

func (r *Request) Referer() string

Refererは、リクエストで送信された場合に参照元のURLを返します。

Refererは、HTTPの初期の日々からの誤りで、リクエスト自体で誤ってスペルがされています。この値はHeader["Referer"]としてHeaderマップから取得することもできますが、メソッドとして利用可能にすることの利点は、代替の（正しい英語の）スペルreq.Referrer()を使用するプログラムをコンパイラが診断できるが、 Header["Referrer"]を使用するプログラムを診断できないことです。

func (*Request) SetBasicAuth ¶

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

SetBasicAuthは、提供されたユーザー名とパスワードを使用して、HTTP Basic認証を使用するようにリクエストのAuthorizationヘッダーを設定します。

HTTP Basic認証では、提供されたユーザー名とパスワードは暗号化されません。 HTTPSリクエストでのみ使用することが一般的です。

ユーザー名にはコロンを含めることはできません。一部のプロトコルでは、ユーザー名とパスワードを事前にエスケープする追加の要件がある場合があります。たとえば、OAuth2と一緒に使用する場合、両方の引数を最初にurl.QueryEscapeでURLエンコードする必要があります。

func (*Request) UserAgent ¶

func (r *Request) UserAgent() string

UserAgentは、リクエストで送信された場合にクライアントのUser-Agentを返します。

func (*Request) WithContext ¶ added in v1.7.0

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

WithContextは、そのコンテキストをctxに変更したrの浅いコピーを返します。提供されたctxはnilであってはなりません。

出力クライアントリクエストの場合、コンテキストはリクエストとそのレスポンスのライフタイム全体を制御します：接続の取得、リクエストの送信、レスポンスヘッダーとボディの読み取り。

コンテキストを持つ新しいリクエストを作成するには、NewRequestWithContextを使用します。新しいコンテキストを持つリクエストのディープコピーを作成するには、Request.Cloneを使用します。

func (*Request) Write ¶

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

Writeは、ワイヤフォーマットでHTTP/1.1リクエスト（ヘッダーとボディ）を書き込みます。このメソッドは、リクエストの以下のフィールドを参照します。

Host
URL
Method（デフォルトは "GET"）
Header
ContentLength
TransferEncoding
Body

Bodyが存在し、Content-Lengthが0以下であり、TransferEncodingが "identity"に設定されていない場合、 Writeはヘッダーに "Transfer-Encoding: chunked"を追加します。Bodyは送信後に閉じられます。

func (*Request) WriteProxy ¶

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

WriteProxyは、Writeと似ていますが、HTTPプロキシが期待する形式でリクエストを書き込みます。特に、WriteProxyは、RFC 7230のセクション5.3に従って、スキームとホストを含む絶対URIでリクエストの最初のRequest-URI行を書き込みます。 WriteProxyは、r.Host または r.URL.Host を使用して、Hostヘッダーも書き込みます。

type Response ¶

type Response struct {
	Status     string
	StatusCode int
	Proto      string
	ProtoMajor int
	ProtoMinor int

	// Headerは、ヘッダーキーを値にマップします。
	// レスポンスに同じキーを持つ複数のヘッダーがある場合、それらはカンマ区切りで連結される場合があります。
	// (RFC 7230、セクション3.2.2では、複数のヘッダーがカンマ区切りのシーケンスとして意味的に等価である必要があります。)
	// Headerの値がこの構造体の他のフィールド(ContentLength、TransferEncoding、Trailerなど)によって重複する場合、フィールド値が優先されます。
	//
	// マップ内のキーは正準化されます(CanonicalHeaderKeyを参照)。
	Header Header

	// Bodyは、レスポンスボディを表します。
	//
	// レスポンスボディは、Bodyフィールドが読み取られるたびにオンデマンドでストリーミングされます。
	// ネットワーク接続が失敗した場合や、サーバーがレスポンスを終了した場合、Body.Read呼び出しはエラーを返します。
	//
	// http ClientおよびTransportは、Bodyが常にnilでないことを保証します。
	// これは、ボディのないレスポンスまたは長さがゼロのボディを持つレスポンスでも同様です。
	// Bodyを閉じるのは呼び出し側の責任です。
	// デフォルトのHTTPクライアントのTransportは、Bodyが完全に読み取られて閉じられていない場合、
	// HTTP/1.xの「keep-alive」TCP接続を再利用しない場合があります。
	//
	// サーバーが「chunked」Transfer-Encodingで返答した場合、Bodyは自動的にデチャンクされます。
	//
	// Go 1.12以降、Bodyは、WebSocketsおよびHTTP/2の「h2c」モードで使用される「101 Switching Protocols」レスポンスに成功した場合、io.Writerも実装します。
	Body io.ReadCloser

	// ContentLengthは、関連するコンテンツの長さを記録します。
	// 値-1は、長さが不明であることを示します。
	// Request.Methodが"HEAD"でない限り、0以上の値は、Bodyから指定されたバイト数を読み取ることができることを示します。
	ContentLength int64

	// TransferEncodingは、最も外側から最も内側の転送エンコーディングを含みます。
	// 値がnilの場合、"identity"エンコーディングが使用されます。
	TransferEncoding []string

	// Closeは、ヘッダーがBodyの読み取り後に接続を閉じるよう指示したかどうかを記録します。
	// この値はクライアントに対するアドバイスです。
	// ReadResponseまたはResponse.Writeは、接続を閉じません。
	Close bool

	// Uncompressedは、レスポンスが圧縮されて送信されたが、httpパッケージによって解凍されたかどうかを報告します。
	// trueの場合、Bodyから読み取ると、サーバーから実際に設定された圧縮されたコンテンツの代わりに、解凍されたコンテンツが返されます。
	// ContentLengthは-1に設定され、"Content-Length"および"Content-Encoding"フィールドはresponseHeaderから削除されます。
	// サーバーからの元のレスポンスを取得するには、Transport.DisableCompressionをtrueに設定します。
	Uncompressed bool

	// Trailerは、トレーラーキーをHeaderと同じ形式の値にマップします。
	//
	// Trailerには最初に、サーバーの"Trailer"ヘッダー値で指定されたキーごとに1つのnil値のみが含まれます。
	// これらの値はHeaderに追加されません。
	//
	// BodyのRead呼び出しと同時にTrailerにアクセスしないでください。
	//
	// Body.Readがio.EOFを返した後、Trailerにはサーバーから送信されたトレーラー値が含まれます。
	Trailer Header

	// Requestは、このResponseを取得するために送信されたリクエストです。
	// RequestのBodyはnilです(すでに消費されています)。
	// これは、クライアントリクエストに対してのみ設定されます。
	Request *Request

	// TLSは、レスポンスを受信したTLS接続に関する情報を含みます。
	// 非暗号化のレスポンスの場合、nilです。
	// このポインタはレスポンス間で共有され、変更してはいけません。
	TLS *tls.ConnectionState
}

Responseは、HTTPリクエストからのレスポンスを表します。

ClientとTransportは、レスポンスヘッダが受信された後、サーバーからResponsesを返します。レスポンスボディは、Bodyフィールドが読み取られるたびにオンデマンドでストリーミングされます。

func Get ¶

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

Getは、指定されたURLにGETを発行します。レスポンスが次のリダイレクトコードの1つである場合、 Getはリダイレクトに従います。最大10回のリダイレクトまで:

301（Moved Permanently）
302（Found）
303（See Other）
307（Temporary Redirect）
308（Permanent Redirect）

リダイレクトが多すぎる場合や、HTTPプロトコルエラーがあった場合はエラーが返されます。非2xxレスポンスはエラーを引き起こしません。任意の返されたエラーは*url.Error型です。url.ErrorのTimeoutメソッドは、リクエストがタイムアウトした場合にtrueを報告します。

errがnilの場合、respには常に非nilのresp.Bodyが含まれます。呼び出し元は、resp.Bodyの読み取りが完了したらresp.Bodyを閉じる必要があります。

Getは、DefaultClient.Getのラッパーです。

カスタムヘッダーでリクエストを作成するには、NewRequestとDefaultClient.Doを使用します。

指定されたcontext.Contextでリクエストを作成するには、NewRequestWithContextとDefaultClient.Doを使用します。

Example ¶

package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net/http"
)

func main() {
	res, err := http.Get("http://www.google.com/robots.txt")
	if err != nil {
		log.Fatal(err)
	}
	body, err := io.ReadAll(res.Body)
	res.Body.Close()
	if res.StatusCode > 299 {
		log.Fatalf("Response failed with status code: %d and\nbody: %s\n", res.StatusCode, body)
	}
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("%s", body)
}

Output:

func Head ¶

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

Headは、指定されたURLに対してHEADリクエストを発行します。レスポンスが以下のリダイレクトコードのいずれかである場合、 Headはリダイレクションをフォローします。最大10回のリダイレクトが許可されます：

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

HeadはDefaultClient.Headのラッパーです。

指定したcontext.Contextでリクエストを作成するには、NewRequestWithContextとDefaultClient.Doを使用します。

func Post ¶

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

Postは、指定されたURLに対してPOSTメソッドを送信します。

呼び出し元は、resp.Bodyの読み込みが完了したらresp.Bodyを閉じる必要があります。

もし提供されたBodyがio.Closerを実装している場合は、リクエストの後で閉じられます。

Postは、DefaultClient.Postのラッパーです。

カスタムヘッダーを設定するには、NewRequestとDefaultClient.Doを使用します。

リダイレクトの処理方法については、Client.Doメソッドのドキュメントを参照してください。

指定されたcontext.Contextでリクエストを作成するには、NewRequestWithContextとDefaultClient.Doを使用します。

func PostForm ¶

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

PostFormは、データのキーと値がURLエンコードされたリクエストボディとして指定されたURLにPOSTを発行します。

Content-Typeヘッダーはapplication/x-www-form-urlencodedに設定されます。他のヘッダーを設定するには、NewRequestとDefaultClient.Doを使用します。

errがnilの場合、respには常に非nilのresp.Bodyが含まれます。呼び出し元は、resp.Bodyの読み取りが完了したらresp.Bodyを閉じる必要があります。

PostFormは、DefaultClient.PostFormのラッパーです。

リダイレクトの処理方法については、Client.Doメソッドのドキュメントを参照してください。

指定されたcontext.Contextでリクエストを作成するには、NewRequestWithContextとDefaultClient.Doを使用します。

func ReadResponse ¶

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

ReadResponseは、rからHTTPレスポンスを読み取り、返します。 reqパラメータは、このResponseに対応するRequestをオプションで指定します。 nilの場合、GETリクエストが想定されます。クライアントは、resp.Bodyを読み取り終えたらresp.Body.Closeを呼び出す必要があります。その呼び出しの後、クライアントはresp.Trailerを調べて、レスポンストレーラーに含まれるキー/値ペアを見つけることができます。

func (*Response) Cookies ¶

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

Cookiesは、Set-Cookieヘッダーで設定されたCookieを解析して返します。

func (*Response) Location ¶

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

Locationは、レスポンスの「Location」ヘッダーのURLを返します。存在する場合、相対リダイレクトはレスポンスのリクエストに対して相対的に解決されます。 Locationヘッダーが存在しない場合、ErrNoLocationが返されます。

func (*Response) ProtoAtLeast ¶

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

ProtoAtLeastは、レスポンスで使用されるHTTPプロトコルが少なくともmajor.minorであるかどうかを報告します。

func (*Response) Write ¶

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

Writeは、HTTP/1.xサーバーレスポンス形式でrをwに書き込みます。ステータス行、ヘッダー、ボディ、およびオプションのトレーラーを含みます。

このメソッドは、レスポンスrの以下のフィールドを参照します。

StatusCode
ProtoMajor
ProtoMinor
Request.Method
TransferEncoding
Trailer
Body
ContentLength
Header, 非正準化キーの値は予測不可能な動作をします

レスポンスボディは送信後に閉じられます。

type ResponseController ¶ added in v1.20.0

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

ResponseControllerは、HTTPハンドラーがレスポンスを制御するために使用されます。

Handler.ServeHTTPメソッドが返された後にResponseControllerを使用することはできません。

func NewResponseController ¶ added in v1.20.0

func NewResponseController(rw ResponseWriter) *ResponseController

NewResponseControllerは、リクエスト用のResponseControllerを作成します。

ResponseWriterは、Handler.ServeHTTPメソッドに渡された元の値である必要があります。または、元のResponseWriterを返すUnwrapメソッドを持っている必要があります。

ResponseWriterが次のいずれかのメソッドを実装している場合、ResponseControllerは適切に呼び出します。

Flush()
FlushError() error // エラーを返す代替Flush
Hijack() (net.Conn、*bufio.ReadWriter、error)
SetReadDeadline(deadline time.Time) error
SetWriteDeadline(deadline time.Time) error
EnableFullDuplex() error

ResponseWriterがメソッドをサポートしていない場合、ResponseControllerは ErrNotSupportedに一致するエラーを返します。

func (*ResponseController) EnableFullDuplex ¶ added in v1.21.0

func (c *ResponseController) EnableFullDuplex() error

EnableFullDuplexは、リクエストハンドラがRequest.Bodyからの読み取りを交互に行い、 ResponseWriterへの書き込みと交互に行うことを示します。

HTTP/1リクエストの場合、Go HTTPサーバーはデフォルトで、レスポンスの書き込みを開始する前にリクエストボディの未読部分を消費し、ハンドラがリクエストから読み取りとレスポンスの書き込みを同時に行うことを防止します。EnableFullDuplexを呼び出すと、この動作が無効になり、ハンドラがリクエストからの読み取りを続けながらレスポンスを同時に書き込むことができるようになります。

HTTP/2リクエストの場合、Go HTTPサーバーは常に並行して読み取りとレスポンスを許可します。

func (*ResponseController) Flush ¶ added in v1.20.0

func (c *ResponseController) Flush() error

Flushは、バッファリングされたデータをクライアントにフラッシュします。

func (*ResponseController) Hijack ¶ added in v1.20.0

func (c *ResponseController) Hijack() (net.Conn, *bufio.ReadWriter, error)

Hijackは、呼び出し元が接続を引き継ぐことを可能にします。詳細については、Hijackerインターフェースを参照してください。

func (*ResponseController) SetReadDeadline ¶ added in v1.20.0

func (c *ResponseController) SetReadDeadline(deadline time.Time) error

SetReadDeadlineは、ボディを含むリクエスト全体の読み取りの期限を設定します。期限が超過した後にリクエストボディから読み取りを行うと、エラーが返されます。ゼロ値は期限がないことを意味します。

期限が超過した後に読み取り期限を設定しても、期限は延長されません。

func (*ResponseController) SetWriteDeadline ¶ added in v1.20.0

func (c *ResponseController) SetWriteDeadline(deadline time.Time) error

SetWriteDeadlineは、レスポンスの書き込みの期限を設定します。期限が超過した後にレスポンスボディに書き込みを行うと、ブロックされず、データがバッファリングされている場合は成功する可能性があります。ゼロ値は期限がないことを意味します。

期限が超過した後に書き込み期限を設定しても、期限は延長されません。

type ResponseWriter ¶

type ResponseWriter interface {
	// Headerは、WriteHeaderによって送信されるヘッダーマップを返します。
	// ヘッダーマップはまた、ハンドラがHTTPトレイラーを設定するメカニズムでもあります。
	//
	// WriteHeader（またはWrite）の呼び出し後にヘッダーマップを変更しても、
	// HTTPステータスコードが1xxクラスであった場合、または変更されたヘッダーがトレイラーであった場合を除き、
	// 影響はありません。
	//
	// トレイラーを設定する方法は2つあります。推奨される方法は、
	// ヘッダーで後で送信するトレイラーを事前に宣言することです。
	// これは、"Trailer"ヘッダーを後で来るトレイラーキーの名前に設定することで行います。
	// この場合、ヘッダーマップのキーはトレイラーであるかのように扱われます。例を参照してください。
	// 2つ目の方法は、最初のWriteの後までハンドラーには未知のトレイラーキーについて、
	// ヘッダーマップのキーにTrailerPrefix定数値をプレフィックスとして付けることです。
	// TrailerPrefixを参照してください。
	//
	// 自動的に設定されるレスポンスヘッダー（例えば "Date"）を抑制するには、
	// その値をnilに設定します。
	Header() Header

	// Writeは、HTTP応答の一部としてデータを接続に書き込みます。
	//
	// WriteHeaderがまだ呼び出されていない場合、Writeはデータを書き込む前に
	// WriteHeader(http.StatusOK)を呼び出します。ヘッダーにContent-Type行が含まれていない場合、
	// Writeは書き込まれたデータの最初の512バイトをDetectContentTypeに渡す結果に設定されたContent-Typeを追加します。
	// さらに、書き込まれたすべてのデータの合計サイズが数KB以下でFlush呼び出しがない場合、
	// Content-Lengthヘッダーが自動的に追加されます。
	//
	// HTTPプロトコルのバージョンとクライアントによっては、
	// WriteまたはWriteHeaderを呼び出すと、今後のRequest.Bodyの読み取りが防止される場合があります。
	// HTTP/1.xのリクエストに対しては、ハンドラはレスポンスを書き込む前に必要なリクエストボディデータを読み取るべきです。
	// ヘッダがフラッシュされると（明示的なFlusher.Flush呼び出しによるものか、フラッシュをトリガーするだけのデータを書き込むことによるものかは問わず）、
	// リクエストボディは利用できなくなる可能性があります。HTTP/2のリクエストに対しては、GoのHTTPサーバーはハンドラがレスポンスを
	// 並行して書き込みながらリクエストボディを読み続けることを許可します。しかし、そのような動作はすべてのHTTP/2クライアントでサポートされているわけではありません。
	// 可能な限り互換性を最大化するために、ハンドラは書き込む前に読み取るべきです。
	Write([]byte) (int, error)

	// WriteHeaderは、提供されたステータスコードでHTTPレスポンスヘッダーを送信します。
	//
	// WriteHeaderが明示的に呼び出されない場合、最初のWriteの呼び出しは
	// 暗黙的なWriteHeader(http.StatusOK)をトリガーします。
	// したがって、WriteHeaderへの明示的な呼び出しは主に、
	// エラーコードや1xx情報応答を送信するために使用されます。
	//
	// 提供されるコードは、有効なHTTP 1xx-5xxのステータスコードでなければなりません。
	// 任意の数の1xxヘッダーを書き込むことができ、その後に最大で
	// 一つの2xx-5xxヘッダーが続きます。1xxヘッダーはすぐに送信されますが、2xx-5xx
	// ヘッダーはバッファリングされる可能性があります。バッファリングされたデータを送信するには
	// Flusherインターフェースを使用します。2xx-5xxヘッダーが
	// 送信されるとヘッダーマップはクリアされますが、1xxヘッダーではクリアされません。
	//
	// サーバーは、リクエストが "Expect: 100-continue" ヘッダーを持っている場合、
	// リクエストボディからの最初の読み取り時に自動的に100（Continue）ヘッダーを送信します。
	WriteHeader(statusCode int)
}

ResponseWriterインターフェースは、HTTPハンドラーがHTTPレスポンスを構築するために使用されます。

Handler.ServeHTTPメソッドが返された後に、ResponseWriterを使用することはできません。

Example (Trailers) ¶

HTTP トレーラーは、ヘッダーの前ではなく、HTTP レスポンスの後にあるヘッダーのようなキー/値のセットです。

package main

import (
	"github.com/shogo82148/std/io"
	"github.com/shogo82148/std/net/http"
)

func main() {
	mux := http.NewServeMux()
	mux.HandleFunc("/sendstrailers", func(w http.ResponseWriter, req *http.Request) {
		// WriteHeader または Write の呼び出しの前に、HTTP レスポンス中に設定するトレーラーを宣言してください。
		// これらの 3 つのヘッダーは、実際にはトレーラーで送信されます。
		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") // これらはトレーラーとして表示されます。
	})
}

Output:

type RoundTripper ¶

type RoundTripper interface {
	// RoundTripは単一のHTTPトランザクションを実行し、
	// 提供されたRequestのResponseを返します。
	//
	// RoundTripはレスポンスを解釈しようとしてはなりません。特に、
	// RoundTripはレスポンスを取得した場合、レスポンスのHTTPステータスコードに関係なく
	// err == nilを返さなければなりません。非nilのerrはレスポンスの取得に失敗した場合に
	// 予約されるべきです。同様に、RoundTripはリダイレクト、認証、またはクッキーなどの
	// 高レベルのプロトコル詳細を処理しようとしてはなりません。
	//
	// RoundTripは、リクエストのBodyを消費して閉じる以外に、
	// リクエストを変更してはなりません。RoundTripは、
	// 別のgoroutineでリクエストのフィールドを読むことができます。呼び出し元は、
	// レスポンスのBodyが閉じられるまで、リクエストを変更したり再利用したりしてはなりません。
	//
	// RoundTripは常にボディを閉じる必要があります。これにはエラー時も含まれますが、
	// 実装によっては、RoundTripが返った後でも別のgoroutineで行うことがあります。
	// これは、後続のリクエストのボディを再利用したい呼び出し元は、
	// それを行う前にClose呼び出しを待つように手配する必要があることを意味します。
	//
	// RequestのURLとHeaderフィールドは初期化されていなければなりません。
	RoundTrip(*Request) (*Response, error)
}

RoundTripperは、指定されたRequestに対するResponseを取得するための単一のHTTPトランザクションを実行する能力を表すインターフェースです。

RoundTripperは、複数のゴルーチンによる同時使用に対して安全である必要があります。

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

DefaultTransportはTransportのデフォルト実装であり、DefaultClientによって使用されます。必要に応じてネットワーク接続を確立し、後続の呼び出しで再利用するためにキャッシュします。環境変数HTTP_PROXY、HTTPS_PROXY、およびNO_PROXY（またはその小文字バージョン）によって指示されたように、HTTPプロキシを使用します。

func NewFileTransport ¶

func NewFileTransport(fs FileSystem) RoundTripper

NewFileTransportは、提供されたFileSystemを提供する新しいRoundTripperを返します。返されたRoundTripperは、その入力リクエストのURLホストを無視し、リクエストの他のほとんどのプロパティも無視します。

NewFileTransport の典型的な使用例は、Transport に "file" プロトコルを登録することです。例:

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

type SameSite ¶ added in v1.11.0

type SameSite int

SameSiteは、サーバーがクッキー属性を定義して、ブラウザがクロスサイトリクエストと一緒にこのクッキーを送信できなくすることを可能にします。主な目的は、クロスオリジン情報漏洩のリスクを軽減し、クロスサイトリクエスト偽造攻撃に対する保護を提供することです。

詳細については、https://tools.ietf.org/html/draft-ietf-httpbis-cookie-same-site-00 を参照してください。

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

type ServeMux ¶

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

ServeMuxは、HTTPリクエストマルチプレクサーです。それは、登録されたパターンのリストに対して、各受信リクエストのURLを一致させ、 URLに最も近いパターンのハンドラーを呼び出します。

パターンは、"/favicon.ico"のような固定されたルートパス、または"/images/"のようなルートサブツリーの名前を付けます（末尾のスラッシュに注意）。より長いパターンが優先されるため、"/images/"と"/images/thumbnails/"の両方にハンドラーが登録されている場合、後者のハンドラーは"/images/thumbnails/"で始まるパスに対して呼び出され、前者は"/images/"サブツリー内の他のパスに対してリクエストを受け取ります。

スラッシュで終わるパターンは、ルートサブツリーを名前付けるため、注意が必要です。パターン"/"は、他の登録されたパターンに一致しないすべてのパス（Path == "/"のURLだけでなく）に一致します。

サブツリーが登録され、トレーリングスラッシュなしでサブツリールートを指定するリクエストが受信された場合、ServeMuxはそのリクエストをサブツリールートにリダイレクトします（トレーリングスラッシュを追加）。この動作は、トレーリングスラッシュなしのパスに対する別個の登録でオーバーライドできます。たとえば、"/images/"を登録すると、ServeMuxは"/images"のリクエストを"/images/"にリダイレクトしますが、"/images"が別個に登録されている場合は、リダイレクトは行われません。

パターンは、ホスト名で始まることがあり、そのホスト上のURLにのみ一致するように制限できます。ホスト固有のパターンは、一般的なパターンより優先されるため、ハンドラーは"/codesearch"と"codesearch.google.com/"の2つのパターンに登録でき、"http://www.google.com/"のリクエストを引き継ぐことはありません。

ServeMuxは、URLリクエストパスとHostヘッダーをサニタイズし、ポート番号を削除し、.または..要素または重複したスラッシュを含むリクエストを同等のクリーンなURLにリダイレクトします。

func NewServeMux ¶

func NewServeMux() *ServeMux

NewServeMuxは、新しいServeMuxを割り当てて返します。

func (*ServeMux) Handle ¶

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

Handleは、指定されたパターンのハンドラを登録します。パターンに対するハンドラがすでに存在する場合、Handleはパニックを発生させます。

Example ¶

// ServeMux を作成し、"/api/" には apiHandler{} を、"/" には無名関数を割り当てます。
mux := http.NewServeMux()
mux.Handle("/api/", apiHandler{})
mux.HandleFunc("/", func(w http.ResponseWriter, req *http.Request) {
	// "/" パターンはすべてにマッチするため、ここでルートにいることを確認する必要があります。
	if req.URL.Path != "/" {
		http.NotFound(w, req)
		return
	}
	fmt.Fprintf(w, "Welcome to the home page!")
})

Output:

func (*ServeMux) HandleFunc ¶

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

HandleFuncは、指定されたパターンのハンドラ関数を登録します。

func (*ServeMux) Handler ¶ added in v1.1.0

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

Handlerは、r.Method、r.Host、およびr.URL.Pathを参照して、指定されたリクエストに使用するハンドラーを返します。常にnilでないハンドラーを返します。パスが正規形式でない場合、ハンドラーは正規パスにリダイレクトする内部生成ハンドラーになります。ホストにポートが含まれている場合、ハンドラーの一致時には無視されます。

CONNECTリクエストでは、パスとホストは変更されずに使用されます。

Handlerは、リクエストに一致する登録済みパターンと、内部生成されたリダイレクトの場合は、リダイレクトをたどった後に一致するパターンを返します。

リクエストに適用される登録済みハンドラーがない場合、 Handlerは「ページが見つかりません」というハンドラーと空のパターンを返します。

func (*ServeMux) ServeHTTP ¶

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

ServeHTTPは、リクエストURLに最も近いパターンを持つハンドラにリクエストをディスパッチします。

type Server ¶

type Server struct {
	// Addrは、サーバーがリッスンするためのTCPアドレスをオプションで指定します。
	// 形式は「host:port」です。空の場合、「:http」（ポート80）が使用されます。
	// サービス名はRFC 6335で定義され、IANAによって割り当てられます。
	// アドレスの形式の詳細については、net.Dialを参照してください。
	Addr string

	Handler Handler

	// DisableGeneralOptionsHandlerがtrueの場合、"OPTIONS *"リクエストをHandlerに渡します。
	// それ以外の場合、200 OKとContent-Length: 0で応答します。
	DisableGeneralOptionsHandler bool

	// TLSConfigは、ServeTLSとListenAndServeTLSで使用するためのTLS構成をオプションで提供します。
	// この値はServeTLSとListenAndServeTLSによってクローンされるため、tls.Config.SetSessionTicketKeysなどのメソッドを使用して構成を変更することはできません。
	// SetSessionTicketKeysを使用するには、TLSリスナーを使用してServer.Serveを使用します。
	TLSConfig *tls.Config

	// ReadTimeoutは、ボディを含むリクエスト全体を読み取るための最大時間です。
	// ゼロまたは負の値はタイムアウトがないことを意味します。
	//
	// ReadTimeoutは、ハンドラが各リクエストボディの許容可能な締め切りまたはアップロードレートを決定することを許可しないため、
	// 大抵のユーザーはReadHeaderTimeoutを使用することを好むでしょう。
	// 両方を使用することもできます。
	ReadTimeout time.Duration

	// ReadHeaderTimeoutは、リクエストヘッダーを読み取るために許可される時間です。
	// ヘッダーを読み取った後、接続の読み取り期限がリセットされ、Handlerはボディに対して何が遅すぎるかを決定できます。
	// ReadHeaderTimeoutがゼロの場合、ReadTimeoutの値が使用されます。
	// 両方がゼロの場合、タイムアウトはありません。
	ReadHeaderTimeout time.Duration

	// WriteTimeoutは、レスポンスの書き込みがタイムアウトする前の最大時間です。
	// 新しいリクエストヘッダーが読み取られるたびにリセットされます。
	// ReadTimeoutと同様に、ハンドラがリクエストごとに決定を下すことを許可しません。
	// ゼロまたは負の値はタイムアウトがないことを意味します。
	WriteTimeout time.Duration

	// IdleTimeoutは、keep-aliveが有効な場合に次のリクエストを待機する最大時間です。
	// IdleTimeoutがゼロの場合、ReadTimeoutの値が使用されます。
	// 両方がゼロの場合、タイムアウトはありません。
	IdleTimeout time.Duration

	// MaxHeaderBytesは、リクエストヘッダーのキーと値、およびリクエストラインを解析するためにサーバーが読み取ることができる最大バイト数を制御します。
	// リクエストボディのサイズには影響しません。
	// ゼロの場合、DefaultMaxHeaderBytesが使用されます。
	MaxHeaderBytes int

	// TLSNextProtoは、ALPNプロトコルアップグレードが発生した場合に提供されたTLS接続の所有権を引き継ぐための関数をオプションで指定します。
	// マップキーはネゴシエートされたプロトコル名です。
	// Handler引数はHTTPリクエストを処理するために使用され、RequestのTLSとRemoteAddrを初期化します（設定されていない場合）。
	// 関数が返されると、接続は自動的に閉じられます。
	// TLSNextProtoがnilでない場合、HTTP/2サポートは自動的に有効になりません。
	TLSNextProto map[string]func(*Server, *tls.Conn, Handler)

	// ConnStateは、クライアント接続の状態が変化したときに呼び出されるオプションのコールバック関数を指定します。
	// 詳細については、ConnState型と関連する定数を参照してください。
	ConnState func(net.Conn, ConnState)

	// ErrorLogは、接続の受け入れ時のエラー、ハンドラの予期しない動作、および
	// FileSystemの基礎となるエラーに対するオプションのロガーを指定します。
	// nilの場合、ログはlogパッケージの標準ロガーを使用して行われます。
	ErrorLog *log.Logger

	// BaseContextは、このサーバーの着信リクエストのベースコンテキストを返すオプションの関数を指定します。
	// 提供されたListenerは、リクエストを開始する特定のリスナーです。
	// BaseContextがnilの場合、デフォルトはcontext.Background()です。
	// nilでない場合、非nilのコンテキストを返す必要があります。
	BaseContext func(net.Listener) context.Context

	// ConnContextは、新しい接続cに使用されるコンテキストを変更するオプションの関数を指定します。
	// 提供されたctxはBaseContextから派生し、ServerContextKeyの値を持ちます。
	ConnContext func(ctx context.Context, c net.Conn) context.Context
	// contains filtered or unexported fields
}

Serverは、HTTPサーバーを実行するためのパラメータを定義します。 Serverのゼロ値は有効な構成です。

func (*Server) Close ¶ added in v1.8.0

func (srv *Server) Close() error

Closeは、すべてのアクティブなnet.Listenerと、StateNew、StateActive、またはStateIdleの状態にある接続をすぐに閉じます。優雅なシャットダウンには、Shutdownを使用してください。

Closeは、WebSocketsなどのハイジャックされた接続を閉じようとはせず（そしてそれらについては何も知りません）、試みません。

Closeは、Serverの基礎となるListenerの閉じる際に返されるエラーを返します。

func (*Server) ListenAndServe ¶

func (srv *Server) ListenAndServe() error

ListenAndServeは、TCPネットワークアドレスsrv.Addrでリッスンし、 Serveを呼び出して着信接続のリクエストを処理します。受け入れられた接続は、TCP keep-alivesを有効にするように構成されます。

srv.Addrが空白の場合、":http"が使用されます。

ListenAndServeは常に非nilのエラーを返します。ShutdownまたはCloseの後、返されるエラーはErrServerClosedです。

func (*Server) ListenAndServeTLS ¶

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

ListenAndServeTLSは、TCPネットワークアドレスsrv.Addrでリッスンし、 ServeTLSを呼び出して着信TLS接続のリクエストを処理します。受け入れられた接続は、TCP keep-alivesを有効にするように構成されます。

サーバーのTLSConfig.CertificatesまたはTLSConfig.GetCertificateがどちらも設定されていない場合、サーバーの証明書と対応する秘密鍵が含まれるファイルを提供する必要があります。証明書が認証局によって署名されている場合、certFileはサーバーの証明書、中間証明書、およびCAの証明書を連結したものである必要があります。

srv.Addrが空白の場合、":https"が使用されます。

ListenAndServeTLSは常に非nilのエラーを返します。ShutdownまたはCloseの後、返されるエラーはErrServerClosedです。

func (*Server) RegisterOnShutdown ¶ added in v1.9.0

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

RegisterOnShutdownは、Shutdown時に呼び出す関数を登録します。これは、ALPNプロトコルアップグレードを受けた接続やハイジャックされた接続を優雅にシャットダウンするために使用できます。この関数は、プロトコル固有の優雅なシャットダウンを開始する必要がありますが、シャットダウンが完了するのを待つ必要はありません。

func (*Server) Serve ¶

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

Serveは、Listener lで着信接続を受け入れ、それぞれに新しいサービスgoroutineを作成します。サービスgoroutineはリクエストを読み取り、srv.Handlerを呼び出してそれに応答します。

Listenerが* tls.Conn接続を返し、TLS Config.NextProtosで「h2」が構成されている場合、HTTP/2サポートが有効になります。

Serveは常に非nilのエラーを返し、lを閉じます。 ShutdownまたはCloseの後、返されるエラーはErrServerClosedです。

func (*Server) ServeTLS ¶ added in v1.9.0

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

ServeTLSは、Listener lで着信接続を受け入れ、それぞれに新しいサービスgoroutineを作成します。サービスgoroutineはTLSのセットアップを実行し、リクエストを読み取り、srv.Handlerを呼び出してそれに応答します。

サーバーのTLSConfig.CertificatesまたはTLSConfig.GetCertificateがどちらも設定されていない場合、サーバーの証明書と対応する秘密鍵が含まれるファイルを提供する必要があります。証明書が認証局によって署名されている場合、certFileはサーバーの証明書、中間証明書、およびCAの証明書を連結したものである必要があります。

ServeTLSは常に非nilのエラーを返し、lを閉じます。 ShutdownまたはCloseの後、返されるエラーはErrServerClosedです。

func (*Server) SetKeepAlivesEnabled ¶ added in v1.3.0

func (srv *Server) SetKeepAlivesEnabled(v bool)

SetKeepAlivesEnabledは、HTTP keep-alivesが有効かどうかを制御します。デフォルトでは、keep-alivesは常に有効になっています。非常にリソースが制限された環境またはシャットダウン中のサーバーのみ、それらを無効にする必要があります。

func (*Server) Shutdown ¶ added in v1.8.0

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

Shutdownは、アクティブな接続を中断することなく、サーバーを優雅にシャットダウンします。 Shutdownは、まずすべてのオープンリスナーを閉じ、次にすべてのアイドル接続を閉じ、接続がアイドル状態に戻ってからシャットダウンするまで無期限に待機します。提供されたコンテキストがシャットダウンが完了する前に期限切れになった場合、Shutdownはコンテキストのエラーを返します。それ以外の場合、Serverの基礎となるListenerの閉じる際に返されるエラーを返します。

Shutdownが呼び出されると、Serve、ListenAndServe、およびListenAndServeTLSはすぐにErrServerClosedを返します。プログラムが終了せずにShutdownが返るのを待つようにしてください。

Shutdownは、WebSocketsなどのハイジャックされた接続を閉じようとはせず（そしてそれらについては何も知りません）、試みません。

Shutdownを呼び出した後、サーバーを再利用することはできません。Serveなどのメソッドを呼び出すと、ErrServerClosedが返されます。

Example ¶

package main

import (
	"github.com/shogo82148/std/context"
	"github.com/shogo82148/std/log"
	"github.com/shogo82148/std/net/http"
	"github.com/shogo82148/std/os"
	"github.com/shogo82148/std/os/signal"
)

func main() {
	var srv http.Server

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

		// 割り込みシグナルを受信したため、シャットダウンします。
		if err := srv.Shutdown(context.Background()); err != nil {
			// リスナーのクローズ時のエラー、またはコンテキストのタイムアウト:
			log.Printf("HTTP server Shutdown: %v", err)
		}
		close(idleConnsClosed)
	}()

	if err := srv.ListenAndServe(); err != http.ErrServerClosed {
		// リスナーの開始またはクローズ時のエラー:
		log.Fatalf("HTTP server ListenAndServe: %v", err)
	}

	<-idleConnsClosed
}

Output:

type Transport ¶

type Transport struct {

	// Proxyは、指定されたRequestに対するプロキシを返す関数を指定します。
	// 関数が非nilのエラーを返す場合、リクエストは提供されたエラーで中止されます。
	//
	// プロキシのタイプは、URLスキームによって決定されます。
	// "http"、"https"、および"socks5"がサポートされています。
	// スキームが空の場合、"http"が想定されます。
	//
	// Proxyがnilであるか、nilの*URLを返す場合、プロキシは使用されません。
	Proxy func(*Request) (*url.URL, error)

	// OnProxyConnectResponseは、TransportがCONNECTリクエストのプロキシからHTTPレスポンスを受信したときに呼び出されます。
	// これは、200 OKレスポンスのチェックの前に呼び出されます。
	// エラーを返すと、リクエストはそのエラーで失敗します。
	OnProxyConnectResponse func(ctx context.Context, proxyURL *url.URL, connectReq *Request, connectRes *Response) error

	// DialContextは、暗号化されていないTCP接続を作成するためのダイアル関数を指定します。
	// DialContextがnilである場合（および下記の非推奨のDialもnilである場合）、
	// トランスポートはnetパッケージを使用してダイアルします。
	//
	// DialContextは、RoundTripの呼び出しと並行して実行されます。
	// ダイアルを開始するRoundTrip呼び出しが、後のDialContextが完了する前に
	// 以前にダイアルされた接続を使用する場合があります。
	DialContext func(ctx context.Context, network, addr string) (net.Conn, error)

	// Dialは、暗号化されていないTCP接続を作成するためのダイアル関数を指定します。
	//
	// Dialは、RoundTripの呼び出しと並行して実行されます。
	// 以前にダイアルされた接続が後でアイドル状態になる場合、
	// 後のDialが完了する前に、ダイアルを開始するRoundTrip呼び出しが以前にダイアルされた接続を使用する場合があります。
	//
	// Deprecated: 代わりにDialContextを使用してください。これにより、トランスポートはダイアルが不要になった直後にキャンセルできます。
	// 両方が設定されている場合、DialContextが優先されます。
	Dial func(network, addr string) (net.Conn, error)

	// DialTLSContextは、プロキシを使用しないHTTPSリクエストのためのTLS接続を作成するためのオプションのダイアル関数を指定します。
	//
	// DialTLSContextがnilである場合（および下記の非推奨のDialTLSもnilである場合）、
	// DialContextとTLSClientConfigが使用されます。
	//
	// DialTLSContextが設定されている場合、HTTPSリクエストに対してDialおよびDialContextフックは使用されず、
	// TLSClientConfigおよびTLSHandshakeTimeoutは無視されます。
	// 返されたnet.Connは、すでにTLSハンドシェイクを完了しているものと見なされます。
	DialTLSContext func(ctx context.Context, network, addr string) (net.Conn, error)

	// DialTLSは、プロキシを使用しないHTTPSリクエストのためのTLS接続を作成するためのオプションのダイアル関数を指定します。
	//
	// Deprecated: 代わりにDialTLSContextを使用してください。これにより、トランスポートはダイアルが不要になった直後にキャンセルできます。
	// 両方が設定されている場合、DialTLSContextが優先されます。
	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の場合、Transportは、Requestに既存のAccept-Encoding値がない場合に、
	// "Accept-Encoding: gzip"リクエストヘッダーで圧縮を要求しません。
	// 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がゼロでない場合、リクエスト（ボディがある場合はそれも含む）を完全に書き込んだ後、
	// サーバーのレスポンスヘッダーを待機する時間を指定します。
	// この時間には、レスポンスボディを読み取る時間は含まれません。
	ResponseHeaderTimeout time.Duration

	// ExpectContinueTimeoutがゼロでない場合、リクエストに"Expect: 100-continue"ヘッダーがある場合、
	// リクエストヘッダーを完全に書き込んだ後、サーバーの最初のレスポンスヘッダーを待機する時間を指定します。
	// ゼロはタイムアウトがないことを意味し、サーバーの承認を待たずに、すぐにボディを送信します。
	// この時間には、リクエストヘッダーを送信する時間は含まれません。
	ExpectContinueTimeout time.Duration

	// TLSNextProtoは、TLS ALPNプロトコルネゴシエーション後にTransportが代替プロトコル（HTTP/2など）に切り替える方法を指定します。
	// Transportがプロトコル名が空でないTLS接続をダイアルし、TLSNextProtoにそのキーのマップエントリが含まれている場合（"h2"など）、
	// リクエストの権限（"example.com"または"example.com:1234"など）とTLS接続でfuncが呼び出されます。
	// この関数は、その後リクエストを処理するRoundTripperを返さなければなりません。
	// TLSNextProtoがnilでない場合、HTTP/2サポートは自動的に有効になりません。
	TLSNextProto map[string]func(authority string, c *tls.Conn) RoundTripper

	// ProxyConnectHeaderは、CONNECTリクエスト中にプロキシに送信するヘッダーをオプションで指定します。
	// ヘッダーを動的に設定するには、GetProxyConnectHeaderを参照してください。
	ProxyConnectHeader Header

	// GetProxyConnectHeaderは、ip:portターゲットへのCONNECTリクエスト中にproxyURLに送信するヘッダーを返すためのオプションの関数を指定します。
	// エラーを返すと、TransportのRoundTripはそのエラーで失敗します。
	// ヘッダーを追加しない場合は、(nil, nil)を返すことができます。
	// GetProxyConnectHeaderが非nilの場合、ProxyConnectHeaderは無視されます。
	GetProxyConnectHeader func(ctx context.Context, proxyURL *url.URL, target string) (Header, error)

	// MaxResponseHeaderBytesは、サーバーのレスポンスヘッダーに許可されるレスポンスバイト数の制限を指定します。
	//
	// ゼロは、デフォルトの制限を使用することを意味します。
	MaxResponseHeaderBytes int64

	// WriteBufferSizeは、トランスポートへの書き込み時に使用される書き込みバッファのサイズを指定します。
	// ゼロの場合、デフォルト値（現在は4KB）が使用されます。
	WriteBufferSize int

	// ReadBufferSizeは、トランスポートから読み取るときに使用される読み取りバッファのサイズを指定します。
	// ゼロの場合、デフォルト値（現在は4KB）が使用されます。
	ReadBufferSize int

	// ForceAttemptHTTP2は、非ゼロの
	// Dial, DialTLS, または DialContext 関数または TLSClientConfig が提供されたときに、
	// HTTP/2が有効になるかどうかを制御します。
	// デフォルトでは、これらのフィールドのいずれかの使用は、保守的にHTTP/2を無効にします。
	// カスタムダイヤラーやTLS設定を使用しつつ、HTTP/2への
	// アップグレードを試みるには、これをtrueに設定します。
	ForceAttemptHTTP2 bool
	// contains filtered or unexported fields
}

Transportは、HTTP、HTTPS、およびHTTPプロキシ（HTTPまたはHTTPS with CONNECTのいずれか）をサポートするRoundTripperの実装です。

デフォルトでは、Transportは将来の再利用のために接続をキャッシュします。これにより、多くのホストにアクセスする場合に多数のオープンな接続が残る可能性があります。この動作は、TransportのCloseIdleConnectionsメソッドとMaxIdleConnsPerHostおよびDisableKeepAlivesフィールドを使用して管理できます。

Transportは必要に応じて作成するのではなく、再利用する必要があります。 Transportは、複数のgoroutineによる同時使用に対して安全です。

Transportは、HTTPおよびHTTPSリクエストを行うための低レベルのプリミティブです。クッキーやリダイレクトなどの高レベルの機能については、Clientを参照してください。

Transportは、HTTP URLではHTTP/1.1を、HTTPS URLではHTTP/1.1またはHTTP/2を使用します。これは、サーバーがHTTP/2をサポートしているかどうか、およびTransportの構成によって異なります。 DefaultTransportはHTTP/2をサポートしています。 Transportで明示的にHTTP/2を有効にするには、golang.org/x/net/http2を使用してConfigureTransportを呼び出します。 HTTP/2についての詳細については、パッケージのドキュメントを参照してください。

ステータスコードが1xx範囲にあるレスポンスは、自動的に処理されます（100 expect-continue）。ただし、HTTPステータスコード101（Switching Protocols）は、終端ステータスと見なされ、RoundTripによって返されます。無視された1xxレスポンスを表示するには、httptraceトレースパッケージのClientTrace.Got1xxResponseを使用します。

Transportは、ネットワークエラーに遭遇した場合にのみ、接続がすでに正常に使用されており、リクエストが冪等であり、ボディがないか、またはRequest.GetBodyが定義されている場合に、リクエストを再試行します。HTTPリクエストは、HTTPメソッドがGET、HEAD、OPTIONS、またはTRACEである場合、またはHeaderマップに「Idempotency-Key」または「X-Idempotency-Key」エントリが含まれている場合、冪等と見なされます。冪等性キーの値がゼロ長のスライスの場合、リクエストは冪等と見なされますが、ヘッダーはワイヤーに送信されません。

func (*Transport) CancelRequest deprecated added in v1.1.0

func (t *Transport) CancelRequest(req *Request)

CancelRequestは、その接続を閉じることにより、進行中のリクエストをキャンセルします。 CancelRequestは、RoundTripが返された後にのみ呼び出す必要があります。

Deprecated: 代わりに、キャンセル可能なコンテキストを持つリクエストを作成するためにRequest.WithContextを使用してください。 CancelRequestは、HTTP/2リクエストをキャンセルできません。

func (*Transport) Clone ¶ added in v1.13.0

func (t *Transport) Clone() *Transport

Cloneは、tのエクスポートされたフィールドのディープコピーを返します。

func (*Transport) CloseIdleConnections ¶

func (t *Transport) CloseIdleConnections()

CloseIdleConnectionsは、以前のリクエストから接続されていたが、現在はアイドル状態になっている"keep-alive"状態の接続を閉じます。現在使用中の接続は中断しません。

func (*Transport) RegisterProtocol ¶

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

RegisterProtocolは、新しいプロトコルをスキームとともに登録します。 Transportは、指定されたスキームを使用してリクエストをrtに渡します。 HTTPリクエストのセマンティクスをシミュレートする責任は、rtにあります。

RegisterProtocolは、他のパッケージが"ftp"や"file"などのプロトコルスキームの実装を提供するために使用できます。

rt.RoundTripがErrSkipAltProtocolを返す場合、Transportは、登録されたプロトコルのように扱わずに、その1つのリクエストに対して自身でRoundTripを処理します。

func (*Transport) RoundTrip ¶

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

RoundTripは、RoundTripperインターフェースを実装します。

クッキーやリダイレクトの処理などのより高度なHTTPクライアントサポートについては、 Get、Post、およびClient型を参照してください。

RoundTripインターフェースと同様に、RoundTripによって返されるエラータイプは未指定です。

Source Files ¶

View all Source files

Directories ¶

Path	Synopsis
cgi パッケージcgiは、RFC 3875で指定されているCGI（Common Gateway Interface）を実装しています。	パッケージcgiは、RFC 3875で指定されているCGI（Common Gateway Interface）を実装しています。
cookiejar Package cookiejar はメモリ内で RFC 6265 に準拠した http.CookieJar を実装します。	Package cookiejar はメモリ内で RFC 6265 に準拠した http.CookieJar を実装します。
fcgi Package fcgiはFastCGIプロトコルを実装します。	Package fcgiはFastCGIプロトコルを実装します。
httptest パッケージhttptestは、HTTPテストのためのユーティリティを提供します。	パッケージhttptestは、HTTPテストのためのユーティリティを提供します。
httptrace パッケージhttptraceは、HTTPクライアントリクエスト内のイベントをトレースするメカニズムを提供します。	パッケージhttptraceは、HTTPクライアントリクエスト内のイベントをトレースするメカニズムを提供します。
httputil Package httputilは、net/httpパッケージにある一般的なものと補完するHTTPユーティリティ関数を提供します。	Package httputilは、net/httpパッケージにある一般的なものと補完するHTTPユーティリティ関数を提供します。
internal Package internal contains HTTP internals shared by net/http and net/http/httputil.	Package internal contains HTTP internals shared by net/http and net/http/httputil.
ascii
testcert Package testcert contains a test-only localhost certificate.	Package testcert contains a test-only localhost certificate.
pprof パッケージpprofは、pprof可視化ツールが期待する形式で実行時プロファイリングデータをHTTPサーバー経由で提供します。	パッケージpprofは、pprof可視化ツールが期待する形式で実行時プロファイリングデータをHTTPサーバー経由で提供します。

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL

Documentation ¶

Overview ¶

Clients and Transports ¶

Servers ¶

HTTP/2 ¶

Index ¶

Examples ¶

Constants ¶

Variables ¶

Functions ¶

func CanonicalHeaderKey ¶

func DetectContentType ¶

func Error ¶

func Handle ¶

func HandleFunc ¶

func ListenAndServe ¶

func ListenAndServeTLS ¶

func MaxBytesReader ¶

func NotFound ¶

func ParseHTTPVersion ¶

func ParseTime ¶ added in v1.1.0

func ProxyFromEnvironment ¶

func ProxyURL ¶

func Redirect ¶

func Serve ¶

func ServeContent ¶

func ServeFile ¶

func ServeTLS ¶ added in v1.9.0

func SetCookie ¶

func StatusText ¶

Types ¶

type Client ¶

func (*Client) CloseIdleConnections ¶ added in v1.12.0

func (*Client) Do ¶

func (*Client) Get ¶

func (*Client) Head ¶

func (*Client) Post ¶

func (*Client) PostForm ¶

type CloseNotifier deprecated added in v1.1.0

type ConnState ¶ added in v1.3.0

func (ConnState) String ¶ added in v1.3.0

type Cookie ¶

func (*Cookie) String ¶

func (*Cookie) Valid ¶ added in v1.18.0

type CookieJar ¶

type Dir ¶

func (Dir) Open ¶

type File ¶

type FileSystem ¶

func FS ¶ added in v1.16.0

type Flusher ¶

type Handler ¶

func AllowQuerySemicolons ¶ added in v1.17.0

func FileServer ¶

func MaxBytesHandler ¶ added in v1.18.0

func NotFoundHandler ¶

func RedirectHandler ¶

func StripPrefix ¶

func TimeoutHandler ¶

type HandlerFunc ¶

func (HandlerFunc) ServeHTTP ¶

type Header ¶

func (Header) Add ¶

func (Header) Clone ¶ added in v1.13.0

func (Header) Del ¶

func (Header) Get ¶

func (Header) Set ¶

func (Header) Values ¶ added in v1.14.0

func (Header) Write ¶

func (Header) WriteSubset ¶

type Hijacker ¶

type MaxBytesError ¶ added in v1.19.0

func (*MaxBytesError) Error ¶ added in v1.19.0

type ProtocolError deprecated

func (*ProtocolError) Error ¶

func (*ProtocolError) Is ¶ added in v1.21.0

type PushOptions ¶ added in v1.8.0

type Pusher ¶ added in v1.8.0

type Request ¶

func NewRequest ¶