Go 语言 HTTP/2 探险之旅

openssl req -newkey rsa:2048 -nodes -keyout server.key -x509 -days 365 -out server.crt

package main
import (    "log"    "net/http")  func main() {    // 在 8000 端口启动服务器    // 确切地说，如何运行HTTP/1.1服务器。
    srv := &http.Server{Addr:":8000", Handler: http.HandlerFunc(handle)}    // 用TLS启动服务器，因为我们运行的是http/2，它必须是与TLS一起运行。    // 确切地说，如何使用TLS连接运行HTTP/1.1服务器。    log.Printf("Serving on https://0.0.0.0:8000")    log.Fatal(srv.ListenAndServeTLS("server.crt", "server.key"))}
func handle(w http.ResponseWriter, r *http.Request) {    // 记录请求协议    log.Printf("Got connection: %s", r.Proto)    // 向客户发送一条消息    w.Write([]byte("Hello"))}

package main
import (    "fmt"    "net/http")
const url = "https://localhost:8000"
func main() {    _, err := http.Get(url)    fmt.Println(err)}

$ go run h2-client.go Get https://localhost:8000: x509: certificate signed by unknown authority

http: TLS handshake error from [::1]:58228: remote error: tls: bad certificate

package main
import (  "crypto/tls"  "crypto/x509"  "flag"  "fmt"  "io/ioutil"  "log"  "net/http"  "golang.org/x/net/http2")  const url = "https://localhost:8000"
var httpVersion = flag.Int("version", 2, "HTTP version")
func main() {  flag.Parse()  client := &http.Client{}  // Create a pool with the server certificate since it is not signed  // by a known CA  caCert, err := ioutil.ReadFile("server.crt")        if err != nil {     log.Fatalf("Reading server certificate: %s", err)  }  caCertPool := x509.NewCertPool()  caCertPool.AppendCertsFromPEM(caCert)  // Create TLS configuration with the certificate of the server  tlsConfig := &tls.Config{    RootCAs: caCertPool,  }
  // Use the proper transport in the client  switch *httpVersion {   case 1:    client.Transport = &http.Transport{      TLSClientConfig: tlsConfig,    }  case 2:    client.Transport = &http2.Transport{      TLSClientConfig: tlsConfig,    }  }  // Perform the request  resp, err := client.Get(url)
  if err != nil {     log.Fatalf("Failed get: %s", err)  }  defer resp.Body.Close()  body, err := ioutil.ReadAll(resp.Body)  if err != nil {     log.Fatalf("Failed reading response body: %s", err)  }  fmt.Printf(    "Got response %d: %s %s\n",    resp.StatusCode, resp.Proto, string(body)        )}

$ go run h2-client.go Got response 200: HTTP/2.0 Hello

$ go run h2-client.go -version 1Got response 200: HTTP/1.1 Hello

func handle(w http.ResponseWriter, r *http.Request) {  // Log the request protocol  log.Printf("Got connection: %s", r.Proto)  // Handle 2nd request, must be before push to prevent recursive calls.  // Don't worry - Go protect us from recursive push by panicking.  if r.URL.Path == "/2nd" {     log.Println("Handling 2nd")    w.Write([]byte("Hello Again!"))    return  }
  // Handle 1st request  log.Println("Handling 1st")  // Server push must be before response body is being written.  // In order to check if the connection supports push, we should use  // a type-assertion on the response writer.  // If the connection does not support server push, or that the push  // fails we just ignore it - server pushes are only here to improve  // the performance for HTTP/2 clients.  pusher, ok := w.(http.Pusher)
  if !ok {     log.Println("Can't push to client")  } else {    err := pusher.Push("/2nd", nil)              if err != nil {       log.Printf("Failed push: %v", err)    }  }  // Send response body  w.Write([]byte("Hello"))}

$ go run ./h2-client.go -version 1Got response 200: HTTP/1.1 Hello

Got connection: HTTP/1.1Handling 1stCan't push to client

go run ./h2-client.go -version 2Got response 200: HTTP/2.0 Hello

Got connection: HTTP/2.0Handling 1stFailed push: feature not supported

Got connection: HTTP/2.0Handling 1stGot connection: HTTP/2.0Handling 2nd

$ curl -i -XPUT --http2 https://http2.golang.org/ECHO -d helloHTTP/2 200 content-type: text/plain; charset=utf-8date: Tue, 24 Jul 2018 12:20:56 GMT
HELLO 

type flushWriter struct {  w io.Writer}
func (fw flushWriter) Write(p []byte) (n int, err error) {  n, err = fw.w.Write(p)  // Flush - send the buffered written data to the client  if f, ok := fw.w.(http.Flusher); ok {    f.Flush()  }        return}
func echoCapitalHandler(w http.ResponseWriter, r *http.Request) {  // First flash response headers  if f, ok := w.(http.Flusher); ok {    f.Flush()  }   // Copy from the request body to the response writer and flush  // (send to client)  io.Copy(flushWriter{w: w}, r.Body)}

const url = "https://http2.golang.org/ECHO"
func main() {        // Create a pipe - an object that implements `io.Reader` and `io.Writer`.         // Whatever is written to the writer part will be read by the reader part.
        pr, pw := io.Pipe()         // Create an `http.Request` and set its body as the reader part of the        // pipe - after sending the request, whatever will be written to the pipe,        // will be sent as the request body.        // This makes the request content dynamic, so we don't need to define it        // before sending the request.  req, err := http.NewRequest(http.MethodPut, url, ioutil.NopCloser(pr))
  if err != nil {     log.Fatal(err)  }          // Send the request  resp, err := http.DefaultClient.Do(req)    if err != nil {             log.Fatal(err)          }  log.Printf("Got: %d", resp.StatusCode)    // Run a loop which writes every second to the writer part of the pipe  // the current time.  go func() {    for {         time.Sleep(1 * time.Second)      fmt.Fprintf(pw, "It is now %v\n", time.Now())    }  }()  
        // Copy the server's response to stdout.  _, err = io.Copy(os.Stdout, res.Body)
  log.Fatal(err)}