Go HTTP 服务器远程关闭与消息通知：从 Hijack 到优雅停机

func stopServer(ohtWriter http.ResponseWriter, phtRequest *http.Request) {
    println("Stopping Server")

    // 尝试发送消息
    iBytesSent, oOsError := ohtWriter.Write([]byte("Message from server - server now stopped."))
    if oOsError != nil {
        println("Error writing response:", oOsError.String())
    } else {
        println("Bytes sent =", strconv.Itoa(iBytesSent))
    }

    // 尝试刷新缓冲区
    ohtFlusher, tCanFlush := ohtWriter.(http.Flusher)
    if tCanFlush {
        ohtFlusher.Flush()
    }

    // 立即退出，可能导致消息未送达
    // go func() {
    //     time.Sleep(3 * time.Second) // 原始问题中的权宜之计
    //     os.Exit(0)
    // }()
    os.Exit(0) // 如果不加sleep，消息很可能收不到
}

package main

import (
    "io"
    "log"
    "net/http"
    "os"
    "strconv"
)

const responseString = "Shutting down\n"

func main() {
    http.HandleFunc("/shutdown", ServeShutdown) // 注册一个专门的关闭路由
    log.Println("Server started on :8081")
    log.Fatal(http.ListenAndServe(":8081", nil))
}

// ServeShutdown 处理关闭请求，并确保消息送达
func ServeShutdown(w http.ResponseWriter, req *http.Request) {
    // 1. 设置响应头
    w.Header().Set("Content-Type", "text/plain; charset=utf-8")
    w.Header().Set("Content-Length", strconv.Itoa(len(responseString)))

    // 2. 写入响应体
    _, err := io.WriteString(w, responseString)
    if err != nil {
        log.Printf("Error writing response: %v", err)
        http.Error(w, "Internal Server Error", http.StatusInternalServerError)
        return
    }

    // 3. 刷新缓冲区，确保数据写入底层TCP连接
    f, canFlush := w.(http.Flusher)
    if canFlush {
        f.Flush()
    } else {
        log.Println("http.ResponseWriter does not implement http.Flusher")
    }

    // 4. 接管底层连接
    hijacker, ok := w.(http.Hijacker)
    if !ok {
        log.Fatalf("http.ResponseWriter does not implement http.Hijacker")
        http.Error(w, "Hijacking not supported", http.StatusInternalServerError)
        return
    }

    conn, buf, err := hijacker.Hijack()
    if err != nil {
        log.Fatalf("Error while hijacking connection: %v", err)
    }
    defer conn.Close() // 确保连接最终被关闭

    // 如果有缓冲数据，确保写入
    if buf.Reader.Buffered() > 0 {
        _, err := buf.WriterTo(conn) // 将缓冲区的剩余数据写入连接
        if err != nil {
            log.Printf("Error writing buffered data to hijacked connection: %v", err)
        }
    }
    if err := buf.Flush(); err != nil { // 刷新写入缓冲区
        log.Printf("Error flushing hijacked buffer: %v", err)
    }

    log.Println("Shutting down server...")
    // 5. 关闭连接并退出进程
    // 在Hijack之后，连接的生命周期由我们控制。
    // 确保消息已发送后，可以安全地退出。
    os.Exit(0)
}

package main

import (
    "context"
    "fmt"
    "log"
    "net/http"
    "os"
    "os/signal"
    "time"
)

func main() {
    // 创建一个HTTP服务器实例
    server := &http.Server{Addr: ":8081"}

    // 注册一个处理函数，模拟一个耗时操作
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        log.Printf("Handling request from %s for %s", r.RemoteAddr, r.URL.Path)
        time.Sleep(2 * time.Second) // 模拟耗时操作
        fmt.Fprintf(w, "Hello, you requested %s\n", r.URL.Path)
    })

    // 注册一个关闭路由，用于触发优雅停机
    http.HandleFunc("/shutdown", func(w http.ResponseWriter, r *http.Request) {
        log.Println("Received /shutdown request. Initiating graceful shutdown...")
        fmt.Fprintln(w, "Server is shutting down gracefully. Please wait...")

        // 创建一个带有超时的Context，用于控制Shutdown的等待时间
        ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
        defer cancel() // 确保Context资源被释放

        // 在goroutine中执行Shutdown，避免阻塞当前请求
        go func() {
            if err := server.Shutdown(ctx); err != nil {
                log.Printf("Server shutdown error: %v", err)
            }
            log.Println("Server gracefully stopped.")
            os.Exit(0) // 优雅停机完成后退出
        }()
    })

    // 在goroutine中启动HTTP服务器
    go func() {
        if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
            log.Fatalf("Could not listen on :8081: %v\n", err)
        }
    }()
    log.Println("Server started on :8081. Send GET /shutdown to stop.")

    // 监听操作系统的中断信号 (Ctrl+C, kill等)
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, os.Interrupt)
    <-quit // 阻塞直到接收到信号

    log.Println("Received OS interrupt signal. Shutting down server...")

    // 再次调用Shutdown进行优雅停机，以防通过信号关闭
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()
    if err := server.Shutdown(ctx); err != nil {
        log.Fatalf("Server forced to shutdown: %v", err)
    }
    log.Println("Server exited gracefully.")
}