go实现HTTP3

╰+哭是因爲堅強的太久メ 2023-06-06 08:30 21阅读 0赞

**一、首先什么是HTTP3？**  
虽然 HTTP/2 解决了很多之前旧版本的问题，但是它还是存在一个巨大的问题，主要是底层支撑的 TCP 协议造成的。

上文提到 HTTP/2 使用了多路复用，一般来说同一域名下只需要使用一个 TCP 连接。但当这个连接中出现了丢包的情况，那就会导致 HTTP/2 的表现情况反倒不如 HTTP/1 了。

因为在出现丢包的情况下，整个 TCP 都要开始等待重传，也就导致了后面的所有数据都被阻塞了。但是对于 HTTP/1.1 来说，可以开启多个 TCP 连接，出现这种情况反到只会影响其中一个连接，剩余的 TCP 连接还可以正常传输数据。

那么可能就会有人考虑到去修改 TCP 协议，其实这已经是一件不可能完成的任务了。因为 TCP 存在的时间实在太长，已经充斥在各种设备中，并且这个协议是由操作系统实现的，更新起来不大现实。

基于这个原因，Google 就更起炉灶搞了一个基于 UDP 协议的 QUIC 协议，并且使用在了 HTTP/3 上，HTTP/3 之前名为 HTTP-over-QUIC，从这个名字中我们也可以发现，HTTP/3 最大的改造就是使用了 QUIC。

QUIC 虽然基于 UDP，但是在原本的基础上新增了很多功能。

[**参考：读懂 HTTP/2 及 HTTP/3 特性**][HTTP_2 _ HTTP_3]

二、用go语言实现HTTP3

package main
    
    import (
    	"compress/flate"
    	"compress/gzip"
    	"flag"
    	"fmt"
    	"io"
    	"log"
    	"net/http"
    	"net/http/httputil"
    	"net/url"
    	"strings"
    
    	"github.com/itchio/go-brotli/enc"
    	"github.com/lucas-clemente/quic-go/http3"
    )
    
    type compressResponseWriter struct {
    	io.Writer
    	http.ResponseWriter
    }
    
    func (w compressResponseWriter) Write(b []byte) (int, error) {
    	return w.Writer.Write(b)
    }
    
    func (w compressResponseWriter) WriteHeader(code int) {
    	w.Header().Del("Content-Length")
    	w.ResponseWriter.WriteHeader(code)
    }
    
    func gzipHandler(fn http.HandlerFunc, w http.ResponseWriter, r *http.Request) {
    	w.Header().Set("Content-Encoding", "gzip")
    	gz, err := gzip.NewWriterLevel(w, gzip.BestSpeed)
    	if err != nil {
    		fmt.Printf("Error closing gzip: %+v\n", err)
    	}
    	defer func() {
    		err := gz.Close()
    		if err != nil {
    			fmt.Printf("Error closing gzip: %+v\n", err)
    		}
    	}()
    	gzr := compressResponseWriter{Writer: gz, ResponseWriter: w}
    	fn(gzr, r)
    }
    
    func deflateHandler(fn http.HandlerFunc, w http.ResponseWriter, r *http.Request) {
    	w.Header().Set("Content-Encoding", "deflate")
    	df, err := flate.NewWriter(w, flate.BestSpeed)
    	if err != nil {
    		fmt.Printf("Error closing deflate: %+v\n", err)
    	}
    	defer func() {
    		err := df.Close()
    		if err != nil {
    			fmt.Printf("Error closing deflate: %+v\n", err)
    		}
    	}()
    	dfr := compressResponseWriter{Writer: df, ResponseWriter: w}
    	fn(dfr, r)
    }
    
    func brotliHandler(fn http.HandlerFunc, w http.ResponseWriter, r *http.Request) {
    	w.Header().Set("Content-Encoding", "br")
    
    	op := &enc.BrotliWriterOptions{
    		Quality: 4,
    		LGWin:   10,
    	}
    	br := enc.NewBrotliWriter(w, op)
    	defer func() {
    		err := br.Close()
    		if err != nil {
    			fmt.Printf("Error closing brotli: %+v\n", err)
    		}
    	}()
    	brr := compressResponseWriter{Writer: br, ResponseWriter: w}
    	fn(brr, r)
    }
    
    type handler struct {
    	enableCompress bool
    }
    
    func (h *handler) makeCompressionHandler(fn http.HandlerFunc) http.HandlerFunc {
    	return func(w http.ResponseWriter, r *http.Request) {
    		if h.enableCompress {
    			w.Header().Set("Vary", "Assept-Encoding")
    			if strings.Contains(r.Header.Get("Accept-Encoding"), "br") {
    				brotliHandler(fn, w, r)
    				return
    			} else if strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
    				gzipHandler(fn, w, r)
    				return
    			} else if strings.Contains(r.Header.Get("Accept-Encoding"), "deflate") {
    				deflateHandler(fn, w, r)
    				return
    			}
    		}
    
    		fn(w, r)
    	}
    }
    
    func reverseProxy(backEndUrl string) func(http.ResponseWriter, *http.Request) {
    	url, err := url.Parse(backEndUrl)
    	if err != nil {
    		panic(err)
    	}
    	proxy := httputil.NewSingleHostReverseProxy(url)
    	return proxy.ServeHTTP
    }
    
    func main() {
    	var (
    		bg             = flag.String("b", "http://localhost:9000", "background")
    		port           = flag.Uint("p", 8080, "front port")
    		useHttp3       = flag.Bool("enable_http3", false, "use http3")
    		certPath       = flag.String("c", "", "cert file path")
    		keyPath        = flag.String("k", "", "key file path")
    		enableCompress = flag.Bool("enable_compress", false, "enable compress")
    	)
    	flag.Parse()
    
    	h := handler{
    		enableCompress: *enableCompress,
    	}
    
    	proxyServer := http.Server{
    		Addr:    fmt.Sprintf("0.0.0.0:%d", *port),
    		Handler: h.makeCompressionHandler(reverseProxy(*bg)),
    	}
    
    	if *useHttp3 {
    		fmt.Println("http3")
    		if err := http3.ListenAndServe(proxyServer.Addr, *certPath, *keyPath, proxyServer.Handler); err != nil {
    			log.Fatalln(err)
    		}
    	} else {
    		fmt.Println("http")
    		if err := proxyServer.ListenAndServe(); err != nil {
    			log.Fatalln(err)
    		}
    	}
    }

[HTTP_2 _ HTTP_3]: https://blog.fundebug.com/2019/03/07/understand-http2-and-http3/