解决 Go WebSocket EOF 错误：保持连接存活-Golang-PHP中文网

解决 Go WebSocket EOF 错误：保持连接存活

霞舞

发布： 2025-08-26 18:10:24

原创

492人浏览过

解决 go websocket eof 错误：保持连接存活

本文旨在解决在使用 Go 语言进行 WebSocket 开发时遇到的 EOF (End-of-File) 错误。通过分析问题根源，提供保持 WebSocket 连接存活的有效方法，并提供一个简单的客户端-服务器示例，展示如何正确处理 WebSocket 连接，避免因连接意外关闭导致的 EOF 错误。

理解 WebSocket EOF 错误

EOF 错误通常发生在 WebSocket 连接意外关闭时。这可能是由于多种原因引起的，包括：

客户端或服务器端主动关闭连接。
网络中断或超时。
服务器端处理连接的 Goroutine 退出。

当尝试在已关闭的连接上进行读写操作时，就会出现 EOF 错误。

解决方案：保持 Goroutine 存活

关键在于确保处理 WebSocket 连接的 Goroutine 持续运行，直到连接被显式关闭。以下是一个基本的服务器端 WebSocket 处理函数的结构：

func WSHandler(ws *websocket.Conn) {
    defer ws.Close()
    fmt.Println("Client Connected")
    for {
        var message Message
        err := websocket.JSON.Receive(ws, &message)
        if err != nil {
            fmt.Printf("Error: %s\n", err.Error())
            return // Goroutine exits here if an error occurs
        }
        fmt.Println(message)

        // do something useful here...

        response := new(Message)
        response.RequestID = message.RequestID
        response.Success = true
        response.SomeOtherThing = "The hot dog left the castle as requested."
        err = websocket.JSON.Send(ws, response)
        if err != nil {
            fmt.Printf("Send failed: %s\n", err.Error())
            return // Goroutine exits here if an error occurs
        }
    }
}

登录后复制

关键点:

defer ws.Close(): 确保在函数退出时关闭 WebSocket 连接，释放资源。
for {} 循环: 使用无限循环保持 Goroutine 运行，持续监听来自客户端的消息。
错误处理: 在 websocket.JSON.Receive 和 websocket.JSON.Send 中检查错误。如果发生错误，return 语句会退出 Goroutine，并最终关闭连接。

为什么需要无限循环？

存了个图

视频图片解析/字幕/剪辑，视频高清保存/图片源图提取

查看详情

如果没有无限循环，Goroutine 在处理完第一个消息后就会退出，导致连接关闭。后续的客户端消息将无法被处理，并可能导致 EOF 错误。

完整示例

以下是一个完整的客户端-服务器示例，演示了如何使用 Go 语言和 code.google.com/p/go.net/websocket 库创建 WebSocket 连接：

package main

import (
    "code.google.com/p/go.net/websocket"
    "flag"
    "fmt"
    "net/http"
    "os"
    "time"
)

type Message struct {
    RequestID      int
    Command        string
    SomeOtherThing string
    Success        bool
}

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))
    fmt.Println("Starting Server")
    err := http.ListenAndServe(*address, nil)
    if err != nil {
        fmt.Printf("HTTP failed: %s\n", err.Error())
        os.Exit(1)
    }
}

func WSHandler(ws *websocket.Conn) {
    defer ws.Close()
    fmt.Println("Client Connected")
    for {
        var message Message
        err := websocket.JSON.Receive(ws, &message)
        if err != nil {
            fmt.Printf("Error: %s\n", err.Error())
            return
        }
        fmt.Println(message)

        // do something useful here...

        response := new(Message)
        response.RequestID = message.RequestID
        response.Success = true
        response.SomeOtherThing = "The hot dog left the castle as requested."
        err = websocket.JSON.Send(ws, response)
        if err != nil {
            fmt.Printf("Send failed: %s\n", err.Error())
            return
        }
    }
}

func RunClient() {
    fmt.Println("Starting Client")
    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)
    }
    incomingMessages := make(chan Message)
    go readClientMessages(ws, incomingMessages)
    i := 0
    for {
        select {
        case <-time.After(time.Duration(2e9)):
            i++
            response := new(Message)
            response.RequestID = i
            response.Command = "Eject the hot dog."
            err = websocket.JSON.Send(ws, response)
            if err != nil {
                fmt.Printf("Send failed: %s\n", err.Error())
                os.Exit(1)
            }
        case message := <-incomingMessages:
            fmt.Println(message)
        }
    }
}

func readClientMessages(ws *websocket.Conn, incomingMessages chan Message) {
    for {
        var message Message
        err := websocket.JSON.Receive(ws, &message)
        if err != nil {
            fmt.Printf("Error: %s\n", err.Error())
            return
        }
        incomingMessages <- message
    }
}

登录后复制

运行示例: