责任链设计模式

责任链模式用于在软件设计中实现松散耦合，其中来自客户端的请求被传递到对象链以处理它们。稍后，链中的对象将自行决定由谁来处理请求，以及是否需要将请求发送到链中的下一个对象。
责任链模式何时何地适用：

• 当您想解耦请求的发送者和接收者时
• 在运行时确定的多个对象是处理请求的候选对象
• 当您不想在代码中显式指定处理程序时
• 当您想向多个对象之一发出请求而不明确指定接收者时。

当多个对象可以处理一个请求并且处理程序不必是特定对象时，建议使用此模式。此外，处理程序是在运行时确定的。请注意，任何处理程序根本没有处理的请求是一个有效的用例。

• 处理程序：这可以是一个接口，主要接收请求并将请求分派到处理程序链。它仅引用链中的第一个处理程序，并且对其余处理程序一无所知。
• 具体处理程序：这些是按某种顺序链接的请求的实际处理程序。
• Client :请求的发起者，这将访问处理程序来处理它。

如何使用责任链在应用程序中发送请求

需要处理请求的客户端将其发送到处理程序链，这些处理程序是扩展 Handler 类的类。
链中的每个处理程序都轮流尝试处理从客户端收到的请求。
如果 ConcreteHandler1 可以处理它，则处理该请求，如果不能，则将其发送到处理程序 ConcreteHandler2，即链中的下一个处理程序。
让我们看一个责任链设计模式的例子：

Java

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 processor;
 
    public Processor(Processor processor){
        this.processor = processor;
    };
     
    public void process(Number request){
        if(processor != null)
            processor.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 processor){
        super(processor);
         
    }
 
    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 processor){
        super(processor);
    }
 
    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 processor){
        super(processor);
    }
 
    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

责任链设计模式的优点

• 降低耦合度。解耦它将请求发送方和接收方。
• 简化的对象。对象不需要知道链结构。
• 增强对象分配职责的灵活性。通过更改链内成员或更改其顺序，允许动态添加或删除职责。
• 增加非常方便的请求处理新类。

责任链设计模式的缺点

• 必须收到请求而不是保证。
• 系统的性能会受到影响，而且在代码调试不方便可能会造成循环调用。
• 由于调试，可能不容易观察操作特性。