websocket.Upgrader

`websocket.Upgrader` 是 Go 语言中的一个结构体，用于升级 HTTP 连接为 WebSocket 连接。它提供了一些配置选项，以及一些方法来处理 WebSocket 连接的升级和关闭。

`websocket.Upgrader` 结构体的定义如下：

type Upgrader struct {
    HandshakeTimeout time.Duration
    ReadBufferSize  int
    WriteBufferSize int
    Error           func(w http.ResponseWriter, r *http.Request, status int, reason error)
    CheckOrigin     func(r *http.Request) bool
    EnableCompression bool
}

其中一些重要的字段和方法包括：

- `HandshakeTimeout`: 设置握手超时时间。
- `ReadBufferSize` 和 `WriteBufferSize`: 设置读写缓冲区的大小。
- `Error`: 自定义处理升级错误的方法。
- `CheckOrigin`: 自定义检查请求来源的方法。
- `EnableCompression`: 是否启用压缩。

使用 `websocket.Upgrader` 可以将普通的 HTTP 连接升级为 WebSocket 连接，使得服务器可以与客户端进行双向通信。

相关问题

func GetOrderAssignmentApi(ctx *gin.Context) { upGrader := websocket.Upgrader{ CheckOrigin: func(r *http.Request) bool { return true }, } ws, err := upGrader.Upgrade(ctx.Writer, ctx.Request, nil) if err != nil { ws.WriteMessage(websocket.TextMessage, []byte(msg.LinkISDisconnect)) ws.Close() return } defer ws.Close() workUserName, _ := ctx.Get("username") orm := database.GetSystemDb() var workuser models.WorkUser orm.Where("account=?", workUserName).First(&workuser) // 绑定到当前节点 node := &Node{ Conn: ws, DataQueue: make(chan []byte, 50), } // 映射关系的绑定 rwLocker.Lock() clientMap[workuser.Id] = node rwLocker.Unlock() for { go senProc(node) } }设置心跳包

在上面的代码中，我们使用了 `github.com/gorilla/websocket` 库来建立 WebSocket 连接，并实现了一个简单的心跳包检测机制。以下是示例代码：

func GetOrderAssignmentApi(ctx *gin.Context) {
    upGrader := websocket.Upgrader{
        CheckOrigin: func(r *http.Request) bool {
            return true
        },
    }
    ws, err := upGrader.Upgrade(ctx.Writer, ctx.Request, nil)
    if err != nil {
        ws.WriteMessage(websocket.TextMessage, []byte(msg.LinkISDisconnect))
        ws.Close()
        return
    }
    defer ws.Close()

    workUserName, _ := ctx.Get("username")
    orm := database.GetSystemDb()
    var workuser models.WorkUser
    orm.Where("account=?", workUserName).First(&workuser)

    // 绑定到当前节点
    node := &Node{
        Conn:      ws,
        DataQueue: make(chan []byte, 50),
    }

    // 映射关系的绑定
    rwLocker.Lock()
    clientMap[workuser.Id] = node
    rwLocker.Unlock()

    // 启动心跳包检测
    go heartbeat(node)

    for {
        go senProc(node)
    }
}

func heartbeat(node *Node) {
    // 发送心跳包的间隔时间
    interval := 5 * time.Second
    // 超时时间
    timeout := 10 * time.Second
    // 心跳包数据
    heartbeatMsg := []byte("heartbeat")

    for {
        // 发送心跳包
        err := node.Conn.WriteMessage(websocket.TextMessage, heartbeatMsg)
        if err != nil {
            fmt.Println("Failed to send heartbeat:", err)
            node.Close()
            return
        }

        // 设置读取超时时间
        node.Conn.SetReadDeadline(time.Now().Add(timeout))

        // 接收响应
        _, _, err = node.Conn.ReadMessage()
        if err != nil {
            fmt.Println("Failed to receive heartbeat response:", err)
            node.Close()
            return
        }

        // 等待下一次发送心跳包
        time.Sleep(interval)
    }
}

在上面的代码中，我们在 `GetOrderAssignmentApi` 函数中建立了 WebSocket 连接，并将连接绑定到一个节点上。然后，在绑定完成后，我们启动了一个 goroutine 来执行 `heartbeat` 函数，实现心跳包检测。在 `heartbeat` 函数中，我们定时发送心跳包并等待响应，如果在超时时间内没有收到响应，则关闭连接。注意，在 `GetOrderAssignmentApi` 函数中，我们还是需要在一个无限循环中不断调用 `senProc` 函数，以便监听节点上的消息队列并发送数据。

websocket.Conn

websocket.Conn是一个在Go语言中用于处理WebSocket连接的结构体。它是由gorilla/websocket包提供的。

WebSocket是一种在单个TCP连接上进行全双工通信的协议。它允许服务器主动向客户端推送数据，而不需要客户端发起请求。websocket.Conn结构体提供了一组方法，用于在Go语言中处理WebSocket连接。

以下是websocket.Conn结构体的一些常用方法：
- ReadMessage()：从连接中读取消息。
- WriteMessage()：向连接中写入消息。
- Close()：关闭连接。

使用websocket.Conn可以实现各种WebSocket应用，例如聊天室、实时通知等。

下面是一个使用websocket.Conn的简单示例代码：

package main

import (
	"log"
	"net/http"

	"github.com/gorilla/websocket"
)

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

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

	for {
		// 读取消息
		_, message, err := conn.ReadMessage()
		if err != nil {
			log.Println(err)
			break
		}

		// 打印消息
		log.Printf("Received message: %s", message)

		// 发送消息
		err = conn.WriteMessage(websocket.TextMessage, message)
		if err != nil {
			log.Println(err)
			break
		}
	}
}

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

这个示例代码创建了一个简单的WebSocket服务器，它会将客户端发送的消息原样返回给客户端。当有新的消息到达时，服务器会打印消息内容，并将消息发送回客户端。