Patrón de diseño de string de responsabilidad

El patrón de string de responsabilidad se utiliza para lograr un acoplamiento débil en el diseño de software donde una solicitud del cliente se pasa a una string de objetos para procesarlos. Más tarde, el objeto de la string decidirá por sí mismo quién procesará la solicitud y si la solicitud debe enviarse al siguiente objeto de la string o no.
Dónde y cuándo se aplica el patrón de string de responsabilidad: 
 

• Cuando desea desacoplar el remitente y el receptor de una solicitud
• Múltiples objetos, determinados en tiempo de ejecución, son candidatos para manejar una solicitud
• Cuando no desea especificar controladores explícitamente en su código
• Cuando desea enviar una solicitud a uno de varios objetos sin especificar explícitamente el receptor.

Este patrón se recomienda cuando varios objetos pueden manejar una solicitud y el controlador no tiene que ser un objeto específico. Además, el controlador se determina en tiempo de ejecución. Tenga en cuenta que una solicitud que ningún controlador gestione en absoluto es un caso de uso válido.
 

• Controlador: esta puede ser una interfaz que recibirá principalmente la solicitud y la enviará a una string de controladores. Tiene referencia al único primer manipulador de la string y no sabe nada del resto de manipuladores.
• Controladores concretos: estos son controladores reales de la solicitud enstringdos en algún orden secuencial.
• Cliente: Originador de la solicitud y este accederá al controlador para manejarlo.

Cómo enviar una solicitud en la aplicación utilizando la String de Responsabilidad

El Cliente que necesita que se maneje una solicitud, la envía a la string de controladores, que son clases que amplían la clase Controlador. 
Cada uno de los controladores de la string se turna para tratar de manejar la solicitud que recibe del cliente. 
Si ConcreteHandler1 puede manejarlo, entonces se maneja la solicitud, si no, se envía al manejador ConcreteHandler2, el siguiente en la string.
Veamos un Ejemplo de Patrón de Diseño de String de Responsabilidad:
 

public class Chain
{
Processor chain;
 
public Chain(){
    buildChain();
}
 
private void buildChain(){
    chain = new NegativeProcessor(new ZeroProcessor(new PositiveProcessor(null)));
}
 
public void process(Number request) {
    chain.process(request);
}
 
}
 
abstract class Processor
{
    private Processor nextProcessor;
 
    public Processor(Processor nextProcessor){
        this.nextProcessor = nextProcessor;
    };
     
    public void process(Number request){
        if(nextProcessor != null)
            nextProcessor.process(request);
    };
}
 
class Number
{
    private int number;
 
    public Number(int number)
    {
        this.number = number;
    }
 
    public int getNumber()
    {
        return number;
    }
 
}
 
class NegativeProcessor extends Processor
{
    public NegativeProcessor(Processor nextProcessor){
        super(nextProcessor);
         
    }
 
    public void process(Number request)
    {
        if (request.getNumber() < 0)
        {
            System.out.println("NegativeProcessor : " + request.getNumber());
        }
        else
        {
            super.process(request);
        }
    }
}
 
class ZeroProcessor extends Processor
{
    public ZeroProcessor(Processor nextProcessor){
        super(nextProcessor);
    }
 
    public void process(Number request)
    {
        if (request.getNumber() == 0)
        {
            System.out.println("ZeroProcessor : " + request.getNumber());
        }
        else
        {
            super.process(request);
        }
    }
}
 
class PositiveProcessor extends Processor
{
 
    public PositiveProcessor(Processor nextProcessor){
        super(nextProcessor);
    }
 
    public void process(Number request)
    {
        if (request.getNumber() > 0)
        {
            System.out.println("PositiveProcessor : " + request.getNumber());
        }
        else
        {
            super.process(request);
        }
    }
}
 
class TestChain
{
    public static void main(String[] args) {
        Chain chain = new Chain();
         
        //Calling chain of responsibility
        chain.process(new Number(90));
        chain.process(new Number(-50));
        chain.process(new Number(0));
        chain.process(new Number(91));
    }
}

PositiveProcessor : 90
NegativeProcessor : -50
ZeroProcessor : 0
PositiveProcessor : 91

Ventajas del patrón de diseño de string de responsabilidad 
 

• Reducir el grado de acoplamiento. El desacoplamiento lo solicitará el emisor y el receptor.
• Objeto simplificado. El objeto no necesita conocer la estructura de la string.
• Mejorar la flexibilidad de los deberes asignados al objeto. Al cambiar los miembros dentro de la string o cambiar su orden, permita agregar o eliminar responsabilidad dinámicamente.
• Aumente la solicitud de procesamiento de nueva clase de muy conveniente.

Desventajas del patrón de diseño de string de responsabilidad
 

• La solicitud debe ser recibido no garantía.
• El rendimiento del sistema se verá afectado, pero también en el código, la depuración no es fácil y puede causar una llamada cíclica.
• Puede que no sea fácil observar las características de funcionamiento debido a la depuración.

Lectura adicional: Patrón de diseño de string de responsabilidad en Python
 

Este artículo es una contribución de Saket Kumar . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.