Golang baut einen WebSocket-Golang-php.cn

Golang ist eine schnell kompilierbare, effiziente und sichere Programmiersprache, die auch in der Webentwicklung weit verbreitet ist. Unter diesen ist die Verwendung von Golang zum Erstellen von Websocket ein sehr beliebtes Anwendungsszenario. In diesem Artikel wird erläutert, wie Sie mit Golang eine Websocket-Anwendung erstellen.

1. Was ist Websocket? Websocket ist ein Protokoll, das den Aufbau einer bidirektionalen Kommunikationsverbindung zwischen dem Browser und dem Server ermöglicht. Das herkömmliche HTTP-Protokoll kann vom Browser nur Anfragen an den Server senden und Antworten vom Server empfangen. Durch die Verwendung von Websocket kann der Server jedoch aktiv Nachrichten an den Browser senden und so eine Vollduplex-Kommunikation zwischen dem Server und dem Browser realisieren.

2. Wie Golang Websocket implementiert: Golang wird mit einer Standardbibliothek net/http geliefert. Dieses Paket stellt eine http.Server-Struktur bereit, mit der ein Web erstellt werden kann Server. Darüber hinaus stellt net/http auch ein Unterpaket websocket bereit, das uns alle Funktionen zur Verfügung stellt, die zum Aufbau eines WebSocket-Servers erforderlich sind.

Herstellen einer WebSocket-Verbindung

Um eine WebSocket-Verbindung herzustellen, muss der Client eine HTTP-Anfrage an den Server senden und den Upgrade-Header tragen, um anzuzeigen, dass die Anfrage aktualisiert wird das WebSocket-Protokoll. Nach Erhalt dieser Anfrage muss der Server den Upgrade-Header überprüfen und ihn entsprechend verarbeiten, je nachdem, ob es sich um eine WebSocket-Anfrage handelt.

Der Server kann die Funktion websocket.IsWebSocketUpgrade verwenden, um zu prüfen, ob es sich bei der Anfrage um eine WebSocket-Anfrage handelt, und die Funktion websocket.Upgrade verwenden, um die Anfrage zu aktualisieren. Nach erfolgreichem Upgrade kann der Server über ein Verbindungsobjekt vom Typ *websocket.Conn mit dem Client kommunizieren. net/http，这个包提供了一个http.Server结构体，它可以用来构建Web服务器。除此之外，net/http也提供了一个websocket子包，它为我们提供了构建WebSocket服务器所需的全部功能。

建立WebSocket连接

要建立WebSocket连接，客户端需要向服务器发送一个HTTP请求，并携带Upgrade头部，指示请求升级为WebSocket协议。服务器端在收到此请求后，需要检查Upgrade头部，并根据是否为WebSocket请求来进行相应的处理。

服务器端可以使用websocket.IsWebSocketUpgrade函数来检查请求是否为WebSocket请求，并使用websocket.Upgrade函数升级请求。升级成功后，服务器就可以通过*websocket.Conn类型的连接对象与客户端进行通信了。

func handler(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println(err)
        return
    }
    defer conn.Close()
    // 使用conn进行通信
}

Nach dem Login kopieren

其中，upgrader是一个websocket.Upgrader类型的变量，通过设置它的属性可以控制WebSocket连接的处理方式。Upgrade函数在升级请求时会阻塞，因此要将其放在goroutine中运行。

发送和接收WebSocket消息

一旦WebSocket连接建立成功，客户端和服务器都可以通过*websocket.Conn对象进行通信。使用这个对象可以发送和接收WebSocket消息。

发送消息很简单，只需要调用WriteMessage方法即可：

err := conn.WriteMessage(websocket.TextMessage, []byte("hello"))

Nach dem Login kopieren

接收消息的方法有三种：

ReadMessage：阻塞读取，直到有消息到来
NextReader：阻塞等待下一个消息到来
NextWriter：返回一个io.WriteCloser对象，可以使用这个对象发送消息

一般使用ReadMessage方法接收WebSocket消息：

_, message, err := conn.ReadMessage()
if err != nil {
    log.Println(err)
    return
}
log.Printf("recv: %s", message)

Nach dem Login kopieren

三、一个简单的WebSocket应用

在这个例子中，我们将创建一个简单的聊天室应用，客户端发送消息之后，服务器将消息广播给所有连接的客户端。

客户端代码：（使用JavaScript）

<!DOCTYPE html>
<html>
<head>
    <title>Chatroom</title>
</head>
<body>
    <input type="text" id="input-message"/>
    <button onclick="sendMessage()">发送</button>
    <ul id="message-list"></ul>

    <script>
        var ws = new WebSocket("ws://localhost:8080/ws");
        ws.onmessage = function(event) {
            var message = event.data;
            var li = document.createElement("li");
            li.appendChild(document.createTextNode(message));
            document.getElementById("message-list").appendChild(li);
        };

        function sendMessage() {
            var message = document.getElementById("input-message").value;
            ws.send(message);
        }
    </script>
</body>
</html>

Nach dem Login kopieren

服务器端代码：

package main

import (
    "fmt"
    "log"
    "net/http"

    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{}

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

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 {
        _, message, err := conn.ReadMessage()
        if err != nil {
            log.Println(err)
            break
        }
        fmt.Printf("recv: %s
", message)

        // 广播给所有客户端
        for _, conn := range conns {
            err := conn.WriteMessage(websocket.TextMessage, message)
            if err != nil {
                log.Println(err)
                break
            }
        }
    }
}

Nach dem Login kopieren

在上面的代码中，我们将所有连接的websocket.Conn对象存储在conns变量中。每当有一个新消息到来时，服务器会将消息广播给所有客户端。

总结

使用Golang搭建WebSocket应用程序非常简单，只需要导入net/http和websocketrrreee

Unter anderem ist upgrader eine Variable vom Typ websocket.Upgrader. Durch Festlegen ihrer Eigenschaften können Sie die Verarbeitungsmethode der WebSocket-Verbindung steuern. Die Funktion Upgrade blockiert das Upgrade der Anfrage und muss daher in einer Goroutine ausgeführt werden. 🎜

WebSocket-Nachrichten senden und empfangen

🎜Sobald die WebSocket-Verbindung erfolgreich hergestellt wurde, können sowohl der Client als auch der Server

*websocket.Conn Objekte kommunizieren. Verwenden Sie dieses Objekt zum Senden und Empfangen von WebSocket-Nachrichten. 🎜🎜Das Senden einer Nachricht ist sehr einfach. Rufen Sie einfach die Methode <code>WriteMessage

auf: 🎜rrreee🎜Es gibt drei Möglichkeiten, Nachrichten zu empfangen: 🎜

ReadMessage: Blockierung Lesen Abrufen, bis eine Nachricht eintrifft
NextReader: Blockiert das Warten auf das Eintreffen der nächsten Nachricht
NextWriter: Gibt einen io .WriteCloser-Objekt, Sie können dieses Objekt zum Senden von Nachrichten verwenden

🎜Verwenden Sie im Allgemeinen die ReadMessage-Methode, um WebSocket-Nachrichten zu empfangen: 🎜rrreee🎜 3. A einfache WebSocket-Anwendung🎜🎜 In diesem Beispiel erstellen wir eine einfache Chatroom-Anwendung. Nachdem der Client eine Nachricht gesendet hat, sendet der Server die Nachricht an alle verbundenen Clients. 🎜🎜Clientseitiger Code: (unter Verwendung von JavaScript) 🎜rrreee🎜Serverseitiger Code: 🎜rrreee🎜Im obigen Code speichern wir alle verbundenen websocket.Conn-Objekte im

conns-Code > variabel. Immer wenn eine neue Nachricht eintrifft, sendet der Server die Nachricht an alle Clients. 🎜🎜Zusammenfassung🎜🎜Es ist sehr einfach, eine WebSocket-Anwendung mit Golang zu erstellen. Sie müssen nur die Pakete <code>net/http

und websocket importieren und die bereitgestellte API direkt verwenden durch die Standardbibliothek, um die Entwicklung von WebSocket-Anwendungen abzuschließen. Ich hoffe, dass dieser Artikel für die Entwicklung von Golang Websocket hilfreich sein kann. 🎜

Das obige ist der detaillierte Inhalt vonGolang baut einen WebSocket. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!