Dalam blog ini, kami akan melaksanakan ruang sembang TCP yang berfungsi sepenuhnya menggunakan Python. Kami akan mempunyai satu pelayan yang mengehoskan bilik dan berbilang pelanggan yang menyambung kepadanya dan berkomunikasi antara satu sama lain.
Protokol Kawalan Penghantaran ialah protokol berorientasikan sambungan untuk komunikasi yang membantu dalam pertukaran mesej antara peranti berbeza melalui rangkaian.
Untuk melaksanakan bilik sembang kami, kami akan menggunakan seni bina pelayan-klien. Ini bermakna kami akan mempunyai berbilang pelanggan (pengguna) dan satu pelayan pusat yang mengehoskan segala-galanya dan menyediakan data untuk pelanggan ini.
1. Untuk menyediakan pelayan asas kami, kami perlu mengimport dua perpustakaan, iaitu soket dan threading. perpustakaan soket akan digunakan untuk mewujudkan dan menyediakan sambungan rangkaian dan perpustakaan berbenang diperlukan untuk melaksanakan pelbagai tugas pada masa yang sama.
import socket import threading
2. Tugas seterusnya ialah untuk menentukan data pelayan kami dan untuk memulakan soket kami. Kami memerlukan alamat IP untuk hos dan nombor port percuma untuk pelayan kami. Dalam blog ini, kami akan menggunakan alamat 127.0.0.1 iaitu localhost dan port 5500 kami.
Nombor port tidak relevan tetapi anda perlu memastikan port yang anda gunakan adalah percuma dan tidak dikhaskan. Jika anda menjalankan bilik sembang ini pada pelayan sebenar atau mesin maya, nyatakan alamat IP pelayan bilik sembang sebagai alamat IP hos mesin maya atau pelayan.
Lihat senarai nombor port yang ditempah ini untuk maklumat lanjut.
# Server Data host = '127.0.0.1' port = 5500
3. Apabila kita menentukan soket kita, kita perlu lulus dua parameter. Ini menentukan jenis soket yang ingin kita gunakan. Yang pertama (AF_INET) menunjukkan bahawa kami menggunakan soket internet dan bukannya soket unix. Parameter kedua bermaksud protokol yang ingin kami gunakan. SOCK_STREAM menunjukkan bahawa kami menggunakan TCP.
Selepas menentukan soket, kami mengikat atau melampirkannya pada hos kami dan port yang ditentukan dengan menghantar tuple yang mengandungi kedua-dua nilai. Kami kemudiannya akan meletakkan pelayan kami ke dalam mod mendengar, supaya ia menunggu untuk pelanggan menyambung dan menghantar mesej..
# Start the Server server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server.bind((host, port)) server.listen()
4. Kami juga akan membuat dua senarai kosong, yang akan kami gunakan untuk menyimpan pelanggan yang disambungkan dan nama panggilan mereka kemudian hari.
import socket import threading
5. Sekarang kami akan mentakrifkan semua fungsi yang akan membantu kami dalam mesej penyiaran. Ia akan menghantar mesej kepada setiap pelanggan yang disambungkan dan oleh itu terdapat dalam senarai pelanggan.
# Server Data host = '127.0.0.1' port = 5500
6. Sekarang kita akan mencipta fungsi handle(). Fungsi ini akan bertanggungjawab untuk mengendalikan mesej daripada pelanggan. Fungsi ini akan berjalan dalam gelung sementara. Fungsi ini akan menerima klien sebagai parameter dan mengendalikannya dalam gelung yang tidak berkesudahan sehingga ralat berlaku atau klien itu sendiri memutuskan sambungan.
# Start the Server server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server.bind((host, port)) server.listen()
7. Kini kami perlu menerima mesej daripada pelanggan dan menyiarkannya kepada semua pelanggan yang berkaitan. Jadi apabila seorang pelanggan menghantar mesej, orang lain boleh melihat mesej ini melalui fungsi broadcast(). Sekarang jika atas sebab tertentu terdapat ralat dengan sambungan kepada pelanggan ini, kami mengalih keluarnya dan nama panggilannya, menutup sambungan dan menyiarkan bahawa pelanggan ini telah meninggalkan sembang.
# Lists For Clients and Their Nicknames clients = [] nicknames = []
Apabila kami bersedia untuk menjalankan pelayan kami, kami akan melaksanakan fungsi terima ini. Sebaik sahaja pelanggan disambungkan ke pelayan, ia akan menghantar rentetan 'NAME' kepadanya, yang akan memberitahu pelanggan bahawa nama panggilannya diminta. Selepas itu ia menunggu respons dan menambahkan klien dengan nama samaran masing-masing pada senarai dan memulakan utas untuk fungsi handle() untuk klien tertentu itu.
8. Kini kami hanya boleh menjalankan fungsi ini dan pelayan kami selesai.
# Sending Messages To All Connected Clients def broadcast(message): for client in clients: client.send(message)
Sekarang kami akan melaksanakan pelanggan kami. Untuk ini, kami sekali lagi perlu mengimport perpustakaan yang sama.
# Handling Clients def handle(client): while True: try: # Broadcasting Messages message = client.recv(1024) broadcast(message) except: # Removing And Closing Clients index = clients.index(client) clients.remove(client) client.close() nickname = nicknames[index] broadcast('{} left!'.format(nickname).encode('ascii')) nicknames.remove(nickname) break
1. Langkah pertama pelanggan ialah memilih nama panggilan dan menyambung ke pelayan kami. Kami perlu mengetahui alamat yang tepat dan port di mana pelayan kami sedang berjalan. Daripada mengikat data dan mendengar, sebagai pelanggan kami menyambung ke pelayan sedia ada.
# Receiving `Function def receive(): while True: # Accept Connection client, address = server.accept() print("Connected with {}".format(str(address))) # Request And Store Nickname client.send('NAME'.encode('ascii')) nickname = client.recv(1024).decode('ascii') nicknames.append(nickname) clients.append(client) # Print And Broadcast Nickname print("Nickname is {}".format(nickname)) broadcast("{} joined!".format(nickname).encode('ascii')) client.send('Connected to server!'.encode('ascii')) # Start Handling Thread For Client thread = threading.Thread(target=handle, args=(client,)) thread.start()
2. Kini, pelanggan perlu mempunyai dua utas yang berjalan pada masa yang sama. Yang pertama akan sentiasa menerima data daripada pelayan dan yang kedua akan menghantar mesej kita sendiri ke pelayan.
receive()
Sekali lagi kami mempunyai gelung sementara yang tidak berkesudahan di sini. Ia sentiasa cuba menerima mesej dan mencetaknya pada skrin. Walau bagaimanapun, jika mesej itu ialah 'NAME', ia tidak mencetaknya tetapi ia menghantar nama panggilannya ke pelayan.
Fungsi penulisan agak singkat. Ia juga berjalan dalam gelung tidak berkesudahan yang sentiasa menunggu input daripada pengguna. Sebaik sahaja ia mendapat beberapa, ia menggabungkannya dengan nama panggilan dan menghantarnya ke pelayan.
3. Perkara terakhir yang perlu kita lakukan ialah memulakan dua utas yang menjalankan dua fungsi ini.
import socket import threading
Dan kini kita sudah selesai. Kami mempunyai pelayan yang berfungsi sepenuhnya dan pelanggan yang berfungsi yang boleh menyambung kepadanya dan berkomunikasi antara satu sama lain.
Mari pergi untuk menjalankan ujian. Perlu diingat bahawa kami sentiasa perlu memulakan pelayan terlebih dahulu kerana jika tidak, pelanggan tidak dapat menyambung ke hos yang tidak wujud.
*Log Pelayan : *
# Server Data host = '127.0.0.1' port = 5500
*Log Pelanggan Satu : *
# Start the Server server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) server.bind((host, port)) server.listen()
*Log Pelanggan Dua : *
# Lists For Clients and Their Nicknames clients = [] nicknames = []
Cari Kod Penuh Di Sini :https://github.com/rajatuiwebdev/tcp-chatroom-in-python
Ikuti saya di Instagram : https://instagram.com/rajatrajput.dev
Ikuti saya di LinkedIn : https://linkedin.com/in/rajatrajput2004
Atas ialah kandungan terperinci Bilik Sembang TCP dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!