责任链模式

一、责任链模式的定义

定义：使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系，将这些对象形成一条链，并沿着这条链传递该请求，直到有对象处理它为止。
需要重点注意的地方：上一个对象必须含有下一个对象的引用，形成一个单向链表。
我画了一张图便于理解：

责任链模式.png

二、基于代码的UML图

UML.PNG

三、具体代码实现

抽象请求类(水果 便于扩展)：

/**
 * 抽象请求类
 * @author dell
 *
 */
public abstract class AbstractRequest {
    
     public Object object;
     
     public Object getContent(){
         return object;
     }
     
     //抽象的方法，交给子类去实现，满足条件就处理请求
     public abstract int getRequestLevel();
}

两个具体请求类(苹果)

public class Request1 extends AbstractRequest{
    
    public int getRequestLevel() {
        return 1;
    }
}
public class Request2 extends AbstractRequest{

    public int getRequestLevel() {
        return 2;
    }

}

抽象处理者

public abstract class Handler {
    
     //如果不满足条件就要传递给下一个对象去出去所以必须持有下一个对象的引用
     public Handler nextHandler;
     
     public void handleRequest(AbstractRequest request){
          if(request.getRequestLevel()==hanleLevel()){
              //满足条件 自己处理
              handle(request);
          }else{
              //不满足条件 传递给下一个 Handler处理
              if(nextHandler!=null){
                  nextHandler.handle(request);
              }else{
                  System.out.println("所有对象都不能处理");
              }
             
          }
          
     }
     
     //子类去实现，满足条件就处理掉 不往后传递
     public abstract void handle(AbstractRequest request);
     
     //能够处理请求的级别
     public abstract int hanleLevel();
}

写了三个具体处理者，继承抽象处理者

public class Handler1 extends Handler{

    public void handle(AbstractRequest request) {
        System.out.println("Handler1处理了"+request.getRequestLevel());
    }

    public int hanleLevel() {
        return 1;
    }

}

public class Handler2 extends Handler{
    
    public void handle(AbstractRequest request) {
        System.out.println("Handler2处理了"+request.getRequestLevel());
    }

    public int hanleLevel() {
        return 2;
    }


}

public class Handler3 extends Handler{

    public void handle(AbstractRequest request) {
        System.out.println("Hanlder3处理了"+request.getRequestLevel());
    }

    public int hanleLevel() {
        return 3;
    }
}

调用端的代码，main函数

public class Client {
    public static void main(String[] args) {
        Handler hander1 = new Handler1();
        Handler hander2 = new Handler2();
        Handler hander3 = new Handler3();
        
        //拼装成一个调用链
        hander1.nextHandler = hander2;
        hander2.nextHandler = hander3;
    
        AbstractRequest request = new Request2();
        //将请求对象丢给第一个对象
        hander1.handle(request);
    }
}

调用端必须要是处理者形成一个处理的单向链表，请求要丢给第一个处理者，这样才能保证每个处理者都能接受到请求。Android源码中这个模式用的比较广泛，譬如，事件分发机制。

四、结语

简单介绍这么多，Android事件分发，和广播机制都用到了这个模式，有兴趣的可以了解一下。