Comment implémenter Websocket dans Golang

À une époque où les frontaux modernes accordent de plus en plus d'attention au temps réel et à l'interactivité, un protocole de communication réseau est devenu plus populaire, il s'agit de WebSocket. Lors de leur utilisation, WebSocket et HTTP présentent certaines similitudes, mais contrairement aux requêtes HTTP traditionnelles, WebSocket peut maintenir les connexions pendant une longue période. Si vous envisagez d'utiliser WebSocket pour créer une application Web, vous devrez peut-être utiliser un langage de programmation pour l'implémenter. Parmi eux, Golang est l'un des langages de programmation les plus populaires. Apprenons à implémenter WebSocket dans Golang.

1. Qu'est-ce que WebSocket ?

WebSocket est un protocole réseau qui permet une communication bidirectionnelle via une seule connexion TCP. Dans le protocole HTTP traditionnel, la requête est envoyée du navigateur au serveur et le serveur renvoie le résultat au navigateur après traitement. Ce processus est un processus unique. Une fois le traitement de la requête terminé, la connexion sera fermée. . Le protocole WebSocket est différent Lorsque le navigateur établit une connexion avec le serveur, la connexion sera maintenue jusqu'à ce que l'utilisateur ou le serveur décide de fermer la connexion. Cela signifie que tant que la connexion est maintenue, le serveur peut envoyer des informations au client à tout moment sans attendre que le navigateur fasse une demande.

2. Golang implémente WebSocket

Golang est un langage de programmation qui prend en charge la programmation simultanée. Il a été développé à l'origine par Google. Son avantage réside dans son efficacité opérationnelle et sa consommation de mémoire extrêmement faible. Ci-dessous, nous présenterons comment implémenter WebSocket à l'aide de Golang.

1. Installez la bibliothèque Gorilla WebSocket
   Gorilla WebSocket est une bibliothèque WebSocket populaire qui fournit une API simple et facile à utiliser pour créer et gérer des connexions WebSocket. Avant d'installer la bibliothèque Gorilla WebSocket, vous devez d'abord installer l'environnement Go. Une fois l'installation de Go terminée, utilisez la commande suivante pour installer la bibliothèque Gorilla WebSocket :

   go get github.com/gorilla/websocket

   Copier après la connexion
2. Écrire du code

Ci-dessous, nous utiliserons Go et le Bibliothèque Gorilla WebSocket pour implémenter une salle de discussion simple. Dans nos salons de discussion, les utilisateurs peuvent envoyer des messages et consulter les messages d'autres utilisateurs. Voici le code pour implémenter le salon de discussion WebSocket :

package main

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

var clients = make(map[*websocket.Conn]bool)
var broadcast = make(chan Message)
var upgrader = websocket.Upgrader{}

// Message struct
type Message struct {
    Username string `json:"username"`
    Body     string `json:"body"`
}

func main() {
    // Configure websocket route
    http.HandleFunc("/ws", handleConnections)

    // Start listening for incoming chat messages
    go handleMessages()

    // Start the server on localhost port 8080 and log any errors
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal("ListenAndServe: ", err)
    }
}

func handleConnections(w http.ResponseWriter, r *http.Request) {
    // Upgrade initial GET request to a websocket
    ws, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Fatal(err)
    }
    // Make sure we close the connection when the function returns
    defer ws.Close()

    // Register our new client
    clients[ws] = true

    for {
        var msg Message
        // Read in a new message as JSON and map it to a Message object
        err := ws.ReadJSON(&msg)
        if err != nil {
            log.Printf("error: %v", err)
            delete(clients, ws)
            break
        }
        // Send the newly received message to the broadcast channel
        broadcast <- msg
    }
}

func handleMessages() {
    for {
        // Grab the next message from the broadcast channel
        msg := <-broadcast
        // Send it out to every client that is currently connected
        for client := range clients {
            err := client.WriteJSON(msg)
            if err != nil {
                log.Printf("error: %v", err)
                client.Close()
                delete(clients, client)
            }
        }
    }
}

L'idée principale du code est de créer une connexion WebSocket et de l'ajouter à la liste des clients, et tous les messages seront écrits au canal diffusion et envoyé à tous les clients d'une autre goroutine. Chaque connexion reçoit des messages en lisant et en allouant des objets Message. L'exemple de code permettant au client d'envoyer un message est le suivant : clients 列表中，任何消息都会被写入到 broadcast 通道中，并在另一个 goroutine 中发送到所有客户端。每个连接通过读取和分配 Message 对象来接收消息。客户端发送消息的示例代码如下：

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

socket.addEventListener("open", function() {
  socket.send(JSON.stringify({
    "username": "John",
    "body": "Hello World!"
  }));
});

socket.addEventListener("message", function(event) {
  console.log("Received: " + event.data);
});

在这个示例中，我们首先创建一个 WebSocket 对象并将其连接到服务器。在连接成功后，我们发送一个 JSON 作为消息体。服务端发送消息给客户端时，我们需要在客户端的 JavaScript 代码中监听 messagerrreee

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!