Server Golang TCP

In questa guida, impareremo come creare un semplice server TCP che accetti le connessioni in arrivo al server. Il server risponderà con un messaggio e i dati correnti e il tempo.

Questo è un buon tutorial per i principianti che vogliono familiarizzare con il pacchetto GO Net e come gestire le richieste.

Iniziare

Sebbene il tutorial sia molto amichevole per principianti, ti consigliamo di avere le basi di lavorare con il linguaggio Go.

Comprendere come lavorare con i pacchetti go è anche molto utile.

Pacchetto netto Golang

Il pacchetto net fa parte della libreria standard Go. Viene utilizzato per fornire interfaccia portatile per lavorare con le operazioni di I/O di rete. Ciò include le prese di dominio TCP/IP, UDP, DNS e UNIX.

Useremo questo pacchetto per creare un server TCP.

Costruire un semplice server TCP

Entriamo ora nel codice e impariamo come costruire un server TCP. Inizia creando un file GO per scrivere il tuo codice:

MKDIR TCP-Server
Touch Server.andare

Modifica il file con il tuo editor di testo di scelta e inserisci le righe qui sotto:

Pacchetto principale
importazione (
"FMT"
"netto"
"OS"
)

Le linee sopra definiscono il pacchetto come un pacchetto autonomo e importano i pacchetti richiesti.

Il prossimo passo è definire i parametri per il nostro server. Possiamo definirli come variabili globali come:

const (
Host = "localhost"
Port = "9001"
Type = "TCP"
)

Il prossimo passo è ascoltare le connessioni in arrivo. Possiamo farlo usando la rete.Metodo di ascolto. La sintassi della funzione è come mostrata:

Func ascolta (rete, stringa indirizzo) (ascoltatore, errore)

Prende il tipo di connessione (come TCP, TCP4, TCP6, UNIX o UNIXPACKET), l'host e la porta di connessione. La funzione restituirà una connessione di ascolto sull'indirizzo specificato.

Un codice di esempio è come mostrato:

Ascolta, err: = net.Ascolta (tipo, host+":"+porta)
Se err != nil
tronco d'albero.Fatale (err)
sistema operativo.Uscita (1)

Controlliamo se l'ascoltatore riscontra errori, se vero, registra il messaggio di errore ed esiste con un codice di stato di 1.

Dobbiamo anche chiudere l'ascoltatore dopo che il server termina. Possiamo farlo usando la parola chiave Defer e il metodo Close

Ascoltare.Vicino()

Il prossimo passo è ascoltare continuamente le connessioni. Possiamo farlo usando un ciclo per:

per
Conn, err: = Ascolta.Accettare()
Se err != nil
tronco d'albero.Fatale (err)
sistema operativo.Uscita (1)
// Gestisci le connessioni in arrivo

Per gestire tutte le richieste in arrivo, possiamo creare una funzione come:

Func HandleInComingRequest (Conn Net.Conn)
// Memorizza i dati in arrivo
Buffer: = make ([] byte, 1024)
_, err: = Conn.Leggi (buffer)
Se err != nil
tronco d'albero.Fatale (err)

// rispondere
tempo: = tempo.Ora().Formato ("lunedì, 02-gen-06 15:04:05 MST")
Conn.Scrivi ([] byte ("ciao!"))
Conn.Scrivere ([] byte (tempo))
// Chiudi Conn
Conn.Vicino()

Nell'esempio sopra, definiamo una funzione che prende Conn of Type Net.Conn struct come parametro.

Definiamo quindi un nuovo buffer per archiviare i dati in arrivo della dimensione 1024. Il blocco successivo legge l'ora corrente usando il tempo.Ora () pacchetto.

Usando il metodo di scrittura, possiamo scrivere l'ora e una stringa al client. Infine, impostiamo il Conn.Chiudere () per chiudere la connessione.

Il codice sorgente completo è come mostrato:

Pacchetto principale
importazione (
"tronco d'albero"
"netto"
"OS"
"tempo"
)
const (
Host = "localhost"
Port = "9001"
Type = "TCP"
)
func main ()
Ascolta, err: = net.Ascolta (tipo, host+":"+porta)
Se err != nil
tronco d'albero.Fatale (err)
sistema operativo.Uscita (1)

// Chiudi ascoltatore
Defer ascolta.Vicino()
per
Conn, err: = Ascolta.Accettare()
Se err != nil
tronco d'albero.Fatale (err)
sistema operativo.Uscita (1)

Go HandleInComingRequest (Conn)


Func HandleInComingRequest (Conn Net.Conn)
// Memorizza i dati in arrivo
Buffer: = make ([] byte, 1024)
_, err: = Conn.Leggi (buffer)
Se err != nil
tronco d'albero.Fatale (err)

// rispondere
tempo: = tempo.Ora().Formato ("lunedì, 02-gen-06 15:04:05 MST")
Conn.Scrivi ([] byte ("ciao!\N"))
Conn.Scrivere ([] byte (tempo))
// Chiudi Conn
Conn.Vicino()

Compila ed esegui il server

Una volta completato, salva il file ed esegui il comando qui sotto per compilare l'ascoltatore in un binario:

Vai a build server.andare

Quindi, eseguire il server come:

./server.exe

Il comando sopra dovrebbe eseguire il server TCP e possiamo stabilire connessioni ad esso.

Testare il server TCP

Per testare il server TCP, è possibile utilizzare NetCAT utilizzando il comando:

NC Localhost 9001

Quindi, invia un messaggio come:

CIAO!

Il server dovrebbe rispondere con un ritorno e la data e l'ora correnti.

Ciao indietro!
Martedì, 01-Feb-22 18:03:56 EAT

Conclusione

E con ciò, abbiamo concluso il nostro tutorial. Questa guida ti introduce alle basi del lavoro con il pacchetto net creando un server TCP.

Grazie per aver letto!