Wie der Name schon sagt, erstellt eine Verantwortungskette eine Kette von Empfängerobjekten zur Bearbeitung von Anfragen.
Dieses Muster entkoppelt den Absender und Empfänger der Anfrage basierend auf dem Anfragetyp.
Dieses Muster fällt unter das Verhaltensmuster.

In diesem Muster hat jedes Empfängerobjekt der Anfrage einen Verweis auf das nächste Objekt. Wenn es die Anfrage nicht verarbeiten kann, wird die Anfrage an den nächsten Empfänger in der Kette weitergeleitet.

Lassen Sie uns dies am Beispiel eines Protokollierungsmechanismus verstehen, der Nachrichten basierend auf der Ebene der Nachricht (Anfrage) protokolliert.

AbstractLogger

package Patterns.Behavioral.chainOfResponsibility;

public abstract class AbstractLogger{
    /**
     * TRACE 



ConcreteLoggers


package Patterns.Behavioral.chainOfResponsibility;

public class DebugLogger extends AbstractLogger {
    private String className = this.getClass().getSimpleName();
    private String logger   = "DEBUG";
    public DebugLogger(){
        this.LEVEL = 1;
    }

    @Override
    void write(String message) {
        System.out.println(className ":" logger ":" message);
    }

}

package Patterns.Behavioral.chainOfResponsibility;

public class InfoLogger extends AbstractLogger {
    private String className = this.getClass().getSimpleName();
    private String logger   = "INFO";
    public InfoLogger(){
        this.LEVEL = 2;
    }

    @Override
    void write(String message) {
        System.out.println(className ":" logger ":" message);
    }

}
package Patterns.Behavioral.chainOfResponsibility;

public class ErrorLogger extends AbstractLogger {
    private String className = this.getClass().getSimpleName();
    private String logger   = "ERROR";
    public ErrorLogger(){
        this.LEVEL = 3;
    }

    @Override
    void write(String message) {
        System.out.println(className ":" logger ":" message);
    }

}




Hauptsächlich


package Patterns.Behavioral.chainOfResponsibility;

public class Main {
    public static AbstractLogger intializeLoggers(){
        AbstractLogger errorLogger = new ErrorLogger(); //LEVEL = 3;
        AbstractLogger infoLogger = new InfoLogger(); //LEVEL = 2;
        AbstractLogger debugLogger = new DebugLogger(); // LEVEL = 1;
        errorLogger.setNextLogger(infoLogger);
        infoLogger.setNextLogger(debugLogger);
        return errorLogger;// return the highest priority Logger first


    }
    public static void main(String args[]){
        // initialize the chain of responsible objects
        AbstractLogger logger  = intializeLoggers();

        //pass the request down the responsibility chain
        //logging level 3 logger
        logger.logMessage(3, "log this error message");
        //loggin level 2 logger
        logger.logMessage(2, "info level log message");
        //logging level 1 logger
        logger.logMessage(1, "debug level log message");
    }
}




Ausgabe:


ErrorLogger:ERROR:log this error message
InfoLogger:INFO:info level log message
DebugLogger:DEBUG:debug level log message




Wichtige Punkte

• Folgt LSP (dem Liskov-Substitutionsprinzip, d. h. einem soliden Designmuster).
• Folgt SRP dem soliden Prinzip.
• Folgt dem soliden OCP-Prinzip, da wir weitere Logger wie Trace, Fatal usw. hinzufügen können, ohne den vorhandenen Code überhaupt zu ändern.
• Folgt auch ISP.