Comment utiliser Websocket dans Golang pour transférer des données

Ces dernières années, avec le développement rapide de la technologie Internet, la technologie Websocket a attiré une attention et une attention croissantes. Websocket est un protocole de communication full-duplex basé sur le protocole TCP, qui permet une communication bidirectionnelle entre les applications Web et les serveurs. Grâce à la technologie Websocket, des connexions critiques en temps réel peuvent être établies tout en réduisant les retards du réseau et en améliorant l'efficacité de la transmission des données. Cet article explique comment utiliser la technologie Websocket pour transférer des données dans Golang.

1. Principe de fonctionnement de Websocket

Le processus de communication Websocket comporte quatre étapes :

1. Établir une connexion : le client envoie une requête HTTP au serveur et met à niveau le protocole Websocket.

2. Handshake : Le serveur confirme la demande et établit une connexion Websocket.

3. Communication : Comme nous le savons tous, HTTP est un protocole sans état. Une fois qu'une connexion HTTP est établie entre le client et le serveur, ils se déconnecteront immédiatement. Ainsi selon ce protocole, lorsque le client et le serveur communiquent, ils doivent envoyer des messages de requête et de réponse. Cependant, dans le protocole Websocket, une fois que le client établit une connexion avec le serveur, il peut maintenir une connexion à long terme sans envoyer plusieurs fois des messages de requête et de réponse HTTP.

4. Fermer : Le client ou le serveur déconnecte la connexion Websocket.

On peut voir que Websocket est différent du protocole HTTP. Le protocole HTTP ne prend en charge que la transmission des messages de requête et de réponse, tandis que le protocole Websocket prend en charge la communication bidirectionnelle en temps réel.

2. Utilisation de la technologie Websocket dans Golang

Dans Golang, vous pouvez utiliser la bibliothèque tierce golang.org/x/net/websocket pour implémenter la communication Websocket. golang.org/x/net/websocket est une bibliothèque standard de golang qui peut facilement implémenter le protocole de communication Websocket.

1. Installation

Dans Golang, l'installation de golang.org/x/net/websocket est très simple. Entrez simplement la commande suivante dans la ligne de commande :

go get golang.org/x/net/websocket

Une fois l'installation terminée, nous pouvons utiliser le package Provides API. pour implémenter les fonctions de communication Websocket.

2. Serveur Websocket

Ce qui suit est un exemple du code du serveur Websocket en golang :

package main

import (
    "golang.org/x/net/websocket"
    "log"
    "net/http"
)

func echoHandler(ws *websocket.Conn) {
    if err := websocket.Message.Send(ws, "Hello, Client!"); err != nil {
        log.Fatal(err)
    }
}

func main() {
    http.Handle("/", websocket.Handler(echoHandler))
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal(err)
    }
}

Dans l'exemple ci-dessus, nous avons défini une fonction nommée echoHandler, qui gère la connexion websocket et l'envoie au client. "Bonjour, Client !". Enfin, nous utilisons la fonction ListenAndServe du package http pour démarrer le serveur Websocket.

3. Client Websocket

Ce qui suit est un exemple de code client de Websocket en golang :

package main

import (
    "fmt"
    "golang.org/x/net/websocket"
    "log"
)

func main() {
    origin := "http://localhost"
    url := "ws://localhost:8080/"
    ws, err := websocket.Dial(url, "", origin)
    if err != nil {
        log.Fatal(err)
    }
    var msg = make([]byte, 512)
    var n int
    if n, err = ws.Read(msg); err != nil {
        log.Fatal(err)
    }
    fmt.Printf("Received: %s.\n", msg[:n])
}

Dans cet exemple, nous utilisons la fonction WebSocket.Dial pour établir une connexion avec le serveur Websocket, puis lisons depuis le serveur via la méthode Read de WebSocket Le message renvoyé.

3. Implémenter le transfert de données Websocket

Lorsque plusieurs clients établissent des connexions avec le serveur Websocket, le serveur doit disposer d'une certaine fonction de transfert de données pour répondre aux besoins de communication en temps réel entre les clients. Voici une méthode pour implémenter le transfert de données Websocket, à l'aide du package golang.org/x/net/websocket :

package main

import (
    "golang.org/x/net/websocket"
    "log"
    "net/http"
)

// 保存所有的客户端连接
var clients []*websocket.Conn

func broadcast() {
    for {
        var data []byte
        // 从所有客户端接收数据
        for i := range clients {
            if err := websocket.Message.Receive(clients[i], &data); err != nil {
                // 如果有任何错误，则断开客户端连接
                clients[i].Close()
                log.Printf("Client %v disconnected\n", clients[i].RemoteAddr())
                // 将已关闭客户端从clients中删除
                clients = append(clients[:i], clients[i+1:]...)
                continue
            }
            // 向其他所有客户端广播数据
            for j := range clients {
                if err := websocket.Message.Send(clients[j], data); err != nil {
                    log.Printf("Unable to send message to %v: %v\n", clients[j].RemoteAddr(), err)
                }
            }
        }
    }
}

func main() {
    // 启动一个广播协程
    go broadcast()
    http.Handle("/", websocket.Handler(func(ws *websocket.Conn) {
        // 保存每个新连接
        clients = append(clients, ws)
        log.Printf("Client %v connected\n", ws.RemoteAddr())
    }))
    
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal(err)
    }
}

Dans cet exemple, nous utilisons une goroutine nommée Broadcast pour gérer la fonction de transfert de données. Lorsqu'un client se connecte, transférez-le à d'autres clients. Dans le même temps, lorsqu'un client se déconnecte, la coroutine de diffusion le supprimera des clients.

Pour résumer, golang est un excellent langage d'implémentation de Websocket, et vous pouvez facilement implémenter le protocole de communication Websocket à l'aide du package golang.org/x/net/websocket. Lorsque vous utilisez Websocket pour établir une connexion de communication en temps réel, une communication instantanée entre les clients peut être obtenue en implémentant la fonction de transfert de données.

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!