Comment programmer en utilisant UDP dans Go ?

UDP (User Datagram Protocol) est un protocole orienté sans connexion et c'est un protocole très important dans la couche transport. Il peut transmettre des données directement à l'hôte cible sans établir de connexion, il est donc largement utilisé dans la transmission de données en temps réel, les jeux et autres applications, et est plus approprié que TCP dans certains scénarios.

L'utilisation de la programmation UDP en langage Go est également très simple. Cet article explique comment utiliser la programmation UDP en langage Go.

1. Comprendre le datagramme du protocole UDP

Dans le protocole UDP, les données sont encapsulées dans un paquet UDP, également appelé datagramme. Le datagramme contient le numéro de port source, le numéro de port de destination, la longueur, la somme de contrôle et d'autres informations.

En langage Go, UDPConn du package net peut être utilisé pour lire et écrire des datagrammes UDP.

2. Écrire le programme serveur UDP

Dans le programme serveur UDP, vous devez d'abord créer une adresse UDP, c'est-à-dire utiliser la méthode ResolveUDPAdr dans le package net. Cette méthode reçoit deux paramètres, à savoir le type de protocole et le serveur. adresse.

Ensuite, utilisez la méthode ListenUDP dans le package net pour écouter l'adresse. Cette méthode renverra un objet UDPConn, qui peut être utilisé pour recevoir et envoyer des datagrammes UDP.

L'étape suivante est le processus de lecture du datagramme. Utilisez la méthode ReadFromUDP de l'objet UDPConn pour lire le datagramme envoyé par le client. Cette méthode bloquera jusqu'à ce que le datagramme soit reçu et renvoie un objet d'erreur et un objet datagramme. Après avoir lu les données, vous pouvez extraire les données et les traiter, par exemple en calculant la valeur de hachage des données. Utilisez ensuite la méthode WriteToUDP de l'objet UDPConn pour envoyer un datagramme de réponse au client.

Ce qui suit est un programme serveur UDP simple :

package main

import (
    "fmt"
    "net"
)

func main() {
    ip := net.ParseIP("127.0.0.1")
    addr := &net.UDPAddr{
        IP:   ip,
        Port: 8080,
    }

    conn, err := net.ListenUDP("udp", addr)
    if err != nil {
        fmt.Println(err)
        return
    }

    defer conn.Close()
    fmt.Println("UDP server listening on port ", addr.Port)
    for {
        data := make([]byte, 1024)
        n, addr, err := conn.ReadFromUDP(data)
        if err != nil {
            fmt.Println("Error: ", err)
            continue
        }
        fmt.Printf("Received from %s:%d : %s
", addr.IP.String(), addr.Port, string(data[:n]))

        reply := []byte("Hello from UDP server")
        conn.WriteToUDP(reply, addr)
    }
}

3. Écrivez un programme client UDP

Dans le programme client UDP, vous devez d'abord créer une adresse UDP, c'est-à-dire utiliser la méthode ResolveUDPAdr dans le package net, qui reçoit Les deux paramètres sont le type de protocole et l'adresse du serveur.

Ensuite, utilisez la méthode DialUDP pour vous connecter à l'adresse du serveur, qui renverra un objet UDPConn, qui pourra être utilisé pour envoyer des datagrammes UDP au serveur.

L'étape suivante consiste à envoyer le datagramme au serveur. Utilisez la méthode Write de l'objet UDPConn pour envoyer le datagramme au serveur. Cette méthode bloquera jusqu'à ce que le datagramme soit envoyé.

Ensuite, utilisez la méthode ReadFromUDP de l'objet UDPConn pour lire le datagramme de réponse du serveur. Cette méthode bloquera jusqu'à ce que le datagramme soit reçu et renverra un objet d'erreur et un objet datagramme. Après avoir lu les données, vous pouvez les supprimer.

Ce qui suit est un programme client UDP simple :

package main

import (
    "fmt"
    "net"
)

func main() {
    ip := net.ParseIP("127.0.0.1")
    addr := &net.UDPAddr{
        IP:   ip,
        Port: 8080,
    }

    conn, err := net.DialUDP("udp", nil, addr)
    if err != nil {
        fmt.Println(err)
        return
    }

    defer conn.Close()
    fmt.Printf("UDP client connected to %s:%d
", addr.IP.String(), addr.Port)

    message := []byte("Hello from UDP client")
    _, err = conn.Write(message)
    if err != nil {
        fmt.Println(err)
        return
    }

    buffer := make([]byte, 1024)
    n, _, err := conn.ReadFromUDP(buffer)
    if err != nil {
        fmt.Println(err)
        return
    }

    fmt.Printf("Response from server: %s
", string(buffer[:n]))
}

4. Résumé

En langage Go, la programmation avec UDP est très simple. Il vous suffit d'utiliser l'objet UDPConn dans le package net pour lire et écrire des datagrammes UDP. Cet article explique comment écrire des programmes serveur UDP et des programmes client UDP, et fournit des exemples de code correspondants. Lorsque vous devez effectuer une transmission de données en temps réel, des jeux et d'autres applications, vous pouvez envisager d'utiliser le protocole UDP.

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!