Go WebSockets 长连接管理：解决 EOF 错误与实现持久化通信

package main

import (
    "flag"
    "fmt"
    "log"
    "net/http"
    "os"
    "time"

    "golang.org/x/net/websocket" // 使用现代的Go WebSocket库
)

// Message 定义了在WebSocket上传输的消息结构
type Message struct {
    RequestID      int    `json:"requestID"`
    Command        string `json:"command"`
    SomeOtherThing string `json:"someOtherThing"`
    Success        bool   `json:"success"`
}

var (
    mode    = flag.String("mode", "server", "Mode: server or client")
    address = flag.String("address", "localhost:8080", "Bind address:port")
)

func main() {
    flag.Parse()

    switch *mode {
    case "server":
        runServer()
    case "client":
        runClient()
    default:
        flag.Usage()
    }
}

// runServer 启动WebSocket服务器
func runServer() {
    http.Handle("/", http.FileServer(http.Dir("./www"))) // 静态文件服务
    http.Handle("/server", websocket.Handler(wsHandler)) // WebSocket处理路由
    fmt.Printf("Starting Server on %s\n", *address)
    err := http.ListenAndServe(*address, nil)
    if err != nil {
        log.Fatalf("HTTP server failed: %s\n", err.Error())
    }
}

// wsHandler 处理单个WebSocket连接
func wsHandler(ws *websocket.Conn) {
    defer func() {
        fmt.Println("Client Disconnected")
        ws.Close() // 确保连接关闭
    }()

    fmt.Println("Client Connected")
    for {
        var message Message
        // 持续接收来自客户端的消息
        err := websocket.JSON.Receive(ws, &message)
        if err != nil {
            // 如果发生错误（如EOF），通常意味着客户端已断开
            fmt.Printf("Error receiving message: %s\n", err.Error())
            return // 退出循环，关闭连接
        }
        fmt.Printf("Received from client: %+v\n", message)

        // 模拟处理业务逻辑
        response := &Message{
            RequestID:      message.RequestID,
            Success:        true,
            SomeOtherThing: "Server processed command: " + message.Command,
        }

        // 发送响应回客户端
        err = websocket.JSON.Send(ws, response)
        if err != nil {
            fmt.Printf("Error sending response: %s\n", err.Error())
            // 发生发送错误时，也可以选择关闭连接
            return
        }
        fmt.Printf("Sent to client: %+v\n", response)
    }
}

// runClient 启动WebSocket客户端
func runClient() {
    fmt.Printf("Starting Client, connecting to ws://%s/server\n", *address)
    ws, err := websocket.Dial(fmt.Sprintf("ws://%s/server", *address), "", fmt.Sprintf("http://%s/", *address))
    if err != nil {
        log.Fatalf("Dial failed: %s\n", err.Error())
    }
    defer func() {
        fmt.Println("Client connection closed.")
        ws.Close()
    }()

    incomingMessages := make(chan Message)
    go readClientMessages(ws, incomingMessages) // 启动独立的Goroutine接收消息

    i := 0
    for {
        select {
        case <-time.After(time.Duration(2 * time.Second)): // 每2秒发送一次消息
            i++
            request := &Message{
                RequestID: i,
                Command:   fmt.Sprintf("Eject the hot dog %d.", i),
            }
            err = websocket.JSON.Send(ws, request)
            if err != nil {
                fmt.Printf("Send failed: %s\n", err.Error())
                return // 发送失败，退出客户端
            }
            fmt.Printf("Client sent: %+v\n", request)
        case message := <-incomingMessages: // 处理来自服务器的消息
            fmt.Printf("Client received from server: %+v\n", message)
        }
    }
}

// readClientMessages 专门用于从WebSocket连接接收消息
func readClientMessages(ws *websocket.Conn, incomingMessages chan Message) {
    for {
        var message Message
        err := websocket.JSON.Receive(ws, &message)
        if err != nil {
            fmt.Printf("Error receiving message on client: %s\n", err.Error())
            close(incomingMessages) // 关闭通道，通知主Goroutine接收端已关闭
            return
        }
        incomingMessages <- message // 将接收到的消息发送到通道
    }
}

/your_project
├── main.go
└── www/ (可选，用于提供静态文件)
    └── index.html (如果需要)

var s = new WebSocket("ws://localhost:8082/server"); // 注意路径是 /server
s.onopen = function(event) {
    console.log("WebSocket connected.");
    // 发送一个JSON对象
    s.send(JSON.stringify({
        RequestID: 1,
        Command: "Pause downloader",
        SomeOtherThing: "urgent"
    }));
};

s.onmessage = function(event) {
    console.log("Received from server:", event.data);
    // 可以在这里发送第二个消息
    setTimeout(() => {
        s.send(JSON.stringify({
            RequestID: 2,
            Command: "Resume downloader",
            SomeOtherThing: "later"
        }));
    }, 2000); // 2秒后发送第二个消息
};

s.onclose = function(event) {
    console.log("WebSocket disconnected:", event.code, event.reason);
};

s.onerror = function(error) {
    console.error("WebSocket error:", error);
};