Netzwerk: Ihr erster TCP/IP-Server und -Client in Go

? Was wir lernen werden

In diesem Tutorial entmystifizieren wir die Netzwerkprogrammierung, indem wir einen einfachen, aber robusten TCP/IP-Server und -Client erstellen. Wenn Sie sich jemals gefragt haben, wie Anwendungen über ein Netzwerk kommunizieren, ist dieser Leitfaden genau das Richtige für Sie!

? Voraussetzungen

• Grundlegende Go-Programmierkenntnisse
• Neugier auf Networking
• Ein Texteditor
• Go wird auf Ihrem Computer installiert
• Go-Modul hinzugefügt (verwenden Sie go mod init tcpIp)

? Netzwerkkommunikation verstehen

Bevor wir in den Code eintauchen, wollen wir aufschlüsseln, was passiert, wenn zwei Computer kommunizieren:

1. TCP/IP: Stellen Sie sich das wie einen Telefonanruf vor

   • TCP (Transmission Control Protocol): Stellt sicher, dass Nachrichten vollständig und in der richtigen Reihenfolge übermittelt werden
   • IP (Internetprotokoll): Hilft, Nachrichten an das richtige Gerät weiterzuleiten

2. Server- und Client-Rollen:

   • Server: Wartet und lauscht auf eingehende Verbindungen
   • Kunde: Initiiert Kontakt und sendet Anfragen

?️ Projektstruktur

tcp-chat-app/
├── server/
│   └── server.go   # Server-side logic
├── client/
│   └── client.go   # Client-side logic
└── main.go         # Starts both server and client

? Schritt 1: Erstellen des Servers

Den Servercode verstehen

package server

import (
    "log"
    "net"
)

// StartServer: Our digital receptionist 
func StartServer() {
    // Choose a "phone number" (address)
    address := "localhost:8080"

    // Set up a "phone line" to listen for calls
    listener, err := net.Listen("tcp", address)
    if err != nil {
        log.Fatalf("Couldn't set up the phone line: %v", err)
    }
    defer listener.Close()

    log.Printf("Server is ready, waiting for connections on %s", address)

    // Forever wait for incoming "calls"
    for {
        // Accept a new connection
        conn, err := listener.Accept()
        if err != nil {
            log.Printf("Missed a call: %v", err)
            continue
        }

        // Handle each "caller" in a separate conversation
        go handleClient(conn)
    }
}

Schlüsselkonzepte erklärt

• net.Listen(): Erstellt einen Netzwerk-„Socket“ zum Empfangen von Verbindungen
• listener.Accept(): Wartet auf eingehende Verbindungen und akzeptiert diese
• go handleClient(conn): Behandelt jeden Client in einem separaten Thread (Goroutine)

? Umgang mit Clientverbindungen

func handleClient(conn net.Conn) {
    // Always clean up after the conversation
    defer conn.Close()

    log.Printf("New client connected: %s", conn.RemoteAddr())

    // Prepare a message buffer
    buffer := make([]byte, 1024)

    // Keep the conversation going
    for {
        // Read message from client
        n, err := conn.Read(buffer)
        if err != nil {
            log.Printf("Connection error: %v", err)
            return
        }

        // Echo the message back
        message := string(buffer[:n])
        log.Printf("Received: %s", message)
        conn.Write([]byte("Server says: " + message))
    }
}

Was passiert hier?

• Puffer: Ein temporärer Speicher für eingehende Nachrichten
• conn.Read(): Empfängt Nachrichten vom Client
• conn.Write(): Sendet Nachrichten zurück an den Client

?️ Schritt 2: Erstellen des Clients

package client

import (
    "bufio"
    "fmt"
    "log"
    "net"
    "os"
)

func StartClient() {
    // Dial the server (like making a phone call)
    conn, err := net.Dial("tcp", "localhost:8080")
    if err != nil {
        log.Printf("Could not connect to server: %v", err)
        return
    }
    defer conn.Close()

    fmt.Println("Connected to server. Start chatting!")

    // Read user input and send to server
    scanner := bufio.NewScanner(os.Stdin)
    for {
        fmt.Print("> ")
        if !scanner.Scan() {
            break
        }

        message := scanner.Text()
        if message == "exit" {
            break
        }

        // Send message to server
        conn.Write([]byte(message + "\n"))

        // Wait for server's response
        response := make([]byte, 1024)
        n, err := conn.Read(response)
        if err != nil {
            log.Printf("Error receiving response: %v", err)
            break
        }

        fmt.Println(string(response[:n]))
    }
}

Kundenmechaniker

• net.Dial(): Mit dem Server verbinden
• scanner.Scan(): Tastatureingabe des Benutzers lesen
• conn.Write(): Nachricht an Server senden
• conn.Read(): Antwort des Servers empfangen

? Alles zusammenbringen: main.go

package main

import (
    "time"
    "tcpIp/server"
    "tcpIp/client"
)

func main() {
    // Start server in background
    go func() {
        server.StartServer()
    }()

    // Give server a moment to start
    time.Sleep(time.Second)

    // Launch client
    client.StartClient()
}

?‍♂️ Ausführen Ihrer Netzwerk-App

go run main.go

? Was Sie gelernt haben

1. Grundlegende Netzwerkkommunikationskonzepte
2. Erstellen eines TCP-Servers in Go
3. Verbinden eines Clients mit dem Server
4. Sicherer Umgang mit Netzwerkverbindungen
5. Grundlegendes Fehlermanagement in der Netzwerkprogrammierung

? Mögliche Verbesserungen

• Authentifizierung
• Unterstützung mehrerer Kunden
• Robuste Fehlerbehandlung
• Verschlüsselung

? Ressourcen

• Go's Net-Paketdokumentation
• Grundlagen des TCP/IP-Protokolls
• Gleichzeitige Programmierung in Go

Referenzen

Verwaltung. (2023, 9. August). Lernen Sie TCP/IP mit dem kostenlosen Switching- und Routing-Leitfaden für alle. Cursin. https://cursin.net/en/learn-tcp-ip-with-the-free-switching-and-routing-guide-for-everyone/

Woodbeck, A. (2021). Netzwerkprogrammierung mit Go. Nein Starch Press, Inc.

Viel Spaß beim Netzwerken! ??

Das obige ist der detaillierte Inhalt vonNetzwerk: Ihr erster TCP/IP-Server und -Client in Go. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!