使编程更有灵活性——责任链模式

《Android源码设计模式解析与实战》读书笔记(九)
《Android源码设计模式解析与实战》PDF资料下载

一、责任链模式简介

责任链模式，是行为型设计模式之一。将多个节点首尾相连构成的模型称为链。

对于链式结构，每个节点都可以被拆开再连接，因此链式结构也具有很好的灵活性。

1.1、定义

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

1.2、使用场景

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

二、责任链模式的简单实现

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

    /**
     * 处理报账请求
     * @param money
     */
    public final void handleRequest(int money) {
        if (money <= limit()) {
            handle(money);
        } else {
            if (null != nextHandler) {
                nextHandler.handleRequest(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+"元");
    }
}

 //构造各个领导对象
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.handleRequest(50000);

对于责任链中的一个处理者对象，其只有两个行为，一是处理请求，二是将请求转送给下一个节点，不允许某个处理者对象在处理了请求后又将请求转送给上一个节点的情况。

对于一条责任链来说，一个请求最终只有两种情况，一是被某个处理对象所处理，另一个是所有对象均未对其处理，对于前一种情况称该责任链为纯的责任链，对于后一种情况称为不纯的责任链，在实际应用中，所见到的责任链模式大多为不纯的责任链。

三、责任链模式实战

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) {
            //获取Intent中附加的字符串消息并Toast
            String msg = intent.getStringExtra("msg");
            Toast.makeText(context, msg, Toast.LENGTH_SHORT).show();
            //终止广播
            abortBroadcast();
        } else {
            //添加信息发送给下一个Receiver
            Bundle b = new Bundle();
            b.putString("new","Message from FirstBroadcast");
            setResultExtras(b);
        }
    }
}

public class SecondReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        //获取Intent中附加的限制值
        int limit = intent.getIntExtra("limit", -1001);
        //如果限制值等于100，则处理，否则继续转发给下一个Receiver
        if (limit == 100) {
            //获取Intent中附加的字符串消息
            String msg = intent.getStringExtra("msg");
            //获取上一个Receiver增加的消息
            Bundle b = getResultExtras(true);
            String str = b.getString("new");
            //Toast
            Toast.makeText(context, msg+"-----"+str, Toast.LENGTH_SHORT).show();
            //终止广播
            abortBroadcast();
        } else {
            //添加信息发送给下一个Receiver
            Bundle b = new Bundle();
            b.putString("new","Message from SecondReceiver");
            setResultExtras(b);
        }
    }
}

public class ThirdReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        //获取Intent中附加的限制值
        int limit = intent.getIntExtra("limit", -1001);
        //如果限制值等于10，则处理，否则继续转发给下一个Receiver
        if (limit == 10) {
            //获取Intent中附加的字符串消息
            String msg = intent.getStringExtra("msg");
            //获取上一个Receiver增加的消息
            Bundle b = getResultExtras(true);
            String str = b.getString("new");
            //Toast
            Toast.makeText(context, msg+"-----"+str, Toast.LENGTH_SHORT).show();
            //终止广播
            abortBroadcast();
        } else {
            //添加信息发送给下一个Receiver
            Bundle b = new Bundle();
            b.putString("new","Message from ThirdReceiver");
            setResultExtras(b);
        }
    }
}

<receiver android:name=".FirstReceiver">
    <intent-filter android:priority="1000">
        <action android:name="com.gimiii.myfirstapp.action.ORDER_BROADCAST"/>
    </intent-filter>
</receiver>
<receiver android:name=".SecondReceiver">
    <intent-filter android:priority="100">
        <action android:name="com.gimiii.myfirstapp.action.ORDER_BROADCAST"/>
    </intent-filter>
</receiver>
<receiver android:name=".ThirdReceiver">
    <intent-filter android:priority="10">
        <action android:name="com.gimiii.myfirstapp.action.ORDER_BROADCAST"/>
    </intent-filter>
</receiver>

Intent i = new Intent();
i.setAction("com.gimiii.myfirstapp.action.ORDER_BROADCAST");
i.putExtra("limit", 100);
i.putExtra("msg", "Message from OrderActivity");
sendOrderedBroadcast(i, null);

将limit设置为100，只有SecondReceiver才会处理它。

四、总结

4.1、优点

可以对请求者和处理者关系解耦，提高代码的灵活性。

4.2、缺点

对链中请求处理者的遍历，如果处理者太多那么遍历必定会影响性能。

学海无涯苦作舟

我的微信公众号