Rangkaian : Pelayan dan Klien TCP/IP Pertama anda dalam Go

? Apa yang Akan Kita Pelajari

Dalam tutorial ini, kami akan mengemiskan pengaturcaraan rangkaian dengan membina pelayan dan klien TCP/IP yang ringkas namun mantap. Jika anda pernah tertanya-tanya bagaimana aplikasi berkomunikasi melalui rangkaian, panduan ini adalah untuk anda!

? Prasyarat

• Pengetahuan pengaturcaraan Asas Go
• Perasaan ingin tahu tentang rangkaian
• Penyunting teks
• Pergi dipasang pada komputer anda
• Modul Go ditambahkan (gunakan go mod init tcpIp)

? Memahami Komunikasi Rangkaian

Sebelum kita menyelami kod, mari kita pecahkan perkara yang berlaku apabila dua komputer bercakap:

1. TCP/IP: Anggap ia seperti panggilan telefon

   • TCP (Protokol Kawalan Penghantaran): Memastikan mesej dihantar sepenuhnya dan teratur
   • IP (Internet Protocol): Membantu menghalakan mesej ke peranti yang betul

2. Peranan Pelayan dan Pelanggan:

   • Pelayan: Menunggu dan mendengar sambungan masuk
   • Pelanggan: Memulakan hubungan dan menghantar permintaan

?️ Struktur Projek

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

? Langkah 1: Mencipta Pelayan

Memahami Kod Pelayan

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)
    }
}

Konsep Utama Diterangkan

• net.Listen(): Mencipta "soket" rangkaian untuk menerima sambungan
• listener.Accept(): Menunggu dan menerima sambungan masuk
• go handleClient(conn): Mengendalikan setiap klien dalam benang berasingan (goroutine)

? Mengendalikan Sambungan Pelanggan

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))
    }
}

Apa yang Berlaku Di Sini?

• penimbal: Storan sementara untuk mesej masuk
• conn.Read(): Menerima mesej daripada klien
• conn.Write(): Menghantar mesej kembali kepada klien

?️ Langkah 2: Mencipta Pelanggan

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]))
    }
}

Mekanik Pelanggan

• net.Dial(): Sambung ke pelayan
• scanner.Scan(): Baca input papan kekunci pengguna
• conn.Write(): Hantar mesej ke pelayan
• conn.Read(): Terima jawapan pelayan

? Membawa Semuanya Bersama: 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()
}

?‍♂️ Menjalankan Apl Rangkaian Anda

go run main.go

? Apa yang Anda Pelajari

1. Konsep komunikasi rangkaian asas
2. Mencipta pelayan TCP dalam Go
3. Menyambungkan pelanggan ke pelayan
4. Mengendalikan sambungan rangkaian dengan selamat
5. Pengurusan ralat asas dalam pengaturcaraan rangkaian

? Potensi Penambahbaikan

• Pengesahan
• Sokongan pelanggan berbilang
• Pengendalian ralat yang mantap
• Penyulitan

? Sumber

• Dokumentasi pakej Go's net
• Asas protokol TCP/IP
• Pengaturcaraan serentak dalam Go

Rujukan

Pentadbiran.(2023, 9 Ogos). Pelajari TCP/IP dengan Panduan Penukaran dan Penghalaan Percuma untuk Semua Orang. Cursin. https://cursin.net/en/learn-tcp-ip-with-the-free-switching-and-routing-guide-for-everyone/

Woodbeck, A. (2021). Pengaturcaraan Rangkaian dengan Go. Tiada Starch Press, Inc.

Selamat Berrangkaian! ??

Atas ialah kandungan terperinci Rangkaian : Pelayan dan Klien TCP/IP Pertama anda dalam Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!