Intégration de Golang WebSocket et du navigateur : parvenir à une communication instantanée-Golang-php.cn

Intégration de Golang WebSocket et du navigateur : parvenir à une communication instantanée

WBOY

Libérer： 2023-12-17 11:21:43

original

671 Les gens l'ont consulté

golang WebSocket与浏览器的集成：实现即时通信

Golang est un langage de programmation efficace, simple et facile à apprendre, et WebSocket est une technologie importante pour la communication instantanée. Cet article expliquera comment intégrer WebSocket dans Golang et mettre en œuvre une communication instantanée avec le navigateur.

1. Introduction

Dans le développement d'applications Web, la communication en temps réel est une exigence fonctionnelle très importante. Le protocole HTTP précédent était un protocole sans état et ne permettait pas d'établir une communication en temps réel. En conséquence, WebSocket a vu le jour. WebSocket est un protocole basé sur TCP qui fournit un canal de communication en duplex intégral permettant une communication en temps réel entre le client et le serveur.

Golang, en tant que langage back-end puissant, prend en charge WebSocket. Grâce aux fonctionnalités de concurrence et à la syntaxe concise de Golang, nous pouvons facilement implémenter une communication instantanée entre WebSocket et le navigateur.

2. WebSocket dans Golang

Tout d'abord, nous devons utiliser le package net/http de Golang pour créer un serveur. Voici un exemple de code simple : net/http包来创建一个服务器。下面是一个简单的示例代码：

package main

import (
    "log"
    "net/http"
)

func wsHandler(w http.ResponseWriter, r *http.Request) {
    // 在这里处理WebSocket的逻辑

}

func main() {
    http.HandleFunc("/", wsHandler)
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal("ListenAndServe: ", err)
    }
}

Copier après la connexion

上述代码中，我们首先定义了一个处理WebSocket请求的wsHandler函数，然后使用http.HandleFunc将它注册到根路径上。最后，我们使用http.ListenAndServe函数将服务器监听在8080端口上。

接下来，我们需要在wsHandler函数中处理WebSocket的逻辑。Golang的net/http包提供了一个Upgrade函数，用于将HTTP请求升级为WebSocket连接。我们可以使用Upgrade函数将HTTP连接升级为WebSocket连接。

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

    for {
        // 在这里处理WebSocket的消息
    }
}

Copier après la connexion

在上述代码中，我们首先调用upgrader.Upgrade函数将HTTP连接升级为WebSocket连接。然后，我们通过conn对象与浏览器进行交互。有了conn对象，我们可以使用WriteMessage函数发送消息给浏览器，使用ReadMessage函数接收浏览器发送的消息。

3. 浏览器端的WebSocket

为了演示Golang与浏览器之间的WebSocket通信，我们需要一个简单的前端页面。下面是一个使用JavaScript实现的WebSocket客户端示例代码：

<!DOCTYPE html>
<html>
<head>
    <title>WebSocket Demo</title>
    <script>
        var ws = new WebSocket("ws://localhost:8080/");

        ws.onopen = function() {
            // 连接建立后的逻辑
        };

        ws.onmessage = function(evt) {
            // 接收到消息后的逻辑
        };

        ws.onclose = function() {
            // 连接关闭后的逻辑
        };

        function sendMessage() {
            var message = document.getElementById("message").value;
            ws.send(message);
        }
    </script>
</head>
<body>
    <input id="message" type="text" />
    <button onclick="sendMessage()">发送消息</button>
</body>
</html>

Copier après la connexion

在上述代码中，我们首先创建了一个WebSocket对象，并指定了服务器的地址。在ws.onopen函数中，我们可以实现连接建立后的逻辑；在ws.onmessage函数中，我们可以实现接收到消息后的逻辑；在ws.onclose函数中，我们可以实现连接关闭后的逻辑。另外，我们还提供了一个sendMessage函数，用于将用户输入的消息发送给服务器。

4. 实现即时通信

有了基本的服务器和客户端代码，我们就可以开始实现即时通信功能了。下面是一个简单的示例，演示在浏览器中输入消息后，在服务器端广播给其他连接的客户端：

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

    for {
        // 接收消息
        messageType, message, err := conn.ReadMessage()
        if err != nil {
            log.Println(err)
            break
        }

        log.Printf("Received message: %s", message)

        // 广播消息
        for c := range connections {
            err := c.WriteMessage(messageType, message)
            if err != nil {
                log.Println(err)
            }
        }
    }
}

Copier après la connexion

在上述代码中，我们首先使用conn.ReadMessage函数接收浏览器发送的消息。然后，我们遍历所有连接的客户端，使用c.WriteMessage函数将消息广播出去。

5. 总结

本文介绍了如何使用Golang集成WebSocket，并在浏览器中实现即时通信功能。我们首先介绍了Golang的net/http包，并创建了一个简单的服务器。然后，我们使用net/http包提供的Upgraderrreee

Dans le code ci-dessus, nous définissons d'abord une fonction wsHandler qui gère les requêtes WebSocket, puis utilisons http.HandleFunc pour l'enregistrer. sur le chemin racine. Enfin, nous utilisons la fonction http.ListenAndServe pour écouter le serveur sur le port 8080.

Ensuite, nous devons gérer la logique de WebSocket dans la fonction wsHandler. Le package net/http de Golang fournit une fonction Upgrade pour mettre à niveau les requêtes HTTP vers les connexions WebSocket. Nous pouvons utiliser la fonction Upgrade pour mettre à niveau la connexion HTTP vers une connexion WebSocket. 🎜rrreee🎜Dans le code ci-dessus, nous appelons d'abord la fonction upgrader.Upgrade pour mettre à niveau la connexion HTTP vers une connexion WebSocket. Ensuite, nous interagissons avec le navigateur via l'objet conn. Avec l'objet conn, nous pouvons utiliser la fonction WriteMessage pour envoyer des messages au navigateur, et utiliser la fonction ReadMessage pour recevoir les messages envoyés par le navigateur. navigateur. 🎜🎜3. WebSocket côté navigateur🎜🎜Afin de démontrer la communication WebSocket entre Golang et le navigateur, nous avons besoin d'une simple page frontale. Voici un exemple de code pour un client WebSocket implémenté en JavaScript : 🎜rrreee🎜Dans le code ci-dessus, nous créons d'abord un objet WebSocket et spécifions l'adresse du serveur. Dans la fonction ws.onopen, nous pouvons implémenter la logique une fois la connexion établie ; dans la fonction ws.onmessage, nous pouvons implémenter la logique après avoir reçu le message ; ws.onclose, nous pouvons implémenter la logique après la fermeture de la connexion. De plus, nous proposons également une fonction sendMessage pour envoyer les messages saisis par l'utilisateur au serveur. 🎜🎜4. Implémenter la messagerie instantanée🎜🎜Avec le code serveur et client de base, nous pouvons commencer à implémenter la fonction de messagerie instantanée. Voici un exemple simple qui démontre qu'après avoir saisi un message dans le navigateur, il est diffusé aux autres clients connectés côté serveur : 🎜rrreee🎜Dans le code ci-dessus, nous utilisons d'abord le conn.ReadMessage fonction pour recevoir le message envoyé par le navigateur. Ensuite, nous parcourons tous les clients connectés et diffusons le message à l'aide de la fonction c.WriteMessage. 🎜🎜5. Résumé🎜🎜Cet article présente comment utiliser Golang pour intégrer WebSocket et implémenter des fonctions de messagerie instantanée dans le navigateur. Nous avons d'abord introduit le package net/http de Golang et créé un serveur simple. Ensuite, nous utilisons la fonction Upgrade fournie par le package net/http pour mettre à niveau la requête HTTP vers une connexion WebSocket. Enfin, nous utilisons JavaScript pour créer un objet WebSocket dans le navigateur et implémenter la logique d'établissement d'une connexion, de réception de messages et d'envoi de messages. 🎜🎜J'espère que cet article pourra vous aider à comprendre comment mettre en œuvre une communication instantanée avec le navigateur dans Golang. Si cela vous intéresse, vous pouvez essayer des fonctionnalités WebSocket plus avancées, telles que l'authentification des messages, la compression des messages, etc. Bonne chance dans votre voyage d’exploration de Golang et WebSocket ! 🎜

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!