Comment utiliser WebSocket pour la communication multiplateforme dans Golang

WebSocket est une technologie utilisée pour la communication bidirectionnelle en temps réel entre un navigateur Web et un serveur. Il fournit un moyen fiable d’envoyer et de recevoir des données et est plus efficace et plus rapide que le mécanisme de requête-réponse HTTP traditionnel. Dans Golang, nous pouvons utiliser des bibliothèques tierces pour prendre en charge la communication WebSocket. Cet article explique comment utiliser la bibliothèque gorilla/websocket pour implémenter la communication WebSocket et fournit des exemples de code spécifiques.

1. Installer la bibliothèque gorilla/websocket

Utilisez la commande go get pour installer facilement la bibliothèque gorilla/websocket :

go get github.com/gorilla/websocket

2. Créer une connexion WebSocket

Côté serveur, utilisez la fonction Upgrader de la bibliothèque gorilla/websocket pour vous connecter HTTP Passez à la connexion WebSocket. Le code est le suivant :

import (
    "net/http"

    "github.com/gorilla/websocket"
)

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

func myHandler(w http.ResponseWriter, r *http.Request) {
    // 将HTTP连接升级为WebSocket连接
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        // 处理错误
        return
    }

    // 处理WebSocket连接
    for {
        // 读取消息
        messageType, p, err := conn.ReadMessage()
        if err != nil {
            // 处理错误
            return
        }

        // 处理消息
        err = conn.WriteMessage(messageType, p)
        if err != nil {
            // 处理错误
            return
        }
    }
}

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

Côté client, on peut utiliser du code JavaScript pour créer une connexion WebSocket. Le code est le suivant :

var ws = new WebSocket("ws://localhost:8080/");

ws.onopen = function() {
    console.log("WebSocket连接已打开");
};

ws.onmessage = function(evt) {
    console.log("接收到消息: " + evt.data);
};

ws.onclose = function() {
    console.log("WebSocket连接已关闭");
};

3. Envoi et réception de messages

Côté serveur, on peut utiliser la fonction WriteMessage pour envoyer des messages au client. Le code est le suivant :

err := conn.WriteMessage(websocket.TextMessage, []byte("Hello, client!"))
if err != nil {
    // 处理错误
    return
}

Côté client, on peut utiliser la fonction send pour envoyer des messages et la fonction onmessage pour recevoir des messages. Le code est le suivant :

ws.send("Hello, server!");

ws.onmessage = function(evt) {
    console.log("接收到消息: " + evt.data);
};

4. Gestion des requêtes WebSocket

Dans les applications réelles, nous pouvons avoir besoin d'effectuer une authentification et une autorisation lors du traitement des requêtes WebSocket. Dans ce cas, nous pouvons utiliser des en-têtes HTTP pour transmettre les informations d'authentification. Par exemple, vous pouvez ajouter des informations similaires aux suivantes dans l'en-tête HTTP :

Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

Ensuite, côté serveur, nous pouvons utiliser l'option CheckOrigin de la fonction Upgrader pour vérifier l'origine de la requête WebSocket, et utiliser les informations d'authentification dans l'en-tête HTTP pour traiter la requête. Le code spécifique est le suivant :

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
    CheckOrigin: func(r *http.Request) bool {
        // 检查请求的来源
        if r.Header.Get("Origin") != "http://localhost:8080" {
            return false
        }

        // 检查认证信息
        if r.Header.Get("Authorization") != "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c" {
            return false
        }

        return true
    },
}

func myHandler(w http.ResponseWriter, r *http.Request) {
    // 将HTTP连接升级为WebSocket连接
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        // 处理错误
        return
    }

    // 处理WebSocket连接
    for {
        // 读取消息
        messageType, p, err := conn.ReadMessage()
        if err != nil {
            // 处理错误
            return
        }

        // 处理消息
        err = conn.WriteMessage(messageType, p)
        if err != nil {
            // 处理错误
            return
        }
    }
}

5. Résumé

Cet article explique comment utiliser la bibliothèque gorilla/websocket dans Golang pour implémenter la communication WebSocket et fournit des exemples de code spécifiques. Grâce à la technologie WebSocket, nous pouvons créer des applications de communication bidirectionnelles efficaces en temps réel, telles que des salons de discussion en ligne et des jeux multijoueurs. Dans les applications pratiques, nous devons également prendre en compte des questions telles que la sécurité et la fiabilité, telles que l'authentification et l'autorisation, la gestion des exceptions, etc.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!