Le modèle de conception médiateur est un modèle de conception comportemental qui aide à réduire le couplage entre les composants d'une application en leur permettant de communiquer entre eux indirectement via un objet médiateur.

Bibliothèques Python populaires qui utilisent ce modèle de conception

Ce modèle de conception est un modèle largement utilisé dans le développement de logiciels, et Python possède de nombreuses bibliothèques populaires qui l'utilisent.

Voici quelques exemples:

1. Django Signals : Django Signals fait partie du framework web Django qui fournit un moyen de découpler les composants d'une application en leur permettant d'envoyer et de recevoir des signaux. Le framework Signals utilise le modèle de conception Mediator pour gérer la communication entre les composants.
2. Pygame : Pygame est un ensemble de modules Python permettant de créer des jeux vidéo. Pygame utilise le modèle Mediator pour dissocier la logique du jeu des graphismes du jeu et de la gestion des entrées. L'objet Mediator dans Pygame s'appelle la file d'attente d'événements et gère le flux d'événements dans le jeu.
3. PyQt : PyQt est un ensemble de liaisons Python pour le framework d'application Qt. Le framework Qt utilise largement le modèle Mediator pour découpler les différents composants de l'interface utilisateur. PyQt fournit un ensemble de classes qui implémentent le modèle Mediator, telles que la QSignalMapperclasse.
4. Flask-Signals : Flask-Signals est une extension Flask qui fournit un moyen simple d'ajouter des signaux à votre application Flask. Flask-Signals utilise le modèle Mediator pour découpler les différentes parties de l'application et fournit un moyen d'enregistrer et de répartir les signaux.
5. PyMediator : PyMediator est une bibliothèque Python qui fournit une implémentation simple du modèle Mediator. Il vous permet de créer un objet médiateur et d'enregistrer des composants qui doivent communiquer entre eux. Il fournit un moyen d'envoyer des messages entre les composants via l'objet médiateur.

Comment ça fonctionne

En Python, vous pouvez implémenter le modèle de médiateur à l'aide de classes et de méthodes.

Voici un exemple:

class Mediator:
    def __init__(self):
        self.components = []

    def register_component(self, component):
        self.components.append(component)

    def notify(self, sender):
        for component in self.components:
            if component != sender:
                component.receive(sender)

class Component:
    def __init__(self, mediator):
        self.mediator = mediator

    def send(self):
        self.mediator.notify(self)

    def receive(self, sender):
        print(f"Received message from {sender}")

if __name__ == '__main__':
    mediator = Mediator()
    component1 = Component(mediator)
    component2 = Component(mediator)
    mediator.register_component(component1)
    mediator.register_component(component2)

    component1.send() # Sends message to the mediator

La Componentclasse représente les composants individuels de l'application. La sendméthode envoie un message au médiateur en appelant la notifyméthode du médiateur. La receiveméthode reçoit le message du médiateur et imprime un message sur la console.

Dans la fonction principale, nous créons un médiateur et deux composants. Nous enregistrons les deux composants auprès du médiateur en utilisant la register_componentméthode. Ensuite, nous appelons la sendméthode de l'un des composants, qui envoie un message au médiateur. Le médiateur avertit l'autre composant, qui imprime un message sur la console.

Ceci n'est qu'un exemple simple, mais le modèle de médiateur peut être utile pour des applications plus complexes où plusieurs composants doivent communiquer entre eux de manière découplée.

Merci pour votre temps!

N'hésitez pas à , partager et suivre !