Pengaturcaraan Pelayan Python: Membina Bilik Sembang Berbilang Pengguna Asynchronous dengan Twisted

Pengaturcaraan Pelayan Python: Gunakan Twisted untuk membina ruang sembang berbilang pengguna tak segerak

Dalam sains komputer moden, aplikasi rangkaian telah menjadi salah satu bahagian terpentingnya. Pengaturcaraan sebelah pelayan adalah bahagian penting dalam aplikasi rangkaian ini. Sebagai bahasa pengaturcaraan peringkat tinggi, Python mempunyai keupayaan pengaturcaraan sebelah pelayan yang sangat berkuasa. Twisted ialah rangka kerja rangkaian tak segerak yang membolehkan kami menulis aplikasi rangkaian yang didorong oleh peristiwa yang cekap melalui Python. Dalam artikel ini, kami akan meneroka cara membina ruang sembang berbilang pengguna tak segerak menggunakan Twisted.

1. Apakah itu Twisted?

Twisted ialah rangka kerja Python untuk menulis aplikasi web dan pelanggan berasaskan acara. Ia adalah rangka kerja rangkaian tak segerak yang sangat sesuai untuk menulis aplikasi rangkaian berskala besar dan tinggi, seperti pelayan web, program sembang, pelayan mel, dsb.

2. Seni bina bilik sembang Twisted

Mula-mula, mari kita lihat seni bina bilik sembang Twisted:

• Pelayan Twisted mendengar TCP port dan menunggu sambungan pelanggan.
• Setiap kali pelanggan berjaya menyambung, pelayan mencipta tika ChatProtocol baharu.
• Setiap contoh ChatProtocol mewakili sambungan klien dan mengendalikan semua input dan output untuk klien tersebut.
• Apabila tika ChatProtocol menerima mesej baharu, ia memajukan mesej itu kepada semua pelanggan lain.

3. Laksanakan ruang sembang Twisted

Seterusnya, mari kita gunakan Twisted untuk melaksanakan bilik sembang kami! Mula-mula, kita perlu memasang perpustakaan Twisted:

pip install twisted

Kemudian, kita perlu menentukan kelas ChatProtocol untuk mengendalikan semua sambungan dan mesej:

from twisted.internet.protocol import Protocol

class ChatProtocol(Protocol):

    def __init__(self, factory):
        self.factory = factory
        self.name = None

    def connectionMade(self):
        self.factory.clients.add(self)
        self.factory.notifyAllClients("New user connected.")

    def connectionLost(self, reason):
        self.factory.clients.remove(self)
        self.factory.notifyAllClients("User disconnected.")

    def dataReceived(self, data):
        message = data.decode().rstrip()
        
        if self.name is None:
            self.name = message
            self.factory.notifyAllClients("{} joined the room.".format(self.name))
        else:
            self.factory.notifyAllClients("{}: {}".format(self.name, message))

    def sendMessage(self, message):
        self.transport.write(message.encode())

Dalam kod di atas, kami mentakrifkan Kelas ChatProtocol , yang mewarisi daripada kelas Protokol, kelas ini mentakrifkan kaedah untuk mengendalikan sambungan dan mesej.

Dalam kaedah __init__, kami memulakan pembolehubah factory dan name. factory ialah kelas kilang yang digunakan untuk mengurus semua sambungan pelanggan dan name mewakili nama pelanggan Apabila pelanggan berjaya menyambung, name ialah None.

Dalam kaedah connectionMade, kami menambah sambungan pelanggan baharu dan menghantar mesej pemberitahuan kepada semua pelanggan lain.

Dalam kaedah connectionLost, kami mengalih keluar pelanggan yang terputus sambungan dan menghantar mesej pemberitahuan kepada semua pelanggan lain.

Dalam kaedah dataReceived, kami memproses mesej yang diterima. Jika nama pelanggan ialah None, maka kami menetapkan mesej ini kepada nama pelanggan dan menghantar mesej pemberitahuan kepada semua pelanggan lain. Jika tidak, kami menghantar mesej ini kepada semua pelanggan lain.

Akhir sekali, dalam kaedah sendMessage, kami menghantar mesej kepada pelanggan.

Sekarang, kita perlu mentakrifkan kelas ChatFactory untuk mengurus semua sambungan pelanggan:

from twisted.internet.protocol import Factory

class ChatFactory(Factory):

    def __init__(self):
        self.clients = set()

    def buildProtocol(self, addr):
        return ChatProtocol(self)

    def notifyAllClients(self, message):
        for client in self.clients:
            client.sendMessage(message)

Dalam kod di atas, kami mentakrifkan kelas ChatFactory, yang mewarisi daripada kelas Factory, Kelas ini mentakrifkan kaedah untuk mencipta contoh ChatProtocol baharu.

Dalam kaedah __init__, kami memulakan pembolehubah clients, yang digunakan untuk menyimpan semua sambungan klien.

Dalam kaedah buildProtocol, kami mencipta contoh ChatProtocol baharu dan menyerahkan self kepadanya.

Akhir sekali, dalam kaedah notifyAllClients, kami menghantar mesej kepada semua pelanggan.

Sekarang kami telah mentakrifkan kelas ChatProtocol dan kelas ChatFactory, marilah kami mencipta pelayan Twisted dan menggunakan ChatFactory sebagai kilangnya:

from twisted.internet import reactor

factory = ChatFactory()
reactor.listenTCP(1234, factory)
reactor.run()

Dalam kod di atas, kami mula-mula Buat contoh ChatFactory dan serahkannya kepada kaedah listenTCP pelayan Twisted. Kaedah ini menunjukkan bahawa pelayan akan mendengar semua sambungan pada port TCP 1234. Akhir sekali, kami memulakan pelayan Twisted supaya ia mula mendengar sambungan dan memproses mesej.

4. Menggunakan Bilik Sembang Twisted

Kini, kami telah berjaya membina bilik sembang berbilang pengguna tak segerak menggunakan Twisted. Mari kita mengujinya! Pertama, kita perlu menjalankan kod Python sisi pelayan:

python chat_server.py

Kemudian, kita perlu menjalankan kod Python sisi klien dalam berbilang tetingkap terminal:

import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(("localhost", 1234))

sock.sendall("Alice
".encode())
sock.sendall("Hello!
".encode())

sock.sendall("Bob
".encode())
sock.sendall("Hi there!
".encode())

sock.sendall("Charlie
".encode())
sock.sendall("How are you guys?
".encode())

Dalam kod di atas, kita mula-mula buat sambungan TCP ke port 1234 pada bahagian pelayan dan kemudian hantar nama setiap pelanggan, bersama-sama dengan mesej yang mereka mahu hantar. Menjalankan kod ini dalam berbilang tetingkap terminal membolehkan berbilang pengguna menyertai bilik sembang pada masa yang sama dan berkomunikasi antara satu sama lain dalam masa nyata.

Ringkasan

Dalam artikel ini, kami memperkenalkan rangka kerja Twisted dan cara menggunakannya untuk membina bilik sembang berbilang pengguna tak segerak. Melalui contoh ini, kami mengalami keupayaan pengaturcaraan rangkaian tak segerak Twisted yang berkuasa dan keupayaan untuk menulis aplikasi rangkaian dipacu peristiwa yang cekap melalui Python.

Atas ialah kandungan terperinci Pengaturcaraan Pelayan Python: Membina Bilik Sembang Berbilang Pengguna Asynchronous dengan Twisted. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!