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:
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.
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.
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:
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!
