Comment gérer efficacement les connexions TCP persistantes et le cadrage des données dans Go ?

Comment gérer les sockets TCP persistants avec net.Conn.Read in Go

Introduction :

Gérer les connexions TCP persistantes in Go implique de gérer efficacement les données entrantes. Cet article aborde les idées fausses courantes sur net.Conn.Read et fournit une solution pratique pour analyser les données d'une connexion TCP basée sur un flux.

Comprendre le cadrage de données TCP :

TCP est un protocole basé sur un flux qui ne fournit aucun cadrage de message. Cela signifie que la détermination des limites des messages individuels dans le flux de données entrant relève de la responsabilité de l'application.

Idée fausse courante :

Une idée fausse courante est que net.Conn .Read connaît automatiquement la fin d'un message et continue en conséquence. Cependant, ce n'est pas le cas.

Cadre de message personnalisé :

Pour analyser efficacement les données d'un flux TCP, un protocole de cadrage de message personnalisé doit être défini. Ceci peut être réalisé en ajoutant un en-tête à chaque message qui indique sa longueur.

bufio.Reader pour améliorer l'efficacité :

Pour améliorer l'efficacité de la lecture et fournir des méthodes supplémentaires pour l'analyse, il est recommandé d'envelopper la connexion dans un bufio.Reader.

Solution :

L'extrait de code suivant fournit un exemple de la façon d'analyser les messages avec un cadrage personnalisé :

import (
    "bufio"
    "fmt"
    "io"
    "net"
)

func main() {
    ln, err := net.Listen("tcp", ":8080")
    if err != nil {
        fmt.Println(err)
        return
    }

    for {
        conn, err := ln.Accept()
        if err != nil {
            fmt.Println(err)
            return
        }

        // Wrap the connection in a bufio.Reader
        br := bufio.NewReader(conn)

        for {
            // Read a single byte containing the message length
            size, err := br.ReadByte()
            if err != nil {
                fmt.Println(err)
                return
            }

            // Read the full message
            buff := make([]byte, size)
            _, err = io.ReadFull(br, buff)
            if err != nil {
                fmt.Println(err)
                return
            }

            fmt.Printf("Received: %x\n", buff)
        }
    }
}

Conclusion :

En définissant un protocole de cadrage de message personnalisé et en utilisant bufio.Reader, il est possible de gérer efficacement les sockets TCP persistants dans Go. Cette approche permet une analyse efficace des données et une communication robuste sur les flux 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!