Como o nome sugere, uma cadeia de responsabilidade cria uma cadeia de objetos receptores para lidar com solicitações.
Este padrão separa o remetente e o destinatário da solicitação com base no tipo de solicitação.
Este padrão está sob o padrão Comportamental.

Neste padrão, cada objeto receptor da solicitação tem uma referência para o próximo objeto, se não puder lidar com a solicitação, a solicitação é passada para o próximo receptor na cadeia.

Vamos entender isso tomando o exemplo de um mecanismo de registro que registra mensagens com base no nível da mensagem (solicitação)

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

}




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




Saída:



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




Pontos-chave

• Segue LSP (O princípio de substituição de Liskov, ou seja, padrão de design sólido).
• Segue SRP de princípios sólidos.
• Segue o OCP de princípios sólidos, pois podemos adicionar mais Loggers como trace, fatal, etc, sem modificar o código existente.
• Também segue o ISP.