Condivisione della tecnologia

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Il modello Chain of Responsibility è un modello di progettazione comportamentale che consente a più oggetti di gestire le richieste in sequenza e ciascun oggetto può scegliere se gestire la richiesta o passarla all'oggetto successivo. Questo modello fornisce maggiore flessibilità e scalabilità disaccoppiando il mittente e il destinatario delle richieste. Di seguito è riportata un’introduzione dettagliata al modello di catena di responsabilità:

1. Definizione e idee fondamentali

Il nucleo del modello di catena di responsabilità è progettare una catena di richieste e identificare la fine della catena. Collega più oggetti di gestione delle richieste in una catena e consente alla richiesta di passare sulla catena finché un oggetto nella catena non decide di gestire la richiesta. Il client che effettua la richiesta non sa quale oggetto nella catena gestirà infine la richiesta, il che consente al sistema di riorganizzare e assegnare dinamicamente le responsabilità senza influire sul client.

2. Diagramma delle classi e ruoli principali

Diagramma delle classi:

Il modello di catena di responsabilità prevede principalmente i seguenti ruoli:

1. Gestore astratto (Gestore) : Definire un'interfaccia per l'elaborazione delle richieste. Se necessario, l'interfaccia può definire un metodo per impostare e restituire un riferimento all'interfaccia successiva. Questo ruolo è solitamente implementato da una classe o interfaccia astratta.

2. Gestore del calcestruzzo : Dopo aver ricevuto la richiesta, lo specifico responsabile del trattamento può scegliere di elaborare la richiesta o di trasmetterla alla parte successiva. Poiché il trasformatore di calcestruzzo contiene un riferimento alla casa successiva, il trasformatore di calcestruzzo può accedere alla casa successiva, se necessario.

3. Classe cliente (Cliente): crea una catena di elaborazione e invia una richiesta all'oggetto processore specifico della testata della catena.

3. Scenari applicabili

Il modello della catena di responsabilità è adatto ai seguenti scenari:

1. Più oggetti elaborano congiuntamente un'attività: ad esempio, un sistema di approvazione multilivello passa la richiesta di approvazione al livello successivo di approvatore in base all'autorità e al livello dell'approvatore fino all'ottenimento del risultato dell'approvazione finale.

2. Flusso di elaborazione della combinazione dinamica: Configurando in modo flessibile la catena di responsabilità, gli oggetti di elaborazione possono essere combinati dinamicamente per implementare diversi processi di elaborazione.

3. Evitare l'accoppiamento diretto tra il mittente e il destinatario di una richiesta: Passando la richiesta alla catena di responsabilità, il mittente della richiesta non ha bisogno di conoscere lo specifico oggetto di elaborazione, riducendo la dipendenza tra gli oggetti.

4. Vantaggi e svantaggi

vantaggio

1. Ridurre l'accoppiamento: Disaccoppia il mittente e il destinatario della richiesta. La richiesta viene solo inviata, indipendentemente da chi la gestisce.
2. Maggiore flessibilità nell'assegnazione degli oggetti: consente l'aggiunta o l'eliminazione dinamica di responsabilità modificando i membri all'interno della catena o spostandone l'ordine.
3. Semplificare gli oggetti: Non è necessario che l'oggetto conosca la struttura della catena.
4. È conveniente aggiungere nuove classi di elaborazione delle richieste: Seguendo il principio di apertura e chiusura, è possibile aggiungere nuovi processori alla catena di responsabilità in qualsiasi momento senza modificare il codice esistente, garantendo una buona scalabilità.

discordanza

1. Non vi è alcuna garanzia che la richiesta venga accolta: se la catena di responsabilità non è configurata correttamente o un processore non gestisce correttamente la richiesta, la richiesta potrebbe non essere elaborata.
2. Problemi di prestazione: Quando la catena di responsabilità è troppo lunga o le richieste vengono passate frequentemente nella catena di responsabilità, le prestazioni potrebbero risentirne.
3. Il debug è scomodo: Quando la catena di responsabilità è particolarmente lunga e presenta molti collegamenti, la logica può essere più complicata durante il debug a causa di un approccio ricorsivo.

5. Scenari applicativi

Il modello della catena di responsabilità è ampiamente utilizzato in molti campi, inclusi ma non limitati a:

1. Sistema di registrazione: Passa i messaggi di registro a diversi logger in base al livello di registro, come logger console, logger file, logger database, ecc.
2. Sistema di gestione delle eccezioni: classifica le eccezioni in base al tipo, ad esempio registrazione, notifiche e-mail, visualizzazione delle eccezioni, ecc.
3. Sistema di approvazione multilivello: ad esempio, lasciando l'approvazione, l'approvazione dell'acquisto, ecc., la richiesta di approvazione viene passata all'approvatore di livello successivo in base all'autorità e al livello dell'approvatore.

6. Esempi di implementazione

Quello che segue è un semplice esempio di implementazione del modello di catena di responsabilità, che viene utilizzato per elaborare i messaggi di log e passare i messaggi a diversi processori in base al livello di log (come DEBUG, INFO, WARN, ERROR):

// 抽象处理者  
abstract class LogHandler {  
    protected int level;  
    protected LogHandler nextHandler;  
  
    public void setNextHandler(LogHandler nextHandler) {  
        this.nextHandler = nextHandler;  
    }  
   
    //这个是精髓：他除了处理自己的逻辑，还会调用nextHandler进行处理
    public void logMessage(int level, String message) {  
        if (this.level <= level) {  
            write(message);  
        }  
        if (nextHandler != null) {  
            nextHandler.logMessage(level, message);  
        }  
    }  
  
    abstract protected void write(String message);  
}  
  
// 具体处理者：ErrorLogHandler  
class ErrorLogHandler extends LogHandler {  
    public ErrorLogHandler(int level) {  
        this.level = level;  
    }  
  
    @Override  
    protected void write(String message) {  
        System.out.println("ErrorLogHandler: " + message);  
    }  
}  
  
// 具体处理者：WarnLogHandler  
class WarnLogHandler extends LogHandler {  
    public WarnLogHandler(int level) {  
        this.level = level;  
    }  
  
    @Override  
    protected void write(String message) {  
        System.out.println("WarnLogHandler: " + message);  
    }  
}  
  
// 具体处理者：InfoLogHandler  
class InfoLogHandler extends LogHandler {  
    public InfoLogHandler(int level) {  
        this.level = level;  
    }  
  
    @Override  
    protected void write(String message) {  
        System.out.println("InfoLogHandler: " + message);  
    }  
}  
  
// 客户端代码  
public class ChainPatternDemo {  
    private static LogHandler getChainOfLoggers() {  
        // 创建链中的处理者  
        LogHandler errorLogHandler = new ErrorLogHandler(3);  
  
        LogHandler warnLogHandler = new WarnLogHandler(2);  
        warnLogHandler.setNextHandler(errorLogHandler);  
  
        LogHandler infoLogHandler = new InfoLogHandler(1);  
        infoLogHandler.setNextHandler(warnLogHandler);  
  
        return infoLogHandler;  
    }  
  
    public static void main(String[] args) {  
        LogHandler loggerChain = getChainOfLoggers();  
  
        loggerChain.logMessage(1, "This is an informational message.");  
        loggerChain.logMessage(2, "This is a warning message.");  
        loggerChain.logMessage(3, "This is an error message.");  
    }  
}

In questo esempio definiamo tre classi concrete di gestori di log (ErrorLogHandler、WarnLogHandler、InfoLogHandler ), gestiscono rispettivamente diversi livelli di messaggi di registro. Ogni gestore contiene un livello (level ), utilizzato per determinare se i messaggi di questo livello devono essere elaborati.A chiamatalogMessagemetodo, la richiesta viene passata al primo gestore della catena (infoLogHandler ), decide se elaborare il messaggio in base al proprio livello e alla propria logica di elaborazione, quindi (se non elaborato) passa la richiesta al processore successivo nella catena. Questo processo continua fino alla fine della catena o fino all'elaborazione della richiesta.

Tieni presente che in un'applicazione reale potrebbe essere necessarioLogHandler La classe aggiunge più metodi e proprietà per supportare logica e configurazione di elaborazione dei log più complesse. Inoltre, i livelli di log utilizzano in genere le enumerazioni (enum) anziché numeri interi per migliorare la leggibilità e la manutenibilità del codice.

7. Conclusione

Il modello della catena di responsabilità raggiunge l'elaborazione flessibile delle richieste e la scalabilità del sistema collegando più oggetti che gestiscono le richieste in una catena e consentendo alla richiesta di passare sulla catena finché un oggetto sulla catena non decide di gestire la richiesta.

Se il modello della catena di responsabilità ti è utile, ricordati di mettere mi piace e collezionarlo.