Go-Sprachserver-Programmierpraxis: Erstellen eines einfachen Web-Chatrooms

Go-Sprache wird zunehmend im Bereich der Serverprogrammierung verwendet. Ihre schnellen, effizienten und gleichzeitigen Funktionen sind zu den Gründen geworden, warum sich viele Menschen für sie entscheiden. In diesem Artikel erfahren Sie, wie Sie einen einfachen Web-Chatroom in der Go-Sprache erstellen, einschließlich Echtzeit-Nachrichtenübertragung, Online-Interaktion mit mehreren Benutzern und anderen verwandten Wissenspunkten.

1. Auswahl der Web-Frameworks der Go-Sprache

In der Go-Sprache stehen viele Web-Frameworks zur Auswahl, darunter Beego, Gin, Echo usw. In diesem Artikel wird die Verwendung des Echo-Frameworks ausgewählt, da es leicht, leistungsstark und einfach zu verwenden ist und sich für die schnelle Erstellung von Webanwendungen eignet. Bevor Sie das Echo-Framework verwenden, öffnen Sie bitte ein Terminal und führen Sie den folgenden Befehl aus, um das Abhängigkeitspaket zu erhalten:

go get -u github.com/labstack/echo

2. Funktionsdesign

Bevor wir diesen Web-Chatroom erstellen, müssen wir die dafür erforderlichen Funktionsmodule und Prozesse entwerfen:

1. Registrieren Sie sich und melden Sie sich an, um eine Benutzerauthentifizierung zu erreichen.
2. Auf der Startseite des Chatrooms können die Liste der Online-Benutzer, historische Chat-Aufzeichnungen usw. angezeigt werden.
3. Nachrichtenübertragung in Echtzeit, die die Online-Interaktion mehrerer Benutzer unterstützt.
4. Beim Schließen des Browsers wird die WebSocket-Verbindung zum Server getrennt und der Benutzer als offline markiert.

3. Implementierungsschritte

Im Folgenden werden wir die oben genannten Funktionsmodule und Prozesse Schritt für Schritt implementieren:

1. Konto registrieren und anmelden:

In der Go-Sprache können Sie das Drittanbieterpaket bcrypt verwenden Implementieren Sie eine Passwortverschlüsselung. Wir müssen zuerst die Benutzerstruktur User erstellen und dann die Gorm-Bibliothek verwenden, um die Datenbanktabelle zu erstellen.

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

Der Verarbeitungsfunktionscode für die Benutzerregistrierung und -anmeldung lautet wie folgt:

// 用户注册
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. Startseite des Chatrooms:

Auf der Startseite des Chatrooms müssen die Liste der Online-Benutzer und die historischen Chat-Aufzeichnungen angezeigt werden. Die Liste der Online-Benutzer kann in einer Karte gespeichert werden, wobei der Schlüssel der Benutzername und der Wert Informationen zur WebSocket-Verbindung sind, wie z. B. Verbindungs-ID, Verbindungszeit usw.

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

Historische Chat-Aufzeichnungen können mithilfe von Arrays oder Redis-ähnlichen Datenstrukturen gespeichert werden. Das Folgende ist der Code der Homepage-Verarbeitungsfunktion:

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

Darunter ist room.html die Vorlagendatei, Clients und Msgs sind die Online-Benutzerliste bzw. historische Chat-Aufzeichnungen.

3. Echtzeit-Nachrichtenübertragung:

Im Echo-Framework kann die Echtzeit-Nachrichtenübertragung sehr einfach mithilfe von WebSockets implementiert werden. Wir müssen eine WebSocket-Verarbeitungsfunktion definieren. Nachdem sich der Client erfolgreich mit dem Server verbunden hat, werden seine Informationen zur Online-Benutzerliste hinzugefügt. Wenn der Client eine Nachricht sendet, wird die Nachricht an alle verbundenen Clients gesendet.

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

4. Wenn Sie eine WebSocket-Verbindung schließen, trennen Sie die Verbindung zum Server und markieren Sie den Benutzer als offline. Wir können die Defer-Anweisung in der WebSocket-Verarbeitungsfunktion verwenden, um die Benutzerinformationen in der Online-Benutzerliste am Ende der Funktion zu löschen.

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

IV. Zusammenfassung

Dieser Artikel implementiert einen einfachen Web-Chatroom mithilfe des Echo-Frameworks und WebSockets, einschließlich Benutzerauthentifizierung, Online-Benutzerliste, historischer Chat-Aufzeichnungen, Echtzeit-Nachrichtenübertragung und anderer Funktionen. Gleichzeitig verwenden wir auch die Gorm-Bibliothek und das Bcrypt-Paket, um Benutzerverwaltungs- und Passwortverschlüsselungsfunktionen zu implementieren.

In der Praxis müssen wir auch Sicherheitsaspekte wie die Nachrichtenfilterung und die Filterung vertraulicher Wörter berücksichtigen. Ich hoffe, dass die Leser durch diesen Artikel lernen können, wie man die Go-Sprache zum Erstellen von Webanwendungen sowie häufig verwendete Bibliotheken und Frameworks verwendet.

Das obige ist der detaillierte Inhalt vonGo-Sprachserver-Programmierpraxis: Erstellen eines einfachen Web-Chatrooms. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!