Golang implementiert lange Verbindungen

Mit der Entwicklung des Internets wurde die Langverbindungstechnologie nach und nach in der Netzwerkkommunikation eingesetzt. In praktischen Anwendungen müssen wir möglicherweise eine langfristige Kommunikationsverbindung mit dem Client aufrechterhalten. In diesem Fall müssen wir eine lange Verbindungstechnologie verwenden. Als beliebte Programmiersprache ist Golang aufgrund seiner Parallelität und hohen Leistung eine ausgezeichnete Wahl für die Implementierung langer Verbindungen. In diesem Artikel wird erläutert, wie Sie mit Golang lange Verbindungen implementieren.

1. Was ist eine lange Verbindung?

Eine lange Verbindung bedeutet, dass der Client und der Server kontinuierlich mehrere Datenpakete übertragen können. Dabei trennt der Server die Verbindung nicht, sondern wartet immer auf neue Anfragen des Clients und antwortet. Diese Übertragungsmethode wird häufig in der Netzwerkkommunikation verwendet, beispielsweise bei Instant Messaging, Server-Push-Daten usw.

Im Vergleich zu kurzen Verbindungen besteht der Vorteil langer Verbindungen darin, dass sie den Zeit- und Ressourcenaufwand für den Aufbau und die Trennung von Verbindungen reduzieren und gleichzeitig die Effizienz und Echtzeitcharakteristik der Datenübertragung verbessern.

2. So implementieren Sie lange Verbindungen in Golang

Es gibt drei Hauptmethoden, um lange Verbindungen in Golang zu implementieren:

1. Verwenden von langen TCP-Verbindungen

Die Verwendung langer TCP-Verbindungen zum Implementieren langer Verbindungen in Golang ist die häufigste und einfacher Weg. Erstellen Sie zuerst eine TCP-Verbindung, übertragen Sie dann Daten in der Verbindung und halten Sie die Verbindung dann aufrecht, bis die Verbindung geschlossen wird. Das Folgende zeigt den grundlegenden Code für die Verwendung einer langen TCP-Verbindung:

package main

import (
    "fmt"
    "net"
)

func main() {
   serverAddr := "127.0.0.1:8888"
   conn, err := net.Dial("tcp", serverAddr)
   if err != nil {
       fmt.Println(err)
   }

   for {
       data := []byte("hello world")
       _, err := conn.Write(data)
       if err != nil {
           fmt.Println(err)
           break
       }

       buf := make([]byte, 1024)
       _, err = conn.Read(buf)
       if err != nil {
           fmt.Println(err)
           break
       }

       fmt.Println(string(buf))
   }
}

In diesem Beispiel erstellen wir eine TCP-Verbindung über die Funktion net.Dial() und übergeben dann conn.Write () Daten an den Server senden, conn.Read()Daten aus der Verbindung lesen. Verwenden Sie eine for-Schleife, um die Verbindung kontinuierlich aufrechtzuerhalten. net.Dial()函数创建了一个TCP连接，之后通过conn.Write()向服务端发送数据，conn.Read()从连接中读取数据。使用for循环可以使连接保持持续不断。

2. 使用WebSocket长连接

WebSocket是一种在单个TCP连接上进行全双工通信的通信协议，在客户端和服务器之间提供了一种基于事件的交互方式。golang中可以使用第三方库gorilla/websocket实现WebSocket长连接。下面我们来看一下使用WebSocket实现长连接的代码：

package main

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

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

func echo(w http.ResponseWriter, r *http.Request) {
    conn, err := upgrader.Upgrade(w, r, nil)
    if err != nil {
        log.Println(err)
        return
    }
    for {
        messageType, p, err := conn.ReadMessage()
        if err != nil {
            log.Println(err)
            break
        }
        log.Println(string(p))
        if err = conn.WriteMessage(messageType, p); err != nil {
            log.Println(err)
            break
        }
    }
}

func main() {
    http.HandleFunc("/echo", echo)
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal(err)
    }
}

在这个例子中，我们使用Upgrader将HTTP连接升级为WebSocket连接，之后可以通过conn.ReadMessage()和conn.WriteMessage()在连接中传输数据。使用for循环可以保持连接持续不断。

3. 使用HTTP长连接

HTTP长连接是基于HTTP协议的长连接技术。相对于TCP长连接，HTTP长连接需要建立一个HTTP连接，然后可以通过这个连接一直进行数据传输。golang中可以使用net/http库实现HTTP长连接。下面演示了如何使用HTTP长连接：

package main

import (
    "bufio"
    "fmt"
    "log"
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    if r.Method != "GET" {
        http.Error(w, "Method not allowed", 405)
        return
    }
    fmt.Fprintf(w, "HTTP/1.1 200 OK
")
    fmt.Fprintf(w, "Content-Type: text/plain
")
    fmt.Fprintf(w, "Connection: keep-alive
")
    fmt.Fprintf(w, "
")

    writer := bufio.NewWriter(w)
    for {
        _, err := writer.WriteString("hello world
")
        if err != nil {
            log.Println(err)
            break
        }
        writer.Flush()
    }
}

func main() {
    http.HandleFunc("/", handler)
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal(err)
    }
}

在这个例子中，我们在HTTP响应中设置Connection: keep-alive头部，使得HTTP连接保持持续不断，之后使用bufio.NewWriter()

Verwenden Sie eine lange WebSocket-Verbindung.

WebSocket ist ein Kommunikationsprotokoll für die Vollduplex-Kommunikation über eine einzelne TCP-Verbindung und bietet eine ereignisbasierte Interaktionsmethode zwischen dem Client und dem Server. In Golang können Sie die Drittanbieterbibliothek gorilla/websocket verwenden, um lange WebSocket-Verbindungen zu implementieren. Werfen wir einen Blick auf den Code für die Verwendung von WebSocket zum Implementieren langer Verbindungen:

rrreee
1. In diesem Beispiel verwenden wir Upgrader, um die HTTP-Verbindung auf eine WebSocket-Verbindung zu aktualisieren, und verwenden dann conn. ReadMessage() und conn.WriteMessage() übertragen Daten in der Verbindung. Verwenden Sie eine for-Schleife, um die Verbindung kontinuierlich aufrechtzuerhalten.

Verwenden Sie eine lange HTTP-Verbindung.

2. HTTP-Langverbindung ist eine Technologie für lange Verbindungen, die auf dem HTTP-Protokoll basiert. Im Vergleich zur dauerhaften TCP-Verbindung erfordert die dauerhafte HTTP-Verbindung den Aufbau einer HTTP-Verbindung, und dann können Daten kontinuierlich über diese Verbindung übertragen werden. In Golang können Sie die Bibliothek net/http verwenden, um lange HTTP-Verbindungen zu implementieren. Im Folgenden wird gezeigt, wie lange HTTP-Verbindungen verwendet werden:
rrreee

In diesem Beispiel legen wir den Header Connection: keep-alive in der HTTP-Antwort fest, um die HTTP-Verbindung kontinuierlich aufrechtzuerhalten, und verwenden dann bufio.NewWriter()Schreibt jedes Mal Daten in die Verbindung.

3. Wie wählt man eine geeignete langfristige Verbindungsmethode?

3. Obwohl es drei Möglichkeiten gibt, lange Verbindungen in Golang zu implementieren, müssen Sie die geeignete Methode basierend auf den tatsächlichen Anforderungen auswählen. Hier sind einige Aspekte, die beachtet werden müssen:

TCP-Langverbindung

Der Vorteil der Verwendung einer TCP-Langverbindung besteht darin, dass sie einfach und direkt ist und lange Verbindungen schnell realisiert werden kann. Allerdings werden lange TCP-Verbindungen während der Datenübertragung nicht verschlüsselt. Datenpakete müssen jedes Mal manuell zusammengestellt werden, und es ist ein benutzerdefiniertes Protokoll erforderlich, um die Datenpaketierung und den asynchronen Rückruf zu implementieren. Es eignet sich für Szenarien, in denen die Datenmenge gering und die Anzahl der Verbindungen gering ist.

🎜WebSocket-Long-Verbindung🎜🎜🎜WebSocket-Long-Verbindung verwendet eine asynchrone Methode zur Datenübertragung, unterstützt den Server beim Pushen von Daten an den Client, die Datenübertragung ist flexibler und bietet die Möglichkeit, automatisch Unterpakete zu erstellen und erneut zu senden. Paket. Allerdings muss die lange WebSocket-Verbindung beim ersten Handshake eine HTTP-Anfrage senden, was ein Mal mehr ist als bei der langen TCP-Verbindungsanfrage. 🎜🎜🎜Persistente HTTP-Verbindung🎜🎜🎜Eine persistente HTTP-Verbindung muss beim ersten Verbindungsaufbau wie eine dauerhafte TCP-Verbindung hergestellt werden. Die Aufrechterhaltung der Verbindung kann jedoch während der Datenübertragung über den HTTP-Header gesteuert werden Übertragen Sie mehrere HTTP-Anfragen und -Antworten. Allerdings ist die Kommunikationseffizienz langer HTTP-Verbindungen etwas geringer als die von langen TCP-Verbindungen und langen WebSocket-Verbindungen. 🎜🎜IV. Zusammenfassung🎜🎜In diesem Artikel werden die drei Möglichkeiten zur Implementierung langer Verbindungen in Golang vorgestellt: lange TCP-Verbindungen, lange WebSocket-Verbindungen und lange HTTP-Verbindungen. Außerdem werden ihre jeweiligen Vorteile und anwendbaren Szenarien analysiert. In der tatsächlichen Entwicklung muss die geeignete Methode basierend auf bestimmten Szenarien ausgewählt werden. Die Langzeitverbindungstechnologie hat breite Anwendungsaussichten in praktischen Anwendungen. In Zukunft werden wir die Entstehung effizienterer, zuverlässigerer und sicherer Langzeitverbindungstechnologien erleben. 🎜

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