Golang construit un websocket-Golang-php.cn

Golang construit un websocket

WBOY

Libérer： 2023-05-22 19:21:07

original

1763 Les gens l'ont consulté

Golang est un langage de programmation à compilation rapide, efficace et sûr qui est également largement utilisé dans le développement Web. Parmi eux, l'utilisation de Golang pour créer Websocket est un scénario d'application très populaire. Cet article explique comment utiliser Golang pour créer une application Websocket.

1. Qu'est-ce que Websocket

Websocket est un protocole qui permet l'établissement d'une connexion de communication bidirectionnelle entre le navigateur et le serveur. Le protocole HTTP traditionnel ne peut envoyer des requêtes au serveur que par le navigateur et recevoir des réponses du serveur. Cependant, l'utilisation de Websocket permet au serveur d'envoyer activement des messages au navigateur, réalisant ainsi une communication en duplex intégral entre le serveur et le navigateur.

2. Comment Golang implémente Websocket

Golang est livré avec une bibliothèque standard net/http. Ce package fournit une structure http.Server, qui peut être utilisée pour créer un site Web. serveur. De plus, net/http fournit également un sous-package websocket, qui nous fournit toutes les fonctions nécessaires pour construire un serveur WebSocket. net/http，这个包提供了一个http.Server结构体，它可以用来构建Web服务器。除此之外，net/http也提供了一个websocket子包，它为我们提供了构建WebSocket服务器所需的全部功能。

建立WebSocket连接

要建立WebSocket连接，客户端需要向服务器发送一个HTTP请求，并携带Upgrade头部，指示请求升级为WebSocket协议。服务器端在收到此请求后，需要检查Upgrade头部，并根据是否为WebSocket请求来进行相应的处理。

服务器端可以使用websocket.IsWebSocketUpgrade函数来检查请求是否为WebSocket请求，并使用websocket.Upgrade函数升级请求。升级成功后，服务器就可以通过*websocket.Conn类型的连接对象与客户端进行通信了。

func handler(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println(err)
        return
    }
    defer conn.Close()
    // 使用conn进行通信
}

Copier après la connexion

其中，upgrader是一个websocket.Upgrader类型的变量，通过设置它的属性可以控制WebSocket连接的处理方式。Upgrade函数在升级请求时会阻塞，因此要将其放在goroutine中运行。

发送和接收WebSocket消息

一旦WebSocket连接建立成功，客户端和服务器都可以通过*websocket.Conn对象进行通信。使用这个对象可以发送和接收WebSocket消息。

发送消息很简单，只需要调用WriteMessage方法即可：

err := conn.WriteMessage(websocket.TextMessage, []byte("hello"))

Copier après la connexion

接收消息的方法有三种：

ReadMessage：阻塞读取，直到有消息到来
NextReader：阻塞等待下一个消息到来
NextWriter：返回一个io.WriteCloser对象，可以使用这个对象发送消息

一般使用ReadMessage方法接收WebSocket消息：

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

Copier après la connexion

三、一个简单的WebSocket应用

在这个例子中，我们将创建一个简单的聊天室应用，客户端发送消息之后，服务器将消息广播给所有连接的客户端。

客户端代码：（使用JavaScript）

<!DOCTYPE html>
<html>
<head>
    <title>Chatroom</title>
</head>
<body>
    <input type="text" id="input-message"/>
    <button onclick="sendMessage()">发送</button>
    <ul id="message-list"></ul>

    <script>
        var ws = new WebSocket("ws://localhost:8080/ws");
        ws.onmessage = function(event) {
            var message = event.data;
            var li = document.createElement("li");
            li.appendChild(document.createTextNode(message));
            document.getElementById("message-list").appendChild(li);
        };

        function sendMessage() {
            var message = document.getElementById("input-message").value;
            ws.send(message);
        }
    </script>
</body>
</html>

Copier après la connexion

服务器端代码：

package main

import (
    "fmt"
    "log"
    "net/http"

    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{}

func main() {
    http.HandleFunc("/ws", wsHandler)
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal("ListenAndServe: ", err)
    }
}

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

    for {
        _, message, err := conn.ReadMessage()
        if err != nil {
            log.Println(err)
            break
        }
        fmt.Printf("recv: %s
", message)

        // 广播给所有客户端
        for _, conn := range conns {
            err := conn.WriteMessage(websocket.TextMessage, message)
            if err != nil {
                log.Println(err)
                break
            }
        }
    }
}

Copier après la connexion

在上面的代码中，我们将所有连接的websocket.Conn对象存储在conns变量中。每当有一个新消息到来时，服务器会将消息广播给所有客户端。

总结

使用Golang搭建WebSocket应用程序非常简单，只需要导入net/http和websocket

Établissement d'une connexion WebSocket

Pour établir une connexion WebSocket, le client doit envoyer une requête HTTP au serveur et porter l'en-tête Upgrade pour indiquer que la requête est mise à niveau vers le protocole WebSocket. Après avoir reçu cette requête, le serveur doit vérifier l'en-tête Upgrade et le traiter en conséquence selon qu'il s'agit d'une requête WebSocket. 🎜🎜Le serveur peut utiliser la fonction websocket.IsWebSocketUpgrade pour vérifier si la requête est une requête WebSocket, et utiliser la fonction websocket.Upgrade pour mettre à niveau la requête. Une fois la mise à niveau réussie, le serveur peut communiquer avec le client via un objet de connexion de type *websocket.Conn. 🎜rrreee🎜 Parmi eux, upgrader est une variable de type websocket.Upgrader En définissant ses propriétés, vous pouvez contrôler la méthode de traitement de la connexion WebSocket. La fonction Upgrade se bloquera lors de la mise à niveau de la requête, elle doit donc être exécutée dans une goroutine. 🎜

Envoyer et recevoir des messages WebSocket

🎜Une fois la connexion WebSocket établie avec succès, le client et le serveur peuvent transmettre

*websocket.Conn communiquent. Utilisez cet objet pour envoyer et recevoir des messages WebSocket. 🎜🎜Envoyer un message est très simple, il suffit d'appeler la méthode <code>WriteMessage

: 🎜rrreee🎜Il existe trois manières de recevoir des messages : 🎜

ReadMessage : blocage lecture Récupérer jusqu'à ce qu'un message arrive
NextReader : bloque l'attente de l'arrivée du prochain message
NextWriter : renvoie un io .WriteCloser, vous pouvez utiliser cet objet pour envoyer des messages

🎜Utilisez généralement la méthode ReadMessage pour recevoir des messages WebSocket : 🎜rrreee🎜 3. A application WebSocket simple🎜🎜 Dans cet exemple, nous allons créer une application de salle de discussion simple Une fois que le client a envoyé un message, le serveur diffuse le message à tous les clients connectés. 🎜🎜Code côté client : (en utilisant JavaScript) 🎜rrreee🎜Code côté serveur : 🎜rrreee🎜Dans le code ci-dessus, nous stockons tous les objets websocket.Conn connectés dans le code conns variable. Chaque fois qu'un nouveau message arrive, le serveur diffuse le message à tous les clients. 🎜🎜Résumé🎜🎜Il est très simple de créer une application WebSocket à l'aide de Golang. Il vous suffit d'importer les packages net/http et websocket, et d'utiliser directement l'API fournie. par la bibliothèque standard pour terminer le développement d'applications WebSocket. J'espère que cet article pourra être utile au développement de Golang Websocket. 🎜

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!