Design pattern in Python

Il design pattern Chain of Responsibility in Python

In questa lezione userai il pattern Chain of Responsibility per passare una richiesta lungo una catena di gestori finché uno non se ne occupa.

  • Avanzato
  • 2 min di lettura
  • 1 esempio eseguibile

Introduzione

Il problema

Una richiesta può dover essere gestita da una tra più persone o regole, a seconda della sua dimensione o del suo tipo: le spese piccole da un team lead, quelle più grandi da un manager. Scrivere nel mittente chi gestisce cosa rende le regole rigide.

Immaginalo così

Chain of Responsibility è come una nota spese che sale in ufficio. Il team lead firma tutto fino a 100; una nota più alta passa al manager, che firma fino a 1000. Il dipendente consegna la nota sempre e solo al team lead, e non ha bisogno di sapere chi la firmerà alla fine.

Dalla nota spese al codice
Approver("Lead", 100, ...)🧑 Il team lead: firma fino a 100
if amount <= self.limit:✅ È entro il mio limite?
self.next.approve(amount)⬆️ No: passala alla persona successiva
"Manager approved 500"🧑‍💼 La firma il manager
Ogni gestore si occupa della richiesta o la passa avanti.
In una frase

Il pattern Chain of Responsibility passa una richiesta lungo una catena di gestori finché uno di essi la gestisce, così il mittente non deve sapere quale gestore risponderà.

Punti chiave

  1. Ogni Approver ha un limit e un approvatore next opzionale.
  2. approve gestisce l'importo se è entro self.limit.
  3. Altrimenti chiama self.next.approve(amount), passando avanti la richiesta.
  4. 500 supera il limite di 100 del Lead, quindi lo approva il Manager; sopra 1000 il risultato sarebbe "Declined".

Quando si usa?

  • Flussi di approvazione con limiti crescenti.
  • Escalation dell'assistenza e instradamento delle richieste.
  • Middleware nei framework web, dove ogni strato può gestire o passare avanti una richiesta.

Quando non serve

  • Si applica sempre esattamente un gestore: una ricerca è più semplice.
  • Richieste che devono essere gestite da ogni passo: quella è una pipeline, non una catena.

Codice di esempio

Esegui codice →
main.py
class Approver:
    # Chain of Responsibility: offer a request to handlers in order.
    def __init__(self, name, limit, next_approver=None):
        self.name, self.limit, self.next = name, limit, next_approver

    def approve(self, amount):
        # Handle locally or pass the request along the chain.
        if amount <= self.limit:
            return f"{self.name} approved {amount}"
        if self.next:
            return self.next.approve(amount)
        return "Declined"


chain = Approver("Lead", 100, Approver("Manager", 1000))
print(chain.approve(500))
Crea un pulsante Run per questo esempio

Risultato dell'esecuzione

Manager approved 500

Spiegazione del codice

Ogni Approver ha un limite. Il responsabile (Lead) approva fino a 100, quindi l'importo di 500 passa al successivo nella catena, Manager, con un limite di 1000. Il Manager approva la richiesta e il risultato è Manager approved 500. Se nessuno nella catena può approvare, il risultato è Declined.

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

Dimenticare la fine della catena

Senza un controllo, l'ultimo gestore chiama None.approve e va in crash.

Problema
return self.next.approve(amount)
Correzione
if self.next:
    return self.next.approve(amount)
return "Declined"

Hai finito questa lezione?

Segnala come imparata per tenere traccia dei tuoi progressi.