责任链模式是一种对象的行为模式，使多个对象都有机会处理请求，从而避免了请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。
链有多个处理者组成。抽象处理者有三个职责：
- 定义一个请求的处理方法handleRequest（），是对外公开的方法；
- 定义一个链的编排方法，指定下一个处理者；
- 定义了具体的处理者必须实现的两个方法：自己处理的级别getHandlerLevel（）和具体的处理handle（）。
如下所示：
/**
* 抽象处理者
*/
public abstract class AbstractHandler {
/**
* 下一节点上的处理者对象
*/
private AbstractHandler nextHandler;
/**
* 处理请求
* @param request
*/
public final void handleRequest(AbstractRequest request){
// 自己能处理，就自己处理，否则传递给下一个处理者
if (getHandlerLevel() == request.getRequestLevel()){
handle(request);
}else {
if (nextHandler != null){
nextHandler.handleRequest(request);
}else {
System.out.println("所有对象都不能处理该请求");
}
}
}
/**
* 设置下一个处理者
* @param nextHandler
*/
public void setNextHandler(AbstractHandler nextHandler) {
this.nextHandler = nextHandler;
}
/**
* 处理请求
* @param request 请求对象
*/
protected abstract void handle(AbstractRequest request);
/**
* 每个处理者具体处理请求对象的实现
* @return 处理级别
*/
protected abstract int getHandlerLevel();
}
handleRequest为什么加final关键字呢？其实这个抽象处理者的实现，类似模板方法模式，抽象的模板方法都加上final，防止恶意操作，不允许被覆写。
然后定义不同的处理者，实现一个责任链：
public class ConcreteHandler1 extends Handler {
@Override
public void handle(AbstractRequest request) {
System.out.println("ConcreteHandler1处理需求。。。");
}
@Override
public int getHandlerLevel(){
return: 1;
}
}
public class ConcreteHandler2 extends Handler {
@Override
public void handle(AbstractRequest request) {
System.out.println("ConcreteHandler2处理需求。。。");
}
@Override
public int getHandlerLevel(){
return: 2;
}
}
public class ConcreteHandler3 extends Handler {
@Override
public void handle(AbstractRequest request) {
System.out.println("ConcreteHandler3处理需求。。。");
}
@Override
public int getHandlerLevel(){
return: 3;
}
}
然后在场景类中进行组装，并传递请求，处理请求。如果需要返回，可以定义handle方法为有返回值类型。
public class Client {
public static void main(String[] args) {
AbstractHandler handler1 = new ConcreteHandler1();
AbstractHandler handler2 = new ConcreteHandler2();
AbstractHandler handler3 = new ConcreteHandler3();
handler1.setNextHandler(handler2); // 设置下一级
handler2.setNextHandler(handler3); // 设置下一级
handler1.handleRequest(Request);//处理需求
}
}
如果 Request.getRequestLevel()==1,就会交给handler1处理，Request.getRequestLevel()==2,就会交给handler2处理，，Request.getRequestLevel()==3,就会交给handler3处理。
代码实现写完了，我们再分析下不用责任链的写法：
if（满足条件1）{
交给处理者1实现
}else if（满足条件2）{
交给处理者2实现
}else if（满足条件3）{
交给处理者3实现
}else{
。。。
}
然后对比下，可以看出来，责任链非常显著的优点是将请求和处理分开。请求者可以不知道是谁处理的，处理者可以不知道请求的全貌。两者解耦，提高灵活性。
当然，责任链也有缺点：
- 性能问题，链条比较长，每个请求都是从链条遍历到链尾。
- 调试也不方便。
所以扬长避短的最佳实践是：链接数需要控制，避免出现超长链的情况。
安卓对应的使用：
- Android 的触摸事件传递与分发机制；
- 利用有序广播实现责任链事件处理；
另外 ：
我们常见的缓存的设计，有内存缓存，返回内存缓存，否则查询磁盘缓存，最后拿去网路数据。
