OKHttp源码分析（四）

  首先我们要了解下什么叫责任链模式？责任链， 顾名思义是将多个节点通过链条的方式连接起来，每一个节点相当于一个对象，而每一个对象层层相关，直接或者间接引用下一个对象（节点）；直到链条中有一个节点处理头节点传下来的事件截止。
  上面这个是官方的定义，我说下我的理解：比如员工A想请假，但是请假的时间比较长(比如一年)，首先给主管申请，但是主管不敢做主，于是申报给经理，但是经理也不敢做主，直接上报给Boss，Boss一看，这不是股东A的儿子的吗？立马给批了，然后经理一看Boss都批准了，也给批了，然后主管也批了，员工A最后得到批准的请求。
  我们还是继续写个例子来说明，代码如下：

public interface Intercepty {

    public boolean interceptor(Chain chain);

    interface Chain {

        String request();

        boolean proceed(String request);
    }
}

首先我们模拟一个 拦截器的接口，然后再实现几个拦截器,如下：

主管

public class GroupIntecepty implements Intercepty{

    @Override
    public boolean interceptor(Chain chain) {
        System.out.println("主管:"+chain.request() + "我没权利批准，报给经理");
        boolean proceed = chain.proceed(chain.request());
        if (proceed) {
            System.out.println("主管：经理同意了，我也同意");
        }else {
            System.out.println("主管：经理拒绝了，我也拒绝");
        }
        return proceed;
    }
}

经理

public class ManagerIntecepty implements Intercepty {

    @Override
    public boolean interceptor(Chain chain) {
        System.out.println("经理："+chain.request() + "我没权利批准，报给BOSS");
        boolean proceed = chain.proceed(chain.request());
        if (proceed) {
            System.out.println("经理：Boss同意了，我也同意");
        }else {
            System.out.println("经理：Boss拒绝了，我也拒绝");
        }
        return proceed;
    }

}

Boss

public class BossIntercepty implements Intercepty {

    @Override
    public boolean interceptor(Chain chain) {
        System.out.println("Boss:"+chain.request());
        System.out.println("因为他是董事A的儿子，所以我批准了");
        return true;
    }

}

实现Chain 接口

public class RealIntercepty implements Chain {

    List<Intercepty> mlist;
    int index;
    String request;
    
    public RealIntercepty(List<Intercepty> list,int index ,String request) {
        this.mlist = list;
        this.index = index;
        this.request = request;
    }
    
    @Override
    public String request() {
        
        return request;
    }

    @Override
    public boolean proceed(String request) {
        if (index >= mlist.size()) {
            return false;
        }
        
        RealIntercepty next = new RealIntercepty(mlist,index + 1,request);
        Intercepty interceptor = mlist.get(index);
        return interceptor.interceptor(next);
    }

}

然后我们员工A进行一年的请假申请：

public class Dispatcher {

    public static void main(String[] args) {
        List<Intercepty> list = new ArrayList<Intercepty>();
        list.add(new GroupIntecepty());
        list.add(new ManagerIntecepty());
        list.add(new BossIntercepty());
        
        RealIntercepty realInterceptyA = new RealIntercepty(list, 0, "员工A申请请假一年");
        System.out.println("请假申请同意了？"+ realInterceptyA.proceed("员工A申请请假一年"));

    }
}

最后我们看打印的结果：

主管:员工A申请请假一年我没权利批准，报给经理
经理：员工A申请请假一年我没权利批准，报给BOSS
Boss:员工A申请请假一年
因为他是董事A的儿子，所以我批准了
经理：Boss同意了，我也同意
主管：经理同意了，我也同意
请假申请同意了？true

从这里我们可以看到，请求经过所有的拦截器，知道有拦截器把请求处理，返回结果；然后结果也经过所有的拦截器，我们得到结果，这个其实就和View的事件传递机制很像。水平有限，拦截器模式就讲到这里了，大家也可以自己深入研究下。