Golang TCP Server

In diesem Handbuch lernen wir, wie Sie einen einfachen TCP -Server erstellen, der eingehende Verbindungen zum Server akzeptiert. Der Server antwortet mit einer Nachricht und den aktuellen Daten und Zeit.

Dies ist ein gutes Tutorial für Anfänger, die sich mit dem Go Net -Paket und dem Umgang mit Anfragen vertraut machen möchten.

Einstieg

Obwohl das Tutorial sehr anfängerfreundlich ist, empfehlen wir die Grundlagen der Arbeit mit der GO -Sprache zur Hand zu haben.

Es ist auch sehr vorteilhaft, zu verstehen, wie man mit Go -Paketen arbeitet.

Golang Net -Paket

Das Netzpaket ist Teil der Go -Standardbibliothek. Es wird verwendet, um eine tragbare Schnittstelle für die Arbeit mit Netzwerk -E/A -Operationen bereitzustellen. Dies umfasst TCP/IP-, UDP-, DNS- und UNIX -Domänen -Sockets.

Wir werden dieses Paket verwenden, um einen TCP -Server zu erstellen.

Erstellen eines einfachen TCP -Servers

Lassen Sie uns nun in den Code einsteigen und lernen, wie Sie einen TCP -Server erstellen. Erstellen Sie zunächst eine Go -Datei, um Ihren Code zu schreiben:

Mkdir TCP-Server
Berührungsserver.gehen

Bearbeiten Sie die Datei mit Ihrem Texteditor Ihrer Wahl und geben Sie die folgenden Zeilen ein:

Paket Main
importieren (
"fmt"
"Netz"
"OS"
)

Die obigen Zeilen definieren das Paket als eigenständiges Paket und importiert die erforderlichen Pakete.

Der nächste Schritt besteht darin, die Parameter für unseren Server zu definieren. Wir können diese als globale Variablen definieren wie:

const (
Host = "Localhost"
Port = "9001"
Typ = "TCP"
)

Der nächste Schritt besteht darin, auf eingehende Verbindungen zu hören. Wir können dies mit dem Netz tun.Hörenmethode. Die Syntax der Funktion ist wie gezeigt:

Func Hören (Netzwerk, Adresszeichenfolge) (Hörer, Fehler)

Der Verbindungstyp (z. B. TCP, TCP4, TCP6, UNIX oder UNIXPacket), den Host und den Verbindungsport. Die Funktion gibt eine Listen -Verbindung in der angegebenen Adresse zurück.

Ein Beispielcode ist wie gezeigt:

Hören Sie, arr: = net.Hören (Typ, Host+":"+Port)
Wenn er irrt != nil
Protokoll.Tödlich (arr)
Betriebssystem.Ausgang (1)

Wir überprüfen, ob der Hörer auf Fehler stoß.

Wir müssen den Hörer auch schließen, nachdem der Server beendet wird. Wir können dies mit dem Schlüsselwort für Defer und der Schließmethode tun

Hören.Schließen()

Der nächste Schritt besteht darin, kontinuierlich auf Verbindungen zu hören. Wir können dies mit einer für die Schleife tun als:

für
conn, arr: = hör zu.Akzeptieren()
Wenn er irrt != nil
Protokoll.Tödlich (arr)
Betriebssystem.Ausgang (1)
// Eingehende Verbindungen verarbeiten

Um eingehende Anforderungen zu bearbeiten, können wir eine Funktion erstellen wie:

Func HandleComingRequest (Conn Net.Conn)
// Eingehende Daten speichern
Puffer: = make ([] byte, 1024)
_, err: = conn.Lesen (Puffer)
Wenn er irrt != nil
Protokoll.Tödlich (arr)

// antworten
Zeit: = Zeit.Jetzt().Format ("Montag, 02-Jan-06 15:04:05 MST")
Conn.Schreiben Sie ([] byte ("Hallo zurück!")))
Conn.Schreiben ([] byte (Zeit))
// Conn schließen
Conn.Schließen()

Im obigen Beispiel definieren wir eine Funktion, die Conn vom Typ NET nimmt.Conn Struktur als Parameter.

Anschließend definieren wir einen neuen Puffer, um die eingehenden Daten der Größe 1024 zu speichern. Der nächste Block liest die aktuelle Zeit mit der Zeit.Jetzt () Paket.

Mit der Schreibmethode können wir die Zeit und eine Zeichenfolge an den Client schreiben. Schließlich setzen wir den Conn.Schließen (), um die Verbindung zu schließen.

Der vollständige Quellcode ist wie gezeigt:

Paket Main
importieren (
"Protokoll"
"Netz"
"OS"
"Zeit"
)
const (
Host = "Localhost"
Port = "9001"
Typ = "TCP"
)
func main ()
Hören Sie, arr: = net.Hören (Typ, Host+":"+Port)
Wenn er irrt != nil
Protokoll.Tödlich (arr)
Betriebssystem.Ausgang (1)

// Hörer schließen
Verschiebung zuhören.Schließen()
für
conn, arr: = hör zu.Akzeptieren()
Wenn er irrt != nil
Protokoll.Tödlich (arr)
Betriebssystem.Ausgang (1)

Gehen Sie HandleIncomingRequest (Conn)


Func HandleComingRequest (Conn Net.Conn)
// Eingehende Daten speichern
Puffer: = make ([] byte, 1024)
_, err: = conn.Lesen (Puffer)
Wenn er irrt != nil
Protokoll.Tödlich (arr)

// antworten
Zeit: = Zeit.Jetzt().Format ("Montag, 02-Jan-06 15:04:05 MST")
Conn.Schreiben Sie ([] byte ("Hallo zurück!\N"))
Conn.Schreiben ([] byte (Zeit))
// Conn schließen
Conn.Schließen()

Server kompilieren und ausführen

Speichern Sie nach Abschluss die Datei und führen Sie den folgenden Befehl aus, um den Hörer in eine binäre zu kompilieren:

Gehen Sie den Server auf.gehen

Führen Sie den Server als nächstes als:

./Server.exe

Der obige Befehl sollte den TCP -Server ausführen und wir können Verbindungen dazu herstellen.

Testen des TCP -Servers

Um den TCP -Server zu testen, können Sie NetCAT mit dem Befehl verwenden:

NC Localhost 9001

Senden Sie als nächstes eine Nachricht als:

Hallo!

Der Server sollte mit einem HI zurück und dem aktuellen Datum und der aktuellen Uhrzeit antworten.

Hallo zurück!
Dienstag, 01-Feb-22 18:03:56 Essen

Abschluss

Und damit haben wir unser Tutorial abgeschlossen. In diesem Handbuch werden Sie in die Grundlagen der Arbeit mit dem Net -Paket vorgestellt, indem Sie einen TCP -Server erstellen.

Danke fürs Lesen!