Go WebSocket 连接EOF错误解析与持久化通信实现

package main

import (
    "code.google.com/p/go.net/websocket" // 示例中使用旧版库，现代项目建议使用github.com/gorilla/websocket
    "flag"
    "fmt"
    "net/http"
    "os"
    "time"
)

// Message 定义了消息的结构，用于JSON序列化
type Message struct {
    RequestID      int    `json:"requestID"`
    Command        string `json:"command"`
    SomeOtherThing string `json:"someOtherThing"`
    Success        bool   `json:"success"`
}

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

func main() {
    flag.Parse()

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

func RunServer() {
    http.Handle("/", http.FileServer(http.Dir("www"))) // 提供静态文件
    http.Handle("/server", websocket.Handler(WSHandler)) // WebSocket处理路由
    fmt.Println("Starting Server on", *address)
    err := http.ListenAndServe(*address, nil)
    if err != nil {
        fmt.Printf("HTTP failed: %s\n", err.Error())
        os.Exit(1)
    }
}

// WSHandler 是处理单个WebSocket连接的函数
func WSHandler(ws *websocket.Conn) {
    defer ws.Close() // 确保连接在函数退出时关闭
    fmt.Println("Client Connected")
    for { // 无限循环，持续处理消息
        var message Message
        // 接收客户端发送的JSON消息
        err := websocket.JSON.Receive(ws, &message)
        if err != nil {
            // 错误处理：EOF或其他读取错误意味着客户端断开或发生异常
            fmt.Printf("Error receiving message: %s\n", err.Error())
            return // 退出Goroutine，触发defer ws.Close()
        }
        fmt.Printf("Received from client: %+v\n", message)

        // 模拟业务逻辑处理
        response := new(Message)
        response.RequestID = message.RequestID
        response.Success = true
        response.SomeOtherThing = fmt.Sprintf("Command '%s' processed successfully.", message.Command)

        // 将响应发送回客户端
        err = websocket.JSON.Send(ws, response)
        if err != nil {
            fmt.Printf("Error sending response: %s\n", err.Error())
            os.Exit(1) // 发送失败通常是严重错误，可能需要退出应用
        }
    }
}

func RunClient() {
    fmt.Println("Starting Client")
    // 建立WebSocket连接
    ws, err := websocket.Dial(fmt.Sprintf("ws://%s/server", *address), "", fmt.Sprintf("http://%s/", *address))
    if err != nil {
        fmt.Printf("Dial failed: %s\n", err.Error())
        os.Exit(1)
    }
    defer ws.Close() // 确保客户端连接在函数退出时关闭

    incomingMessages := make(chan Message) // 用于接收服务端消息的通道
    // 启动一个Goroutine专门负责接收消息
    go readClientMessages(ws, incomingMessages)

    i := 0
    for { // 主循环用于发送消息和处理接收到的消息
        select {
        case <-time.After(time.Duration(2e9)): // 每2秒发送一条消息
            i++
            request := new(Message)
            request.RequestID = i
            request.Command = fmt.Sprintf("Eject the hot dog %d.", i)
            fmt.Printf("Sending request: %+v\n", request)
            err = websocket.JSON.Send(ws, request)
            if err != nil {
                fmt.Printf("Send failed: %s\n", err.Error())
                os.Exit(1)
            }
        case message := <-incomingMessages: // 处理从服务端接收到的消息
            fmt.Printf("Received from server: %+v\n", message)
        }
    }
}

// readClientMessages Goroutine负责持续接收服务端消息
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 from server: %s\n", err.Error())
            // 接收失败，通常意味着连接断开，退出此Goroutine
            return
        }
        incomingMessages <- message // 将接收到的消息发送到通道
    }
}

type Message struct {
    RequestID      int    `json:"requestID"`
    Command        string `json:"command"`
    SomeOtherThing string `json:"someOtherThing"`
    Success        bool   `json:"success"`
}