So implementieren Sie WebSocket in Golang

In einer Zeit, in der moderne Frontends immer mehr Wert auf Echtzeit und Interaktivität legen, ist ein Netzwerkkommunikationsprotokoll immer beliebter geworden: WebSocket. In der Verwendung weisen WebSocket und HTTP gewisse Ähnlichkeiten auf, aber im Gegensatz zu herkömmlichen HTTP-Anfragen kann WebSocket Verbindungen über einen langen Zeitraum aufrechterhalten. Wenn Sie erwägen, WebSocket zum Erstellen einer Webanwendung zu verwenden, müssen Sie möglicherweise eine Programmiersprache verwenden, um diese zu implementieren. Unter ihnen ist Golang eine der beliebtesten Programmiersprachen. Lassen Sie uns lernen, wie man WebSocket in Golang implementiert.

1. Was ist WebSocket?

WebSocket ist ein Netzwerkprotokoll, das bidirektionale Kommunikation über eine einzige TCP-Verbindung ermöglicht. Beim herkömmlichen HTTP-Protokoll wird die Anforderung vom Browser an den Server gesendet und der Server gibt das Ergebnis nach der Verarbeitung an den Browser zurück. Nach Abschluss der Anforderungsverarbeitung wird die Verbindung geschlossen . Das WebSocket-Protokoll ist anders. Wenn der Browser eine Verbindung mit dem Server herstellt, bleibt die Verbindung bestehen, bis der Benutzer oder der Server beschließt, die Verbindung zu schließen. Dies bedeutet, dass der Server jederzeit Informationen an den Client senden kann, während die Verbindung aufrechterhalten wird, ohne auf eine Anfrage des Browsers warten zu müssen.

2. Golang implementiert WebSocket

Golang ist eine Programmiersprache, die die gleichzeitige Programmierung unterstützt. Ihr Vorteil liegt in ihrer Betriebseffizienz und dem extrem geringen Speicherverbrauch. Im Folgenden stellen wir vor, wie Sie WebSocket mit Golang implementieren.

1. Installieren Sie die Gorilla WebSocket-Bibliothek
   Gorilla WebSocket ist eine beliebte WebSocket-Bibliothek, die eine einfache und benutzerfreundliche API zum Erstellen und Verwalten von WebSocket-Verbindungen bietet. Bevor Sie die Gorilla WebSocket-Bibliothek installieren, müssen Sie zuerst die Go-Umgebung installieren. Nachdem die Go-Installation abgeschlossen ist, verwenden Sie den folgenden Befehl, um die Gorilla WebSocket-Bibliothek zu installieren:

   go get github.com/gorilla/websocket

   Nach dem Login kopieren
2. Code schreiben

Im Folgenden verwenden wir Go und die Gorilla WebSocket-Bibliothek zur Implementierung eines einfachen Chatrooms. In unseren Chatrooms können Benutzer Nachrichten senden und Nachrichten anderer Benutzer anzeigen. Das Folgende ist der Code zum Implementieren des WebSocket-Chatrooms:

package main

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

var clients = make(map[*websocket.Conn]bool)
var broadcast = make(chan Message)
var upgrader = websocket.Upgrader{}

// Message struct
type Message struct {
    Username string `json:"username"`
    Body     string `json:"body"`
}

func main() {
    // Configure websocket route
    http.HandleFunc("/ws", handleConnections)

    // Start listening for incoming chat messages
    go handleMessages()

    // Start the server on localhost port 8080 and log any errors
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal("ListenAndServe: ", err)
    }
}

func handleConnections(w http.ResponseWriter, r *http.Request) {
    // Upgrade initial GET request to a websocket
    ws, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Fatal(err)
    }
    // Make sure we close the connection when the function returns
    defer ws.Close()

    // Register our new client
    clients[ws] = true

    for {
        var msg Message
        // Read in a new message as JSON and map it to a Message object
        err := ws.ReadJSON(&msg)
        if err != nil {
            log.Printf("error: %v", err)
            delete(clients, ws)
            break
        }
        // Send the newly received message to the broadcast channel
        broadcast <- msg
    }
}

func handleMessages() {
    for {
        // Grab the next message from the broadcast channel
        msg := <-broadcast
        // Send it out to every client that is currently connected
        for client := range clients {
            err := client.WriteJSON(msg)
            if err != nil {
                log.Printf("error: %v", err)
                client.Close()
                delete(clients, client)
            }
        }
    }
}

Die Hauptidee des Codes besteht darin, eine WebSocket-Verbindung zu erstellen und sie zur clients-Liste hinzuzufügen, und alle Nachrichten werden geschrieben an den Broadcast-Kanal gesendet und an alle Clients in einer anderen Goroutine gesendet. Jede Verbindung empfängt Nachrichten durch Lesen und Zuweisen von Message-Objekten. Der Beispielcode für den Client zum Senden einer Nachricht lautet wie folgt: clients 列表中，任何消息都会被写入到 broadcast 通道中，并在另一个 goroutine 中发送到所有客户端。每个连接通过读取和分配 Message 对象来接收消息。客户端发送消息的示例代码如下：

let socket = new WebSocket("ws://localhost:8080/ws");

socket.addEventListener("open", function() {
  socket.send(JSON.stringify({
    "username": "John",
    "body": "Hello World!"
  }));
});

socket.addEventListener("message", function(event) {
  console.log("Received: " + event.data);
});

在这个示例中，我们首先创建一个 WebSocket 对象并将其连接到服务器。在连接成功后，我们发送一个 JSON 作为消息体。服务端发送消息给客户端时，我们需要在客户端的 JavaScript 代码中监听 messagerrreee

Das obige ist der detaillierte Inhalt vonSo implementieren Sie WebSocket in Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!