Serveur Golang TCP

Dans ce guide, nous apprendrons à créer un serveur TCP simple qui accepte les connexions entrantes au serveur. Le serveur répondra par un message et les données et le temps actuels.

Ceci est un bon tutoriel pour les débutants qui souhaitent se familiariser avec le package GO Net et comment gérer les demandes.

Commencer

Bien que le tutoriel soit très adapté aux débutants, nous vous recommandons d'avoir les bases de travailler avec la langue Go à portée de main.

Comprendre comment travailler avec les forfaits GO est également très bénéfique.

Package de filet Golang

Le package net fait partie de la bibliothèque standard Go. Il est utilisé pour fournir une interface portable pour travailler avec les opérations d'E / S de réseau. Cela inclut les prises de domaine TCP / IP, UDP, DNS et UNIX.

Nous utiliserons ce package pour créer un serveur TCP.

Construire un serveur TCP simple

Laissez maintenant entrer dans le code et apprendre à créer un serveur TCP. Commencez par créer un fichier Go pour écrire votre code:

MKDIR TCP-Server
serveur tactile.aller

Modifiez le fichier avec votre éditeur de texte de choix et entrez les lignes ci-dessous:

package principal
importer (
"FMT"
"filet"
"OS"
)

Les lignes ci-dessus définissent le package comme un package autonome et importe les packages requis.

L'étape suivante consiste à définir les paramètres de notre serveur. Nous pouvons les définir comme des variables globales comme:

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

L'étape suivante consiste à écouter les connexions entrantes. Nous pouvons le faire en utilisant le filet.Méthode d'écoute. La syntaxe de la fonction est comme indiqué:

Func Listen (réseau, chaîne d'adresse) (écouteur, erreur)

Il prend le type de connexion (tel que TCP, TCP4, TCP6, UNIX ou UNIXPACKET), l'hôte et le port de connexion. La fonction renverra une connexion d'écoute sur l'adresse spécifiée.

Un exemple de code est comme indiqué:

Écoutez, euh: = net.Écouter (type, hôte + ":" + port)
Si err != nil
enregistrer.Fatal (euh)
OS.Sortie (1)

Nous vérifions si l'auditeur rencontre des erreurs, si elle est vraie, elle enregistre le message d'erreur et existe avec un code d'état de 1.

Nous devons également fermer l'auditeur après la fin du serveur. Nous pouvons le faire en utilisant le mot-clé de différence et la méthode étroite

écouter.Fermer()

L'étape suivante consiste à écouter en continu les connexions. Nous pouvons le faire en utilisant une boucle pour:

pour
Conn, err: = écouter.Accepter()
Si err != nil
enregistrer.Fatal (euh)
OS.Sortie (1)
// gérer les connexions entrantes

Pour gérer toutes les demandes entrantes, nous pouvons créer une fonction comme:

func hreatheincomingrequest (Conn net.Conn)
// Stockez les données entrantes
tampon: = make ([] octet, 1024)
_, euh: = conn.Lire (tampon)
Si err != nil
enregistrer.Fatal (euh)

// répondre
Temps: = temps.Maintenant().Format ("Lundi, 02-Jan-06 15:04:05 MST")
Connecticut.Écrire ([] octet ("salut en arrière!"))
Connecticut.Écrire ([] octet (temps))
// ferme Conn
Connecticut.Fermer()

Dans l'exemple ci-dessus, nous définissons une fonction qui prend uneonn.Conn structure comme paramètre.

Nous définissons ensuite un nouveau tampon pour stocker les données entrantes de la taille 1024. Le bloc suivant lit l'heure actuelle en utilisant l'heure.Package maintenant ().

En utilisant la méthode d'écriture, nous pouvons écrire l'heure et une chaîne au client. Enfin, nous définissons le Conn.Fermer () pour fermer la connexion.

Le code source complet est comme indiqué:

package principal
importer (
"enregistrer"
"filet"
"OS"
"temps"
)
const (
Host = "localhost"
Port = "9001"
Type = "TCP"
)
func main ()
Écoutez, euh: = net.Écouter (type, hôte + ":" + port)
Si err != nil
enregistrer.Fatal (euh)
OS.Sortie (1)

// Closez auditeur
Référer à écouter.Fermer()
pour
Conn, err: = écouter.Accepter()
Si err != nil
enregistrer.Fatal (euh)
OS.Sortie (1)

go handleincomingrequest (Conn)


func hreatheincomingrequest (Conn net.Conn)
// Stockez les données entrantes
tampon: = make ([] octet, 1024)
_, euh: = conn.Lire (tampon)
Si err != nil
enregistrer.Fatal (euh)

// répondre
Temps: = temps.Maintenant().Format ("Lundi, 02-Jan-06 15:04:05 MST")
Connecticut.Écrire ([] octet ("salut en arrière!\ n "))
Connecticut.Écrire ([] octet (temps))
// ferme Conn
Connecticut.Fermer()

Compiler et exécuter le serveur

Une fois terminé, enregistrez le fichier et exécutez la commande ci-dessous pour compiler l'auditeur dans un binaire:

GO Build Server.aller

Ensuite, exécutez le serveur comme:

./serveur.exe

La commande ci-dessus doit exécuter le serveur TCP et nous pouvons y établir des connexions.

Tester le serveur TCP

Pour tester le serveur TCP, vous pouvez utiliser NetCAT à l'aide de la commande:

NC localhost 9001

Ensuite, envoyez un message comme:

Salut!

Le serveur doit répondre avec un retour en arrière et la date et l'heure actuelles.

Rebonjour!
Mardi 01-Feb-22 18:03:56 manger

Conclusion

Et avec ça, nous avons conclu notre tutoriel. Ce guide vous présente les bases de travailler avec le package net en créant un serveur TCP.

Merci d'avoir lu!