Maison > Article > développement back-end > Tutoriel Golang Websocket : Comment développer la fonction de soumission en ligne

Tutoriel Golang Websocket : Comment développer la fonction de soumission en ligne

王林original: 2023-12-17 10:23:211087parcourir

golang Websocket教程：如何开发在线投稿功能

Tutoriel Golang Websocket : Comment développer une fonction de soumission en ligne

Introduction :
Avec le développement rapide d'Internet, de plus en plus d'applications doivent implémenter des fonctions de communication en temps réel. Dans les applications réseau, la technologie Websocket est devenue un protocole de communication couramment utilisé. Cet article vise à enseigner aux lecteurs comment utiliser le langage Golang pour développer une fonction de soumission en ligne et utiliser Websocket pour obtenir une interaction en temps réel.

1. Introduction à Websocket
Websocket est un protocole de communication full-duplex qui peut établir une connexion persistante entre le navigateur et le serveur pour établir une communication en temps réel. Par rapport au protocole HTTP traditionnel, Websocket a une latence plus faible et un débit plus élevé, et convient aux scénarios d'application qui traitent des données en temps réel.

2. Configuration de l'environnement de développement
Avant de commencer le développement, vous devez configurer l'environnement de développement Golang.

Installez Golang : visitez le site officiel https://golang.org/doc/install pour télécharger et installer la version Golang adaptée à votre système d'exploitation.
Installer les bibliothèques associées :
```
go get github.com/gorilla/websocket
```

3. Conception de la structure du projet
Avant de développer la fonction de soumission en ligne, vous devez planifier la structure des répertoires du projet.

- main.go
- handler.go
- template
  - index.html

4. Implémentation du code

main.go

package main

import (
    "html/template"
    "log"
    "net/http"

    "github.com/gorilla/websocket"
)

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

func homeHandler(w http.ResponseWriter, r *http.Request) {
    homeTemplate.Execute(w, nil)
}

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

    clients[conn] = true

    for {
        _, msg, err := conn.ReadMessage()
        if err != nil {
            log.Println(err)
            delete(clients, conn)
            return
        }
        broadcast <- msg
    }
}

func handleMessages() {
    for {
        msg := <-broadcast
        for client := range clients {
            err := client.WriteMessage(websocket.TextMessage, msg)
            if err != nil {
                log.Println(err)
                client.Close()
                delete(clients, client)
            }
        }
    }
}

func main() {
    // 配置文件路径
    homeTemplate = template.Must(template.ParseFiles("template/index.html"))

    http.HandleFunc("/", homeHandler)
    http.HandleFunc("/ws", websocketHandler)

    go handleMessages()

    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal(err)
    }
}

handler.go

package main

import (
    "net/http"
    "path/filepath"
)

func homeHandler(w http.ResponseWriter, r *http.Request) {
    filePath, _ := filepath.Abs("template/index.html")
    http.ServeFile(w, r, filePath)
}

template/index.html

<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>在线投稿功能</title>
</head>
<body>
    <h1>在线投稿功能</h1>
    <textarea id="message-input" rows="5" cols="30"></textarea>
    <button id="send-btn">发送</button>
    <br>
    <ul id="message-list"></ul>
</body>
<script>
    var socket = new WebSocket("ws://localhost:8080/ws");
    socket.onmessage = function (event) {
        var messageList = document.getElementById("message-list");
        var messageItem = document.createElement("li");
        messageItem.innerText = event.data;
        messageList.appendChild(messageItem);
    };

    document.getElementById("send-btn").addEventListener("click", function () {
        var messageInput = document.getElementById("message-input");
        var message = messageInput.value;
        socket.send(message);
    });
</script>
</html>

```
go run main.go
```
Ouvrez le navigateur et saisissez l'adresse http://localhost:8080/ pour accéder à la page.
6. Résumé

Grâce aux étapes ci-dessus, nous avons achevé le développement d'une fonction de soumission en ligne basée sur Golang. La livraison des messages en temps réel est réalisée via Websocket Une fois que l'utilisateur a saisi le message dans la zone de texte et cliqué sur le bouton d'envoi, le message peut être envoyé au serveur et affiché instantanément sur la page.

Continuer à apprendre et à pratiquer les technologies liées à Websocket apportera plus de possibilités et d'innovation au développement. J'espère que les lecteurs pourront utiliser les conseils de cet article pour mieux utiliser Golang afin de développer davantage d'applications réseau interactives en temps réel.

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!

golang html http https websocket

Déclaration：

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

Article précédent：Partir de zéro : utiliser ECharts et Golang pour créer de superbes graphiques statistiquesArticle suivant：Partir de zéro : utiliser ECharts et Golang pour créer de superbes graphiques statistiques

Articles Liés

Voir plus