设计模式-责任链模式

责任链模式的介绍

​ 责任链模式(Iterator Pattren),是行为型设计模式之一。什么是“链”？我们将多个节点首尾相连所构成的模型称为链，比如生活中常见的锁链，就是由一个个圆角长方形的铁环串起来的结构。对于链式结构，每个节点都可以被拆开再连接，因此，链式结构也具有很好的灵活性。将这样一种结构应用于编程领域，将每个节点看作是一个对象，每个对象拥有不同的处理逻辑，将一个请求从链式的首端发出，沿着链的路径一次传递给每一个节点对象，直至有对象处理这个请求为止，我们将这样的一种模式称为责任链模式。

责任链模式的定义

​ 使多个对象都有机会处理请求，从而避免了请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。

责任链模式的使用场景

• 多个对象可以处理同一请求，但具体由哪个对象处理则在运行时动态决定。
• 在请求处理者不明确的情况下向多个对象中的一个提交一个请求。
• 需要动态指定一组对象处理请求。

责任链模式的UML类图

责任链模式类图.png

根据类图我们可以得出如下一个责任链模式简化版通用模式代码。

//抽象处理类
public abstract class Handler {
    protected Handler successor; //下一个节点的处理者
    /**
     * 请求处理
     * @param conditon 请求条件
     */
    public abstract void handlerRequest(String conditon);
}

//具体的处理者1
public class ConcreteHandler1 extends Handler {

    @Override
    public void handlerRequest(String conditon) {
        if (conditon.equals("ConcreteHandler1")) {
            System.out.println("ConcreteHandler1 handler");
        } else {
            successor.handlerRequest(conditon);
        }
    }
}


//具体处理者2
public class ConcreteHandler2 extends Handler {

    @Override
    public void handlerRequest(String conditon) {
        if (conditon.equals("ConcreteHandler2")) {
            System.out.println("ConcreteHandler2 handler");
        } else {
            successor.handlerRequest(conditon);
        }
    }
}

//客户类 
public class Client {
    @Test
    public void test() {
        //构造一个ConcreteHandler1对象
        ConcreteHandler1 handler1 = new ConcreteHandler1();

        //构造一个ConcreteHandler2对象
        ConcreteHandler2 handler2 = new ConcreteHandler2();

        //设置handler1的下一个节点
        handler1.successor = handler2;

        //设置handler2的下一个节点
        handler2.successor = handler1;

        //处理请求
        handler1.handlerRequest("ConcreteHandler2");
    }
}

角色介绍

• Handler ：抽象处理者角色，声明一个请求处理的方法，并在其中保持一个对下一个处理节Handler 对象的引用。
• ConcreteHandler :具体的处理者对请求进行处理 ，如果不能处理则将该请求转发给下一个节点上的处理对象。

上面我们说这个一个简化版的通用模板代码，为什么这个说呢？因为对于请求来说，其形式是固定的，就是一个字符串，而判断一个节点上的对象是否能够处理该请求的标志，则是该字符串是否与之匹配。然而 在大多数情况下，责任链中的请求和对应的处理规则是不尽相同的，在这种情况下可以将请求进行封装，同时对请求的处理规则也进行封装作为一个独立的对象，类图如下所示：

责任链模式封装类图.png

首先我们看下AbstractHandler 抽象处理者，其声明了处理者对象处理请求的方法和获取处理级别的方法，并对具体的处理转发逻辑进行了实现。

public abstract class AbstractHandler {
    
    protected AbstractHandler nextHandler;
    
    public final void handleRequest(AbstractRequest request){
        //判断当前处理者对象的处理级别是否与请求者的处理级别一致
        if (getHandleLevel()==request.getHandleLevel()){
            handle(request);
        }else {
            //否则将请求对象转发给下一个节点上的请求对象
            if (nextHandler!=null){
                nextHandler.handleRequest(request);
            }else {
                //当所有处理者对象均不能处理该请求输出
                System.out.println("All of haandler can't handle the request");
            }
        }
    }
    
    /**
     * 获取处理者对象的处理级别
     * @return 处理级别
     */
    protected abstract int getHandleLevel();

    /**
     * 每个处理者对象的具体处理方式
     * @param request 请求者对象
     */
    protected abstract void handle(AbstractRequest request);
}

在这种情况下我们的责任转发逻辑由抽象处理类控制，而对于抽象请求者，其内部也声明了一个获取请求级别的方法，其与抽象处理者中返回的处理级别保持对应，什么级别的处理逻辑就对应什么样的请求级别。

//抽象请求类
public abstract class AbstractRequest {
    //处理 对象
    private Object obj;

    public AbstractRequest(Object obj) {
        this.obj = obj;
    }

    /**
     * 获取处理的内容对象
     * @return 具体的处理对象
     */
    public Object getContent(){
        return obj;
    }

    /**
     * 获取请求级别
     * @return 请求级别
     */
    public abstract int getHandleLevel();
}

下面我们分别实现3个请求者和3 个处理者对象 ，逻辑很简单。

public class Request1 extends AbstractRequest {
    public Request1(Object obj) {
        super(obj);
    }

    @Override
    public int getHandleLevel() {
        return 1;
    }
}

public class Request2 extends AbstractRequest {
    public Request2(Object obj) {
        super(obj);
    }

    @Override
    public int getHandleLevel() {
        return 2;
    }
}

public class Request3 extends AbstractRequest {
    public Request3(Object obj) {
        super(obj);
    }

    @Override
    public int getHandleLevel() {
        return 3;
    }
}

处理者

public class Handler1 extends AbstractHandler {
    @Override
    protected int getHandleLevel() {
        return 1;
    }

    @Override
    protected void handle(AbstractRequest request) {
        System.out.println("Handle1 handle request:"+request.getHandleLevel());
    }
}

public class Handler2 extends AbstractHandler {
    @Override
    protected int getHandleLevel() {
        return 2;
    }

    @Override
    protected void handle(AbstractRequest request) {
        System.out.println("Handle2 handle request:"+request.getHandleLevel());
    }
}

public class Handler3 extends AbstractHandler {
    @Override
    protected int getHandleLevel() {
        return 2;
    }

    @Override
    protected void handle(AbstractRequest request) {
        System.out.println("Handle3 handle request:"+request.getHandleLevel());
    }
}

下面是客户类

public class Client {
    @Test
    public void main(){
        //构造三个处理者对象
        Handler1 handler1 = new Handler1();
        Handler2 handler2 = new Handler2();
        Handler3 handler3 = new Handler3();

        //设置当前处理者对象的下一个节点
        handler1.nextHandler = handler2;
        handler2.nextHandler = handler3;

        //构造三个请求者对象
        Request1 request1 = new Request1("Request1");
        Request2 request2 = new Request2("Request2");
        Request3 request3 = new Request3("Request3");

        //总是从链式的首端发起请求
        handler1.handleRequest(request1);
        handler2.handleRequest(request2);
        handler1.handleRequest(request3);
    }
}
结果:
Handle1 handle request:1
Handle2 handle request:2
Handle3 handle request:3

责任链模式的简单实现

举个例子：公司安排小明出差，出差回来后花费了近5万元，于是小明第二天上班找组长申请报销费用，组长一看是一笔不小的数目，他没有权限审批，于是组长拿着票据去找部门主管，主管一看要报这么多钱，自己权限只能批5千以下的费用，这完全超出了自己的范围，于是主管又去找经理，经理一看二话不说直接拿着票据去了老板的办公室，因为他只能批一万以下的费用，上面的情景就是一个责任链模式的小例子，每一个人，准确的说是每一类人代表这条链上的一个节点，小明是请求的发起者，而老板则是出于链条顶端的类，小明在链条底端发起一个申请报账的请求，首先由组长处理该请求，组长对比后发现自己权限不够于是将该请求转发给位于链中的下一个节点的主管，主管对比后也发现自己的权限不够又将该请求转发给经理，而经理也基于同样的原因将请求转发给老板，这样层层转达直至请求被处理，从中大家可以看到一个显而易见的事，就是至始至终小明只与组长产生的关联，后面具体由谁处理的票据，小明并不关心，唯一在乎的是报账的结果，责任链模式在这里很好地将请求的发起者与处理者解耦。我们在代码 中模拟这个过程，首先还是先声明一个抽象的领导类。

//抽象领导者
public abstract class Leader {
    //上一级领导处理者
    protected Leader nexthandler;

    public void handlerRequest(int money){
        if (money<=limit()) {
            handle(money);
        }else {
            if (nexthandler != null) {
                nexthandler.handle(money);
            }
        }
    }

    /**
     * 自身能审批的额度
     * @return 额度
     */
    public abstract int limit();

    /**
     * 处理报账行为
     * @param money 具体金额
     */
    public abstract void handle(int money);
}

在这个抽象的领导类中只做了两件事，一是定义了两个抽象接口方法来确定一个领导者应有的行为和属性，而是声明了一个处理报账请求的方法来确定当前领导是否有能力处理报账请求，如果没有这个权限，则将该请求转发给上一级的领导处理，接下来是各个领导类的实现。

public class GroupLeader extends Leader {
    @Override
    public int limit() {
        return 1000;
    }

    @Override
    public void handle(int money) {
        System.out.println("组长审批报销"+money +"元");
    }
}

public class Director extends Leader {
    @Override
    public int limit() {
        return 5000;
    }

    @Override
    public void handle(int money) {
        System.out.println("主管审批报销"+money +"元");
    }
}

public class Manager extends Leader {
    @Override
    public int limit() {
        return 10000;
    }

    @Override
    public void handle(int money) {
        System.out.println("经理审批报销"+money +"元");
    }
}

public class Boss extends Leader {
    @Override
    public int limit() {
        return Integer.MAX_VALUE;
    }

    @Override
    public void handle(int money) {
        System.out.println("老板审批报销"+money +"元");
    }
}

最后小明从组长开始请求申请报帐。

    @Test
    public void main() {
        //构造各个领导
        GroupLeader groupLeader = new GroupLeader();
        Director director = new Director();
        Manager manager = new Manager();
        Boss boss = new Boss();
        //设置上一级领导处理者
        groupLeader.nexthandler = director;
        director.nexthandler = manager;
        manager.nexthandler = boss;
        //发起请求
        groupLeader.handlerRequest(50000);
    }
结果
老板审批报销50000元

这里大家可能会想，可不可以直接越过组长找组长报账呢？答案是肯定的，这也是责任链模式的灵活之处，请求的发起可以从责任链的任何一个节点开始，同时也可以改变责任链内部的传递规则，如果主管不在，我们完全可以跨过主管从组长直接将请求转送给经理。

对于责任链中的一个处理者对象，其中只有两个行为，一是请求处理，而是将请求转送给下一个节点，不允许某个处理者对象在处理了请求后又将请求转发给上一个节点的情况。对于一条责任链来说，一个请求最终只有两种情况，一是被某个处理对象所处理，另一个是所有对象均未对其处理，对于前一个情况我们称该责任链为纯的责任链，对于后一种情况我们称为不纯的责任链，在实际应用中，我们所见到的责任链模式大多为不纯的责任链。

责任链模式的实战

责任链模式与其说实在Android 中的应用倒不如说是在Java 中的应用，毕竟上层应用开发大多都是基于Java 的，而我们的设计模式也是针对Java 而言，Android 中我们可以借鉴责任链模式的思想来优化BroadcastReceiver 使之成为一个全局的责任处理者，具体方法很简单，我们知道Broadcast 可以分为两种，一种是Normal Broadcast 普通广播，另一种是Order Broadcast 有序广播，普通广播是异步的，发出时可以被所有的接收者收到；而有序广播则是根据优先级一次传播的，直到有接收者将其终止或所有接收者都不终止它，有序广播的这一特性与我们的责任链模式很想近，通过它可以实现一种全局的责任链事件处理，这里我们创建3个 BroadcastReceiver。

public class FirstReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        //获取Intent中附加的限制值
        int limit = intent.getIntExtra("limit", -1001);
        //如果限制值等于1000则处理，否则继续转发给下一个Receiver
        if (limit!=1000) {
            Bundle bundle = new Bundle();
            bundle.putString("new","Message from FirstReceiver");
            setResultExtras(bundle);
        }else {
            String msg = intent.getStringExtra("msg");
            Toast.makeText(context, msg, Toast.LENGTH_SHORT).show();
        }
    }
}

在发送广播的时候我们在Intent 中附加两个值，一个int类型的值用于存储权限值，另一个String类型的则存储消息，一个接收者能否处理本次广播的唯一条件则是看广播中所附加的权限值是否与自身相等如上面FirstReceiver 的处理权限值是1000；则只有当limit =1000时才会处理本次广播，否则在广播的Intent中在附加一条信息传递出去给下一个接收者。

public class FirstReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        //获取Intent中附加的限制值
        int limit = intent.getIntExtra("limit", -1001);
        //如果限制值等于1000则处理，否则继续转发给下一个Receiver
        if (limit!=1000) {
            Bundle bundle = new Bundle();
            bundle.putString("new","Message from FirstReceiver");
            setResultExtras(bundle);
        }else {
            String msg = intent.getStringExtra("msg");
            Toast.makeText(context, msg, Toast.LENGTH_SHORT).show();
        }
    }
}

public class SecondReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        //获取Intent中附加的限制值
        int limit = intent.getIntExtra("limit", -1001);
        //如果限制值等于1000则处理，否则继续转发给下一个Receiver
        if (limit!=100) {
            Bundle bundle = new Bundle();
            bundle.putString("new","Message from SecondReceiver");
            setResultExtras(bundle);
        }else {
            String msg = intent.getStringExtra("msg");
            Bundle bundle = getResultExtras(true);
            String str = bundle.getString("new");
            Toast.makeText(context,msg+"<<<>>>" +str, Toast.LENGTH_SHORT).show();
            abortBroadcast();
        }
    }
}

public class ThridReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        //获取Intent中附加的限制值
        int limit = intent.getIntExtra("limit", -1001);
        //如果限制值等于1000则处理，否则继续转发给下一个Receiver
        if (limit!=10) {
            Bundle bundle = new Bundle();
            bundle.putString("new","Message from ThridReceiver");
            setResultExtras(bundle);
        }else {
            String msg = intent.getStringExtra("msg");
            Bundle bundle = getResultExtras(true);
            String str = bundle.getString("new");
            Toast.makeText(context,msg+"<<<>>>" +str, Toast.LENGTH_SHORT).show();
            abortBroadcast();
        }
    }
}

最后我们还要在清单文件声明3个Receiver,并设定对应的权限值。

完成后，我们在一个Activity中发送一个广播

        Intent intent = new Intent();
        intent.setAction("ORDER_BROADCAST");
        intent.putExtra("limit",1000);
        intent.putExtra("msg","Message from MainActivity");
        sendOrderedBroadcast(intent,null);

这里将limit 设置为100 ，也就是说只有SecondReceiver才会处理它。

总结

• 优点：可以对请求者和处理者关系解耦，提高代码的灵活性。
• 缺点：对链中请求处理者的遍历，如果处理者太多，那么遍历必定会影响性能，特别是在一些递归调用中。

Demo

设计模式Demo

参考

《Android源码设计模式》