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.
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.
Approver("Lead", 100, ...)🧑 Il team lead: firma fino a 100if amount <= self.limit:✅ È entro il mio limite?self.next.approve(amount)⬆️ No: passala alla persona successiva"Manager approved 500"🧑💼 La firma il managerIl 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
- Ogni
Approverha unlimite un approvatorenextopzionale. approvegestisce l'importo se è entroself.limit.- Altrimenti chiama
self.next.approve(amount), passando avanti la richiesta. - 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
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))
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.
- Sostituisci il dominio di esempio mantenendo la struttura del pattern.
- Confronta il pattern con un’implementazione più semplice e spiegane i compromessi.
- Scrivi test per ogni partecipante prima di aggiungere un’altra implementazione.
Errori comuni
Dimenticare la fine della catena
Senza un controllo, l'ultimo gestore chiama None.approve e va in crash.
return self.next.approve(amount)
if self.next:
return self.next.approve(amount)
return "Declined"
Hai finito questa lezione?
Segnala come imparata per tenere traccia dei tuoi progressi.