Go语言中实现HTTP双工流式处理：利用http.Hijacker进行连接劫持

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

package main

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

// duplexHandler 是一个处理HTTP双工通信的函数
func duplexHandler(w http.ResponseWriter, r *http.Request) {
    // 1. 检查并获取 http.Hijacker 接口
    // 并非所有 http.ResponseWriter 都支持 Hijacker，需要进行类型断言
    hj, ok := w.(http.Hijacker)
    if !ok {
        http.Error(w, "服务器不支持连接劫持", http.StatusInternalServerError)
        return
    }

    // 2. 劫持连接
    // Hijack() 返回底层的 net.Conn 和一个 *bufio.ReadWriter
    conn, bufrw, err := hj.Hijack()
    if err != nil {
        http.Error(w, fmt.Sprintf("劫持连接失败: %v", err), http.StatusInternalServerError)
        return
    }
    // 确保底层TCP连接最终被关闭，释放资源
    defer func(conn net.Conn) {
        err := conn.Close()
        if err != nil {
            log.Printf("关闭连接失败: %v", err)
        }
        log.Println("连接已关闭。")
    }(conn)

    log.Printf("连接已劫持，客户端地址: %s", conn.RemoteAddr())

    // 3. 手动发送初始HTTP响应头
    // 劫持后，标准HTTP服务器不再管理响应，我们需要手动构造并发送HTTP响应头。
    // 注意：使用 CRLF (\r\n) 作为行结束符，并用一个空行 (\r\n) 结束头部。
    _, err = bufrw.WriteString("HTTP/1.1 200 OK\r\n")
    if err != nil {
        log.Printf("写入初始HTTP状态行失败: %v", err)
        return
    }
    _, err = bufrw.WriteString("Content-Type: text/plain; charset=utf-8\r\n")
    if err != nil {
        log.Printf("写入Content-Type头失败: %v", err)
        return
    }
    _, err = bufrw.WriteString("Connection: keep-alive\r\n") // 保持连接活跃
    if err != nil {
        log.Printf("写入Connection头失败: %v", err)
        return
    }
    _, err = bufrw.WriteString("\r\n") // 重要的空行，表示HTTP头结束
    if err != nil {
        log.Printf("写入HTTP头结束符失败: %v", err)
        return
    }

    // 立即刷新缓冲区，确保头信息发送到客户端
    err = bufrw.Flush()
    if err != nil {
        log.Printf("刷新初始HTTP头失败: %v", err)
        return
    }
    log.Println("初始HTTP响应头已发送。")

    // 4. 实现请求体和响应体的双向流式处理
    // 启动一个goroutine来并发读取请求体数据
    go func() {
        defer func() {
            log.Println("请求体读取goroutine结束。")
            // 即使 Hijack 了，r.Body 仍然是基于底层连接的，
            // 在读取完成后手动关闭是良好的实践。
            // 但在并发读写场景下，关闭 r.Body 可能会影响 bufrw 的写入，
            // 因此更安全的做法是让其自然结束或仅在确定不再需要时关闭。
            // 在此示例中，我们主要通过 bufrw 来管理连接的读写。
            // r.Body 最终会被 Go 的 GC 回收。
        }()

        // 从原始请求体中读取数据
        // 注意：r.Body 在 Hijack 之后仍然是可读的，因为它只是底层连接的一个视图。
        // 但一旦 Hijack，Go 标准库就不再负责其生命周期管理。
        buf := make([]byte, 1024)
        for {
            n, readErr := r.Body.Read(buf)
            if n > 0 {
                receivedData := string(buf[:n])
                log.Printf("从请求体接收到数据: %s", receivedData)
                // 可以在这里对接收到的数据进行处理或转换
                // 然后通过 bufrw.Writer 将处理后的数据发送回客户端
                responsePart := fmt.Sprintf("服务器回显: %s (收到于 %s)\n", receivedData, time.Now().Format("15:04:05"))
                _, writeErr := bufrw.WriteString(responsePart)
                if writeErr != nil {
                    log.Printf("写入回显数据到客户端失败: %v", writeErr)
                    return // 写入失败，退出goroutine
                }
                flushErr := bufrw.Flush() // 刷新缓冲区，确保数据发送
                if flushErr != nil {
                    log.Printf("刷新回显数据失败: %v", flushErr)
                    return // 刷新失败，退出goroutine
                }
            }
            if readErr == io.EOF {
                log.Println("请求体已读取完毕 (EOF)。")
                break
            }
            if readErr != nil {
                log.Printf("读取请求体时发生错误: