Création d'un serveur WebSocket dans Go avec Gorilla

Créer un serveur Go WebSocket en temps réel avec Gorilla

Les WebSockets offrent une solution robuste pour la communication bidirectionnelle en temps réel entre les clients et les serveurs. Ce didacticiel vous guide dans la création d'un serveur WebSocket dans Go, en tirant parti de la populaire bibliothèque Gorilla WebSocket.

---

Table des matières

1. Comprendre WebSockets et Gorilla
2. Configuration du projet
3. Structure des répertoires
4. Installation de Gorilla WebSocket
5. Construction du serveur WebSocket
6. Traitement des messages
7. Exécuter l'application
8. Conclusion
9. Référentiel GitHub (espace réservé au lien)

---

Comprendre WebSockets et Gorilla

Les WebSockets fournissent des canaux de communication persistants et en duplex intégral, contrairement au modèle requête-réponse de HTTP. Cette connexion constante permet un échange de données efficace et continu.

La bibliothèque Gorilla WebSocket simplifie l'implémentation de WebSocket dans Go, en gérant la prise de contact, les E/S des messages et le cycle de vie de la connexion.

---

Configuration du projet

Ce tutoriel crée un serveur et un client WebSocket de base :

1. Un serveur WebSocket acceptant les connexions.
2. Un client interagissant avec le serveur.

---

Structure des répertoires

Organisez votre projet comme suit :

<code>websocket-server/
├── main.go           # Application entry point
├── handlers/         # WebSocket handler functions
│   └── websocket.go  # Handles WebSocket connections and messages
├── static/           # Client-side HTML/JS files
│   └── index.html    # Simple client interface
└── go.mod            # Go module file</code>

---

Installation de Gorilla WebSocket

Installez le package Gorilla WebSocket :

<code class="language-bash">go get -u github.com/gorilla/websocket</code>

---

Construction du serveur WebSocket

Étape 1 : main.go

Créer main.go :

<code class="language-go">package main

import (
    "fmt"
    "log"
    "net/http"
    "websocket-server/handlers"
)

func main() {
    http.HandleFunc("/ws", handlers.HandleWebSocket)
    http.Handle("/", http.FileServer(http.Dir("./static")))
    port := ":8080"
    fmt.Printf("Server running on http://localhost%s\n", port)
    log.Fatal(http.ListenAndServe(port, nil))
}</code>

Cela configure un serveur HTTP, sert les fichiers statiques et gère les connexions WebSocket sur /ws.

Étape 2 : Gestionnaire WebSocket (websocket.go)

Dans le répertoire handlers, créez websocket.go :

<code class="language-go">package handlers

import (
    "fmt"
    "net/http"

    "github.com/gorilla/websocket"
)

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

func HandleWebSocket(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        fmt.Println("Upgrade failed:", err)
        return
    }
    defer conn.Close()
    fmt.Println("Client connected")
    for {
        _, msg, err := conn.ReadMessage()
        if err != nil {
            fmt.Println("Read failed:", err)
            break
        }
        fmt.Printf("Received: %s\n", msg)
        if err := conn.WriteMessage(websocket.TextMessage, msg); err != nil {
            fmt.Println("Write failed:", err)
            break
        }
    }
}</code>

Ce gestionnaire met à niveau la connexion HTTP, lit les messages et les renvoie.

---

Traitement des messages

HandleWebSocket traite les messages entrants. Vous pouvez étendre cela pour implémenter des fonctionnalités telles que la diffusion ou la persistance des messages.

---

Exécuter l'application

Étape 1 : Client simple (index.html)

Créez index.html dans le répertoire static : (Cette section nécessite une implémentation JavaScript côté client pour se connecter au websocket. Un exemple de base est omis par souci de concision, mais de nombreux exemples sont facilement disponibles en ligne.)

Étape 2 : Exécuter le serveur

Exécutez go run main.go. Ensuite, ouvrez http://localhost:8080 dans votre navigateur (avec le JavaScript approprié côté client inclus).

---

Conclusion

Ce didacticiel montre un serveur Web WebSocket de base à l'aide de Gorilla. WebSockets est idéal pour les applications en temps réel. Développez cette fondation avec l'authentification, la radiodiffusion et le stockage de données au besoin.

---

Référentiel GitHub

[Insérez le lien du référentiel GitHub ici]

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!