设计模式：责任链模式

参考
行为型模式（一）：责任链模式

责任链模式

类型：行为型

为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。

角色：

1. 抽象处理者（Handler）角色：定义一个处理请求的接口，包含抽象处理方法和一个后继连接。
2. 具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断能否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者。
3. 客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它不关心处理细节和请求的传递过程。

UML

模式的应用场景

1. 有多个对象可以处理一个请求，哪个对象处理该请求由运行时刻自动确定。
2. 可动态指定一组对象处理请求，或添加新的处理者。
3. 在不明确指定请求处理者的情况下，向多个处理者中的一个提交请求。

包结构

处理者基类

package 责任链模式.handler;

public abstract class Handler {
    protected Handler nextHandler;
    public void setNextHandler(Handler nextHandler){
        this.nextHandler=nextHandler;
    }
    public Handler getNextHandler(){
        return this.nextHandler;
    }
    public abstract String handleReq(double reqMoney);
}

权限从小到大的处理者

package 责任链模式.handler;

public class SmallHandler extends Handler{
    private double permission = 1e3;

    @Override
    public String handleReq(double reqMoney) {
        if(reqMoney<=permission){
            System.out.println("小领导还是有这个能力的");
            return "小领导办了";
        }else{
            System.out.println("小领导没这个权限，去找中领导吧");
            return this.getNextHandler().handleReq(reqMoney);
        }
    }
}
//
package 责任链模式.handler;

public class MediumHandler extends Handler{
    private double permission = 1e4;

    @Override
    public String handleReq(double reqMoney) {
        if(reqMoney<=permission){
            System.out.println("中领导还是有这个能力的");
            return "中领导办了";
        }else{
            System.out.println("中领导没这个权限，去找大领导吧");
            return this.getNextHandler().handleReq(reqMoney);
        }
    }
}
//
package 责任链模式.handler;

public class BigHandler extends Handler{
    private double permission = 1e5;

    @Override
    public String handleReq(double reqMoney) {
        if(reqMoney<=permission){
            System.out.println("大领导还是有这个能力的");
            return "大领导办了";
        }else{
            System.out.println("大领导没这个权限，去找更大领导吧");
            return this.getNextHandler().handleReq(reqMoney);
        }
    }
}
//
package 责任链模式.handler;

public class BiggerHandler extends Handler{
    private double permission = 1e6;

    @Override
    public String handleReq(double reqMoney) {
        if(reqMoney<=permission){
            System.out.println("更大领导还是有这个能力的");
            return "更大领导办了";
        }else{
            System.out.println("要这么多钱干嘛？不批");
            return "这笔钱没批下来";
        }
    }
}
//

客户端

package 责任链模式.client;

import 责任链模式.handler.BigHandler;
import 责任链模式.handler.BiggerHandler;
import 责任链模式.handler.MediumHandler;
import 责任链模式.handler.SmallHandler;

public class Client {
    public static void main(String[] args) {
        BiggerHandler biggerHandler = new BiggerHandler();
        BigHandler bigHandler = new BigHandler();
        MediumHandler mediumHandler = new MediumHandler();
        SmallHandler smallHandler = new SmallHandler();
        //先设置next
        bigHandler.setNextHandler(biggerHandler);
        mediumHandler.setNextHandler(bigHandler);
        smallHandler.setNextHandler(mediumHandler);
        //开始处理
        for(double i=100;i<=1e6;i=i*10){
            double req = i+1;
            System.out.println("----请求经费为"+req+"----");
            String resp= smallHandler.handleReq(req);
            System.out.println("最终是"+resp+'\n');
        }
    }
}

效果

----请求经费为101.0----
小领导还是有这个能力的
最终是小领导办了

----请求经费为1001.0----
小领导没这个权限，去找中领导吧
中领导还是有这个能力的
最终是中领导办了

----请求经费为10001.0----
小领导没这个权限，去找中领导吧
中领导没这个权限，去找大领导吧
大领导还是有这个能力的
最终是大领导办了

----请求经费为100001.0----
小领导没这个权限，去找中领导吧
中领导没这个权限，去找大领导吧
大领导没这个权限，去找更大领导吧
更大领导还是有这个能力的
最终是更大领导办了

----请求经费为1000001.0----
小领导没这个权限，去找中领导吧
中领导没这个权限，去找大领导吧
大领导没这个权限，去找更大领导吧
要这么多钱干嘛？不批
最终是这笔钱没批下来


Process finished with exit code 0

模式的扩展

职责链模式存在以下两种情况：
1、纯的职责链模式：一个请求必须被某一个处理者对象所接收，且一个具体处理者对某个请求的处理只能采用以下两种行为之一：自己处理（承担责任）；把责任推给下家处理。
2、不纯的职责链模式：允许出现某一个具体处理者对象在承担了请求的一部分责任后又将剩余的责任传给下家的情况，且一个请求可以最终不被任何接收端对象所接收。