Comment la fonction « net.Conn.Read » de Go gère-t-elle les limites des messages TCP ?

Comprendre la fonction de lecture dans Go pour les sockets TCP

En ce qui concerne les sockets TCP persistants, l'un des aspects cruciaux est la gestion des données entrantes efficacement. La fonction net.Conn.Read est couramment utilisée à cette fin, mais elle soulève des questions sur la façon dont elle détermine les limites des messages.

Cadre des messages TCP

Contrairement aux autres protocoles de communication , TCP ne fournit pas intrinsèquement de cadrage de message. Il traite les données comme un flux continu d'octets sans aucun délimiteur indiquant les limites des messages. Par conséquent, il est de la responsabilité de la couche application de définir et de mettre en œuvre un mécanisme de cadrage.

Approche de Go

L'implémentation de net.Conn par Go suppose que le cadrage des messages est géré au niveau le niveau de l’application. Il permet aux applications de lire un flux d'octets bruts et de l'interpréter en fonction de leurs protocoles définis.

Exemple d'utilisation

Le code fourni dans la question montre comment recevoir des données en utilisant net.Conn.Read en boucle :

func (tcpSocket *TCPServer) HandleConnection(conn net.Conn) {
    for {
        // Read message size and data without any message framing
        messageSize, err := conn.Read(recieveBuffer)
        if err != nil {
            return
        }
        // ...
    }
}

Le problème se pose car le code ne définit pas explicitement comment la taille du message est déterminée dans le délai reçu flux d'octets.

Solution : Bufio Reader et analyse manuelle

Pour résoudre ce problème, il est recommandé d'envelopper la connexion TCP dans un bufio.Reader. Cela fournit des méthodes plus efficaces et plus pratiques pour analyser le flux. Un exemple de la façon dont vous pourriez implémenter le cadrage des messages à l'aide d'un bufio.Reader :

buff := make([]byte, 50)
c := bufio.NewReader(conn)

for {
    // Read message length from the first byte
    size, err := c.ReadByte()
    if err != nil {
        return err
    }
    // Read the remaining message data
    _, err := io.ReadFull(c, buff[:int(size)])
    if err != nil {
        return err
    }
    fmt.Printf("Received %x\n", buff[:int(size)])
}

Dans cet exemple, nous lisons d'abord un seul octet pour déterminer la taille du message. Ensuite, nous utilisons io.ReadFull pour lire les octets restants du message. Cette approche fournit un cadrage de message explicite et nous permet de travailler avec des messages de différentes tailles.

En comprenant comment fonctionne le cadrage de message TCP et en utilisant des outils appropriés comme bufio.Reader, vous pouvez gérer efficacement les données entrantes sur les sockets TCP persistants dans Allez-y.

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!