Golang中如何让http.Server处理来自连接的请求

在Go标准库的net/http包中，虽然没有像fasthttp那样直接的ServeConn方法，但你可以通过劫持连接并使用http.Server的底层处理机制来实现类似功能。以下是实现方案：

核心解决方案

package main

import (
    "bufio"
    "context"
    "crypto/tls"
    "fmt"
    "net"
    "net/http"
    "time"
)

type connWrapper struct {
    net.Conn
}

func (cw *connWrapper) Close() error {
    return cw.Conn.Close()
}

// 处理解密后的TLS连接
func handleDecryptedConnection(conn net.Conn, server *http.Server) error {
    // 创建连接包装器
    wrappedConn := &connWrapper{Conn: conn}
    
    // 使用Server的底层连接处理机制
    return server.Serve(net.Listener(&singleConnListener{conn: wrappedConn}))
}

// 单连接监听器实现
type singleConnListener struct {
    conn net.Conn
    done bool
}

func (l *singleConnListener) Accept() (net.Conn, error) {
    if l.done {
        return nil, fmt.Errorf("listener closed")
    }
    l.done = true
    return l.conn, nil
}

func (l *singleConnListener) Close() error {
    return l.conn.Close()
}

func (l *singleConnListener) Addr() net.Addr {
    return l.conn.LocalAddr()
}

// 代理服务器处理函数
func proxyHandler(server *http.Server) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // 劫持连接
        hijacker, ok := w.(http.Hijacker)
        if !ok {
            http.Error(w, "Hijacking not supported", http.StatusInternalServerError)
            return
        }
        
        clientConn, _, err := hijacker.Hijack()
        if err != nil {
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        
        // 发送连接建立响应
        fmt.Fprintf(clientConn, "HTTP/1.1 200 Connection established\r\n\r\n")
        
        // 执行TLS握手（这里需要你实际的TLS配置）
        tlsConfig := &tls.Config{
            // 你的TLS配置
        }
        
        tlsConn := tls.Server(clientConn, tlsConfig)
        if err := tlsConn.Handshake(); err != nil {
            tlsConn.Close()
            return
        }
        
        // 处理解密后的连接
        go handleDecryptedConnection(tlsConn, server)
    }
}

完整示例

func main() {
    // 创建HTTP服务器
    server := &http.Server{
        Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            fmt.Fprintf(w, "处理请求: %s %s\n", r.Method, r.URL.Path)
        }),
        ReadTimeout:  10 * time.Second,
        WriteTimeout: 10 * time.Second,
    }
    
    // 代理服务器
    proxyServer := &http.Server{
        Addr: ":8080",
        Handler: proxyHandler(server),
    }
    
    fmt.Println("代理服务器运行在 :8080")
    if err := proxyServer.ListenAndServe(); err != nil {
        fmt.Printf("服务器错误: %v\n", err)
    }
}

更高效的实现方式

如果你需要更低的延迟和内存分配，可以直接使用bufio.Reader和HTTP请求解析：

func handleHTTPConnection(conn net.Conn, handler http.Handler) {
    defer conn.Close()
    
    reader := bufio.NewReader(conn)
    writer := bufio.NewWriter(conn)
    
    for {
        // 读取HTTP请求
        req, err := http.ReadRequest(reader)
        if err != nil {
            break
        }
        
        // 创建响应写入器
        rw := &responseWriter{
            conn:   conn,
            writer: writer,
            header: make(http.Header),
        }
        
        // 处理请求
        handler.ServeHTTP(rw, req)
        
        // 刷新缓冲区
        if err := writer.Flush(); err != nil {
            break
        }
        
        // 如果不是keep-alive，则退出循环
        if !isKeepAlive(req) {
            break
        }
    }
}

// 自定义响应写入器
type responseWriter struct {
    conn   net.Conn
    writer *bufio.Writer
    header http.Header
    status int
}

func (rw *responseWriter) Header() http.Header {
    return rw.header
}

func (rw *responseWriter) Write(data []byte) (int, error) {
    return rw.writer.Write(data)
}

func (rw *responseWriter) WriteHeader(statusCode int) {
    rw.status = statusCode
}

func isKeepAlive(req *http.Request) bool {
    return req.Close == false
}

关键要点

1. 使用singleConnListener：通过实现net.Listener接口来包装单个连接，让http.Server能够处理该连接。

2. 避免额外内存分配：重用连接和缓冲区，减少GC压力。

3. 正确处理连接生命周期：确保连接在适当的时候关闭，避免资源泄漏。

4. 性能优化：对于高并发场景，可以考虑使用连接池和对象重用模式。

这种方法让你能够利用标准库的HTTP处理能力，同时保持对底层连接的控制，实现高效的代理服务器功能。