《Android源码设计模式》之责任链模式

####责任链模式介绍
　　责任链模式（Iterator Pattern），是行为型设计模式之一。什么是“链”？我们将多个节点首尾相连所构成的模型称为链，比如生活中常见的锁链，就是由一个个圆角长方形的铁环串起来的结构。对于链式结构，每个节点都可以被拆开再连接，因此，链式结构也具有很好的灵活性。将这样一种结构应用于编程领域，将每一个节点看作是一个对象，每一个对象拥有不同的处理逻辑，将一个请求从链式的首端发出，沿着链的路径依次传递给每一个节点对象，直至有对象处理这个请求为止，我们将这样的一种模式称为责任链模式。
####责任链模式的定义
　　使多个对象都有机会处理请求，从而避免了请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，只到有对象处理它为止。
####责任链模式的使用场景
　　多个对象可以处理同一请求，但具体由哪个对象处理则在运行时动态决定。
　　在请求处理者不明确的情况下向多个对象中的一个提交一次请求。
　　需要动态指定一组对象处理请求。
####责任链模式的UML类图


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

抽象处理者 ``` package com.guifa.iteratorpatterndemo;

public abstract class Handler {
/**
* 下一节点的处理者
*/
protected Handler successor;

/**
 * 请求处理
 *
 * @param condition 请求条件
 */
public abstract void handleRequest(String condition);

}

<center>具体的处理者1

package com.guifa.iteratorpatterndemo;

public class ConcreteHandler1 extends Handler {
@Override
public void handleRequest(String condition) {
if (“ConcreteHandler1”.equals(condition)) {
System.out.println(“ConcreteHandler1 handled”);
} else {
successor.handleRequest(condition);
}
}
}

<center>具体的处理者2

package com.guifa.iteratorpatterndemo;

public class ConcreteHandler2 extends Handler {
@Override
public void handleRequest(String condition) {
if (“ConcreteHandler2”.equals(condition)) {
System.out.println(“ConcreteHandler2 handled”);
} else {
successor.handleRequest(condition);
}
}
}

<center>客户类

package com.guifa.iteratorpatterndemo;

public class Client {
public static void main(String[] args) {
// 构造一个ConcreteHandler1对象
ConcreteHandler1 handler1 = new ConcreteHandler1();
// 构造一个ConcreteHandler2对象
ConcreteHandler2 handler2 = new ConcreteHandler2();
// 设置handler1的下一个节点
handler1.successor = handler2;
// 设置handler2的下一个节点
handler2.successor = handler1;
// 处理请求
handler1.handleRequest(“ConcreteHandler2”);
}
}

　　角色介绍。
　　Handler：抽象处理者角色，声明一个请求处理的方法，并在其中保持一个对下一个处理节点Handler对象的引用。
　　ConcreteHandler：具体处理者角色，对请求进行处理，如果不能处理则将该请求转发给下一个节点上的处理对象。
　　上面我们说到这是一个简化版的通用模式代码。对于请求来说，其形式是固定的，就是一个字符串，而判断一个节点上的对象是否能够处理该请求的标志，则是该字符串是否与之匹配。然而在大多数情况下，责任链中的请求和对应的处理规则是不尽相同的，在这种情况下可以将请求进行封装，同时对请求的处理规则也进行封装作为一个独立的对象，如图所示：
<center>
![这里写图片描述](//img-blog.youkuaiyun.com/20180509105943482?watermark/2/text/Ly9ibG9nLmNzZG4ubmV0L3FxXzE2MjQwMzkz/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)

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

package com.guifa.iteratorpatterndemo;

public abstract class AbstractHandler {
/**
* 下一节点上的处理者对象
*/
protected AbstractHandler nextHandler;

public final void handleRequest(AbstractRequest request) {
    // 判断当前处理者对象的处理级别是否与请求者的处理级别一致
    if (getHandleLevel() == request.getRequestLevel()) {
        // 一致则由该处理对象处理
        handle(request);
    } else {
        // 当所有处理者对象均不能处理该请求时输出
        System.out.println("All of handler can not handle the request");
    }
}

/**
 * 获取处理者对象的处理级别
 *
 * @return 处理级别
 */
protected abstract int getHandleLevel();

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

}

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

package com.guifa.iteratorpatterndemo;

public abstract class AbstractRequest {
/**
* 处理对象
*/
private Object object;

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

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

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

}

　　接着分别实现3个请求者和3个处理者对象。
<center>请求者

package com.guifa.iteratorpatterndemo;

public class Request1 extends AbstractRequest {

public Request1(Object object) {
    super(object);
}

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

}

package com.guifa.iteratorpatterndemo;

public class Request2 extends AbstractRequest {

public Request2(Object object) {
    super(object);
}

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

}

package com.guifa.iteratorpatterndemo;

public class Request3 extends AbstractRequest {

public Request3(Object object) {
    super(object);
}

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

}

<center>处理者

package com.guifa.iteratorpatterndemo;

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

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

}

package com.guifa.iteratorpatterndemo;

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

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

}

package com.guifa.iteratorpatterndemo;

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

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

}

　　下面是客户类。

package com.guifa.iteratorpatterndemo;

public class Client {
public static void main(String[] args) {
// 构造3个处理者对象
AbstractHandler handler1 = new Handler1();
AbstractHandler handler2 = new Handler2();
AbstractHandler handler3 = new Handler3();

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

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

    // 总是从链式的首端发起请求
    handler1.handleRequest(request1);
    handler1.handleRequest(request2);
    handler1.handleRequest(request3);
}

}

　　输出结果：
<center>
![这里写图片描述](//img-blog.youkuaiyun.com/20180509154916691?watermark/2/text/Ly9ibG9nLmNzZG4ubmV0L3FxXzE2MjQwMzkz/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)
####责任链模式的简单实现
　　举个例子，比如工作中需要某一设备，需要向领导申请购买，价格是5万元，你向组长申请费用，组长一看数目不小，他没权限，于是组长得向部门领导申请，部门一看这么多钱他也没权限，只能向主管申请，主管只能申请1万元，所以他得向上层领导申请，直至有权限的领导审批。这个情景其实就是一个责任链的例子，每一层领导可以算是这条链上的一个节点，你是请求的发起者，而老板则是处于链条顶端的类。首先我们先声明一个抽象的领导者。
<center>抽象领导者

package com.guifa.iteratorpatterndemo;

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

/**
 * 处理报账请求
 *
 * @param money 能批复的报账额度
 */
public final void handleRequest(int money) {
    if (money <= limit()) {
        handle(money);
    } else {
        if (nextHandler != null) {
            nextHandler.handleRequest(money);
        }
    }
}

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

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

}

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

package com.guifa.iteratorpatterndemo;

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

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

}

package com.guifa.iteratorpatterndemo;

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

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

}

package com.guifa.iteratorpatterndemo;

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

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

}

package com.guifa.iteratorpatterndemo;

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

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

}

　　最后，你从组长开始发起请求申请报账。
　　<center>客户类

package com.guifa.iteratorpatterndemo;

public class You {
public static void main(String[] args) {
// 构造各个领导对象
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);
}

}

　　输出结果：
<center>
![这里写图片描述](//img-blog.youkuaiyun.com/20180510104708790?watermark/2/text/Ly9ibG9nLmNzZG4ubmV0L3FxXzE2MjQwMzkz/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)

　　这里大家可能会想，可不可以直接越过组长找主管报账呢？答案是肯定的，这也是责任链模式的灵魂之处，请求的发起可以从责任链的任何一个节点处开始，同时也可以改变责任链内部传递的规则，如主管不在，我们完全可以跨过主管从组长直接将请求转送给经理。
　　对于责任链中的一个处理者对象，其只有两个行为，一是处理请求，二是请求转送给下一个节点，不允许某个处理者对象在处理了请求后又将请求转送给上一个节点的情况。对于一条责任链来说，一个请求最终只有两种情况，一是被某个处理对象所处理，另一个是所有对象均未对其处理，对于前一种情况，我们称该责任链为纯的责任链，对于后一种情况我们称为不纯的责任链，在实际应用中，我们所见到的责任链模式大多为不纯的责任链。
####责任链模式实战
　　Android中我们可以借鉴责任链模式的思想来优化BroadcastReceiver使之成为一个全局的责任链处理者，具体方法很简单，我们知道Broadcast可以被分为两种，一种是Normal Broadcast普通广播，另一种是Ordered Broadcast有序广播，普通广播是异步的发出时可以被所有的接收者收到，而有序广播则是根据优先级依次传播的，直到有接收者将其终止或所有接收者都不终止它，有序广播的这一特性与我们的责任链模式很相近，通过它可以轻松地实现一种全局的责任链事件处理，这里我们创建3个BroadcastReceiver：

package com.guifa.iteratorpatterndemo;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.widget.Toast;

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 bundle = new Bundle();
        bundle.putString("new", "Message from FirstReceiver");
        setResultExtras(bundle);
    }
}

}

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

package com.guifa.iteratorpatterndemo;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.widget.Toast;

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中附加的字符串消息并Toast
        String msg = intent.getStringExtra("msg");

        // 获取上一个Receiver增加的消息
        Bundle bundle = getResultExtras(true);
        String str = bundle.getString("new");

        Toast.makeText(context, msg + "-----------" + str, Toast.LENGTH_SHORT).show();

        // 终止广播
        abortBroadcast();
    } else {
        // 添加信息发送给下一个Receiver
        Bundle bundle = new Bundle();
        bundle.putString("new", "Message from SecondReceiver");
        setResultExtras(bundle);
    }
}

}

package com.guifa.iteratorpatterndemo;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.widget.Toast;

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中附加的字符串消息并Toast
        String msg = intent.getStringExtra("msg");

        // 获取上一个Receiver增加的消息
        Bundle bundle = getResultExtras(true);
        String str = bundle.getString("new");

        Toast.makeText(context, msg + "-----------" + str, Toast.LENGTH_SHORT).show();

        // 终止广播
        abortBroadcast();
    } else {
        // 添加信息发送给下一个Receiver
        Bundle bundle = new Bundle();
        bundle.putString("new", "Message from ThirdReceiver");
        setResultExtras(bundle);
    }
}

}

　　最后我们在AndroidManifest.xml文件中声明这3个Receiver，并设定对应的权限值：

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

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

package com.guifa.iteratorpatterndemo;

import android.content.Intent;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;

public class MainActivity extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    Button button = findViewById(R.id.sendBroadBtn);
    button.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            Intent intent = new Intent();
            intent.setAction("com.guifa.iteratorpatterndemo.action.ORDER_BROADCAST");
            intent.putExtra("limit", 100);
            intent.putExtra("msg", "Message from MainActivity");
            sendOrderedBroadcast(intent, null);
        }
    });
}

}

　　这里我们将limit设置为100，也就是说只有SecondReceiver才会处理它，结果就不展示了。
####总结
　　责任链模式的优点是可以对请求者和处理者关系解耦，提高代码的灵活性。责任链模式的最大缺点是对链中请求处理者的遍历，如果处理者太多那么遍历必定会影响性能，特别是在一些递归调用中，要慎重。