Rangkaian Linux dan TCP/IP untuk Pembangun · Pelajaran

Soket Pelanggan-Pelayan TCP

Laksanakan komunikasi yang boleh dipercayai dan berorientasikan sambungan dengan membina aplikasi pelanggan serta pelayan TCP asas dalam Python.

Pelajaran 2 daripada 411 langkah

Soket Pelanggan-Pelayan TCP ialah pelajaran Rangkaian Linux dan TCP/IP untuk Pembangun percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Rangkaian Linux dan TCP/IP untuk Pembangun, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Rangkaian Linux dan TCP/IP untuk Pembangun merangkumi sejumlah 4 pelajaran.

Socket TCP: Sambungan Dahulu

Selamat datang ke pembinaan aplikasi rangkaian dengan Python! Pelajaran ini memfokuskan pada socket TCP (Protokol Kawalan Penghantaran), yang menjadi tulang belakang komunikasi internet yang boleh dipercayai.

Tidak seperti UDP, TCP ialah protokol berorientasikan sambungan. Ini bermakna pautan langsung dan stabil diwujudkan antara dua aplikasi sebelum sebarang data dihantar.

Mengapa TCP Boleh Dipercayai

TCP memastikan data anda tiba dengan betul dan mengikut turutan. TCP mengendalikan:

Penghantaran Terjamin: Segmen data dihantar semula jika hilang.
Data Mengikut Turutan: Data tiba mengikut turutan penghantarannya.
Pemeriksaan Ralat: Keutuhan data disahkan.
Kawalan Aliran: Menghalang penghantar yang pantas daripada membebankan penerima yang perlahan.

Hal ini menjadikan TCP sesuai untuk pelayaran web, e-mel dan pemindahan fail.

Pelayan TCP: Pendengar

Peranan pelayan TCP adalah untuk mendengar sambungan masuk daripada klien. Berikut ialah aliran kerja biasa bagi pelayan:

Cipta socket.
Ikat socket pada alamat IP dan port.
Dengar sambungan klien.
Terima sambungan masuk.
Berkomunikasi (hantar/terima data).
Tutup socket.

Mencipta Socket TCP Python

Dalam Python, kita menggunakan modul socket terbina dalam. Untuk mencipta socket TCP, kita menentukan socket.AF_INET bagi pengalamatan IPv4 dan socket.SOCK_STREAM bagi TCP.

Cuba jalankan contoh asas ini:

import socket

def main():
    # Create a TCP/IP socket
    # AF_INET for IPv4, SOCK_STREAM for TCP
    tcp_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    print("TCP socket created successfully!")
    tcp_socket.close()
    print("Socket closed.")

if __name__ == "__main__":
    main()

Pelayan: Ikat pada Alamat dan Port

Selepas mencipta socket, pelayan perlu mengikatnya pada alamat IP dan nombor port tertentu. Ini memberitahu sistem pengendalian tempat pelayan akan mendengar sambungan.

.bind((HOST, PORT)) mengaitkan socket tersebut. .listen(backlog) menyediakannya untuk menerima sambungan, dengan backlog sebagai bilangan maksimum sambungan dalam baris gilir.

import socket

def main():
    HOST = '127.0.0.1'  # Localhost
    PORT = 65432        # Port to listen on (non-privileged)

    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        server_socket.bind((HOST, PORT))
        server_socket.listen(1) # Allow 1 pending connection
        print(f"Server listening on {HOST}:{PORT}")
    except Exception as e:
        print(f"Error binding or listening: {e}")
    finally:
        server_socket.close()
        print("Server socket closed.")

if __name__ == "__main__":
    main()

Pelayan: Menerima Klien

Kaedah .accept() amat penting bagi pelayan. Kaedah ini menyekat pelaksanaan sehingga klien cuba berhubung. Apabila sambungan diwujudkan, kaedah ini mengembalikan dua nilai:

Objek socket baharu (conn) untuk berkomunikasi dengan klien tertentu itu.
Alamat klien (addr), iaitu tuple (host, port).

import socket

def main():
    HOST = '127.0.0.1'
    PORT = 65432

    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind((HOST, PORT))
    server_socket.listen(1)
    print(f"Server waiting for connection on {HOST}:{PORT}...")

    # This will block until a client connects
    conn, addr = server_socket.accept()
    with conn: # Use 'with' for auto-closing the client socket
        print(f"Connected by client from {addr}")
        # In a real app, send/recv would happen here
        conn.sendall(b"Hello from server!") # Send some bytes
        print("Sent greeting to client.")
    server_socket.close()
    print("Server socket closed.")

if __name__ == "__main__":
    main()

Klien TCP: Memulakan Sambungan

Peranan klien TCP adalah untuk memulakan sambungan kepada pelayan. Berikut ialah aliran kerja biasanya:

Cipta socket.
Berhubung dengan alamat IP dan port pelayan.
Berkomunikasi (hantar/terima data).
Tutup socket.

Klien: Berhubung dengan Pelayan

Klien menggunakan kaedah .connect((HOST, PORT)) untuk mewujudkan sambungan dengan pelayan. Jika berjaya, litar maya dicipta. Jika pelayan tidak mendengar, anda akan menerima ConnectionRefusedError.

Jalankan kod ini. Jika tiada pelayan yang sedang berjalan, ralat akan dipaparkan:

import socket

def main():
    HOST = '127.0.0.1'  # Server's IP address
    PORT = 65432        # Server's port

    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        print(f"Attempting to connect to server at {HOST}:{PORT}...")
        client_socket.connect((HOST, PORT))
        print("Successfully connected to the server!")
    except ConnectionRefusedError:
        print("Connection refused. Is the server running?")
    except Exception as e:
        print(f"Client connection error: {e}")
    finally:
        client_socket.close()
        print("Client socket closed.")

if __name__ == "__main__":
    main()

Menghantar dan Menerima Data

Selepas berhubung, klien dan pelayan boleh menghantar serta menerima data. Ingat bahawa data rangkaian dihantar sebagai bita, jadi anda biasanya perlu menggunakan .encode() pada rentetan sebelum menghantarnya dan menukar semula bita yang diterima menjadi rentetan dengan .decode().

.sendall(data): Menghantar semua data dengan boleh dipercayai.
.recv(buffer_size): Menerima sehingga buffer_size bita.

import socket

def main():
    HOST = '127.0.0.1'
    PORT = 65432

    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        client_socket.connect((HOST, PORT))
        message = "Hello from the client!"
        client_socket.sendall(message.encode('utf-8'))
        print(f"Client sent: '{message}'")

        data = client_socket.recv(1024) # Receive up to 1024 bytes
        if data:
            print(f"Client received: '{data.decode('utf-8')}'")
        else:
            print("Client received no data (server might have closed).")
    except ConnectionRefusedError:
        print("Connection refused. Please run the server example first!")
    except Exception as e:
        print(f"Client communication error: {e}")
    finally:
        client_socket.close()
        print("Client socket closed.")

if __name__ == "__main__":
    main()

Aliran Komunikasi TCP

Pertimbangkan langkah biasa yang dilakukan oleh pelayan TCP Python untuk mewujudkan sambungan dan oleh klien gema untuk berkomunikasi.

Jawab dalam pelajaran interaktif

Imbas Kembali: Socket Klien-Pelayan TCP

Syabas! Anda telah mempelajari asas komunikasi klien-pelayan TCP dalam Python:

TCP menyediakan komunikasi yang boleh dipercayai dan berorientasikan sambungan.
Pelayan bind pada alamat, listen untuk sambungan dan accept klien.
Klien connect ke alamat pelayan.
Kedua-duanya menggunakan .sendall() untuk menghantar dan .recv() untuk menerima bita.

Konsep ini amat penting untuk membina aplikasi rangkaian yang kukuh!

Percuma untuk bermula

Pelajari Rangkaian Linux dan TCP/IP untuk Pembangun dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 12
Pelajaran: 48

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Soket Pelanggan-Pelayan TCP” percuma?

Ya — teks penuh “Soket Pelanggan-Pelayan TCP” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Rangkaian Linux dan TCP/IP untuk Pembangun, tingkat taraf kepada CoddyKit PRO. Kursus Rangkaian Linux dan TCP/IP untuk Pembangun merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Soket Pelanggan-Pelayan TCP”?

Laksanakan komunikasi yang boleh dipercayai dan berorientasikan sambungan dengan membina aplikasi pelanggan serta pelayan TCP asas dalam Python. Anda berlatih Rangkaian Linux dan TCP/IP untuk Pembangun menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Rangkaian Linux dan TCP/IP untuk Pembangun?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Rangkaian Linux dan TCP/IP untuk Pembangun di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “Soket Pelanggan-Pelayan TCP” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Rangkaian Linux dan TCP/IP untuk Pembangun ini?

Ya. Setiap pelajaran Rangkaian Linux dan TCP/IP untuk Pembangun menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Rangkaian Linux dan TCP/IP untuk Pembangun