So starten und schließen Sie eine Websocket-Verbindung in Golang

Websocket ist ein Netzwerkprotokoll, das eine bidirektionale Echtzeitkommunikation zwischen Client und Server ermöglicht. Es kann gleichzeitig eine effiziente Datenübertragung und Interaktionseffekte mit geringer Latenz erzielen, ohne HTTP-Abfragen zu verwenden. Golang ist eine Open-Source-Hochleistungsprogrammiersprache mit hervorragender Parallelitätsleistung und hervorragender Codequalität. Auch in der Websocket-Kommunikation verfügt Golang über hervorragende Implementierungsmethoden. In diesem Artikel erfahren Sie, wie Sie Websocket-Verbindungen in Golang starten und schließen.

Implementierung von Websocket in Golang

Um Websocket in Golang zu implementieren, müssen Sie die folgenden Schritte ausführen:

1. Importieren des entsprechenden Pakets

In der Go-Sprache erfordert die Implementierung von Websocket die Unterstützung von WebSocket- und HTTP-Paketen. Der Code lautet wie folgt:

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

Unter diesen ist github.com/gorilla/websocket ein hervorragendes WebSocket-Paket, das mehrere Protokolle unterstützt. Es enthält einige WebSocket-bezogene Strukturen und Funktionen, mit denen wir schnell eine WebSocket-Verbindung implementieren können.

2. WebSocket-Verbindungsverarbeitungsfunktion definieren

In der Funktion, die WebSocket-Verbindungen verarbeitet, müssen wir die folgenden Aufgaben ausführen:

a. WebSocket-Upgrade definieren

Für eine HTTP-Anfrage, wenn wir auf eine WebSocket-Verbindung aktualisieren müssen , müssen wir es verarbeiten und die entsprechende Upgrade-Anfrage zurücksenden. Der Code lautet wie folgt:

var upgrader = websocket.Upgrader{
    ReadBufferSize:  1024,
    WriteBufferSize: 1024,
    CheckOrigin: func(r *http.Request) bool {
        return true
    },
}

func websocketHandler(w http.ResponseWriter, r *http.Request) {
    // 升级为WebSocket连接
    ws, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println(err)
        return
    }
    
    // 实现WebSocket通信
    ...
}

In diesem Code verwenden wir die Upgrader-Struktur, die Funktion in der Gorilla/Websocket-Bibliothek zur Implementierung des WebSocket-Upgrades.

Upgrader umfasst Lese- und Schreibpuffergröße und CheckOrigin-Funktion. Mit CheckOrigin wird überprüft, ob die Anfrage von einer legitimen Quelle stammt. Wenn diese Methode „false“ zurückgibt, wird die Upgrade-Anfrage abgelehnt. Da wir in diesem Beispiel die Gültigkeit nicht überprüfen müssen, gibt unser CheckOrigin immer true zurück.

Nach dem Aufruf der Upgrader.Upgrade-Methode erhalten wir ein WebSocket-Objekt ws. Für dieses Objekt können wir Methoden wie ReadMessage und WriteMessage aufrufen, um die nachfolgende WebSocket-Kommunikation abzuschließen.

b. WebSocket-Nachrichten lesen

Nachdem wir die WebSocket-Verbindung hergestellt haben, müssen wir die vom Client gesendeten Nachrichten kontinuierlich lesen. Um WebSocket-Nachrichten zu lesen, können Sie die ReadMessage-Methode verwenden. Der Code lautet wie folgt:

func websocketHandler(w http.ResponseWriter, r *http.Request) {
    ...
    
    for {
        // 读取消息
        _, message, err := ws.ReadMessage()
        if err != nil {
            log.Println(err)
            break
        }
        
        // 处理消息
        ...
    }
}

In diesem Code verwenden wir eine for-Schleife, um kontinuierlich Nachrichten von WebSocket zu lesen. Wenn der Lesevorgang fehlschlägt, wurde die WebSocket-Verbindung geschlossen und wir verlassen die Schleife.

c. WebSocket-Nachricht senden

Nach der Verarbeitung der vom Client gesendeten Nachricht müssen wir möglicherweise einige Verarbeitungsergebnisse an den Client senden. Zum Senden von WebSocket-Nachrichten können Sie die Methode WriteMessage verwenden. Der Code lautet wie folgt:

func websocketHandler(w http.ResponseWriter, r *http.Request) {
    ...
    
    for {
        ...
        
        // 发送消息
        err = ws.WriteMessage(websocket.TextMessage, []byte(reply))
        if err != nil {
            log.Println(err)
            break
        }
    }
}

In diesem Code senden wir über die WriteMessage-Methode eine Nachricht an den Client. Der erste Parameter dieser Methode ist der Nachrichtentyp, den wir als TextMessage oder BinaryMessage angeben können; der zweite Parameter ist ein Byte-Array, das die zu sendenden Daten enthält.

3. Starten Sie den WebSocket-Dienst

Nach Abschluss der oben genannten Schritte können wir einen WebSocket-Dienst starten. Der Code lautet wie folgt:

func main() {
    http.HandleFunc("/ws", websocketHandler)
    log.Println("Server started at http://127.0.0.1:8080")
    http.ListenAndServe(":8080", nil)
}

In diesem Code rufen wir die Funktion http.HandleFunc auf, um den Pfad „/ws“ unserer WebSocket-Verarbeitungsfunktion websocketHandler zuzuordnen. Zum Schluss rufen wir http.ListenAndServe auf, um den Dienst zu starten.

WebSocket-Verbindung schließen

Nach der Verwendung von WebSocket müssen wir die Verbindung manuell schließen. Um die WebSocket-Verbindung normal zu schließen, müssen Sie die folgenden Punkte beachten:

a. Die Serverseite schließt aktiv.

Wenn die Serverseite die WebSocket-Verbindung schließen muss, kann sie die Methode WebSocket.Close aufrufen. Der Code lautet wie folgt:

func websocketHandler(w http.ResponseWriter, r *http.Request) {
    defer ws.Close() // 关闭WebSocket连接
    
    for {
        ...
    }
}

In diesem Code verwenden wir die Defer-Anweisung, um die WebSocket-Verbindung am Ende der Websocket-Funktion automatisch zu schließen.

b. Client schließt aktiv

Wenn der Client die WebSocket-Verbindung schließen muss, kann er eine Close-Nachricht an den Server senden. Der Server empfängt die Close-Nachricht und schließt nach Erhalt der Nachricht aktiv die WebSocket-Verbindung.

Wir können einen Zweig hinzufügen, um die Schließnachricht in der serverseitigen Websocket-Funktion zu verarbeiten. Der Code lautet wie folgt:

func websocketHandler(w http.ResponseWriter, r *http.Request) {
    ...
    
    for {
        // 读取消息
        messageType, message, err := ws.ReadMessage()
        if err != nil {
            log.Println(err)
            break
        }
        
        // 处理消息
        switch messageType {
        case websocket.CloseMessage:
            // 收到关闭消息，关闭连接
            return
        case websocket.TextMessage:
            // 收到文本消息，处理消息
            ...
        case websocket.BinaryMessage:
            ...
        }
    }
    
    // 关闭WebSocket连接
    ws.Close()
}

In diesem Code fügen wir einen Verarbeitungszweig mit dem Nachrichtentyp CloseMessage hinzu. Nach Erhalt der Close-Nachricht beenden wir sofort die WebSocket-Funktion und schließen die WebSocket-Verbindung.

c. Abnormales Schließen

Wenn eine Anomalie in der WebSocket-Verbindung auftritt, muss die Verbindung rechtzeitig geschlossen werden. Wenn beispielsweise die Netzwerkverbindung unterbrochen wird, die Verbindung zwischen Client und Server eine Zeitüberschreitung erfährt usw., muss die WebSocket-Verbindung geschlossen werden.

Wir können die Ausnahme in der WebSocket-Funktion abfangen und die WebSocket-Verbindung schließen, wenn die Ausnahme abgefangen wird. Der Code lautet wie folgt:

func websocketHandler(w http.ResponseWriter, r *http.Request) {
    defer ws.Close() // 当函数退出时关掉WebSocket连接
    
    for {
        _, message, err := ws.ReadMessage()
        if err != nil {
            if websocket.IsUnexpectedCloseError(err, websocket.CloseGoingAway) {
                log.Printf("error: %v", err)
            }
            break
        }
        
        // 处理消息
        ...
    }
}

In diesem Code schließen wir die WebSocket-Verbindung manuell über die Defer-Anweisung, bevor die Websocket-Funktion zurückkehrt. Im ReadMessage-Vorgang haben wir die Möglichkeit hinzugefügt, Ausnahmefehler zu erfassen und eine Protokollausgabe durchzuführen.

Zusammenfassung

In Golang kann die Websocket-Verbindung über die Gorilla/Websocket-Bibliothek hergestellt werden. Wir können die Upgrader-Struktur in der Verarbeitungsfunktion der WebSocket-Kommunikation verwenden, um das HTTP-Protokoll auf WebSocket zu aktualisieren. Beim Herstellen einer Verbindung zu WebSocket müssen wir einige Lese- und Sendevorgänge für WebSocket-Nachrichten implementieren.

Um das normale Schließen der WebSocket-Verbindung sicherzustellen, müssen wir auf folgende Punkte achten:

1. Der Server muss die WebSocket-Verbindung nach Abschluss des Vorgangs manuell schließen.
2. Wenn der Client die Schließmeldung erhält, sollte der Server die WebSocket-Verbindung sofort schließen.
3. Wenn eine Ausnahme in der WebSocket-Verbindung auftritt, muss die Verbindung unterbrochen werden wurde sofort geschlossen, nachdem die Ausnahme erkannt wurde.

Das obige ist der detaillierte Inhalt vonSo starten und schließen Sie eine Websocket-Verbindung in Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!