Programmation serveur Python : création d'une salle de discussion multi-utilisateurs asynchrone à l'aide de Twisted

Programmation de serveur Python : Utiliser Twisted pour créer une salle de discussion multi-utilisateurs asynchrone

Dans l'informatique moderne, les applications réseau en sont devenues l'une des parties les plus importantes. La programmation côté serveur fait partie intégrante de ces applications réseau. En tant que langage de programmation de haut niveau, Python possède des capacités de programmation côté serveur très puissantes. Twisted est un framework réseau asynchrone qui nous permet d'écrire des applications réseau efficaces et basées sur les événements via Python. Dans cet article, nous explorerons comment créer une salle de discussion multi-utilisateurs asynchrone à l'aide de Twisted.

1. Qu'est-ce que Twisted ?

Twisted est un framework Python permettant d'écrire des applications et des clients Web basés sur des événements. Il s'agit d'un framework réseau asynchrone très adapté à l'écriture d'applications réseau à grande échelle et hautement concurrentes, telles que des serveurs Web, des programmes de chat, des serveurs de messagerie, etc.

2. Architecture du salon de discussion Twisted

Jetons d'abord un coup d'œil à l'architecture du salon de discussion Twisted :

• Twisted Le serveur écoute un port TCP et attend que le client se connecte.
• Chaque fois qu'un client se connecte avec succès, le serveur crée une nouvelle instance de ChatProtocol.
• Chaque instance de ChatProtocol représente une connexion client et gère toutes les entrées et sorties du client.
• Lorsqu'une instance de ChatProtocol reçoit un nouveau message, elle transmet le message à tous les autres clients.

3. Implémenter la salle de discussion Twisted

Ensuite, utilisons Twisted pour implémenter notre salle de discussion ! Tout d'abord, nous devons installer la bibliothèque Twisted :

pip install twisted

Ensuite, nous devons définir une classe ChatProtocol pour gérer toutes les connexions et tous les messages :

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

Dans le code ci-dessus, nous Une classe ChatProtocol est définie, qui hérite de la classe Protocol. Cette classe définit les méthodes de traitement des connexions et des messages.

Dans la méthode __init__, on initialise les variables factory et name. factory est une classe d'usine utilisée pour gérer toutes les connexions client, et name représente le nom du client lorsqu'un client se connecte avec succès, name >. est Aucun. __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

Dans la méthode connectionMade, nous ajoutons une nouvelle connexion client et envoyons des messages de notification à tous les autres clients.

Dans la méthode connectionLost, nous supprimons le client déconnecté et envoyons des messages de notification à tous les autres clients.

Dans la méthode dataReceived, nous traitons le message reçu. Si le nom du client est Aucun, alors nous définissons ce message sur le nom du client et envoyons des messages de notification à tous les autres clients. Sinon, nous envoyons ce message à tous les autres clients.

Enfin, dans la méthode sendMessage, on envoie le message au client.

Maintenant, nous devons définir une classe ChatFactory pour gérer toutes les connexions clients :

python chat_server.py

Dans le code ci-dessus, nous définissons une classe ChatFactory, qui hérite de la classe Factory, cette classe définit des méthodes pour créer de nouvelles instances de ChatProtocol.

Dans la méthode __init__, on initialise la variable clients, qui sert à stocker toutes les connexions clients. #🎜🎜##🎜🎜#Dans la méthode buildProtocol, nous créons une nouvelle instance de ChatProtocol et lui passons self. #🎜🎜##🎜🎜#Enfin, dans la méthode notifyAllClients, nous envoyons un message à tous les clients. #🎜🎜##🎜🎜#Maintenant que nous avons défini la classe ChatProtocol et la classe ChatFactory, créons un serveur Twisted et utilisons ChatFactory comme usine : #🎜🎜#

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

#🎜🎜#Dans le code ci-dessus, nous créons d'abord un ChatFactory et transmettez-la à la méthode listenTCP du serveur Twisted. Cette méthode indique que le serveur écoutera toutes les connexions sur le port TCP 1234. Enfin, nous démarrons le serveur Twisted pour qu'il commence à écouter les connexions et à traiter les messages. #🎜🎜##🎜🎜#4. Utilisation de Twisted Chat Room#🎜🎜##🎜🎜#Maintenant, nous avons réussi à créer une salle de discussion multi-utilisateurs asynchrone à l'aide de Twisted. Mettons-le à l'épreuve ! Tout d'abord, nous devons exécuter le code Python côté serveur : #🎜🎜#rrreee#🎜🎜# Ensuite, nous devons exécuter le code Python côté client dans plusieurs fenêtres de terminal : #🎜🎜#rrreee#🎜🎜# Dans le code ci-dessus, nous établissons d'abord une connexion TCP au port 1234 côté serveur, puis envoyons le nom de chaque client et le message qu'il souhaite envoyer. L'exécution de ce code dans plusieurs fenêtres de terminal permet à plusieurs utilisateurs de rejoindre la salle de discussion en même temps et de communiquer entre eux en temps réel. #🎜🎜##🎜🎜#Résumé#🎜🎜##🎜🎜#Dans cet article, nous avons présenté le framework Twisted et comment l'utiliser pour créer des salles de discussion multi-utilisateurs asynchrones. Grâce à cet exemple, nous avons découvert les puissantes capacités de programmation réseau asynchrone de Twisted et la capacité d'écrire des applications réseau efficaces basées sur des événements via Python. #🎜🎜#

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!