Golang WebSocket 创建单独会话_golang 实现聊天会话

package main

import (
    "log"
    "net/http"

    "github.com/gorilla/websocket"
)

// 创建一个 upgrader 对象，用于升级 HTTP 连接为 WebSocket 连接
var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

func main() {
    http.HandleFunc("/ws", handleWebSocket)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func handleWebSocket(w http.ResponseWriter, r \*http.Request) {
    // 将 HTTP 连接升级为 WebSocket 连接
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println("Upgrade failed:", err)
        return
    }

    defer conn.Close()

    // 处理 WebSocket 会话
    for {
        // 读取客户端发送的消息
        messageType, message, err := conn.ReadMessage()
        if err != nil {
            log.Println("Read message failed:", err)
            break
        }

        // 处理客户端发送的消息
        log.Printf("Received message: %s", message)

        // 回复客户端消息
        err = conn.WriteMessage(messageType, message)
        if err != nil {
            log.Println("Write message failed:", err)
            break
        }
    }
}

在上面的示例中，我们首先创建了一个 upgrader 对象，它用于将 HTTP 连接升级为 WebSocket 连接。然后，我们定义了一个 handleWebSocket 函数，用于处理 WebSocket 会话。在该函数中，我们首先将 HTTP 连接升级为 WebSocket 连接，然后进入一个无限循环，不断读取客户端发送的消息，并给客户端回复相同的消息。

最后，我们使用 http.HandleFunc 函数将 /ws 路径映射到 handleWebSocket 函数，然后调用 http.ListenAndServe 函数来启动 WebSocket 服务器。

创建 WebSocket 客户端

接下来，我们需要创建一个 WebSocket 客户端，用于向服务器发送 WebSocket 请求，并处理服务器推送的消息。以下是一个简单的 WebSocket 客户端示例：

package main

import (
    "log"
    "os"
    "os/signal"
    "time"

    "github.com/gorilla/websocket"
)

func main() {
    // 创建一个 dialer 对象，用于建立 WebSocket 连接
    dialer := websocket.Dialer{
        HandshakeTimeout: 10 \* time.Second,
    }

    // 建立 WebSocket 连接
    conn, \_, err := dialer.Dial("ws://localhost:8080/ws", nil)
    if err != nil {
        log.Fatal("Dial failed:", err)
    }
    defer conn.Close()

    // 启动一个 goroutine 来接收服务器推送的消息
    go func() {
        for {
            \_, message, err := conn.ReadMessage()
            if err != nil {
                log.Println("Read message failed:", err)
                break
            }

            log.Printf("Received message: %s", message)
        }
    }()

    // 向服务器发送消息
    message := []byte("Hello, WebSocket!")
    err = conn.WriteMessage(websocket.TextMessage, message)
    if err != nil {
        log.Println("Write message failed:", err)
        return
    }

    // 等待用户按下 Ctrl+C 终止程序
    interrupt := make(chan os.Signal, 1)
    signal.Notify(interrupt, os.Interrupt)
    <-interrupt
}

在上面的示例中，我们首先创建了一个 dialer 对象，它用于建立 WebSocket 连接。然后，我们使用 dialer.Dial 函数建立 WebSocket 连接，并指定服务器的地址为 ws://localhost:8080/ws。然后，我们使用 conn.WriteMessage 函数向服务器发送消息，并使用一个 goroutine 来接收服务器推送的消息。

最后，我们使用 signal.Notify 函数来注册一个信号监听器，当用户按下 Ctrl+C 时，程序会接收到一个中断信号，然后程序退出。

创建单独会话

在实际应用中，我们可能需要为每个客户端创建一个单独的会话，以便管理和跟踪客户端的状态。在 Golang 中，可以通过为每个 WebSocket 连接创建一个独立的 goroutine 来实现这一点。以下是一个示例：

package main

import (
    "log"
    "net/http"

    "github.com/gorilla/websocket"
)

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

func main() {
    http.HandleFunc("/ws", handleWebSocket)
    log.Fatal(http.ListenAndServe(":8080", nil))
}

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

    defer conn.Close()

    // 创建一个独立的会话
    session := NewSession()

    // 处理会话
    session.Handle(conn)
}

type Session struct {
    conn \*websocket.Conn
}

func NewSession() \*Session {
    return &Session{}
}

func (s \*Session) Handle(conn \*websocket.Conn) {
    s.conn = conn

    go s.readLoop()
    go s.writeLoop()
}

func (s \*Session) readLoop() {
    for {
        messageType, message, err := s.conn.ReadMessage()
        if err != nil {
            log.Println("Read message failed:", err)
            break
        }

        log.Printf("Received message: %s", message)
    }
}

func (s \*Session) writeLoop() {
    for {
        select {
        // 从消息队列中获取消息并发送给客户端
        case message := <-s.messageQueue:
            err := s.conn.WriteMessage(websocket.TextMessage, message)
            if err != nil {
                log.Println("Write message failed:", err)
            }
        }
    }
}

在上面的示例中，我们首先定义了一个 Session 结构体，它包含一个 WebSocket 连接。然后，我们创建了一个 NewSession 函数，用于创建一个新的会话对象。会话对象有两个重要的方法：Handle 方法用

场景

Golang的WebSocket可以用于创建单独的会话，适用于许多场景。以下是一个使用场景的介绍：

场景：在线聊天室

在一个在线聊天室中，用户可以通过WebSocket与其他用户进行实时的文字交流。每个用户都可以创建一个单独的会话，与其他用户进行私聊或在群组中发送消息。

使用场景描述：

1. 用户进入聊天室，并在前端页面上输入昵称和聊天内容。
2. 前端页面通过WebSocket与后端的Golang服务器建立连接。
3. 后端服务器使用Golang的WebSocket包处理客户端的连接请求。
4. 当用户发送消息时，前端页面将消息通过WebSocket发送至后端服务器。