Démo d'application Web en temps réel avec WebSocket - Backend

Introduction

Dans cet article, j'explorerai l'implémentation backend de mon application WebSocket en temps réel. Construit à l'aide de Gin and Go, le backend gère efficacement les connexions WebSocket, stocke les messages et diffuse les mises à jour à tous les clients connectés.

---

Structure du projet

https://github.com/tom-takeru/web-socket-demo

Mon projet backend est organisé pour garantir la modularité et la réutilisabilité. Vous trouverez ci-dessous la structure des répertoires mise à jour :

./backend
├── go.mod
├── go.sum
├── main.go
└── stores
    └── messages.go

Répertoires et fichiers clés

• go.mod : Définit les dépendances et les versions du module.
• main.go : Point d'entrée de l'application qui initialise le serveur WebSocket et les routes.
• stores/messages.go : gère le stockage des messages avec des opérations thread-safe.

---

Composant principal : main.go

main.go est le point d'entrée principal de mon application serveur WebSocket. Il configure le routeur Gin, définit la route WebSocket et gère le cycle de vie de WebSocket.

Procédure pas à pas du code

package main

import (
    "encoding/json"
    "net/http"
    "sync"
    "time"

    "github.com/gin-gonic/gin"
    "github.com/gorilla/websocket"

    "github.com/tom-takeru/web-socket-demo/backend/stores"
)

var (
    upgrader = websocket.Upgrader{
        CheckOrigin: func(r *http.Request) bool {
            origin := r.Header.Get("Origin")
            // NOTE: This project is for local development only.
            return origin == "http://localhost:3000"
        },
    }
    messageStore = stores.NewMessageStore()
    clients      = make(map[*websocket.Conn]bool)
    clientsMu    sync.Mutex
)

func handleWebSocket(c *gin.Context) {
    conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to upgrade to WebSocket"})
        return
    }
    defer conn.Close()

    clientsMu.Lock()
    clients[conn] = true
    clientsMu.Unlock()

    // Send existing messages to the new connection
    for _, msg := range messageStore.MarshalMessages() {
        conn.WriteMessage(websocket.TextMessage, msg)
    }

    for {
        _, message, err := conn.ReadMessage()
        if err != nil {
            break
        }

        var msgData map[string]string
        if err := json.Unmarshal(message, &msgData); err != nil {
            break
        }

        timestamp := time.Now().Format(time.RFC3339)
        msgData["timestamp"] = timestamp

        messageStore.AddMessage(msgData)

        modifiedMessage, err := json.Marshal(msgData)
        if err != nil {
            break
        }

        clientsMu.Lock()
        for client := range clients {
            if err := client.WriteMessage(websocket.TextMessage, modifiedMessage); err != nil {
                client.Close()
                delete(clients, client)
            }
        }
        clientsMu.Unlock()
    }

    clientsMu.Lock()
    delete(clients, conn)
    clientsMu.Unlock()
}

func main() {
    r := gin.Default()
    r.GET("/ws", handleWebSocket)
    r.Run("localhost:8080")
}

Fonctionnalités clés

1. Gestion de l'état : suit les clients connectés et garantit un accès sécurisé aux threads à l'aide d'un mutex.
2. WebSocket Lifecycle : gère la configuration de la connexion, la diffusion des messages et le nettoyage à la déconnexion.

---

Conclusion

L'implémentation backend de mon application de démonstration WebSocket montre comment gérer efficacement la communication en temps réel à l'aide de Gin and Go. En tirant parti de WebSocket pour les connexions persistantes et d'un magasin de messages thread-safe, cette application constitue une base solide pour la création d'applications Web en temps réel.

Dans le prochain article, je discuterai des stratégies de déploiement et de l'optimisation des performances de WebSocket.

---

Liens vers la série

• Démo d'application Web en temps réel avec WebSocket - Présentation
• Démo d'application Web en temps réel avec WebSocket - Frontend

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!