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.

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

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

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!