Golang implementiert WebSocket

Mit der kontinuierlichen Weiterentwicklung der Internettechnologie ist die Echtzeitverbindung zu einer wesentlichen Funktion für immer mehr Anwendungen geworden. WebSocket ist ein Netzwerkprotokoll, das auf dem TCP-Protokoll basiert und es dem Server ermöglicht, Daten an den Client zu übertragen, um eine bidirektionale Kommunikation in Echtzeit zu erreichen.

Go ist eine schnelle und effiziente Programmiersprache und hat sich in den letzten Jahren zu einer der beliebtesten Sprachen entwickelt. In diesem Artikel stellen wir vor, wie Sie den WebSocket-Dienst mithilfe der Go-Sprache implementieren.

Was ist WebSocket? Das WebSocket-Protokoll ist ein Vollduplex-Kommunikationsprotokoll, das auf dem TCP-Protokoll basiert und eine Echtzeitkommunikation zwischen dem Client und dem Server ermöglicht. Im Vergleich zum herkömmlichen HTTP-Anforderungs- und Antwortmodus kann WebSocket den Verbindungsstatus nach dem Verbindungsaufbau beibehalten und so eine bidirektionale Kommunikation in Echtzeit erreichen.

Der Workflow des WebSocket-Protokolls ist wie folgt:

Der Client initiiert eine WebSocket-Verbindungsanforderung.

1. Nach Erhalt der Anfrage führt der Server ein Handshake-Protokoll durch, um zu bestätigen, dass die WebSocket-Verbindung verwendet werden kann.
2. Nachdem die WebSocket-Verbindung hergestellt wurde, können Client und Server eine bidirektionale Echtzeitkommunikation durchführen.
3. Wenn der Server Daten an den Client senden muss, kann er diese direkt an den Client senden und umgekehrt.
4. Im Vergleich zu herkömmlichen HTTP-Anfragen bietet WebSocket folgende Vorteile:

Zwei-Wege-Kommunikation in Echtzeit, geeignet für Echtzeit-Anwendungsszenarien wie Online-Spiele, Echtzeit-Chat und Online-Videos.

1. Weniger Anfragen und Antworten, reduzierter Netzwerkbandbreitenverbrauch und verbesserte Datenübertragungseffizienz.
2. Go implementiert WebSocket

Go ist eine aufstrebende Sprache. Aufgrund seiner Einfachheit, Effizienz, Sicherheit und anderer Eigenschaften beginnen immer mehr Teams, Go zur Entwicklung von Netzwerkanwendungen zu verwenden. In Go gibt es eine Standardbibliothek net/http, die APIs zur Implementierung von HTTP- und WebSocket-Diensten bereitstellt.

Stellen Sie eine WebSocket-Verbindung her

Um eine WebSocket-Verbindung herzustellen, müssen wir die folgenden Vorgänge auf dem Server bzw. Client ausführen:

Server

Erstellen Sie einen HTTP-Dienst und verwenden Sie den http.HandleFunc Funktion zum Registrieren eines Routers und ermöglicht der entsprechenden Routing-Verarbeitungsfunktion die Durchführung der WebSocket-Kommunikation.

1. http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
       // 判断是否支持 WebSocket，如果支持则进入 WebSocket 通信处理函数。
       if websocket.IsWebSocketUpgrade(r) {
           websocket.Handler(handleWebSocket).ServeHTTP(w, r)
           return
       }
   
       http.ServeFile(w, r, "index.html")
   })

   http.HandleFunc 函数注册一个路由器，并允许对应的路由处理函数进行 WebSocket 通信。

   func handleWebSocket(conn *websocket.Conn) {
       defer conn.Close()
   
       // 输出日志信息，表示已经建立连接。
       log.Println("WebSocket connected")
   
       for {
           // 读取客户端发送过来的消息。
           _, msg, err := conn.ReadMessage()
           if err != nil {
               log.Println("Read error:", err)
               return
           }
   
           // 输出日志信息，表示接收到客户端发送的消息。
           log.Printf("Received: %s
   ", msg)
   
           // 处理完毕后，发送消息。
           err = conn.WriteMessage(websocket.TextMessage, msg)
           if err != nil {
               log.Println("Write error:", err)
               return
           }
       }
   }

   2. 在 WebSocket 通信处理函数中进行建立连接操作。

   var socket = new WebSocket("ws://127.0.0.1:8080/");
   
   socket.onopen = function() {
     console.log("WebSocket connected");
   };
   
   socket.onmessage = function(event) {
     console.log("Received: " + event.data);
   };
   
   socket.onclose = function(event) {
     console.log("WebSocket closed");
   };
   
   socket.onerror = function(event) {
     console.log("WebSocket error: " + event.data);
   };

   客户端

   在客户端中，我们需要使用 JavaScript 代码进行 WebSocket 连接的操作。具体代码如下：

   socket.send("Hello world");

   发送消息

   当 WebSocket 连接建立后，服务端和客户端就可以进行实时双向通信了。服务端可以通过 conn.WriteMessage 函数向客户端发送消息，客户端可以通过 socket.send 函数向服务端发送消息。

   从客户端发送消息：

   _, msg, err := conn.ReadMessage()
   if err != nil {
       log.Println("Read error:", err)
       return
   }
   
   log.Printf("Received: %s
   ", msg)

   在服务端接收并处理消息：

   err = conn.WriteMessage(websocket.TextMessage, []byte("Hello world"))
   if err != nil {
       log.Println("Write error:", err)
       return
   }

   从服务端发送消息：

   socket.onmessage = function(event) {
       console.log("Received: " + event.data);
   };

   在客户端接收并处理消息：

   defer conn.Close()

   WebSocket 的错误处理

   在实际开发中，WebSocket 可能会出现各种异常情况，例如网络中断、连接超时、服务器崩溃等。在 Go 中，我们可以通过错误处理来处理这些异常情况。

   在服务端中，我们可以通过 defer 语句来进行资源释放，例如关闭 WebSocket 连接等。

   _, msg, err := conn.ReadMessage()
   if err != nil {
       log.Println("Read error:", err)
       return
   }

   同时，在进行 websocket 通信处理函数的过程中，我们需要对可能发生的错误进行预处理。例如：

   socket.onerror = function(event) {
       console.log("WebSocket error: " + event.data);
   };

   在客户端中，我们可以通过 onerrorFühren Sie den Verbindungsaufbauvorgang in der WebSocket-Kommunikationsverarbeitungsfunktion durch.

   rrreee

   Client
   Im Client müssen wir JavaScript-Code verwenden, um die WebSocket-Verbindung zu betreiben. Der spezifische Code lautet wie folgt: 🎜rrreee🎜Nachricht senden🎜🎜Wenn die WebSocket-Verbindung hergestellt ist, können der Server und der Client eine bidirektionale Echtzeitkommunikation durchführen. Der Server kann über die Funktion conn.WriteMessage Nachrichten an den Client senden, und der Client kann über die Funktion socket.send Nachrichten an den Server senden. 🎜🎜Senden Sie eine Nachricht vom Client: 🎜rrreee🎜Empfangen und verarbeiten Sie die Nachricht auf dem Server: 🎜rrreee🎜Senden Sie eine Nachricht vom Server: 🎜rrreee🎜Empfangen und verarbeiten Sie die Nachricht auf dem Client: 🎜rrreee🎜WebSocket-Fehlerbehandlung🎜 🎜In der Praxis Während der Entwicklung kann es bei WebSocket zu verschiedenen ungewöhnlichen Situationen kommen, z. B. zu Netzwerkunterbrechungen, Verbindungszeitüberschreitungen, Serverabstürzen usw. In Go können wir diese Ausnahmen durch Fehlerbehandlung behandeln. 🎜🎜Auf der Serverseite können wir die Anweisung defer verwenden, um Ressourcen freizugeben, z. B. das Schließen der WebSocket-Verbindung usw. 🎜rrreee🎜Gleichzeitig müssen wir während des Prozesses der Websocket-Kommunikationsverarbeitungsfunktion möglicherweise auftretende Fehler vorverarbeiten. Zum Beispiel: 🎜rrreee🎜Im Client können wir WebSocket-Fehler über das Ereignis onerror behandeln, zum Beispiel: 🎜rrreee🎜Zusammenfassung🎜🎜In diesem Artikel wird erläutert, wie Sie die Go-Sprache zum Implementieren von WebSocket-Diensten verwenden. einschließlich Einrichten einer WebSocket-Verbindung, Senden von Nachrichten, Ausnahmebehandlung usw. Das WebSocket-Protokoll bietet eine bidirektionale Echtzeit-Kommunikationsmethode und kann in Echtzeit-Anwendungsszenarien wie Online-Spielen, Echtzeit-Chat und Online-Videos verwendet werden. In Go kann der WebSocket-Dienst einfach mithilfe der API implementiert werden, die von der Standardbibliothek net/http bereitgestellt wird. 🎜

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