Comme son nom l'indique, une chaîne de responsabilité crée une chaîne d'objets récepteurs pour gérer les demandes.
Ce modèle dissocie l'expéditeur et le destinataire de la demande en fonction du type de demande.
Ce modèle relève du modèle comportemental.

Dans ce modèle, chaque objet récepteur de la requête a une référence à l'objet suivant s'il ne peut pas gérer la requête, la requête est transmise au récepteur suivant dans la chaîne.

Comprenons cela en prenant l'exemple d'un mécanisme de journalisation qui enregistre les messages en fonction du niveau du message (requête)

Enregistreur abstrait

package Patterns.Behavioral.chainOfResponsibility;

public abstract class AbstractLogger{
    /**
     * TRACE 



Enregistreurs de béton



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);
    }

}




Principal



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");
    }
}




Sortir:



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




Points clés

• Suit le LSP (le principe de substitution de Liskov, c'est-à-dire un modèle de conception solide).
• Suit le SRP d'un principe solide.
• Suit OCP de principe solide car nous pouvons ajouter plus de loggers comme trace, fatal, etc. sans modifier du tout le code existant.
• Suit également le FAI.