How does Go WebSocket extend and customize message formats?

Yes, you can use MessageHandler or Subprotocols to customize the Go WebSocket message format. MessageHandler allows you to directly define message processing logic, while Subprotocols provide a way to negotiate subprotocols before establishing a connection. The specific steps are as follows: Use MessageHandler to customize the message format: Create a new WebSocketConn and pass it to the upgrader.WebSocket defines OnMessage and OnOpen methods on the MessageHandler interface to customize message processing and connection establishment processing logic. Use Subprotocols to negotiate subprotocols: add Subprotocols Parameters passed to the upgrader access the determined protocol through the Subprotocol() method of WebSocketConn. Through these methods, you can easily extend and customize the message format of Go WebSocket according to your specific needs.

Go WebSocket message format customization

WebSocket is a protocol that allows a full set of Duplex communication channel. Although WebSocket messages are typically transmitted using JSON format, sometimes you may need to customize the message format. Go provides several ways to achieve this.

Using MessageHandler

The MessageHandler interface defines two methods:

type MessageHandler interface {
    // OnMessage 实现 ReadMessage 方法。
    OnMessage(message []byte)
    // OnOpen 实现对 WebSocket 连接建立的处理。
    OnOpen()
}

To use MessageHandler, you can create a new WebSocketConn and pass it to upgrader.WebSocket:

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

ws, err := upgrader.Upgrade(w, r, wsConfig, wsHandler{})

wsHandler should implement the MessageHandler interface defined above.

// wsHandler 定义新的消息处理程序。
type wsHandler struct{}

// OnMessage 处理新消息。
func (wsHandler) OnMessage(message []byte) {
    // 自定义消息处理逻辑
}

// OnOpen 处理连接建立。
func (wsHandler) OnOpen() {
    // 可选的连接建立处理逻辑
}

Using Subprotocols

WebSocket allows both parties to negotiate subprotocols before establishing a connection. To use a subprotocol, you can pass the Subprotocols parameter to the upgrader:

upgrader := websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
    Subprotocols:    []string{"your-protocol"},
}

The determined protocol can then be accessed through the Subprotocol() method of WebSocketConn:

ws, _ := upgrader.Upgrade(w, r, wsConfig, wsHandler{})
protocol := ws.Subprotocol()

Practical Case

Suppose we want to customize the message format for a chat application. The message will contain the fields:

• #type: Message type (e.g., text, image).
• sender: Sender.
• content: Message content.

We can create the following custom message type:

type Message struct {
    Type     string `json:"type"`
    Sender   string `json:"sender"`
    Content  string `json:"content"`
}

We can then update wsHandler to handle the custom message:

func (wsHandler) OnMessage(message []byte) {
    var msg Message
    if err := json.Unmarshal(message, &msg); err != nil {
        log.Println(err)
        return
    }

    switch msg.Type {
    case "text":
        // 处理文本消息
    case "image":
        // 处理图片消息
    default:
        log.Printf("未知消息类型：%s", msg.Type)
    }
}

By following these instructions, you can easily extend and customize Go WebSocket's message format to meet your specific needs.

The above is the detailed content of How does Go WebSocket extend and customize message formats?. For more information, please follow other related articles on the PHP Chinese website!