Golang WebSocket 示例：服务端等待客户端连接并接收消息

以下是一个简单的 Golang WebSocket 示例，实现了服务端等待客户端连接，并在客户端连接后接收和发送消息的功能。

package main

import (
    "fmt"
    "log"
    "net/http"

    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

func main() {
    http.HandleFunc("/ws", wsHandler)
    log.Println("Starting server on :8080")
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal("ListenAndServe: ", err)
    }
}

func wsHandler(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println("Upgrade:", err)
        return
    }
    defer conn.Close()

    for {
        _, message, err := conn.ReadMessage()
        if err != nil {
            log.Println("ReadMessage:", err)
            return
        }
        log.Printf("Received message: %s\n", message)

        reply := fmt.Sprintf("Received: %s", message)
        err = conn.WriteMessage(websocket.TextMessage, []byte(reply))
        if err != nil {
            log.Println("WriteMessage:", err)
            return
        }
    }
}

客户端代码如下：

package main

import (
    "fmt"
    "log"
    "net/url"
    "os"
    "os/signal"
    "syscall"

    "github.com/gorilla/websocket"
)

func main() {
    interrupt := make(chan os.Signal, 1)
    signal.Notify(interrupt, os.Interrupt, syscall.SIGTERM)

    u := url.URL{Scheme: "ws", Host: "localhost:8080", Path: "/ws"}
    log.Printf("Connecting to %s", u.String())

    c, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
    if err != nil {
        log.Fatal("dial:", err)
    }
    defer c.Close()

    done := make(chan struct{})

    go func() {
        defer close(done)
        for {
            _, message, err := c.ReadMessage()
            if err != nil {
                log.Println("read:", err)
                return
            }
            log.Printf("Received message: %s\n", message)
        }
    }()

    for {
        select {
        case <-done:
            return
        case <-interrupt:
            log.Println("interrupt")
            err := c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
            if err != nil {
                log.Println("write close:", err)
                return
            }
            select {
            case <-done:
            case <-interrupt:
                log.Println("interrupt")
                return
            }
        }
    }
}

在服务端启动后，客户端连接到服务端并发送消息，服务端接收到消息并回复。如果客户端在服务端启动前启动，服务端会一直等待客户端连接并接收消息，直到客户端连接并发送消息后才会回复。