// 設(shè)置要轉(zhuǎn)發(fā)的地址
target, err := url.Parse("http://www.domain.com")
if err != nil {
    panic(err)
}
// 實(shí)例化 ReverseProxy 包
proxy := httputil.NewSingleHostReverseProxy(target)
//http.HandleFunc("/", proxy.ServeHTTP)
// 啟動(dòng)服務(wù)
log.Fatal(http.ListenAndServe(":8082", proxy))

type ReverseProxy struct {
	// 對請求內(nèi)容進(jìn)行修改 (對象是業(yè)務(wù)傳入req的一個(gè)副本)
	Director func(*http.Request)
	// 連接池復(fù)用連接，用于執(zhí)行請求, 默認(rèn)為http.DefaultTransport 
	Transport http.RoundTripper
	// 定時(shí)刷新內(nèi)容到客戶端的時(shí)間間隔(流式/無內(nèi)容此參數(shù)忽略)
	FlushInterval time.Duration
	// 默認(rèn)為std.err，用于記錄內(nèi)部錯(cuò)誤日志
	ErrorLog *log.Logger
	// 用于執(zhí)行 copyBuffer 復(fù)制響應(yīng)體時(shí)，利用的bytes內(nèi)存池化
	BufferPool BufferPool
	// 如果配置后, 可修改目標(biāo)代理的響應(yīng)結(jié)果(響應(yīng)頭和內(nèi)容)
    // 如果此方法返回error, 將調(diào)用 ErrorHandler 方法
	ModifyResponse func(*http.Response) error
    // 配置后代理執(zhí)行過程中, 發(fā)生錯(cuò)誤均會(huì)回調(diào)此方法
    // 默認(rèn)邏輯不響應(yīng)任務(wù)內(nèi)容, 狀態(tài)碼返回502
	ErrorHandler func(http.ResponseWriter, *http.Request, error)
}

// 實(shí)例化 ReverseProxy 包
proxy := httputil.NewSingleHostReverseProxy(target)

// 實(shí)例化 ReverseProxy 對象
// 初始化 Director 對象, 將請求地址轉(zhuǎn)換為代理目標(biāo)地址.
// 對請求header頭進(jìn)行處理
func NewSingleHostReverseProxy(target *url.URL) *ReverseProxy {
	targetQuery := target.RawQuery
	director := func(req *http.Request) {
		req.URL.Scheme = target.Scheme
		req.URL.Host = target.Host
		req.URL.Path, req.URL.RawPath = joinURLPath(target, req.URL)
		if targetQuery == "" || req.URL.RawQuery == "" {
			req.URL.RawQuery = targetQuery + req.URL.RawQuery
		} else {
			req.URL.RawQuery = targetQuery + "&" + req.URL.RawQuery
		}
		if _, ok := req.Header["User-Agent"]; !ok {
			// explicitly disable User-Agent so it's not set to default value
			req.Header.Set("User-Agent", "")
		}
	}
	return &ReverseProxy{Director: director}
}

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

// 服務(wù)請求處理方法
func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request) {
	// 檢測是否設(shè)置http.Transport對象
    // 如果未設(shè)置則使用默認(rèn)對象
    transport := p.Transport
	if transport == nil {
		transport = http.DefaultTransport
	}
    // 檢測請求是否被終止
    // 終止請求或是正常結(jié)束請求等 notifyChan 都會(huì)收到請求結(jié)束通知, 之后進(jìn)行cancel
	ctx := req.Context()
	if cn, ok := rw.(http.CloseNotifier); ok {
		var cancel context.CancelFunc
		ctx, cancel = context.WithCancel(ctx)
		defer cancel()
		notifyChan := cn.CloseNotify()
		go func() {
			select {
			case <-notifyChan:
				cancel()
			case <-ctx.Done():
			}
		}()
	}
    // 對外部傳入的http.Request對象進(jìn)行克隆
    // outreq 是給代理服務(wù)器傳入的請求對象
	outreq := req.Clone(ctx)
	if req.ContentLength == 0 {
        // 主要修復(fù) ReverseProxy 與 http.Transport 重試不兼容性問題
        // 如果請求方法為 GET、HEAD、OPTIONS、TRACE, 同時(shí)body為nil情況下, 將會(huì)發(fā)生重試
        // 避免因?yàn)閺?fù)制傳入的request創(chuàng)建傳入代理的請求內(nèi)容, 導(dǎo)致無法發(fā)生重試.
        // https://github.com/golang/go/issues/16036
		outreq.Body = nil
	}
	if outreq.Body != nil {
		// 避免因panic問題導(dǎo)致請求未正確關(guān)閉, 其他協(xié)程繼續(xù)從中讀取
        // https://github.com/golang/go/issues/46866
		defer outreq.Body.Close()
	}
	if outreq.Header == nil {
        // Issue 33142: historical behavior was to always allocate
		outreq.Header = make(http.Header)
	}
    // 調(diào)用實(shí)現(xiàn)的 Director 方法修改請求代理的request對象
	p.Director(outreq)
	if outreq.Form != nil {
		outreq.URL.RawQuery = cleanQueryParams(outreq.URL.RawQuery)
	}
	outreq.Close = false
    // 升級http協(xié)議，HTTP Upgrade
    // 判斷header Connection 中是否有Upgrade
	reqUpType := upgradeType(outreq.Header)
    // 根據(jù)《網(wǎng)絡(luò)交換的 ASCII 格式》規(guī)范, 升級協(xié)議中是否包含禁止使用的字符
    // https://datatracker.ietf.org/doc/html/rfc20#section-4.2
	if !ascii.IsPrint(reqUpType) {
        // 調(diào)用 ReverseProxy 對象的 ErrorHandler 方法
		p.getErrorHandler()(
            rw, 
        	req, 
         	fmt.Errorf("client tried to switch to invalid protocol %q", reqUpType))
		return
	}
    // 請求下游移除Connetion頭
    // https://datatracker.ietf.org/doc/html/rfc7230#section-6.1
	removeConnectionHeaders(outreq.Header)
	// 請求下游根據(jù)RFC規(guī)范移除協(xié)議頭
	for _, h := range hopHeaders {
		outreq.Header.Del(h)
	}
	// Transfer-Encoding: chunked 分塊傳輸編碼
	if httpguts.HeaderValuesContainsToken(req.Header["Te"], "trailers") {
		outreq.Header.Set("Te", "trailers")
	}
	// 請求下游指定協(xié)議升級, 例如 websockeet
	if reqUpType != "" {
		outreq.Header.Set("Connection", "Upgrade")
		outreq.Header.Set("Upgrade", reqUpType)
	}
    // 添加 X-Forwarded-For 頭
    // 最開始的是離服務(wù)端最遠(yuǎn)的設(shè)備 IP，然后是每一級代理設(shè)備的 IP
    // 類似于 X-Forwarded-For: client, proxy1, proxy2
	if clientIP, _, err := net.SplitHostPort(req.RemoteAddr); err == nil {
		prior, ok := outreq.Header["X-Forwarded-For"]
        // 如果header頭 X-Forwarded-For 設(shè)置為nil, 則不再 X-Forwarded-For
        // 這個(gè)參數(shù)下面我們將詳細(xì)說明
		omit := ok && prior == nil
		if len(prior) > 0 {
			clientIP = strings.Join(prior, ", ") + ", " + clientIP
		}
		if !omit {
			outreq.Header.Set("X-Forwarded-For", clientIP)
		}
	}
    // 使用transport對象中維護(hù)的鏈接池, 向下游發(fā)起請求
	res, err := transport.RoundTrip(outreq)
	if err != nil {
		p.getErrorHandler()(rw, outreq, err)
		return
	}
    // 處理下游響應(yīng)的升級協(xié)議請求
	// Deal with 101 Switching Protocols responses: (WebSocket, h2c, etc)
	if res.StatusCode == http.StatusSwitchingProtocols {
		if !p.modifyResponse(rw, res, outreq) {
			return
		}
		p.handleUpgradeResponse(rw, outreq, res)
		return
	}
    // 根據(jù)協(xié)議規(guī)范刪除響應(yīng) Connection 頭
	removeConnectionHeaders(res.Header)
    // 下游響應(yīng)根據(jù)RFC規(guī)范移除協(xié)議頭
	for _, h := range hopHeaders {
		res.Header.Del(h)
	}
    // 如有設(shè)置 modifyResponse, 則修改響應(yīng)內(nèi)容
    // 調(diào)用 ReverseProxy 對象 modifyResponse 方法
	if !p.modifyResponse(rw, res, outreq) {
		return
	}
    // 拷貝響應(yīng)Header到上游response對象
	copyHeader(rw.Header(), res.Header)
	// 分塊傳輸部分協(xié)議 header 頭設(shè)置, 已跳過
    // 寫入響應(yīng)碼到上游response對象
	rw.WriteHeader(res.StatusCode)
    // 拷貝結(jié)果到上游
    // flushInterval將響應(yīng)定時(shí)刷新到緩沖區(qū)
	err = p.copyResponse(rw, res.Body, p.flushInterval(res))
	if err != nil {
		defer res.Body.Close()
		// ... 調(diào)用errorHandler
        panic(http.ErrAbortHandler)
	}
    // 關(guān)閉響應(yīng)body
	res.Body.Close()
    // chunked 分塊傳輸編碼調(diào)用flush刷新到客戶端
	if len(res.Trailer) > 0 {
		// Force chunking if we saw a response trailer.
		// This prevents net/http from calculating the length for short
		// bodies and adding a Content-Length.
		if fl, ok := rw.(http.Flusher); ok {
			fl.Flush()
		}
	}
    // 以下為分塊傳輸編碼相關(guān)header設(shè)置
	if len(res.Trailer) == announcedTrailers {
		copyHeader(rw.Header(), res.Trailer)
		return
	}
	for k, vv := range res.Trailer {
		k = http.TrailerPrefix + k
		for _, v := range vv {
			rw.Header().Add(k, v)
		}
	}
}

type ServeHTTP struct {
    // 代理鏈接地址
	targetUrl         string
    // net/http 內(nèi)置的 ReverseProxy 對象
	reverseProxy      *httputil.ReverseProxy
    // 代理錯(cuò)誤處理
	proxyErrorHandler ProxyErrorHandler
    // 日志對象
	logger            log.Logger
}

// NewServeHTTP 初始化代理對象
func NewServeHTTP(targetUrl string, logger log.Logger) *ServeHTTP {
	target, err := url.Parse(targetUrl)
	if err != nil {
		panic(err)
	}
    // 重新設(shè)置 Director 復(fù)制請求處理
	proxy := &httputil.ReverseProxy{Director: func(req *http.Request) {
		req.URL.Scheme = target.Scheme
		req.URL.Host = target.Host
		req.Host = target.Host
		if _, ok := req.Header["User-Agent"]; !ok {
			req.Header.Set("User-Agent", "")
		}
		if req.Header.Get("Content-Length") == "0" {
			req.Header.Del("Content-Length")
		}
		req.Header["X-Forwarded-For"] = nil
		for _, name := range removeRequestHeaders {
			req.Header.Del(name)
		}
	}}
	serveHttp := &ServeHTTP{
		targetUrl:         targetUrl,
		logger:            logger,
		reverseProxy:      proxy,
		proxyErrorHandler: DefaultProxyErrorHandler,
	}
    // 設(shè)置trasport處理對象(主要調(diào)配鏈接池大小和超時(shí)時(shí)間)
	serveHttp.reverseProxy.Transport = HttpTransportDefault()
    // 定義錯(cuò)誤處理
	serveHttp.reverseProxy.ErrorHandler = serveHttp.getErrorHandler(logger)
    // 定義響應(yīng)處理
	serveHttp.reverseProxy.ModifyResponse = serveHttp.getResponseHandler(logger)
	return serveHttp
}
// SetProxyErrorFunc 設(shè)置錯(cuò)誤處理函數(shù)
func (s *ServeHTTP) SetProxyErrorFunc(handler ProxyErrorHandler) *ServeHTTP {
	s.proxyErrorHandler = handler
	return s
}

netHttp.Transport{
		Proxy: proxyURL,
		DialContext: (&net.Dialer{
			Timeout:   30 * time.Second,
			KeepAlive: 30 * time.Second,
		}).DialContext,
		ForceAttemptHTTP2:     true,
		MaxIdleConns:          200,
		MaxIdleConnsPerHost:   200,
		IdleConnTimeout:       90 * time.Second,
		TLSHandshakeTimeout:   10 * time.Second,
		ExpectContinueTimeout: 1 * time.Second,
	}

// ServeHTTP 服務(wù)轉(zhuǎn)發(fā)
func (s *ServeHTTP) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
	var (
		reqBody []byte
		err     error
        // 生成traceId
		traceId = s.getTraceId(request)
	)
    // 前置獲取請求頭, 放入context中
    // 調(diào)用結(jié)束后請求 body 將會(huì)被關(guān)閉, 后面將無法再獲取
	if request.Body != nil {
		reqBody, err = io.ReadAll(request.Body)
		if err == nil {
			request.Body = io.NopCloser(bytes.NewBuffer(reqBody))
		}
	}
    // header 設(shè)置 traceId和超時(shí)時(shí)間傳遞
	request.Header.Set(utils.TraceKey, traceId)
	request.Header.Set(utils.Timeoutkey, cast.ToString(s.getTimeout(request)))
	// 計(jì)算獲取超時(shí)時(shí)間, 發(fā)起轉(zhuǎn)發(fā)請求
	ctx, cancel := context.WithTimeout(
        request.Context(), 
         time.Duration(s.getTimeout(request))*time.Millisecond,
    )
	defer cancel()
    // 設(shè)置請求體
	ctx = context.WithValue(ctx, ctxReqBody, string(reqBody))
    // 設(shè)置請求時(shí)間, 用于響應(yīng)結(jié)束后計(jì)算請求耗時(shí)
	ctx = context.WithValue(ctx, ctxReqTime, time.Now())
    // context 設(shè)置traceId, 用于鏈路日志打印
	ctx = context.WithValue(ctx, utils.TraceKey, traceId)
	request = request.WithContext(ctx)
    // 調(diào)用 reverseProxy ServeHTTP, 處理轉(zhuǎn)發(fā)邏輯
	s.reverseProxy.ServeHTTP(writer, request)
}

// getTraceId 獲取traceId
// header頭中不存在則生成
func (s *ServeHTTP) getTraceId(request *http.Request) string {
	traceId := request.Header.Get(utils.TraceKey)
	if traceId != "" {
		return traceId
	}
	return uuid.NewV4().String()
}
// getTimeout 獲取超時(shí)時(shí)間
// header中不存在timeoutKey, 返回默認(rèn)超時(shí)時(shí)間
// header頭存在, 則判斷是否大于默認(rèn)超時(shí)時(shí)間, 大于則使用默認(rèn)超時(shí)時(shí)間
// 否則返回header設(shè)置的超時(shí)時(shí)間
func (s *ServeHTTP) getTimeout(request *http.Request) uint32 {
	timeout := request.Header.Get(utils.Timeoutkey)
	if timeout == "" {
		return DefaultTimeoutMs
	}
	headerTimeoutMs := cast.ToUint32(timeout)
	if headerTimeoutMs > DefaultTimeoutMs {
		return DefaultTimeoutMs
	}
	return cast.ToUint32(timeout)
}

// getErrorHandler 記錄錯(cuò)誤記錄
func (s *ServeHTTP) getErrorHandler(logger log.Logger) ErrorHandler {
	return func(writer http.ResponseWriter, request *http.Request, e error) {
		var (
			reqBody []byte
			err     error
		)
		if request.Body != nil {
			reqBody, err = io.ReadAll(request.Body)
			if err == nil {
				request.Body = io.NopCloser(bytes.NewBuffer(reqBody))
			}
		}
        // 初始化時(shí)確認(rèn)proxyErrorHandler具體處理方法
        // 調(diào)用 proxyErrorHandler,處理響應(yīng)部分
		s.proxyErrorHandler(writer, e)
        // 獲取必要信息, 記錄錯(cuò)誤日志
		scheme := s.getSchemeDataByRequest(request)
		_ = log.WithContext(request.Context(), logger).Log(log.LevelError,
			"x_module", "proxy/server/error",
			"x_component", scheme.kind,
			"x_error", e,
			"x_header", request.Header,
			"x_action", scheme.operation,
			"x_param", string(reqBody),
			"x_trace_id", request.Context().Value(utils.TraceKey),
		)
	}
}
// 具體代理業(yè)務(wù)錯(cuò)誤處理
// 包含默認(rèn)錯(cuò)誤響應(yīng)和具體代理業(yè)務(wù)錯(cuò)誤響應(yīng). 
// 以下為某個(gè)業(yè)務(wù)響應(yīng)
func XXXProxyErrorHandler(writer http.ResponseWriter, err error) {
	resp := HttpXXXResponse{
		ErrCode: 1,
		ErrMsg:  err.Error(),
		Data:    struct{}{},
	}
	writer.Header().Set("Content-Type", "application/json; charset=utf-8")
	writer.Header().Set("Connection", "keep-alive")
	writer.Header().Set("Cache-Control", "no-cache")
    // 設(shè)置狀態(tài)碼為200
	writer.WriteHeader(http.StatusOK)
    // 將響應(yīng)值序列化
	respByte, _ := json.Marshal(resp)
    // 將response數(shù)據(jù)寫入writer, 刷新到Flush
    // 關(guān)于Flush部分, 一般是不需要主動(dòng)刷新的, 請求結(jié)束后會(huì)自動(dòng)Flush
	_, _ = fmt.Fprintf(writer, string(respByte))
	if f, ok := writer.(http.Flusher); ok {
		f.Flush()
	}
}

// getResponseHandler 獲取響應(yīng)數(shù)據(jù)
func (s *ServeHTTP) getResponseHandler(logger log.Logger) func(response *http.Response) error {
	return func(response *http.Response) error {
		var (
			duration float64
			logLevel = log.LevelInfo
			header   http.Header
		)
        // 獲取請求體
		reqBody := response.Request.Context().Value(ctxReqBody)
        // 獲取開始請求時(shí)間, 計(jì)算請求耗時(shí)
		startTime := response.Request.Context().Value(ctxReqBody)
		if startTime != nil {
			_, ok := startTime.(time.Time)
			if ok {
				duration = time.Since(startTime.(time.Time)).Seconds()
			}
		}
        // 獲取響應(yīng)數(shù)據(jù)
        // 如果響應(yīng)碼非200, 調(diào)整日志等級
		scheme := s.getSchemeDataByResponse(response)
		if response.StatusCode != http.StatusOK {
			logLevel = log.LevelError
			header = scheme.header
		}
        // 記錄日志
		_ = log.WithContext(response.Request.Context(), logger).Log(logLevel,
			"x_module", "proxy/server/resp",
			"x_component", "http",
			"x_code", scheme.code,
			"x_header", header,
			"x_action", scheme.operation,
			"x_params", reqBody,
			"x_response", scheme.responseData,
			"x_duration", duration,
			"x_trace_id", response.Request.Context().Value(utils.TraceKey),
		)
		// 設(shè)置響應(yīng)頭
		response.Header.Set("Content-Type", "application/json; charset=utf-8")
		return nil
	}
}

urlStr := "https://" + targetHost
proxy := utilsProxy.NewServeHTTP(urlStr, logger).SetProxyErrorFunc(utilsProxy.XXXProxyErrorHandler)
log.Fatal(http.ListenAndServe(":8082", proxy))