Golang implémente une longue connexion

Avec le développement d'Internet, la technologie des connexions longues a progressivement été appliquée aux communications en réseau. Dans des applications pratiques, nous pouvons avoir besoin de maintenir une connexion de communication à long terme avec le client. Dans ce cas, nous devons utiliser une technologie de connexion longue. En tant que langage de programmation populaire, la concurrence et les hautes performances de Golang en font un excellent choix pour implémenter des connexions longues. Cet article explique comment utiliser Golang pour implémenter des connexions longues.

1. Qu'est-ce qu'une longue connexion ?

Une longue connexion signifie qu'une fois que le client et le serveur ont établi une connexion, ils peuvent transmettre en continu plusieurs paquets de données. A cet égard, le serveur ne se déconnectera pas, mais attendra toujours les nouvelles demandes du client et répondra. Cette méthode de transmission est largement utilisée dans les communications réseau, telles que la messagerie instantanée, les données push du serveur, etc.

Par rapport aux connexions courtes, l'avantage des connexions longues est qu'elles réduisent le temps et les ressources nécessaires à l'établissement et à la déconnexion des connexions, tout en améliorant l'efficacité et la nature en temps réel de la transmission des données.

2. Comment implémenter des connexions longues dans Golang

Il existe trois façons principales d'implémenter des connexions longues dans Golang :

1. Utiliser des connexions longues TCP

L'utilisation de connexions longues TCP pour implémenter des connexions longues dans Golang est la plus courante et manière simple. Créez d'abord une connexion TCP, puis transférez les données dans la connexion, puis la connexion peut être maintenue jusqu'à ce que la connexion soit fermée. Ce qui suit montre le code de base pour utiliser une longue connexion TCP :

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))
   }
}

Dans cet exemple, nous créons une connexion TCP via la fonction net.Dial(), puis passons conn.Write () Envoyer les données au serveur, conn.Read()Lire les données de la connexion. Utilisez une boucle for pour maintenir la connexion continue. 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()

Utilisez une connexion longue WebSocket

WebSocket est un protocole de communication pour la communication en duplex intégral sur une seule connexion TCP, fournissant une interaction basée sur des événements entre le client et le serveur. Dans Golang, vous pouvez utiliser la bibliothèque tierce gorilla/websocket pour implémenter des connexions longues WebSocket. Jetons un coup d'œil au code permettant d'utiliser WebSocket pour implémenter des connexions longues :

rrreee
1. Dans cet exemple, nous utilisons Upgrader pour mettre à niveau la connexion HTTP vers une connexion WebSocket, puis utilisons conn. ReadMessage() et conn.WriteMessage() transmettent des données dans la connexion. Utilisez une boucle for pour maintenir la connexion continue.

Utiliser une connexion longue HTTP

2. La connexion longue HTTP est une technologie de connexion longue basée sur le protocole HTTP. Par rapport à la connexion persistante TCP, la connexion persistante HTTP nécessite l'établissement d'une connexion HTTP, puis les données peuvent être transmises en continu via cette connexion. Dans Golang, vous pouvez utiliser la bibliothèque net/http pour implémenter des connexions HTTP longues. Ce qui suit montre comment utiliser les connexions HTTP longues :
rrreee

Dans cet exemple, nous définissons l'en-tête Connection: keep-alive dans la réponse HTTP pour maintenir la connexion HTTP continue, puis utilisons bufio.NewWriter()Écrit des données sur la connexion à chaque fois.

3. Comment choisir une méthode de connexion à long terme adaptée ?

3. Bien qu'il existe trois façons de mettre en œuvre des connexions longues dans Golang, vous devez choisir la méthode appropriée en fonction des besoins réels. Voici quelques aspects qui nécessitent une attention particulière :

Connexion longue TCP

L'avantage de l'utilisation d'une connexion longue TCP est qu'elle est simple et directe, et permet de réaliser rapidement une connexion longue. Cependant, les longues connexions TCP ne sont pas chiffrées pendant la transmission des données et les paquets de données doivent être assemblés manuellement à chaque fois. Dans le même temps, un protocole personnalisé est requis pour mettre en œuvre la mise en paquets des données et le rappel asynchrone. Il convient aux scénarios dans lesquels la quantité de données et le nombre de connexions sont faibles.

🎜Connexion longue WebSocket🎜🎜🎜La connexion longue WebSocket utilise une manière asynchrone pour transmettre des données, prend en charge le serveur pour transmettre les données au client, la transmission de données est plus flexible et a la capacité de sous-paqueter et de re- emballer. Cependant, la connexion longue WebSocket doit envoyer une requête HTTP lors de la première prise de contact, ce qui est une fois de plus que la requête de connexion longue TCP. 🎜🎜🎜Connexion persistante HTTP🎜🎜🎜La connexion persistante HTTP doit établir une connexion TCP comme une connexion persistante TCP lors de l'établissement de la connexion pour la première fois, mais la maintenance de la connexion peut être contrôlée via l'en-tête HTTP pendant la transmission des données. transmettre plusieurs requêtes et réponses HTTP. Cependant, l'efficacité de la communication des connexions longues HTTP est légèrement inférieure à celle des connexions longues TCP et des connexions longues WebSocket. 🎜🎜IV.Résumé🎜🎜Cet article présente les trois manières d'implémenter des connexions longues dans Golang : les connexions longues TCP, les connexions longues WebSocket et les connexions longues HTTP. Il analyse également leurs avantages respectifs et les scénarios applicables. Dans le développement réel, la méthode appropriée doit être sélectionnée en fonction de scénarios spécifiques. La technologie de connexion à long terme offre de larges perspectives d’application dans des applications pratiques. À l’avenir, nous verrons l’émergence de technologies de connexion à long terme plus efficaces, plus fiables et plus sûres. 🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!