Wie verwende ich WebSocket in Go?

In den letzten Jahren ist die WebSocket-Technologie zu einem unverzichtbaren Bestandteil der Webentwicklung geworden. WebSocket ist ein Protokoll für die Vollduplex-Kommunikation über eine einzelne TCP-Verbindung, das die Kommunikation zwischen Client und Server reibungsloser und effizienter macht. Heutzutage verwenden viele moderne Webanwendungen die WebSocket-Technologie, beispielsweise Echtzeit-Chat, Online-Spiele und Echtzeit-Datenvisualisierung.

Als moderne Programmiersprache bietet die Go-Sprache natürlich eine gute Unterstützung für die WebSocket-Technologie. In diesem Artikel werden wir uns eingehend mit der Verwendung der WebSocket-Technologie in Go befassen.

Implementierung von WebSocket in der Go-Sprache

Das WebSocket-Protokoll ist ein aktualisiertes Protokoll von HTTP, sodass die Verwendung von WebSocket in der Go-Sprache auch eine Kombination mit dem HTTP-Protokoll erfordert. Die Go-Sprache verfügt über ein integriertes net/http-Paket, das verschiedene HTTP-bezogene Funktionen bereitstellt. Wenn wir WebSocket in Go verwenden möchten, importieren Sie einfach die Bibliotheken net/http und github.com/gorilla/websocket. net/http包，该包提供了各种HTTP相关的功能。如果我们想要在Go中使用WebSocket，只需导入net/http和github.com/gorilla/websocket库即可。

下面，我们就来看一下如何使用github.com/gorilla/websocket库来实现WebSocket。

创建WebSocket服务端

在Go语言中，创建WebSocket服务端的方式也比较简单。我们直接看下列代码，它展示了如何创建一个HTTP服务器，等待客户端的WebSocket连接：

package main

import (
    "fmt"
    "log"
    "net/http"
    "github.com/gorilla/websocket"
)

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
}

func main() {
    http.HandleFunc("/ws", handleWebSocket)
    http.ListenAndServe(":8080", nil)
}

func handleWebSocket(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)
            return
        }
        log.Printf("Received message: %s
", message)

        err = conn.WriteMessage(messageType, message)
        if err != nil {
            log.Println(err)
            return
        }
        log.Printf("Sent message: %s
", message)
    }
}

在上面的代码中，我们首先创建了一个websocket.Upgrader对象，它负责将传入的HTTP连接升级为WebSocket连接。然后，我们创建了一个handleWebSocket函数，它会在客户端进行连接时被调用。该函数会先将传入的HTTP连接升级为WebSocket连接，然后进入循环，不断地接收来自客户端的信息，并将接收到的信息回传给客户端。其中，conn.ReadMessage()和conn.WriteMessage()分别用于读取和写入信息。

最后，我们将该handleWebSocket函数绑定到/ws路由上，并启动了HTTP服务器，以便客户端可以连接到该WebSocket服务器。如果一切正常，当我们启动上述代码后，您会看到类似如下输出：

2021/10/13 15:20:06 http: Server started at http://127.0.0.1:8080

这意味着您已经成功地创建了一个WebSocket服务器，客户端可以通过ws://localhost:8080/ws地址来连接该服务器。

创建WebSocket客户端

与创建WebSocket服务端类似，我们也可以很容易地在Go语言中创建一个WebSocket客户端。我们来看下面的代码，它描述了如何创建一个与WebSocket服务器建立连接的客户端：

package main

import (
    "fmt"
    "log"
    "net/url"
    "os"
    "os/signal"
    "syscall"
    "github.com/gorilla/websocket"
)

func main() {
    interrupt := make(chan os.Signal, 1)
    signal.Notify(interrupt, os.Interrupt, syscall.SIGTERM)

    u := url.URL{Scheme: "ws", Host: "localhost:8080", Path: "/ws"}
    log.Printf("Connecting to %s", u.String())

    conn, _, err := websocket.DefaultDialer.Dial(u.String(), nil)
    if err != nil {
        log.Fatal("dial:", err)
    }
    defer conn.Close()

    done := make(chan struct{})
    go func() {
        defer close(done)
        for {
            messageType, message, err := conn.ReadMessage()
            if err != nil {
                log.Println("read:", err)
                return
            }
            log.Printf("Received message: %s
", message)
            if err := conn.WriteMessage(messageType, message); err != nil {
                log.Println("write:", err)
                return
            }
            log.Printf("Sent message: %s
", message)
        }
    }()

    for {
        select {
        case <-done:
            return
        case <-interrupt:
            log.Println("interrupt")

            if err := conn.WriteMessage(websocket.CloseMessage, websocket.FormatCloseMessage(websocket.CloseNormalClosure, "")); err != nil {
                log.Println("write close:", err)
                return
            }
            select {
            case <-done:
            case <-time.After(time.Second):
            }
            return
        }
    }
}

在上面的代码中，我们使用websocket.Dial方法来与WebSocket服务器建立连接。建立连接后，我们再进入一个无限循环，不断地发送和接收来自WebSocket服务器的信息。其中，conn.ReadMessage()和conn.WriteMessage()用于读取和写入信息。

值得注意的是，在上述代码中，我们使用了channels来等待操作完成。如果接收到interrupt信号，我们将使用websocket.CloseMessage消息发送给服务器，以关闭WebSocket连接。

结论

在本文中，我们学习了如何在Go语言中使用github.com/gorilla/websocket

Schauen wir uns nun an, wie man die Bibliothek github.com/gorilla/websocket zum Implementieren von WebSocket verwendet.

Erstellen Sie einen WebSocket-Server🎜🎜In der Go-Sprache ist die Erstellung eines WebSocket-Servers relativ einfach. Schauen wir uns direkt den folgenden Code an, der zeigt, wie man einen HTTP-Server erstellt und auf die WebSocket-Verbindung des Clients wartet: 🎜rrreee🎜Im obigen Code erstellen wir zunächst ein websocket.Upgrader-Objekt Verantwortlich für die Konvertierung eingehender HTTP-Verbindungen werden auf WebSocket-Verbindungen aktualisiert. Dann haben wir eine handleWebSocket-Funktion erstellt, die aufgerufen wird, wenn der Client eine Verbindung herstellt. Diese Funktion aktualisiert zunächst die eingehende HTTP-Verbindung auf eine WebSocket-Verbindung, tritt dann in eine Schleife ein, empfängt kontinuierlich Informationen vom Client und gibt die empfangenen Informationen an den Client zurück. Unter diesen werden conn.ReadMessage() und conn.WriteMessage() zum Lesen bzw. Schreiben von Informationen verwendet. 🎜🎜Schließlich haben wir die Funktion handleWebSocket an die Route /ws gebunden und den HTTP-Server gestartet, damit der Client eine Verbindung zum WebSocket-Server herstellen kann. Wenn alles gut geht, sehen Sie beim Starten des obigen Codes eine Ausgabe ähnlich der folgenden: 🎜rrreee🎜 Das bedeutet, dass Sie erfolgreich einen WebSocket-Server erstellt haben und der Client über ws://localhost darauf zugreifen kann: 8080/ wsAdresse zum Herstellen einer Verbindung zum Server. 🎜🎜Erstellen eines WebSocket-Clients🎜🎜Ähnlich wie beim Erstellen eines WebSocket-Servers können wir auch ganz einfach einen WebSocket-Client in der Go-Sprache erstellen. Schauen wir uns den folgenden Code an, der beschreibt, wie ein Client erstellt wird, der eine Verbindung mit dem WebSocket-Server herstellt: 🎜rrreee🎜 Im obigen Code verwenden wir die Methode websocket.Dial, um eine Verbindung herzustellen der WebSocket-Server. Nachdem die Verbindung hergestellt wurde, treten wir in eine Endlosschleife ein und senden und empfangen ständig Informationen vom WebSocket-Server. Unter anderem werden conn.ReadMessage() und conn.WriteMessage() zum Lesen und Schreiben von Informationen verwendet. 🎜🎜Es ist erwähnenswert, dass wir im obigen Code Kanäle verwenden, um auf den Abschluss des Vorgangs zu warten. Wenn das interrupt-Signal empfangen wird, verwenden wir die Nachricht websocket.CloseMessage, um sie an den Server zu senden, um die WebSocket-Verbindung zu schließen. 🎜🎜Fazit🎜🎜In diesem Artikel haben wir gelernt, wie man WebSocket in der Go-Sprache mithilfe der github.com/gorilla/websocket-Bibliothek implementiert. Der Einsatz der WebSocket-Technologie kann unseren Webanwendungen mehr Dynamik und Interaktion verleihen und die Anwendung moderner und benutzerfreundlicher machen. 🎜🎜Wenn Sie Fragen oder Kommentare zur WebSocket-Technologie und deren Verwendung in der Go-Sprache haben, hinterlassen Sie bitte unten eine Nachricht, um uns Ihre Gedanken mitzuteilen. 🎜

Das obige ist der detaillierte Inhalt vonWie verwende ich WebSocket in Go?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!