Maison > développement back-end > Golang > Tutoriel Golang Websocket : Comment développer une fonction de questions et réponses en ligne

Tutoriel Golang Websocket : Comment développer une fonction de questions et réponses en ligne

WBOY
Libérer: 2023-12-02 10:14:49
original
607 Les gens l'ont consulté

golang Websocket教程:如何开发在线问答功能

Tutoriel Golang Websocket : Comment développer une fonction de questions-réponses en ligne, des exemples de code spécifiques sont nécessaires

À l'ère actuelle d'Internet développé, les plateformes de questions-réponses en ligne sont devenues un moyen important pour les gens d'acquérir des connaissances, de partager des expériences et de résoudre des problèmes. Afin de répondre aux besoins d'immédiateté et d'interactivité des utilisateurs, utiliser la technologie Websocket pour mettre en œuvre des fonctions de questions et réponses en ligne est un bon choix. Cet article expliquera comment utiliser Golang pour développer une fonction de questions et réponses en ligne basée sur Websocket et fournira des exemples de code spécifiques.

1. Préparation du projet
Avant de commencer notre tutoriel, nous devons faire quelques préparatifs :

  1. Installer Golang : Tout d'abord, assurez-vous que Golang est installé sur votre ordinateur, veuillez vous rendre sur le site officiel de Golang pour le télécharger et l'installer.
  2. Installez les bibliothèques nécessaires : nous utiliserons la bibliothèque gorilla/websocket de Golang pour implémenter la fonctionnalité Websocket. Vous pouvez l'installer avec la commande suivante :
    go get github.com/gorilla/websocket
  3. Créez la structure du répertoire du projet : créez un nouveau dossier dans votre chemin de travail pour stocker nos fichiers de projet.

2. Créer un serveur Websocket
Nous devons d'abord créer un serveur Websocket pour gérer les connexions client et la livraison des messages. Créez un fichier nommé server.go dans le répertoire du projet et ajoutez le code suivant :

package main

import (
    "log"
    "net/http"

    "github.com/gorilla/websocket"
)

// 定义全局变量用于存储连接的客户端
var clients = make(map[*websocket.Conn]bool)

// 定义通道用于传递消息
var broadcast = make(chan Message)

// 定义消息结构体
type Message struct {
    Username string `json:"username"`
    Content  string `json:"content"`
}

// 定义升级HTTP请求为Websocket的方法
var upgrader = websocket.Upgrader{
    CheckOrigin: func(r *http.Request) bool {
        return true
    },
}

// 处理Websocket连接
func handleConnections(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

    // 将连接的客户端添加到全局变量中
    clients[conn] = true

    for {
        var msg Message
        err := conn.ReadJSON(&msg)
        if err != nil {
            log.Printf("error: %v", err)
            delete(clients, conn)
            break
        }
        broadcast <- msg
    }
}

// 处理广播消息
func handleMessages() {
    for {
        msg := <-broadcast
        for client := range clients {
            err := client.WriteJSON(msg)
            if err != nil {
                log.Printf("error: %v", err)
                client.Close()
                delete(clients, client)
            }
        }
    }
}

func main() {
    http.HandleFunc("/ws", handleConnections)
    go handleMessages()
    log.Println("Server start on http://localhost:8000")
    log.Fatal(http.ListenAndServe(":8000", nil))
}
Copier après la connexion

Le code ci-dessus implémente un simple serveur Websocket qui diffuse les messages clients à tous les clients connectés.

3. Créer un client Websocket
Ensuite, nous devons créer un client Websocket pour que les utilisateurs puissent envoyer et recevoir des messages sur la page frontale. Créez un fichier nommé client.go dans le répertoire du projet et ajoutez le code suivant :

package main

import (
    "log"
    "net/url"
    "os"
    "os/signal"
    "time"

    "github.com/gorilla/websocket"
)

// 定义消息结构体
type Message struct {
    Username string
    Content  string
}

func main() {
    // 创建WebSocket连接
    u := url.URL{Scheme: "ws", Host: "localhost:8000", Path: "/ws"}
    c, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
    if err != nil {
        log.Fatal("dial:", err)
    }
    defer c.Close()

    // 监听系统信号
    interrupt := make(chan os.Signal, 1)
    signal.Notify(interrupt, os.Interrupt)

    // 创建一个通道用于接收消息
    done := make(chan struct{})

    // 创建一个协程来监听用户输入并发送消息
    go func() {
        for {
            var msg Message
            err := c.ReadJSON(&msg)
            if err != nil {
                log.Println("read:", err)
                close(done)
                return
            }
            log.Printf("received: %v", msg)
        }
    }()

    // 创建一个协程来发送消息给服务器
    go func() {
        ticker := time.NewTicker(time.Second)
        defer ticker.Stop()

        for {
            select {
            case <-done:
                return
            case t := <-ticker.C:
                err := c.WriteJSON(Message{Username: "Alice", Content: "Hello, World!"})
                if err != nil {
                    log.Println("write:", err)
                    return
                }
                log.Printf("sent: %v", t.String())
            }
        }
    }()

    // 等待系统信号
    <-interrupt
    log.Println("interrupt")

    // 关闭连接
    err = c.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, ""))
    if err != nil {
        log.Println("write close:", err)
    }
    select {
    case <-done:
    case <-time.After(time.Second):
    }
    log.Println("server closed")
}
Copier après la connexion

Le code ci-dessus crée un client Websocket, qui enverra un message au serveur toutes les secondes et imprimera le message reçu.

4. Compilez et exécutez
Ouvrez le terminal dans le répertoire du projet et exécutez les commandes suivantes pour compiler et exécuter le projet :

  1. Compiler le serveur
    go build server.go
  2. Exécuter le serveur
    ./server
  3. Compiler le client
    allez build client.go
  4. Exécutez le client
    ./client

5. Fonction de test
Visitez http://localhost:8000 dans le navigateur et ouvrez la console, vous verrez les messages envoyés par le client et Broadcast. messages à d'autres clients. Essayez de taper un message dans la console et d'appuyer sur Entrée, le message sera diffusé à tous les clients connectés.

6. Résumé
Ce tutoriel vous présente comment utiliser la technologie Golang et Websocket pour développer une fonction simple de questions et réponses en ligne. En étudiant ce didacticiel, vous devriez être capable de comprendre comment créer un serveur et un client Websocket, et être capable d'appliquer les technologies associées dans votre projet. J'espère que ce tutoriel pourra vous être utile, et je vous souhaite un bon apprentissage de la programmation !

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