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

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

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

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!