设计模式之责任链模式
在软件设计中使用责任链模式来实现松散耦合，将客户端的请求传递给对象链进行处理。然后链中的对象将自己决定谁将处理请求，以及请求是否需要被发送到链中的下一个对象。
一、JDK中的应用
如JDK中的switch、try-catch中的多个catch块等。
二、举个例子
责任链模式的一个很好的例子是自动提款机。用户输入要分发的金额，然后机器以指定货币的形式分发金额，如50美元、20美元、10美元等。
如果用户输入的数值不是10的倍数，就会抛出错误。我们将使用责任链模式来实现此解决方案。链处理请求的顺序如下图所示。
请注意：我们可以在单个程序中轻松实现此解决方案，但这样会增加复杂性，并且是紧耦合的。
所以我们将创建一个分发系统链来分发50美元、20美元和10美元的钞票。
- 创建一个货币类来存储需要分发数量
public class Currency {
private int amount;
public Currency(int amt){
this.amount=amt;
}
public int getAmount(){
return this.amount;
}
}
- 定义抽象处理者接口
它应该有处理请求，以及传递给下一个处理者的抽象方法。like thiis:
public interface DispenseChain {
void setNextChain(DispenseChain nextChain);
void dispense(Currency cur);
}
- 定义具体的处理者，
当然有三个
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);
}
}
}
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);
}
}
}
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);
}
}
}
这里通过三个实现类总结两点：
每个具体的处理者，都实现了dspense，但他们可以选择如何处理。这里是部分处理。
当未处理，或完全处理，就必须要交给链上的下一个处理者了。
所以每个处理者，拥有下个处理者的引用。这里使用的是组合。
三、客户端调用
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.
四、 小结
客户端并不知道链上的了哪个Handler将会处理请求，
链上的每个处理者都实现了抽象的处理方法，但如何处理，不做具体要求。不过既然称之为责任链模式，一般处理不了或部分处理时。总要交个下一个处理者去继续处理。
为了传递请求，每个处理者都拥有对下个处理者的引用。这是种组合模式。
典型应用：
- java.util.logging.Logger#log()
- javax.servlet.Filter#doFilter()啊