Go: creare un client ed un server UDP

Go (o Golang) è un linguaggio di programmazione open-source sviluppato da Google che offre prestazioni elevate, facilità di utilizzo e supporto per il networking. In questo articolo, esploreremo come creare un semplice client e server UDP utilizzando Go.

Che cos'è UDP?

User Datagram Protocol (UDP) è un protocollo di comunicazione senza connessione e non affidabile. A differenza del TCP, UDP non stabilisce una connessione prima di inviare dati, il che lo rende più veloce, ma meno affidabile, in quanto i pacchetti inviati potrebbero essere persi o arrivare fuori sequenza. È particolarmente utile per le applicazioni in cui la velocità è critica e la perdita di alcuni dati non è un problema, come nei giochi online o nello streaming di contenuti.

Creare il Server UDP

Iniziamo creando il server UDP. Questo server ascolterà su una specifica porta e riceverà i dati inviati dai client.

package main

import (
	"fmt"
	"net"
)

func main() {
	// Specifica l'indirizzo e la porta su cui il server UDP deve ascoltare
	serverAddr, err := net.ResolveUDPAddr("udp", ":8080")
	if err != nil {
		fmt.Println("Errore nella risoluzione dell'indirizzo:", err)
		return
	}

	// Crea una connessione UDP
	conn, err := net.ListenUDP("udp", serverAddr)
	if err != nil {
		fmt.Println("Errore nell'ascolto UDP:", err)
		return
	}
	defer conn.Close()

	fmt.Println("Server UDP in ascolto su", conn.LocalAddr())

	// Buffer per memorizzare i dati ricevuti
	buffer := make([]byte, 1024)

	for {
		// Ricevi dati dal client
		n, addr, err := conn.ReadFromUDP(buffer)
		if err != nil {
			fmt.Println("Errore nella lettura:", err)
			continue
		}

		// Converti i dati ricevuti in una stringa e stampali
		data := string(buffer[:n])
		fmt.Printf("Ricevuti %d byte da %s: %s\n", n, addr, data)
	}
}

Creare il Client UDP

Ora creiamo il client UDP, che invierà i dati al server specificato.

package main

import (
	"fmt"
	"net"
)

func main() {
	// Specifica l'indirizzo del server UDP
	serverAddr, err := net.ResolveUDPAddr("udp", "localhost:8080")
	if err != nil {
		fmt.Println("Errore nella risoluzione dell'indirizzo:", err)
		return
	}

	// Crea una connessione UDP
	conn, err := net.DialUDP("udp", nil, serverAddr)
	if err != nil {
		fmt.Println("Errore nella connessione UDP:", err)
		return
	}
	defer conn.Close()

	// Dati da inviare al server
	message := []byte("Ciao, server! Questo è un messaggio UDP.")

	// Invia i dati al server
	_, err = conn.Write(message)
	if err != nil {
		fmt.Println("Errore nell'invio dei dati:", err)
		return
	}

	fmt.Println("Dati inviati al server con successo.")
}

Il client si connette al server utilizzando net.Dial e specificando l'indirizzo e la porta del server a cui connettersi. Successivamente, invia i dati al server utilizzando conn.Write([]byte(data)).

Esecuzione di Server e Client

Per eseguire il server, salva il codice del server in un file chiamato server.go e il codice del client in un file chiamato client.go. Quindi, apri due terminali e naviga in entrambe le cartelle contenenti i file dei rispettivi client e server.

Nel primo terminale, esegui il server:

go run server.go

Nel secondo terminale, esegui il client:

go run client.go

Dovresti vedere l'output del server che indica la ricezione dei dati dal client e l'output del client che indica l'invio dei dati al server.

Conclusione

In questo articolo, hai imparato come creare un semplice client e un server UDP utilizzando il linguaggio di programmazione Go. Ora hai una base solida per sviluppare applicazioni di rete più complesse e personalizzate in Go. Ricorda che l'UDP è un protocollo non affidabile, quindi dovresti implementare meccanismi di gestione degli errori e di controllo di flusso appropriati se desideri utilizzarlo per applicazioni più critiche. Sperimenta con il codice fornito e esplora ulteriori funzionalità e possibilità offerte da Go per il networking.