通俗易懂系列 | 设计模式（六）：责任链模式

责任链设计模式是行为设计模式之一。

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

JDK中的责任链模式示例

让咱们看一下JDK中责任链模式的例子，而后咱们将继续实现这种模式的真实例子。咱们知道在try-catch块代码中咱们能够有多个catch块。这里每一个catch块都是处理该特定异常的处理器。

所以当try块中发生任何异常时，它会发送到第一个catch块进行处理。若是catch块没法处理它，它会将请求转发到链中的下一个对象，即下一个catch块。若是即便最后一个catch块也没法处理它，那么异常将被抛出连接到调用程序。

责任链设计模式示例

责任链模式的一个很好的例子是ATM分配机器。用户按照定义的货币帐单输入要分配的金额和机器分配金额，例如50美圆，20美圆，10美圆等。
若是用户输入的数量不是10的倍数，则会引起错误。咱们将使用Chain of Responsibility模式来实现此解决方案。链将以与下图相同的顺序处理请求。

请注意，咱们能够在单应用程序中轻松实现此解决方案，但随后复杂性将增长，解决方案将紧密耦合。所以，咱们将建立一系列分配系统，以分配50美圆，20美圆和10美圆的帐单。

责任链设计模式 - 基类和接口

咱们能够建立一个类Currency来存储分配和链实现使用的数量。
Currency.java

package com.journaldev.design.chainofresponsibility;

public class Currency {

    private int amount;
    
    public Currency(int amt){
        this.amount=amt;
    }
    
    public int getAmount(){
        return this.amount;
    }
}

基接口应该有一个方法来定义链中的下一个处理器以及处理请求的方法。咱们的ATM Dispense界面以下所示。
DispenseChain.java

package com.journaldev.design.chainofresponsibility;

public interface DispenseChain {

    void setNextChain(DispenseChain nextChain);
    
    void dispense(Currency cur);
}

责任链模式 - 链实现

咱们须要建立不一样的处理器类来实现DispenseChain接口并提供分配方法的实现。因为咱们正在开发咱们的系统以使用三种类型的货币帐单--50美圆，20美圆和10美圆，咱们将建立三个具体实施。
Dollar50Dispenser.java

package com.journaldev.design.chainofresponsibility;

public class Dollar50Dispenser implements DispenseChain {

    private DispenseChain chain;
    
    @Override
    public void setNextChain(DispenseChain nextChain) {
        this.chain=nextChain;
    }

    @Override
    public void dispense(Currency cur) {
        if(cur.getAmount() >= 50){
            int num = cur.getAmount()/50;
            int remainder = cur.getAmount() % 50;
            System.out.println("Dispensing "+num+" 50$ note");
            if(remainder !=0) this.chain.dispense(new Currency(remainder));
        }else{
            this.chain.dispense(cur);
        }
    }

}

Dollar20Dispenser.java

package com.journaldev.design.chainofresponsibility;

public class Dollar20Dispenser implements DispenseChain{

    private DispenseChain chain;
    
    @Override
    public void setNextChain(DispenseChain nextChain) {
        this.chain=nextChain;
    }

    @Override
    public void dispense(Currency cur) {
        if(cur.getAmount() >= 20){
            int num = cur.getAmount()/20;
            int remainder = cur.getAmount() % 20;
            System.out.println("Dispensing "+num+" 20$ note");
            if(remainder !=0) this.chain.dispense(new Currency(remainder));
        }else{
            this.chain.dispense(cur);
        }
    }

}

Dollar10Dispenser.java

package com.journaldev.design.chainofresponsibility;

public class Dollar10Dispenser implements DispenseChain {

    private DispenseChain chain;
    
    @Override
    public void setNextChain(DispenseChain nextChain) {
        this.chain=nextChain;
    }

    @Override
    public void dispense(Currency cur) {
        if(cur.getAmount() >= 10){
            int num = cur.getAmount()/10;
            int remainder = cur.getAmount() % 10;
            System.out.println("Dispensing "+num+" 10$ note");
            if(remainder !=0) this.chain.dispense(new Currency(remainder));
        }else{
            this.chain.dispense(cur);
        }
    }

}

这里要注意的重点是分配方法的实施。您会注意到每一个实现都在尝试处理请求，而且根据数量，它可能会处理部分或所有部分。
若是其中一个链不能彻底处理它，它会将请求发送到链中的下一个处理器以处理剩余的请求。若是处理器没法处理任何内容，它只会将相同的请求转发到下一个链。

责任链设计模式 - 建立链

这是很是重要的一步，咱们应该仔细建立链，不然处理器可能根本没有获得任何请求。例如，在咱们的实现中，若是咱们将第一个处理器链保持为Dollar10Dispenser而后Dollar20Dispenser，那么请求将永远不会被转发到第二个处理器，而且链将变得无用。

这是咱们的ATM Dispenser实现，用于处理用户请求的数量。

ATMDispenseChain.java

package com.journaldev.design.chainofresponsibility;

import java.util.Scanner;

public class ATMDispenseChain {

    private DispenseChain c1;

    public ATMDispenseChain() {
        // initialize the chain
        this.c1 = new Dollar50Dispenser();
        DispenseChain c2 = new Dollar20Dispenser();
        DispenseChain c3 = new Dollar10Dispenser();

        // set the chain of responsibility
        c1.setNextChain(c2);
        c2.setNextChain(c3);
    }

    public static void main(String[] args) {
        ATMDispenseChain atmDispenser = new ATMDispenseChain();
        while (true) {
            int amount = 0;
            System.out.println("Enter amount to dispense");
            Scanner input = new Scanner(System.in);
            amount = input.nextInt();
            if (amount % 10 != 0) {
                System.out.println("Amount should be in multiple of 10s.");
                return;
            }
            // process the request
            atmDispenser.c1.dispense(new Currency(amount));
        }

    }

}

当咱们运行上面的应用程序时，咱们获得以下的输出。

Enter amount to dispense
530
Dispensing 10 50$ note
Dispensing 1 20$ note
Dispensing 1 10$ note
Enter amount to dispense
100
Dispensing 2 50$ note
Enter amount to dispense
120
Dispensing 2 50$ note
Dispensing 1 20$ note
Enter amount to dispense
15
Amount should be in multiple of 10s.

责任链设计模式类图

咱们的ATM分配示例的责任链设计模式实现以下图所示。

责任链设计模式重点

• 客户端不知道链的哪一个部分将处理请求，它将把请求发送到链中的第一个对象。例如，在咱们的程序中，ATMDispenseChain不知道谁在处理分配输入金额的请求。
• 链中的每一个对象都有本身的实现来处理请求，所有或部分或将其发送到链中的下一个对象。
• 链中的每一个对象都应该引用链中的下一个对象来转发请求，它由java组成。
• 仔细建立链很是重要，不然可能会出现请求永远不会转发到特定处理器或链中没有可以处理请求的对象的状况。在个人实现中，我添加了对用户输入数量的检查，以确保它被全部处理器彻底处理，可是若是请求到达最后一个对象而且链中没有其余对象，咱们可能不检查它并抛出异常将请求转发给。这是一个设计决定。
• 责任链设计模式很好地实现了失去耦合，但若是大多数代码在全部实现中都很常见，那么它会带来不少实现类和维护问题的权衡。

JDK中的责任链模式示例

• java.util.logging.Logger#log()
• javax.servlet.Filter#doFilter()

这就是责任链设计模式的所有内容，我但愿你喜欢它，而且可以清楚你对这种设计模式的理解。

翻译：journaldev