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-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))
}

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")
}

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!