Como sugiere el nombre, una cadena de responsabilidad crea una cadena de objetos receptores para manejar las solicitudes.
Este patrón desacopla al remitente y al receptor de la solicitud según el tipo de solicitud.
Este patrón se incluye en el patrón de comportamiento.

En este patrón, cada objeto receptor de la solicitud tiene una referencia al siguiente objeto; si no puede manejar la solicitud, la solicitud se pasa al siguiente receptor de la cadena.

Entendamos esto tomando el ejemplo de un mecanismo de registro que registra mensajes según el nivel del mensaje (solicitud)

Registrador abstracto

package Patterns.Behavioral.chainOfResponsibility;

public abstract class AbstractLogger{
    /**
     * TRACE 



Registradores de hormigón


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




Producción:


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




Puntos clave

• Sigue LSP (El principio de sustitución de Liskov, es decir, patrón de diseño sólido).
• Sigue SRP de principio sólido.
• Sigue OCP de principio sólido, ya que podemos agregar más registradores como trace, fatal, etc. sin modificar el código existente en absoluto.
• También sigue al ISP.