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

链有多个处理者组成。抽象处理者有三个职责：

1. 定义一个请求的处理方法handleRequest（），是对外公开的方法；
2. 定义一个链的编排方法，指定下一个处理者；
3. 定义了具体的处理者必须实现的两个方法：自己处理的级别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{
    。。。
}

然后对比下，可以看出来，责任链非常显著的优点是将请求和处理分开。请求者可以不知道是谁处理的，处理者可以不知道请求的全貌。两者解耦，提高灵活性。

当然，责任链也有缺点：

1. 性能问题，链条比较长，每个请求都是从链条遍历到链尾。
2. 调试也不方便。

所以扬长避短的最佳实践是：链接数需要控制，避免出现超长链的情况。

安卓对应的使用：

• Android 的触摸事件传递与分发机制；
• 利用有序广播实现责任链事件处理；

另外 ：

我们常见的缓存的设计，有内存缓存，返回内存缓存，否则查询磁盘缓存，最后拿去网路数据。