Maison > développement back-end > Golang > le corps du texte

Apprendre les fonctions de programmation réseau en langage Go et mettre en œuvre une communication en temps réel avec les serveurs WebSocket ?

WBOY
Libérer: 2023-07-31 16:41:32
original
1460 Les gens l'ont consulté

Apprenez les fonctions de programmation réseau en langage Go et mettez en œuvre une communication en temps réel avec les serveurs WebSocket

À l'ère d'Internet d'aujourd'hui, la communication en temps réel devient de plus en plus importante dans de nombreuses applications. Afin d'établir une communication en temps réel, de nombreux développeurs choisiront d'utiliser le protocole WebSocket car il permet d'établir une communication bidirectionnelle entre le client et le serveur. Dans cet article, nous allons apprendre les fonctions de programmation réseau en langage Go et l'utiliser pour implémenter un simple serveur WebSocket pour une communication en temps réel.

Avant de commencer, nous devons installer l'environnement de développement du langage Go. Je n'entrerai pas dans les détails ici. Si vous ne l'avez pas encore installé, veuillez vous référer au site officiel de Go Language pour l'installer.

Tout d'abord, nous devons utiliser le package net/http du langage Go pour créer un serveur HTTP de base, puis utiliser le package gorilla/websocket pour gérer la connexion WebSocket avec le client.

  1. Importez les packages requis :
import (
    "log"
    "net/http"
    "github.com/gorilla/websocket"
)
Copier après la connexion
  1. Définissez le programme de mise à niveau WebSocket :
var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}
Copier après la connexion
  1. Définissez le gestionnaire WebSocket :
func wsHandler(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println(err)
        return
    }

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

        log.Printf("Received message: %s
", message)

        if err := conn.WriteMessage(messageType, message); err != nil {
            log.Println(err)
            return
        }
    }
}
Copier après la connexion
  1. Définissez le gestionnaire de requêtes HTTP :
func helloHandler(w http.ResponseWriter, r *http.Request) {
    http.ServeFile(w, r, "index.html")
}
Copier après la connexion
  1. Démarrez le serveur :
func main() {
    http.HandleFunc("/ws", wsHandler)
    http.HandleFunc("/", helloHandler)
    log.Println("Server starting on localhost:8080")
    http.ListenAndServe(":8080", nil)
}
Copier après la connexion

Maintenant nous avons réalisé un simple serveur WebSocket. Nous pouvons ouvrir le fichier index.html dans le navigateur puis utiliser le code JavaScript pour communiquer avec le serveur.

<!DOCTYPE html>
<html>
<head>
    <title>WebSocket Example</title>
    <script>
        var socket = new WebSocket("ws://localhost:8080/ws");

        socket.onopen = function(event) {
            console.log("Connection opened.");
        };

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

        socket.onclose = function(event) {
            console.log("Connection closed.");
        };

        socket.onerror = function(event) {
            console.log("Error: " + event.data);
        };

        function sendMessage() {
            var message = document.getElementById("message").value;
            socket.send(message);
            console.log("Sent message: " + message);
        }
    </script>
</head>
<body>
    <input type="text" id="message" placeholder="Type a message">
    <button onclick="sendMessage()">Send</button>
</body>
</html>
Copier après la connexion

Le code ci-dessus peut être testé dans le navigateur. Le message peut être envoyé au serveur en saisissant le message dans la zone de saisie et en cliquant sur le bouton d'envoi. Le serveur renverra le message reçu au client tel quel et l'affichera sur la console. De cette façon, nous avons réalisé une communication simple en temps réel.

En apprenant les fonctions de programmation réseau en langage Go et en utilisant le package gorilla/websocket pour gérer les connexions WebSocket, nous pouvons facilement implémenter un serveur WebSocket pour une communication en temps réel. De plus, l'efficacité et la concurrence du langage Go en font également un excellent choix linguistique pour gérer les communications en temps réel. J'espère que cet article vous sera utile pour apprendre la programmation réseau en langage Go et implémenter le serveur 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!

Étiquettes associées:
source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal
À propos de nous Clause de non-responsabilité Sitemap
Site Web PHP chinois:Formation PHP en ligne sur le bien-être public,Aidez les apprenants PHP à grandir rapidement!