Wie programmiere ich mit TCP in Go?

Go-Sprache ist eine leistungsstarke Programmiersprache, die zahlreiche Netzwerkprogrammierungsbibliotheken bereitstellt, einschließlich TCP/IP-Sockets. In diesem Artikel wird hauptsächlich die Verwendung der Go-Sprache für die TCP-Programmierung vorgestellt.

1. TCP/IP

TCP/IP ist eine Protokollsuite, die die Grundlage der Netzwerkkommunikation und das Kernprotokoll des Internets darstellt. Es ist für die Übertragung von Daten im Netzwerk verantwortlich. Es umfasst zwei Protokolle: TCP und IP. TCP sorgt für die Zuverlässigkeit der Datagrammübertragung, und IP ist für die Weiterleitung der Datagrammübertragung verantwortlich. 2. TCP-Programmierung in Go ): Hört auf einen TCP-Port;

net.TCPConn(): Stellt eine TCP-Verbindung dar.

Im Folgenden stellen wir vor, wie Sie diese Funktionen für die TCP-Programmierung verwenden.

1. TCP-Verbindung herstellen
3. Der Client kann die Funktion net.DialTCP() verwenden, um eine TCP-Verbindung zum Server herzustellen. Das Folgende ist ein Beispielcode:

package main

import (
    "fmt"
    "net"
)

func main() {
    conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
        IP:   net.IPv4(127, 0, 0, 1),
        Port: 9999,
    })
    if err != nil {
        fmt.Println(err)
        return
    }
    defer conn.Close()

    fmt.Println("Connected!")
}

Im obigen Code ist der erste Parameter der DialTCP()-Funktion die Zeichenfolge „tcp“, die den Netzwerkprotokolltyp angibt, und der zweite Parameter ist eine Adressstruktur, die zur Angabe des Verbindungsziels verwendet wird . Hier geben wir eine Verbindung zum Port 9999 auf der lokalen IP-Adresse 127.0.0.1 an. Bei erfolgreicher Verbindung wird „Verbunden!“ ausgegeben.

Überwachen Sie den TCP-Port

Der Server kann die Funktion net.ListenTCP() verwenden, um einen bestimmten TCP-Port abzuhören. Das Folgende ist ein Beispielcode:

package main

import (
    "fmt"
    "net"
)

func main() {
    tcpListener, err := net.ListenTCP("tcp", &net.TCPAddr{
        IP:   net.IPv4(0, 0, 0, 0),
        Port: 9999,
    })
    if err != nil {
        fmt.Println(err)
        return
    }
    defer tcpListener.Close()

    fmt.Println("Listening on port", 9999)
    for {
        conn, err := tcpListener.AcceptTCP()
        if err != nil {
            fmt.Println(err)
            continue
        }

        fmt.Println("New client connected.")
        go handleClient(conn)
    }
}

func handleClient(conn *net.TCPConn) {
    defer conn.Close()
    // TODO: 处理客户端请求
}

Im obigen Code ist der erste Parameter der Funktion ListenTCP() die Zeichenfolge „tcp“, die den Netzwerkprotokolltyp angibt, und der zweite Parameter ist eine Adressstruktur, die zur Angabe der Überwachungs-IP verwendet wird Adresse und Portnummer. Hier geben wir Port 9999 an, um alle IP-Adressen abzuhören. Bei erfolgreichem Abhören wird „Listening on port 9999“ ausgegeben.

Dann rufen wir die Funktion AcceptTCP() in einer Endlosschleife auf, um darauf zu warten, dass der Client eine Verbindung herstellt. Wenn ein Client verbunden ist, wird eine neue Goroutine erstellt, um die Client-Anfrage zu verarbeiten, und „Neuer Client verbunden“ wird an die Konsole ausgegeben.

TCP-Verbindungsverarbeitung

Der Code zur Verarbeitung von TCP-Verbindungen ist oft komplexer. Im Allgemeinen müssen wir die Funktion bufio.NewReader() verwenden, um die Anforderungsdaten des Clients zu lesen, und dann die Funktion bufio.NewWriter() verwenden, um die Antwortdaten zu schreiben.

Hier ist der Beispielcode für die Handhabung der TCP-Verbindung:

func handleClient(conn *net.TCPConn) {
    defer conn.Close()

    // 读取客户端请求
    reader := bufio.NewReader(conn)
    req, err := reader.ReadString('
')
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("Received request:", req)

    // 发送响应数据
    writer := bufio.NewWriter(conn)
    resp := "Hello, client!
"
    _, err = writer.WriteString(resp)
    if err != nil {
        fmt.Println(err)
        return
    }
    writer.Flush()
}

Im obigen Code erstellen wir zunächst ein bufio.NewReader()-Objekt, um die Client-Anfrage zu lesen. Nach dem Lesen der Daten erstellen wir ein bufio.NewWriter()-Objekt, um die Antwortdaten zu schreiben. Beachten Sie, dass die Verwendung der bufio.NewWriter()-Funktion zum Erstellen eines Writers Ausgabedaten zwischenspeichern und die Leistung verbessern kann.

3. Schließlich verwenden wir die Funktion WriteString(), um die Antwortdaten in den Writer zu schreiben, und rufen die Funktion Flush() auf, um die Pufferdaten auszusenden.

3. Vollständiges Beispiel

Abschließend demonstrieren wir ein vollständiges TCP-Programmierbeispiel, einschließlich Client und Server:

Servercode:

package main

import (
    "bufio"
    "fmt"
    "net"
)

func main() {
    tcpListener, err := net.ListenTCP("tcp", &net.TCPAddr{
        IP:   net.IPv4(0, 0, 0, 0),
        Port: 9999,
    })
    if err != nil {
        fmt.Println(err)
        return
    }
    defer tcpListener.Close()

    fmt.Println("Listening on port", 9999)
    for {
        conn, err := tcpListener.AcceptTCP()
        if err != nil {
            fmt.Println(err)
            continue
        }

        fmt.Println("New client connected.")
        go handleClient(conn)
    }
}

func handleClient(conn *net.TCPConn) {
    defer conn.Close()

    // 读取客户端请求
    reader := bufio.NewReader(conn)
    req, err := reader.ReadString('
')
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("Received request:", req)

    // 发送响应数据
    writer := bufio.NewWriter(conn)
    resp := "Hello, client!
"
    _, err = writer.WriteString(resp)
    if err != nil {
        fmt.Println(err)
        return
    }
    writer.Flush()
}

Client-Code:

package main

import (
    "bufio"
    "fmt"
    "net"
)

func main() {
    conn, err := net.DialTCP("tcp", nil, &net.TCPAddr{
        IP:   net.IPv4(127, 0, 0, 1),
        Port: 9999,
    })
    if err != nil {
        fmt.Println(err)
        return
    }
    defer conn.Close()

    // 发送请求数据
    writer := bufio.NewWriter(conn)
    req := "Hello, server!
"
    _, err = writer.WriteString(req)
    if err != nil {
        fmt.Println(err)
        return
    }
    writer.Flush()

    // 接收响应数据
    reader := bufio.NewReader(conn)
    resp, err := reader.ReadString('
')
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println("Received response:", resp)
}

Im obigen Code lauscht der Server zunächst auf Port 9999 und Warten Sie dann auf Clientverbindungen. Wenn der Client eine Verbindung herstellt, liest der Server die Client-Anfrage und sendet dann Antwortdaten.

Der Client stellt zunächst eine TCP-Verbindung zum Server her und sendet dann Anforderungsdaten an den Server. Nach dem Senden der Anfrage wartet der Client auf den Empfang von Antwortdaten vom Server.

4. Zusammenfassung

In diesem Artikel wird die Verwendung der Go-Sprache für die TCP-Programmierung vorgestellt. Wir lernten die Grundlagen des TCP/IP-Protokolls und führten dann ein, wie man die TCP-Programmierung in der Go-Sprache mithilfe der vom Net-Paket bereitgestellten API implementiert. Gleichzeitig bietet dieser Artikel ein vollständiges Beispiel. Ich hoffe, dass er den Lesern hilfreich sein wird.

Das obige ist der detaillierte Inhalt vonWie programmiere ich mit TCP in Go?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!