Comment utiliser WebSocket dans Go ?

Ces dernières années, la technologie WebSocket est devenue un élément indispensable du développement Web. WebSocket est un protocole de communication en duplex intégral sur une seule connexion TCP, qui rend la communication entre le client et le serveur plus fluide et plus efficace. Aujourd'hui, de nombreuses applications Web modernes utilisent la technologie WebSocket, comme le chat en temps réel, les jeux en ligne et la visualisation de données en temps réel.

En tant que langage de programmation moderne, le langage Go offre naturellement un bon support pour la technologie WebSocket. Dans cet article, nous examinerons en profondeur comment utiliser la technologie WebSocket dans Go.

Implémentation de WebSocket en langage Go

Le protocole WebSocket est un protocole mis à niveau à partir de HTTP, donc l'utilisation de WebSocket en langage Go nécessite également de le combiner avec le protocole HTTP. Le langage Go possède un package net/http intégré, qui fournit diverses fonctions liées à HTTP. Si nous voulons utiliser WebSocket dans Go, importez simplement les bibliothèques net/http et github.com/gorilla/websocket. net/http包，该包提供了各种HTTP相关的功能。如果我们想要在Go中使用WebSocket，只需导入net/http和github.com/gorilla/websocket库即可。

下面，我们就来看一下如何使用github.com/gorilla/websocket库来实现WebSocket。

创建WebSocket服务端

在Go语言中，创建WebSocket服务端的方式也比较简单。我们直接看下列代码，它展示了如何创建一个HTTP服务器，等待客户端的WebSocket连接：

package main

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

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

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

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

    for {
        messageType, message, err := conn.ReadMessage()
        if err != nil {
            log.Println(err)
            return
        }
        log.Printf("Received message: %s
", message)

        err = conn.WriteMessage(messageType, message)
        if err != nil {
            log.Println(err)
            return
        }
        log.Printf("Sent message: %s
", message)
    }
}

在上面的代码中，我们首先创建了一个websocket.Upgrader对象，它负责将传入的HTTP连接升级为WebSocket连接。然后，我们创建了一个handleWebSocket函数，它会在客户端进行连接时被调用。该函数会先将传入的HTTP连接升级为WebSocket连接，然后进入循环，不断地接收来自客户端的信息，并将接收到的信息回传给客户端。其中，conn.ReadMessage()和conn.WriteMessage()分别用于读取和写入信息。

最后，我们将该handleWebSocket函数绑定到/ws路由上，并启动了HTTP服务器，以便客户端可以连接到该WebSocket服务器。如果一切正常，当我们启动上述代码后，您会看到类似如下输出：

2021/10/13 15:20:06 http: Server started at http://127.0.0.1:8080

这意味着您已经成功地创建了一个WebSocket服务器，客户端可以通过ws://localhost:8080/ws地址来连接该服务器。

创建WebSocket客户端

与创建WebSocket服务端类似，我们也可以很容易地在Go语言中创建一个WebSocket客户端。我们来看下面的代码，它描述了如何创建一个与WebSocket服务器建立连接的客户端：

package main

import (
    "fmt"
    "log"
    "net/url"
    "os"
    "os/signal"
    "syscall"
    "github.com/gorilla/websocket"
)

func main() {
    interrupt := make(chan os.Signal, 1)
    signal.Notify(interrupt, os.Interrupt, syscall.SIGTERM)

    u := url.URL{Scheme: "ws", Host: "localhost:8080", Path: "/ws"}
    log.Printf("Connecting to %s", u.String())

    conn, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
    if err != nil {
        log.Fatal("dial:", err)
    }
    defer conn.Close()

    done := make(chan struct{})
    go func() {
        defer close(done)
        for {
            messageType, message, err := conn.ReadMessage()
            if err != nil {
                log.Println("read:", err)
                return
            }
            log.Printf("Received message: %s
", message)
            if err := conn.WriteMessage(messageType, message); err != nil {
                log.Println("write:", err)
                return
            }
            log.Printf("Sent message: %s
", message)
        }
    }()

    for {
        select {
        case <-done:
            return
        case <-interrupt:
            log.Println("interrupt")

            if err := conn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, "")); err != nil {
                log.Println("write close:", err)
                return
            }
            select {
            case <-done:
            case <-time.After(time.Second):
            }
            return
        }
    }
}

在上面的代码中，我们使用websocket.Dial方法来与WebSocket服务器建立连接。建立连接后，我们再进入一个无限循环，不断地发送和接收来自WebSocket服务器的信息。其中，conn.ReadMessage()和conn.WriteMessage()用于读取和写入信息。

值得注意的是，在上述代码中，我们使用了channels来等待操作完成。如果接收到interrupt信号，我们将使用websocket.CloseMessage消息发送给服务器，以关闭WebSocket连接。

结论

在本文中，我们学习了如何在Go语言中使用github.com/gorilla/websocket

Voyons maintenant comment utiliser la bibliothèque github.com/gorilla/websocket pour implémenter WebSocket.

Créer un serveur WebSocket🎜🎜En langage Go, la manière de créer un serveur WebSocket est relativement simple. Regardons directement le code suivant, qui montre comment créer un serveur HTTP et attendre la connexion WebSocket du client : 🎜rrreee🎜Dans le code ci-dessus, nous créons d'abord un objet websocket.Upgrader, qui est responsables de la conversion des connexions HTTP entrantes sont mises à niveau vers des connexions WebSocket. Ensuite, nous avons créé une fonction handleWebSocket qui sera appelée lorsque le client se connectera. Cette fonction mettra d'abord à niveau la connexion HTTP entrante vers une connexion WebSocket, puis entrera dans une boucle, recevra en continu les informations du client et transmettra les informations reçues au client. Parmi eux, conn.ReadMessage() et conn.WriteMessage() sont utilisés respectivement pour lire et écrire des informations. 🎜🎜Enfin, nous avons lié la fonction handleWebSocket à la route /ws et démarré le serveur HTTP afin que le client puisse se connecter au serveur WebSocket. Si tout se passe bien, lorsque nous démarrons le code ci-dessus, vous verrez un résultat similaire à celui-ci : 🎜rrreee🎜 Cela signifie que vous avez créé avec succès un serveur WebSocket et que le client peut y accéder via ws://localhost : 8080/ wsAdresse pour se connecter au serveur. 🎜🎜Création d'un client WebSocket🎜🎜Semblable à la création d'un serveur WebSocket, nous pouvons également facilement créer un client WebSocket dans le langage Go. Regardons le code suivant, qui décrit comment créer un client qui établit une connexion avec le serveur WebSocket : 🎜rrreee🎜 Dans le code ci-dessus, nous utilisons la méthode websocket.Dial pour établir une connexion avec le serveur WebSocket. Une fois la connexion établie, nous entrons dans une boucle infinie, envoyant et recevant constamment des informations du serveur WebSocket. Parmi eux, conn.ReadMessage() et conn.WriteMessage() sont utilisés pour lire et écrire des informations. 🎜🎜Il convient de noter que dans le code ci-dessus, nous utilisons des canaux pour attendre la fin de l'opération. Si le signal interrupt est reçu, nous utiliserons le message websocket.CloseMessage à envoyer au serveur pour fermer la connexion WebSocket. 🎜🎜Conclusion🎜🎜Dans cet article, nous avons appris comment implémenter WebSocket en langage Go à l'aide de la bibliothèque github.com/gorilla/websocket. L'utilisation de la technologie WebSocket peut ajouter plus de dynamique et d'interactions à nos applications Web, rendant l'application plus moderne et conviviale. 🎜🎜Si vous avez des questions ou des commentaires sur la technologie WebSocket et sur la manière de l'utiliser en langage Go, n'hésitez pas à laisser un message ci-dessous pour partager vos réflexions avec nous. 🎜

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!