Design pattern in Python

Il design pattern Mediator in Python

In questa lezione userai il pattern Mediator perché gli oggetti comunichino tra loro tramite un oggetto intermediario.

  • Avanzato
  • 2 min di lettura
  • 1 esempio eseguibile

Introduzione

Il problema

Quando molti oggetti parlano direttamente tra loro, come utenti di una chat, campi di un modulo o aerei, ogni oggetto deve conoscere tutti gli altri. I collegamenti si moltiplicano e modificare un oggetto costringe a modificarne molti altri.

Immaginalo così

Un mediator è come un'app di chat di gruppo. Ada non manda mai un messaggio direttamente al telefono di Lin: lo manda nella chat, e la chat lo consegna a Lin con il nome di Ada. Un nuovo membro deve solo entrare nella chat, non conoscere tutti gli altri.

Dalla chat di gruppo al codice
ChatRoom💬 La chat in mezzo
User("Ada", room)📱 Un membro che conosce solo la chat
self.room.send(...)📤 Manda alla chat, non a un altro membro
recipient.receive(...)📥 La chat lo consegna al membro giusto
Gli oggetti comunicano tramite un unico coordinatore.
In una frase

Il pattern Mediator fa passare la comunicazione tra gli oggetti da un oggetto coordinatore, così gli oggetti non hanno riferimenti diretti l'uno all'altro.

Punti chiave

  1. Ogni User conosce solo room, la ChatRoom condivisa.
  2. ada.send(lin, "Hello") chiede alla stanza di consegnare il messaggio.
  3. ChatRoom.send chiama recipient.receive(...) sull'utente giusto.
  4. Aggiungere altri utenti non cambia la classe User.

Quando si usa?

  • Chat e hub di messaggi.
  • Moduli in cui i campi dipendono l'uno dall'altro.
  • Coordinare più componenti che altrimenti dovrebbero conoscersi tutti a vicenda.

Quando non serve

  • Due oggetti che parlano solo tra loro: una chiamata diretta è più semplice.
  • Il mediator cresce fino a diventare una classe che sa tutto e fa tutto.

Codice di esempio

Esegui codice →
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")
Crea un pulsante Run per questo esempio

Risultato dell'esecuzione

Lin from Ada: Hello

Spiegazione del codice

ChatRoom fa da intermediario. Quando Ada invia un messaggio a Lin, il metodo send() di User passa il messaggio a ChatRoom, che lo inoltra al destinatario. Gli oggetti User non devono sapere come inviarsi i messaggi tra loro, quindi il risultato è Lin from Ada: Hello.

Modifica i valori ed esegui il programma nel compilatore Python online CodeUtility senza installare Python.

Esercizi di approfondimento

Prova a modificare il codice seguendo i suggerimenti qui sotto. Cambiare il codice e osservare il risultato ti aiuta a capire molto più che leggerlo soltanto.

  1. Sostituisci il dominio di esempio mantenendo la struttura del pattern.
  2. Confronta il pattern con un’implementazione più semplice e spiegane i compromessi.
  3. Scrivi test per ogni partecipante prima di aggiungere un’altra implementazione.
Esegui nel compilatore Python →

Errori comuni

Utenti che si chiamano direttamente

Ogni utente avrebbe allora bisogno di riferimenti a tutti gli altri.

Problema
def send(self, recipient, message):
    recipient.receive(self.name, message)
Correzione
def send(self, recipient, message):
    self.room.send(self, recipient, message)

Hai finito questa lezione?

Segnala come imparata per tenere traccia dei tuoi progressi.