Pratique de programmation de serveur de langage Go : création d'une salle de discussion Web simple

Le langage

Go est de plus en plus utilisé dans le domaine de la programmation serveur. Ses fonctionnalités rapides, efficaces et concurrentes sont devenues les raisons pour lesquelles de nombreuses personnes le choisissent. Cet article vous expliquera comment créer une salle de discussion Web simple en langage Go, y compris la transmission de messages en temps réel, l'interaction en ligne multi-utilisateurs et d'autres points de connaissances connexes.

1. Sélection du framework Web du langage Go

Dans le langage Go, il existe de nombreux frameworks Web parmi lesquels choisir, parmi lesquels les plus populaires sont Beego, Gin, Echo, etc. . Cet article choisit d'utiliser le framework Echo car il est léger, performant et facile à utiliser, et convient à la création rapide d'applications Web. Avant d'utiliser le framework Echo, veuillez ouvrir un terminal et exécuter la commande suivante pour obtenir le package de dépendances :

go get -u github.com/labstack/echo

2. Conception fonctionnelle

Avant de construire ce salon de discussion Web, nous besoin de le concevoir Modules fonctionnels et processus requis :

1. Inscrivez-vous et connectez-vous au compte pour obtenir l'authentification de l'utilisateur.
2. La page d'accueil du salon de discussion peut afficher la liste des utilisateurs en ligne, l'historique des enregistrements de discussion, etc.
3. Transmission de messages en temps réel, prenant en charge l'interaction en ligne multi-utilisateurs.
4. Lorsque le navigateur est fermé, la connexion WebSocket au serveur est déconnectée et l'utilisateur est marqué comme hors ligne.

3. Étapes de mise en œuvre

Ci-dessous, nous mettrons en œuvre les modules fonctionnels et les processus ci-dessus étape par étape :

1. Inscrivez-vous et connectez-vous au compte :

En langage Go, vous pouvez utiliser le package tiers bcrypt pour implémenter le cryptage des mots de passe. Nous devons d'abord créer la structure utilisateur User, puis utiliser la bibliothèque gorm pour créer la table de base de données.

type User struct {
    gorm.Model
    Username string `gorm:"unique;not null"`
    Password string `gorm:"not null"`
}

Le code de fonction de traitement pour l'enregistrement et la connexion des utilisateurs est le suivant :

// 用户注册
func Register(c echo.Context) error {
    username := c.FormValue("username")
    password := c.FormValue("password")
    confirmPwd := c.FormValue("confirm_pwd")
    u := &models.User{
        Username: username,
        Password: util.HashPwd(password),
    }
    if password != confirmPwd {
        return c.JSON(http.StatusOK, map[string]interface{}{
            "success": false,
            "message": "Passwords do not match",
        })
    }
    err := db.Create(&u).Error
    if err != nil {
        return c.JSON(http.StatusOK, map[string]interface{}{
            "success": false,
            "message": "Username already exists",
        })
    }
    return c.JSON(http.StatusOK, map[string]interface{}{
        "success": true,
        "message": "Register success",
    })
}

// 用户登录
func Login(c echo.Context) error {
    username := c.FormValue("username")
    password := c.FormValue("password")
    user := &models.User{}
    err := db.Where("username = ?", username).First(&user).Error
    if err != nil {
        return c.JSON(http.StatusOK, map[string]interface{}{
            "success": false,
            "message": "Username or password is incorrect",
        })
    }
    if util.CheckPwd(password, user.Password) {
        return c.JSON(http.StatusOK, map[string]interface{}{
            "success": true,
            "message": "Login success",
        })
    }
    return c.JSON(http.StatusOK, map[string]interface{}{
        "success": false,
        "message": "Username or password is incorrect",
    })
}

2. Page d'accueil du salon de discussion :

#🎜🎜 # discute Sur la page d'accueil de la salle, la liste des utilisateurs en ligne et l'historique des enregistrements de discussion doivent être affichés. La liste des utilisateurs en ligne peut être enregistrée dans une carte, où la clé est le nom d'utilisateur et la valeur est des informations liées à la connexion WebSocket, telles que l'ID de connexion, l'heure de connexion, etc.

// 在线用户列表
var clients = make(map[string]*Client)

Les enregistrements de discussion historiques peuvent être stockés à l'aide de tableaux ou de structures de données de type Redis. Voici le code de la fonction de traitement de la page d'accueil :

// 聊天室首页
func Room(c echo.Context) error {
    return c.Render(http.StatusOK, "room.html", map[string]interface{}{
        "clients": clients,
        "msgs":    msgs,
    })
}

Parmi eux, room.html est le fichier modèle, les clients et les msgs sont respectivement la liste des utilisateurs en ligne et les enregistrements de discussion historiques.

Transmission de messages en temps réel :

Dans le framework Echo, la transmission de messages en temps réel peut être réalisée très simplement à l'aide de WebSockets. Nous devons définir une fonction de traitement WebSocket. Une fois que le client s'est connecté avec succès au serveur, ses informations seront ajoutées à la liste des utilisateurs en ligne ; lorsque le client envoie un message, le message sera envoyé à tous les clients connectés.

// WebSocket处理函数
func wsHandler(c echo.Context) error {
    // 建立WebSocket连接
    ws, err := upgrader.Upgrade(c.Response(), c.Request(), nil)
    if err != nil {
        return err
    }
    defer ws.Close()

    // 获取用户名
    username, ok := c.QueryParams()["username"]
    if !ok {
        return errors.New("username is required")
    }

    // 添加用户
    client := &Client{
        WS:        ws,
        Username: username[0],
        ConnTime:  time.Now(),
    }
    clients[client.Username] = client

    // 遍历用户列表，发送欢迎消息
    for _, c := range clients {
        msg := &Message{
            Type: WelcomeMsg,
            Data: fmt.Sprintf("User '%s' joined the chat room", client.Username),
        }
        err = c.Send(msg)
        if err != nil {
            log.Println(err)
            continue
        }
    }

    // 接收消息，广播给所有用户
    for {
        msg := &Message{}
        err = client.Receive(msg)
        if err != nil {
            if err == io.EOF {
                delete(clients, client.Username)
                for _, c := range clients {
                    msg = &Message{
                        Type: LeaveMsg,
                        Data: fmt.Sprintf("User '%s' left the chat room", client.Username),
                    }
                    err = c.Send(msg)
                    if err != nil {
                        log.Println(err)
                        continue
                    }
                }
                break
            }
            log.Println(err)
            continue
        }
        for _, c := range clients {
            if c.Username == client.Username {
                continue
            }
            err = c.Send(msg)
            if err != nil {
                log.Println(err)
                continue
            }
        }
        msgs = append(msgs, *msg)
    }

    return nil
}

Lors de la fermeture d'une connexion WebSocket, déconnectez-vous du serveur et marquez l'utilisateur hors ligne. Nous pouvons utiliser l'instruction defer dans la fonction de traitement WebSocket pour supprimer les informations utilisateur dans la liste des utilisateurs en ligne à la fin de la fonction.

defer func() {
    delete(clients, client.Username)
}()

4. Résumé
Cet article utilise le framework Echo et WebSockets pour implémenter une salle de discussion Web simple, comprenant l'authentification des utilisateurs, la liste des utilisateurs en ligne, l'historique du chat enregistrement, transmission de messages en temps réel et autres fonctions. Dans le même temps, nous utilisons également la bibliothèque gorm et le package bcrypt pour implémenter les fonctions de gestion des utilisateurs et de cryptage des mots de passe.
En pratique, nous devons également prendre en compte les problèmes de sécurité tels que le filtrage des messages et le filtrage des mots sensibles. J'espère que les lecteurs pourront apprendre grâce à cet article comment utiliser le langage Go pour créer des applications Web, ainsi que des bibliothèques et des frameworks couramment utilisés.

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!