Wie programmiere ich mit UDP in Go?

UDP (User Datagram Protocol) ist ein verbindungsloses Protokoll und ein sehr wichtiges Protokoll in der Transportschicht. Es kann Daten direkt an den Zielhost übertragen, ohne eine Verbindung herzustellen. Daher wird es häufig in Echtzeit-Datenübertragungen, Spielen und anderen Anwendungen verwendet und ist in einigen Szenarien besser geeignet als TCP.

Die Verwendung der UDP-Programmierung in der Go-Sprache ist ebenfalls sehr einfach. In diesem Artikel wird die Verwendung der UDP-Programmierung in der Go-Sprache vorgestellt.

1. Verstehen Sie das Datagramm des UDP-Protokolls

Im UDP-Protokoll werden Daten in ein UDP-Paket gekapselt, das auch Datagramm genannt wird. Das Datagramm enthält Quellportnummer, Zielportnummer, Länge, Prüfsumme und andere Informationen.

In der Go-Sprache kann UDPConn des Net-Pakets zum Lesen und Schreiben von UDP-Datagrammen verwendet werden.

2. Schreiben Sie ein UDP-Serverprogramm

Im UDP-Serverprogramm müssen Sie zunächst eine UDP-Adresse erstellen, dh die ResolveUDPAddr-Methode im Netzpaket verwenden. Diese Methode empfängt zwei Parameter, nämlich den Protokolltyp und den Server Adresse.

Verwenden Sie dann die ListenUDP-Methode im Netzpaket, um die Adresse abzuhören. Diese Methode gibt ein UDPConn-Objekt zurück, das zum Empfangen und Senden von UDP-Datagrammen verwendet werden kann.

Der nächste Schritt ist das Lesen des Datagramms. Verwenden Sie die ReadFromUDP-Methode des UDPConn-Objekts, um das vom Client gesendete Datagramm zu lesen und ein Fehlerobjekt und ein Datagrammobjekt zurückzugeben. Nach dem Lesen der Daten können Sie die Daten herausnehmen und verarbeiten, z. B. den Hash-Wert der Daten berechnen. Verwenden Sie dann die WriteToUDP-Methode des UDPConn-Objekts, um ein Antwortdatagramm an den Client zu senden.

Das Folgende ist ein einfaches UDP-Serverprogramm:

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. Schreiben Sie ein UDP-Client-Programm

Im UDP-Client-Programm müssen Sie zunächst eine UDP-Adresse erstellen, dh die ResolveUDPAddr-Methode im Netzpaket verwenden. welche empfängt Die beiden Parameter sind Protokolltyp und Serveradresse.

Verwenden Sie dann die DialUDP-Methode, um eine Verbindung zur Serveradresse herzustellen, die ein UDPConn-Objekt zurückgibt, das zum Senden von UDP-Datagrammen an den Server verwendet werden kann.

Der nächste Schritt besteht darin, das Datagramm an den Server zu senden. Verwenden Sie die Write-Methode des UDPConn-Objekts, um das Datagramm an den Server zu senden.

Verwenden Sie dann die ReadFromUDP-Methode des UDPConn-Objekts, um das Antwortdatagramm vom Server zu lesen. Diese Methode blockiert, bis das Datagramm empfangen wird, und gibt ein Fehlerobjekt und ein Datagrammobjekt zurück. Nachdem Sie die Daten gelesen haben, können Sie die Daten herausnehmen.

Das Folgende ist ein einfaches UDP-Client-Programm:

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. Zusammenfassung

In der Go-Sprache ist die Programmierung mit UDP sehr einfach. Sie müssen nur das UDPConn-Objekt im Netzpaket verwenden, um UDP-Datagramme zu lesen und zu schreiben. In diesem Artikel wird das Schreiben von UDP-Serverprogrammen und UDP-Clientprogrammen vorgestellt und entsprechende Codebeispiele bereitgestellt. Wenn Sie Echtzeit-Datenübertragungen, Spiele und andere Anwendungen durchführen müssen, können Sie die Verwendung des UDP-Protokolls in Betracht ziehen.

Das obige ist der detaillierte Inhalt vonWie programmiere ich mit UDP in Go?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!