Go语言中实现HTTP双工流处理：使用http.Hijacker进行底层连接控制

type Hijacker interface {
    Hijack() (c net.Conn, rw *bufio.ReadWriter, err error)
}

package main

import (
    "bufio"
    "fmt"
    "io"
    "log"
    "net"
    "net/http"
    "time"
)

func duplexHandler(w http.ResponseWriter, r *http.Request) {
    // 1. 检查并劫持连接
    hj, ok := w.(http.Hijacker)
    if !ok {
        http.Error(w, "Hijacking not supported", http.StatusInternalServerError)
        return
    }

    conn, bufrw, err := hj.Hijack()
    if err != nil {
        http.Error(w, fmt.Sprintf("Failed to hijack connection: %v", err), http.StatusInternalServerError)
        return
    }
    defer conn.Close() // 确保连接最终被关闭
    log.Printf("Connection hijacked from %s", conn.RemoteAddr())

    // 在这里，你已经完全控制了底层的TCP连接。
    // 标准的http.Request.Body 在劫持后可能不再可用或行为不确定，
    // 如果需要处理请求体，应在劫持前完成读取，或者通过bufrw.Reader直接读取原始数据。
    // 对于本例，我们假设请求头已经足够，或者我们将在劫持后处理自定义协议。
}

// ... (接上文代码)

    // 2. 手动发送HTTP响应头
    // 例如，发送一个200 OK响应
    _, err = bufrw.WriteString("HTTP/1.1 200 OK\r\n")
    if err != nil {
        log.Printf("Error writing status line: %v", err)
        return
    }
    _, err = bufrw.WriteString("Content-Type: text/plain\r\n")
    if err != nil {
        log.Printf("Error writing Content-Type header: %v", err)
        return
    }
    _, err = bufrw.WriteString("Connection: close\r\n") // 或者 keep-alive，取决于你的需求
    if err != nil {
        log.Printf("Error writing Connection header: %v", err)
        return
    }
    _, err = bufrw.WriteString("\r\n") // 结束响应头
    if err != nil {
        log.Printf("Error writing header separator: %v", err)
        return
    }
    err = bufrw.Flush() // 立即发送缓冲区中的数据
    if err != nil {
        log.Printf("Error flushing headers: %v", err)
        return
    }
    log.Println("HTTP headers sent.")

    // ... (继续处理响应体和双工通信)

// ... (接上文代码)

    // 3. 实现双向数据流 - 写入响应体
    go func() {
        for i := 0; i < 10; i++ {
            message := fmt.Sprintf("This is streaming response part %d\n", i+1)
            _, err := bufrw.WriteString(message)
            if err != nil {
                log.Printf("Error writing response part: %v", err)
                return
            }
            err = bufrw.Flush() // 每次写入后立即刷新，确保数据实时发送
            if err != nil {
                log.Printf("Error flushing response part: %v", err)
                return
            }
            log.Printf("Sent: %s", message)
            time.Sleep(500 * time.Millisecond) // 模拟数据生成延迟
        }
        log.Println("Finished sending streaming response.")
    }()

    // 3. 实现双向数据流 - 读取客户端数据 (如果客户端在发送数据)
    // 在劫持连接后，如果客户端继续发送数据，你可以从bufrw.Reader读取。
    // 这对于实现自定义协议（如WebSocket）非常有用。
    // 注意：对于标准的HTTP客户端，在收到200 OK后可能不会继续发送数据，除非是特殊的场景。
    clientReader := make([]byte, 1024)
    for {
        conn.SetReadDeadline(time.Now().Add(5 * time.Second)) // 设置读取超时
        n, err := bufrw.Read(clientReader)
        if err != nil {
            if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
                // log.Println("Read timeout, no more data from client for now.")
                continue // 继续等待
            }
            if err == io.EOF {
                log.Println("Client closed the connection.")
                break
            }
            log.Printf("Error reading from client: %v", err)
            break
        }
        if n > 0 {
            log.Printf("Received %d bytes from client: %s", n, string(clientReader[:n]))
            // 你可以在这里处理接收到的数据，并可能发送一个响应
            _, writeErr := bufrw.WriteString(fmt.Sprintf("Server received: %s\n", string(clientReader[:n])))
            if writeErr != nil {
                log.Printf("Error writing echo response: %v", writeErr)
                break
            }
            bufrw.Flush()
        }
    }
    log.Println("Handler finished.")
}

func main() {
    http.HandleFunc("/duplex", duplexHandler)
    log.Println("Server starting on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}