Patrons de conception Python

Le patron de conception Mediator en Python

Dans cette leçon, vous allez utiliser le patron Mediator pour que les objets communiquent entre eux par l'intermédiaire d'un objet médiateur.

  • Avancé
  • 2 min de lecture
  • 1 exemple exécutable

Introduction

Le problème

Quand beaucoup d'objets se parlent directement, comme des utilisateurs de chat, des champs de formulaire ou des avions, chaque objet doit connaître tous les autres. Les liaisons se multiplient et modifier un objet en affecte beaucoup d'autres.

Imaginez-le ainsi

Un médiateur ressemble à une application de discussion de groupe. Ada n'envoie jamais un message directement sur le téléphone de Lin : elle l'envoie dans le salon, et le salon le remet à Lin avec le nom d'Ada. Un nouveau membre n'a qu'à rejoindre le salon, sans connaître tous les autres.

D'une discussion de groupe au code
ChatRoom💬 Le salon de discussion au milieu
User("Ada", room)📱 Un membre qui ne connaît que le salon
self.room.send(...)📤 Envoyer au salon, pas à un autre membre
recipient.receive(...)📥 Le salon remet le message au bon membre
Les objets communiquent via un seul coordinateur.
En une phrase

Le pattern Mediator fait passer la communication entre objets par un objet coordinateur unique, pour que les objets ne se référencent pas directement.

Points clés

  1. Chaque User ne connaît que room, le ChatRoom partagé.
  2. ada.send(lin, "Hello") demande au salon de livrer le message.
  3. ChatRoom.send appelle recipient.receive(...) sur le bon utilisateur.
  4. Ajouter des utilisateurs ne change pas la classe User.

Quand l’utiliser ?

  • Les salons de discussion et les centres de messages.
  • Les formulaires où les champs dépendent les uns des autres.
  • Coordonner plusieurs composants qui se référenceraient sinon mutuellement.

Quand s'en passer

  • Deux objets qui ne parlent qu'entre eux : un appel direct est plus simple.
  • Le médiateur devient une classe qui sait tout et fait tout.

Code d’exemple

Exécuter le code →
main.py
class ChatRoom:
    # Mediator: route colleague communication through a coordinator.
    def send(self, sender, recipient, message):
        # Coordinate communication between colleague objects.
        recipient.receive(sender.name, message)


class User:
    def __init__(self, name, room): self.name, self.room = name, room
    def send(self, recipient, message): self.room.send(self, recipient, message)
    def receive(self, sender, message): print(f"{self.name} from {sender}: {message}")


room = ChatRoom()
ada, lin = User("Ada", room), User("Lin", room)
ada.send(lin, "Hello")
Obtenir un bouton Run pour cet exemple

Résultat de l’exécution

Lin from Ada: Hello

Explication du code

ChatRoom joue le rôle de médiateur. Quand Ada envoie un message à Lin, la méthode send() de User transmet le message à ChatRoom, qui le fait suivre au destinataire. Les objets User n'ont pas besoin de savoir comment s'envoyer des messages entre eux, le résultat est donc Lin from Ada: Hello.

Modifiez les valeurs et exécutez le programme avec le compilateur Python en ligne CodeUtility, sans installation locale.

Exercices d’approfondissement

Essayez de modifier le code en suivant les pistes ci-dessous. Changer le code et observer le résultat vous fera bien mieux comprendre la leçon que la simple lecture.

  1. Remplacez le domaine de l’exemple tout en conservant la structure du pattern.
  2. Comparez le pattern à une implémentation plus simple et expliquez les compromis.
  3. Écrivez des tests pour chaque participant avant d’ajouter une autre implémentation.
Exécuter dans le compilateur Python →

Erreurs fréquentes

Des utilisateurs qui s'appellent directement

Chaque utilisateur a alors besoin de références vers tous les autres.

Problème
def send(self, recipient, message):
    recipient.receive(self.name, message)
Correction
def send(self, recipient, message):
    self.room.send(self, recipient, message)

Leçon terminée ?

Marquez-la comme apprise pour suivre votre progression.