Go: creare un client ed un server TCP

Go, noto anche come Golang, è un linguaggio di programmazione open-source sviluppato da Google. La sua semplicità, efficienza e facilità di utilizzo lo rendono perfetto per creare applicazioni di rete come client e server. In questo articolo, esploreremo come creare un client e un server TCP in Go.

Che cos'è TCP?

TCP (Transmission Control Protocol) è un protocollo di comunicazione affidabile e orientato alla connessione utilizzato per trasferire dati su una rete. Essendo un protocollo affidabile, TCP garantisce la consegna dei dati senza errori e in ordine corretto.

Creare il Server TCP

Iniziamo creando il server TCP che ascolterà le connessioni in arrivo e gestirà le richieste dei client. Ecco il codice per il server TCP in Go:

package main

import (
	"fmt"
	"net"
)

func handleConnection(conn net.Conn) {
	defer conn.Close()

	// Qui puoi gestire la connessione con il client.
	// Ad esempio, puoi leggere i dati inviati dal client o rispondere alle sue richieste.

	fmt.Println("Nuova connessione accettata:", conn.RemoteAddr().String())

	// Esempio di lettura dei dati inviati dal client
	buffer := make([]byte, 1024)
	n, err := conn.Read(buffer)
	if err != nil {
		fmt.Println("Errore durante la lettura dei dati:", err)
		return
	}
	fmt.Printf("Dati ricevuti: %s\n", buffer[:n])
}

func main() {
	// Avvia il server sulla porta 8080
	listener, err := net.Listen("tcp", ":8080")
	if err != nil {
		fmt.Println("Errore durante l'avvio del server:", err)
		return
	}
	defer listener.Close()

	fmt.Println("Server in ascolto su", listener.Addr())

	for {
		// Accetta una nuova connessione
		conn, err := listener.Accept()
		if err != nil {
			fmt.Println("Errore durante l'accettazione della connessione:", err)
			return
		}

		// Gestisci la connessione in modo asincrono
		go handleConnection(conn)
	}
}

Il server crea un socket in ascolto sulla porta 8080 utilizzando net.Listen. Quando un client si connette, viene accettata la connessione utilizzando listener.Accept(), e il server gestirà la connessione in modo asincrono utilizzando il goroutine go handleConnection(conn).

La funzione handleConnection è responsabile di gestire la connessione con il client. Al momento, stampa semplicemente i dati ricevuti dal client, ma puoi personalizzarla per rispondere alle richieste del client in base alle tue esigenze.

Creare il Client TCP

Ora che abbiamo il nostro server in funzione, creiamo un client TCP che si connetta al server e invii dati. Ecco il codice per il client TCP in Go:

package main

import (
	"fmt"
	"net"
)

func main() {
	// Connetti il client al server
	conn, err := net.Dial("tcp", "localhost:8080")
	if err != nil {
		fmt.Println("Errore durante la connessione al server:", err)
		return
	}
	defer conn.Close()

	// Dati da inviare al server
	data := "Ciao, server! Sono un client."

	// Invia i dati al server
	_, err = conn.Write([]byte(data))
	if err != nil {
		fmt.Println("Errore durante l'invio dei dati:", err)
		return
	}

	fmt.Println("Dati inviati al server:", data)
}

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.