Python-Serverprogrammierung: Erstellen eines asynchronen Mehrbenutzer-Chatrooms mit Twisted

Python-Serverprogrammierung: Erstellen Sie einen asynchronen Mehrbenutzer-Chatroom mit Twisted

In der modernen Informatik sind Netzwerkanwendungen zu einem der wichtigsten Teile davon geworden. Die serverseitige Programmierung ist ein integraler Bestandteil dieser Netzwerkanwendungen. Als höhere Programmiersprache verfügt Python über sehr leistungsstarke serverseitige Programmierfunktionen. Twisted ist ein asynchrones Netzwerk-Framework, das es uns ermöglicht, effiziente, ereignisgesteuerte Netzwerkanwendungen über Python zu schreiben. In diesem Artikel erfahren Sie, wie Sie mit Twisted einen asynchronen Mehrbenutzer-Chatroom erstellen.

1. Was ist verdreht?

Twisted ist ein Python-Framework zum Schreiben ereignisbasierter Webanwendungen und Clients. Es handelt sich um ein asynchrones Netzwerk-Framework, das sich sehr gut zum Schreiben umfangreicher, hochgradig gleichzeitiger Netzwerkanwendungen wie Webserver, Chat-Programme, Mail-Server usw. eignet.

2. Twisted-Chatroom-Architektur

Lassen Sie uns zunächst einen Blick auf die Architektur des Twisted-Chatrooms werfen:

• Der Twisted-Server lauscht auf einen TCP-Port und wartet auf Client-Verbindungen.
• Immer wenn ein Client erfolgreich eine Verbindung herstellt, erstellt der Server eine neue ChatProtocol-Instanz.
• Jede ChatProtocol-Instanz stellt eine Client-Verbindung dar und verarbeitet alle Ein- und Ausgaben des Clients.
• Wenn eine ChatProtocol-Instanz eine neue Nachricht empfängt, leitet sie die Nachricht an alle anderen Clients weiter.

3. Twisted-Chatroom implementieren

Als nächstes verwenden wir Twisted, um unseren Chatroom zu implementieren! Zuerst müssen wir die Twisted-Bibliothek installieren:

pip install twisted

Dann müssen wir eine ChatProtocol-Klasse definieren, um alle Verbindungen und Nachrichten zu verarbeiten:

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

Im obigen Code definieren wir eine ChatProtocol-Klasse, die von der Protocol-Klasse erbt. Diese Klasse definiert Methoden zur Verarbeitung von Verbindungen und Nachrichten.

In der Methode __init__ initialisieren wir die Variablen factory und name. factory ist eine Factory-Klasse, die zum Verwalten aller Client-Verbindungen verwendet wird, und name stellt den Namen des Clients dar. Wenn ein Client erfolgreich eine Verbindung herstellt, name > ist Keine. __init__方法中，我们初始化变量factory和name。factory是一个用于管理所有客户端连接的工厂类，而name表示客户端的名称，当一个客户端连接成功时，name为None。

在connectionMade方法中，我们添加新的客户端连接，并发送通知消息到所有其他客户端。

在connectionLost方法中，我们移除已经断开的客户端，并发送通知消息到所有其他客户端。

在dataReceived方法中，我们处理收到的消息。如果客户端的名称为None，那么我们将这个消息设置为客户端的名称，并发送通知消息到所有其他客户端。否则，我们将这个消息发送到所有其他客户端。

最后，在sendMessage方法中，我们将消息发送到客户端。

现在，我们需要定义一个ChatFactory类，用于管理所有的客户端连接：

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)

在上面的代码中，我们定义了一个ChatFactory类，它继承自Factory类，这个类定义了用于创建新的ChatProtocol实例的方法。

在__init__方法中，我们初始化变量clients，该变量用于存储所有的客户端连接。

在buildProtocol方法中，我们创建一个新的ChatProtocol实例，并将self传递给它。

最后，在notifyAllClients方法中，我们向所有客户端发送一条消息。

现在，我们已经定义了ChatProtocol类和ChatFactory类，接下来让我们创建一个Twisted服务器，并将ChatFactory作为它的工厂：

from twisted.internet import reactor

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

在上面的代码中，我们首先创建一个ChatFactory实例，并将它传递给Twisted服务器的listenTCP

In der Methode connectionMade fügen wir eine neue Client-Verbindung hinzu und senden Benachrichtigungen an alle anderen Clients.

In der Methode connectionLost entfernen wir den getrennten Client und senden Benachrichtigungen an alle anderen Clients.

In der Methode dataReceived verarbeiten wir die empfangene Nachricht. Wenn der Name des Clients None ist, setzen wir diese Nachricht auf den Namen des Clients und senden Benachrichtigungen an alle anderen Clients. Andernfalls senden wir diese Nachricht an alle anderen Kunden.

Schließlich senden wir in der Methode sendMessage die Nachricht an den Client.

Jetzt müssen wir eine ChatFactory-Klasse definieren, um alle Client-Verbindungen zu verwalten:

python chat_server.py

Im obigen Code definieren wir eine ChatFactory-Klasse, die von der Factory-Klasse erbt. Diese Klasse definiert die Funktionen, die zum Erstellen einer neuen Methode verwendet werden ChatProtocol-Instanz.

In der Methode __init__ initialisieren wir die Variable clients, die zum Speichern aller Client-Verbindungen verwendet wird. 🎜🎜In der Methode buildProtocol erstellen wir eine neue ChatProtocol-Instanz und übergeben ihr self. 🎜🎜Abschließend senden wir in der Methode notifyAllClients eine Nachricht an alle Clients. 🎜🎜Nachdem wir nun die ChatProtocol-Klasse und die ChatFactory-Klasse definiert haben, erstellen wir einen Twisted-Server und verwenden ChatFactory als Factory: 🎜

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

🎜Im obigen Code erstellen wir zunächst eine ChatFactory-Instanz und fügen sie Passed zum listenTCP-Methode. Diese Methode gibt an, dass der Server auf alle Verbindungen am TCP-Port 1234 wartet. Schließlich starten wir den Twisted-Server, damit er auf Verbindungen wartet und Nachrichten verarbeitet. 🎜🎜4. Verwendung von Twisted Chat Room🎜🎜Jetzt haben wir mit Twisted erfolgreich einen asynchronen Mehrbenutzer-Chatroom erstellt. Stellen wir es auf die Probe! Zuerst müssen wir den serverseitigen Python-Code ausführen: 🎜rrreee🎜 Dann müssen wir den clientseitigen Python-Code in mehreren Terminalfenstern ausführen: 🎜rrreee🎜Im obigen Code stellen wir zunächst eine TCP-Verbindung zum Server her -seitiger 1234-Port. Senden Sie dann den Namen jedes Clients zusammen mit der Nachricht, die er senden möchte. Wenn Sie diesen Code in mehreren Terminalfenstern ausführen, können mehrere Benutzer gleichzeitig dem Chatroom beitreten und in Echtzeit miteinander kommunizieren. 🎜🎜Zusammenfassung🎜🎜In diesem Artikel stellen wir das Twisted-Framework vor und wie man es zum Erstellen asynchroner Mehrbenutzer-Chatrooms verwendet. Anhand dieses Beispiels haben wir die leistungsstarken asynchronen Netzwerkprogrammierfunktionen von Twisted und die Fähigkeit, effiziente ereignisgesteuerte Netzwerkanwendungen über Python zu schreiben, kennengelernt. 🎜

Das obige ist der detaillierte Inhalt vonPython-Serverprogrammierung: Erstellen eines asynchronen Mehrbenutzer-Chatrooms mit Twisted. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!