Comment programmer avec TCP en Go ?

Le langage Go est un langage de programmation puissant qui fournit de nombreuses bibliothèques de programmation réseau, notamment des sockets TCP/IP. Cet article présente principalement comment utiliser le langage Go pour la programmation TCP.

1. TCP/IP

TCP/IP est une suite de protocoles, qui constitue la base de la communication réseau et le protocole principal d'Internet. Il est responsable de la transmission des données dans le réseau. Il comprend deux protocoles, TCP et IP, qui assurent la fiabilité de la transmission des datagrammes, et IP est responsable du transfert de la transmission des datagrammes.

2. Programmation TCP en Go

Le package net en langage Go fournit des API liées à la programmation TCP, qui incluent principalement les fonctions suivantes :

1. net.DialTCP() : Créer une connexion TCP
2. net. ) : écoute un port TCP ;
3. net.TCPConn() : représente une connexion TCP.

Ci-dessous, nous présenterons comment utiliser ces fonctions pour la programmation TCP.

1. Établir une connexion TCP

Le client peut utiliser la fonction net.DialTCP() pour établir une connexion TCP avec le serveur. Voici un exemple de code :

package main

import (
    "fmt"
    "net"
)

func main() {
    conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
        IP:   net.IPv4(127, 0, 0, 1),
        Port: 9999,
    })
    if err != nil {
        fmt.Println(err)
        return
    }
    defer conn.Close()

    fmt.Println("Connected!")
}

Dans le code ci-dessus, le premier paramètre de la fonction DialTCP() est la chaîne "tcp" indiquant le type de protocole réseau, et le deuxième paramètre est une structure d'adresse utilisée pour spécifier la destination de la connexion. . Nous spécifions ici une connexion au port 9999 sur l'adresse IP locale 127.0.0.1. Si la connexion réussit, « Connecté ! » sera affiché.

2. Écouter le port TCP

Le serveur peut utiliser la fonction net.ListenTCP() pour écouter un port TCP spécifique. Voici un exemple de code :

package main

import (
    "fmt"
    "net"
)

func main() {
    tcpListener, err := net.ListenTCP("tcp", &net.TCPAddr{
        IP:   net.IPv4(0, 0, 0, 0),
        Port: 9999,
    })
    if err != nil {
        fmt.Println(err)
        return
    }
    defer tcpListener.Close()

    fmt.Println("Listening on port", 9999)
    for {
        conn, err := tcpListener.AcceptTCP()
        if err != nil {
            fmt.Println(err)
            continue
        }

        fmt.Println("New client connected.")
        go handleClient(conn)
    }
}

func handleClient(conn *net.TCPConn) {
    defer conn.Close()
    // TODO: 处理客户端请求
}

Dans le code ci-dessus, le premier paramètre de la fonction ListenTCP() est la chaîne "tcp" indiquant le type de protocole réseau, et le deuxième paramètre est une structure d'adresse utilisée pour spécifier l'adresse IP d'écoute. adresse et numéro de port. Ici, nous spécifions le port 9999 pour écouter sur toutes les adresses IP. Si l'écoute réussit, « Écoute sur le port 9999 » sera affiché.

Ensuite, nous appelons la fonction AcceptTCP() dans une boucle infinie pour attendre que le client se connecte. Lorsqu'un client est connecté, une nouvelle goroutine sera créée pour gérer la demande du client et "Nouveau client connecté sera affiché sur la console".

3. Traitement des connexions TCP

Le code de traitement des connexions TCP est souvent plus complexe. De manière générale, nous devons utiliser la fonction bufio.NewReader() pour lire les données de requête du client, puis utiliser la fonction bufio.NewWriter() pour écrire les données de réponse.

Voici l'exemple de code pour gérer la connexion TCP :

func handleClient(conn *net.TCPConn) {
    defer conn.Close()

    // 读取客户端请求
    reader := bufio.NewReader(conn)
    req, err := reader.ReadString('
')
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("Received request:", req)

    // 发送响应数据
    writer := bufio.NewWriter(conn)
    resp := "Hello, client!
"
    _, err = writer.WriteString(resp)
    if err != nil {
        fmt.Println(err)
        return
    }
    writer.Flush()
}

Dans le code ci-dessus, nous créons d'abord un objet bufio.NewReader() pour lire la requête du client. Après avoir lu les données, nous créons un objet bufio.NewWriter() pour écrire les données de réponse. Notez que l'utilisation de la fonction bufio.NewWriter() pour créer un rédacteur peut mettre en cache les données de sortie et améliorer les performances.

Enfin, nous utilisons la fonction WriteString() pour écrire les données de réponse dans l'écrivain et appelons la fonction Flush() pour envoyer les données du tampon.

3. Exemple complet

Enfin, nous démontrons un exemple complet de programmation TCP, comprenant le client et le serveur :

Code serveur :

package main

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

func main() {
    tcpListener, err := net.ListenTCP("tcp", &net.TCPAddr{
        IP:   net.IPv4(0, 0, 0, 0),
        Port: 9999,
    })
    if err != nil {
        fmt.Println(err)
        return
    }
    defer tcpListener.Close()

    fmt.Println("Listening on port", 9999)
    for {
        conn, err := tcpListener.AcceptTCP()
        if err != nil {
            fmt.Println(err)
            continue
        }

        fmt.Println("New client connected.")
        go handleClient(conn)
    }
}

func handleClient(conn *net.TCPConn) {
    defer conn.Close()

    // 读取客户端请求
    reader := bufio.NewReader(conn)
    req, err := reader.ReadString('
')
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("Received request:", req)

    // 发送响应数据
    writer := bufio.NewWriter(conn)
    resp := "Hello, client!
"
    _, err = writer.WriteString(resp)
    if err != nil {
        fmt.Println(err)
        return
    }
    writer.Flush()
}

Code client :

package main

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

func main() {
    conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
        IP:   net.IPv4(127, 0, 0, 1),
        Port: 9999,
    })
    if err != nil {
        fmt.Println(err)
        return
    }
    defer conn.Close()

    // 发送请求数据
    writer := bufio.NewWriter(conn)
    req := "Hello, server!
"
    _, err = writer.WriteString(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    writer.Flush()

    // 接收响应数据
    reader := bufio.NewReader(conn)
    resp, err := reader.ReadString('
')
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("Received response:", resp)
}

Dans le code ci-dessus, le serveur écoute d'abord le port 9999 et puis attendez les connexions client. Lorsque le client se connecte, le serveur lit la demande du client puis envoie les données de réponse.

Le client établit d'abord une connexion TCP avec le serveur, puis envoie les données de requête au serveur. Après avoir envoyé la demande, le client attend de recevoir les données de réponse du serveur.

4. Résumé

Cet article présente comment utiliser le langage Go pour la programmation TCP. Nous avons appris les bases du protocole TCP/IP, puis avons présenté la méthode d'implémentation de la programmation TCP dans le langage Go à l'aide de l'API fournie par le package net. En même temps, cet article fournit un exemple complet, j'espère qu'il sera utile aux lecteurs.

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!