Comment démarrer et fermer la connexion Websocket dans Golang

Websocket est un protocole réseau capable d'établir une communication bidirectionnelle en temps réel entre le client et le serveur. Il peut obtenir simultanément une transmission de données efficace et des effets d'interaction à faible latence sans utiliser d'interrogation HTTP. Golang est un langage de programmation open source hautes performances avec d'excellentes performances de concurrence et une excellente qualité de code. Dans la communication Websocket, Golang dispose également d'excellentes méthodes d'implémentation. Cet article explique comment démarrer et fermer les connexions Websocket dans Golang.

Implémentation de Websocket dans Golang

Pour implémenter Websocket dans Golang, vous devez effectuer les étapes suivantes :

1. Importer le package correspondant

En langage Go, l'implémentation de Websocket nécessite la prise en charge des packages WebSocket et Http. Le code est le suivant :

import (
    "net/http"
    
    "github.com/gorilla/websocket"
)

Parmi eux, github.com/gorilla/websocket est un excellent package WebSocket qui prend en charge plusieurs protocoles. Il contient certaines structures et fonctions liées à WebSocket, que nous pouvons utiliser pour implémenter rapidement une connexion WebSocket.

2. Définir la fonction de traitement des connexions WebSocket

Dans la fonction qui gère les connexions WebSocket, nous devons effectuer les tâches suivantes :

a Définir la mise à niveau de WebSocket

Pour une requête HTTP, si nous devons passer à une connexion WebSocket. , nous devons le traiter et renvoyer la demande de mise à niveau correspondante. Le code est le suivant :

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
    CheckOrigin: func(r *http.Request) bool {
        return true
    },
}

func websocketHandler(w http.ResponseWriter, r *http.Request) {
    // 升级为WebSocket连接
    ws, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println(err)
        return
    }
    
    // 实现WebSocket通信
    ...
}

Dans ce code, nous utilisons la structure Upgrader, qui est la fonction de la bibliothèque gorilla/websocket pour implémenter la mise à niveau de WebSocket.

Upgrader inclut la taille du tampon de lecture et d'écriture et la fonction CheckOrigin. CheckOrigin est utilisé pour vérifier si la demande provient d'une source légitime. Si cette méthode renvoie faux, la demande de mise à niveau sera rejetée. Puisque nous n'avons pas besoin de vérifier la validité dans cet exemple, notre CheckOrigin renvoie toujours vrai.

Après avoir appelé la méthode Upgrader.Upgrade, nous obtiendrons un objet WebSocket ws. Sur cet objet, nous pouvons appeler des méthodes telles que ReadMessage et WriteMessage pour terminer la communication WebSocket ultérieure.

b. Lire les messages WebSocket

Après avoir obtenu la connexion WebSocket, nous devons lire en continu les messages envoyés par le client. Pour lire les messages WebSocket, vous pouvez utiliser la méthode ReadMessage. Le code est le suivant :

func websocketHandler(w http.ResponseWriter, r *http.Request) {
    ...
    
    for {
        // 读取消息
        _, message, err := ws.ReadMessage()
        if err != nil {
            log.Println(err)
            break
        }
        
        // 处理消息
        ...
    }
}

Dans ce code, nous utilisons une boucle for pour lire en continu les messages de WebSocket. Si la lecture échoue, la connexion WebSocket a été fermée et nous sortons de la boucle.

c. Envoyer un message WebSocket

Après avoir traité le message envoyé par le client, nous devrons peut-être envoyer certains résultats du traitement au client. Pour envoyer des messages WebSocket, vous pouvez utiliser la méthode WriteMessage. Le code est le suivant :

func websocketHandler(w http.ResponseWriter, r *http.Request) {
    ...
    
    for {
        ...
        
        // 发送消息
        err = ws.WriteMessage(websocket.TextMessage, []byte(reply))
        if err != nil {
            log.Println(err)
            break
        }
    }
}

Dans ce code, nous envoyons un message au client via la méthode WriteMessage. Le premier paramètre de cette méthode est le type de message, que nous pouvons spécifier comme TextMessage ou BinaryMessage ; le deuxième paramètre est un tableau d'octets qui contient les données à envoyer.

3. Démarrer le service WebSocket

Après avoir terminé les étapes ci-dessus, nous pouvons démarrer un service WebSocket. Le code est le suivant :

func main() {
    http.HandleFunc("/ws", websocketHandler)
    log.Println("Server started at http://127.0.0.1:8080")
    http.ListenAndServe(":8080", nil)
}

Dans ce code, nous appelons la fonction http.HandleFunc pour mapper le chemin "/ws" à notre fonction de traitement WebSocket websocketHandler. Enfin, nous appelons http.ListenAndServe pour démarrer le service.

Fermer la connexion WebSocket

Après avoir utilisé WebSocket, nous devons fermer la connexion manuellement. Pour fermer la connexion WebSocket normalement, vous devez faire attention aux points suivants :

a. Le côté serveur se ferme activement

Lorsque le côté serveur doit fermer la connexion WebSocket, il peut appeler la méthode WebSocket.Close. Le code est le suivant :

func websocketHandler(w http.ResponseWriter, r *http.Request) {
    defer ws.Close() // 关闭WebSocket连接
    
    for {
        ...
    }
}

Dans ce code, nous utilisons l'instruction defer pour fermer automatiquement la connexion WebSocket à la fin de la fonction websocket.

b. Le client se ferme activement

Lorsque le client doit fermer la connexion WebSocket, il peut envoyer un message de fermeture au serveur. Le serveur recevra le message Close et fermera activement la connexion WebSocket après avoir reçu le message.

Nous pouvons ajouter une branche pour gérer le message Close dans la fonction websocket côté serveur. Le code est le suivant :

func websocketHandler(w http.ResponseWriter, r *http.Request) {
    ...
    
    for {
        // 读取消息
        messageType, message, err := ws.ReadMessage()
        if err != nil {
            log.Println(err)
            break
        }
        
        // 处理消息
        switch messageType {
        case websocket.CloseMessage:
            // 收到关闭消息，关闭连接
            return
        case websocket.TextMessage:
            // 收到文本消息，处理消息
            ...
        case websocket.BinaryMessage:
            ...
        }
    }
    
    // 关闭WebSocket连接
    ws.Close()
}

Dans ce code, nous ajoutons une branche de traitement avec le type de message CloseMessage. Après avoir reçu le message Close, nous quittons immédiatement la fonction websocket et fermons la connexion WebSocket.

c. Fermeture anormale

Lorsqu'une anomalie se produit dans la connexion WebSocket, la connexion doit être fermée à temps. Par exemple, lorsque le réseau est déconnecté, la connexion entre le client et le serveur expire, etc., la connexion WebSocket doit être fermée.

Nous pouvons intercepter l'exception dans la fonction websocket et fermer la connexion WebSocket lorsque l'exception est interceptée. Le code est le suivant :

func websocketHandler(w http.ResponseWriter, r *http.Request) {
    defer ws.Close() // 当函数退出时关掉WebSocket连接
    
    for {
        _, message, err := ws.ReadMessage()
        if err != nil {
            if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway) {
                log.Printf("error: %v", err)
            }
            break
        }
        
        // 处理消息
        ...
    }
}

Dans ce code, nous fermons manuellement la connexion WebSocket via l'instruction defer avant le retour de la fonction websocket. Dans l'opération ReadMessage, nous avons ajouté la possibilité de capturer les erreurs d'exception et d'effectuer une sortie de journal.

Résumé

Dans Golang, la connexion Websocket peut être réalisée via la bibliothèque gorilla/websocket. Nous pouvons utiliser la structure Upgrader dans la fonction de traitement de la communication WebSocket pour mettre à niveau le protocole HTTP vers WebSocket. Lors de la connexion à WebSocket, nous devons implémenter certaines opérations de lecture et d'envoi de messages WebSocket.

Afin d'assurer la fermeture normale de la connexion WebSocket, nous devons faire attention aux points suivants :

1. Le serveur doit fermer manuellement la connexion WebSocket après avoir terminé l'opération ;
2. Lorsque le client reçoit le message Close, le serveur doit immédiatement fermer la connexion WebSocket ;
3. Lorsqu'une exception se produit dans la connexion WebSocket, la connexion doit être fermé rapidement après avoir détecté l'exception.

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!