Android中OkHttp源码阅读二(责任链模式)

博主前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住也分享一下给大家
👉点击跳转到教程

Android OkHttp源码阅读详解一

看OkHttp源码，发现OkHttp里面使用了责任链设计模式，所以才要学习责任链设计模式  小节2
最终会返回Response
Response getResponseWithInterceptorChain() throws IOException {
    // Build a full stack of interceptors.
    List<Interceptor> interceptors = new ArrayList<>();
    interceptors.addAll(client.interceptors());
    interceptors.add(retryAndFollowUpInterceptor);
    interceptors.add(new BridgeInterceptor(client.cookieJar()));
    interceptors.add(new CacheInterceptor(client.internalCache()));
    interceptors.add(new ConnectInterceptor(client));
    if (!forWebSocket) {
      interceptors.addAll(client.networkInterceptors());
    }
    interceptors.add(new CallServerInterceptor(forWebSocket));

    Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,
        originalRequest, this, eventListener, client.connectTimeoutMillis(),
        client.readTimeoutMillis(), client.writeTimeoutMillis());

    return chain.proceed(originalRequest);
  }

chain包下的案例 熟悉责任链模式
chain2包下的案例 对应OkHttp源码中的责任链模式getResponseWithInterceptorChain()

阅读OkHttp源码的总结
1.OSI七层模型，TCP/IP参考模型，HTTP格式
2.我们阅读了OkHttp源码的主线流程
3.我们阅读了OkHttp源码缓存方案的线程池
4.我们阅读了OkHttp源码，发现了构建者设计模式，责任链模式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

一、首先写一个案例熟悉责任链模式

1、定义一个抽象类BaseTask

public abstract class BaseTask {
    //判断当前任务节点，有没有能力执行
    private boolean isTask;


    public BaseTask(boolean isTask) {
        this.isTask = isTask;
    }

    //执行下一个节点
    private BaseTask nextTask; //t2,t3

    //添加下一个节点任务
    public void addNextTask(BaseTask nextTask) {
        this.nextTask = nextTask;
    }

    //让子节点任务去完成的
    public abstract void doActon();

    //动作
    public void action() { //t1=false  t2=false,t3=true
        if (isTask) {
            doActon(); //执行子节点 链条就断了
        } else {
            //继续执行下一个任务节点
            if (nextTask != null) {
                nextTask.action();
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

2、定义四个Task类，都继承自BaseTask，这里只写一个其它三个同理

public class Task1 extends BaseTask {
    public Task1(boolean isTask) {
        super(isTask);
    }

    @Override
    public void doActon() {
        //执行子节点
        System.out.println("Task1 任务节点一 执行了");
    }
}
1
2
3
4
5
6
7
8
9
10
11

3、定一个Test类进行测试

public class Test {
    public static void main(String[] args) {
        Task1 task1 = new Task1(false);
        Task2 task2 = new Task2(false);
        Task3 task3 = new Task3(true);
        Task4 task4 = new Task4(false);

        task1.addNextTask(task2);
        task2.addNextTask(task3);
        task3.addNextTask(task4);

        //执行第一个任务节点
        task1.action();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

输出结果：

Task3  任务节点三 执行了
1

二、写一个案例熟悉责任链模式，对应OkHttp源码中的责任链模式getResponseWithInterceptorChain()

1.首先定义一个接口

public interface IBaseTask {
    /**
     * @param isTask    任务节点是否有人执行
     * @param iBaseTask 下一个任务节点
     */
    void doRunAction(String isTask, IBaseTask iBaseTask);
}
1
2
3
4
5
6
7

2.定义一个链条管理类ChainManager

public class ChainManager implements IBaseTask {
    private List<IBaseTask> mIBaseTaskList = new ArrayList<>();
    private int index = 0;

    public void addTask(IBaseTask iBaseTask) {
        mIBaseTaskList.add(iBaseTask);
    }

    @Override
    public void doRunAction(String isTask, IBaseTask iBaseTask) {
        if (mIBaseTaskList.isEmpty()) {
            //抛出异常
            return;
        }
        if (index >= mIBaseTaskList.size()) {
            return;
        }
        IBaseTask iBaseTaskResult = mIBaseTaskList.get(index);//t1
        index++;
        iBaseTaskResult.doRunAction(isTask, iBaseTask);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3.定义三个Task1，Task2，Task3

public class Task1 implements IBaseTask {
    @Override
    public void doRunAction(String isTask, IBaseTask iBaseTask) {
        if ("no".equals(isTask)) {
            System.out.println("拦截器任务节点1 处理了...");
            return;
        } else {
            iBaseTask.doRunAction(isTask, iBaseTask);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12

public class Task2 implements IBaseTask {
    @Override
    public void doRunAction(String isTask, IBaseTask iBaseTask) {
        if ("ok".equals(isTask)) {
            System.out.println("拦截器任务节点2 处理了...");
            return;
        } else {
            iBaseTask.doRunAction(isTask, iBaseTask);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

public class Task3 implements IBaseTask {
    @Override
    public void doRunAction(String isTask, IBaseTask iBaseTask) {
        if ("no".equals(isTask)) {
            System.out.println("拦截器任务节点3 处理了...");
            return;
        } else {
            iBaseTask.doRunAction(isTask, iBaseTask);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11

4、定义一个Test类进行测试

public class Test {
    public static void main(String[] args) {
        ChainManager chainManager = new ChainManager();
        chainManager.addTask(new Task1());
        chainManager.addTask(new Task2());
        chainManager.addTask(new Task3());
        chainManager.doRunAction("ok", chainManager);
    }
}
1
2
3
4
5
6
7
8
9

输出结果如下：

拦截器任务节点2 处理了...
1