• Android OkHttp源码阅读详解一

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

    前言：源码阅读基于okhttp:3.10.0

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

    implementation 'com.squareup.okhttp3:okhttp:3.10.0'

    • 1

    1、首先回顾OkHttp的使用

    public class MainActivity extends RxActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    /**
     * OkHttp的使用
     */
    private static void okHttpUseAction() {
        //通过构建者设计模式得到OkHttpClient
        OkHttpClient okHttpClient = new OkHttpClient.Builder().build();
        //get请求 构建者模式拿到request
        Request request = new Request.Builder().url("https://www.baidu.com/").get().build();
        //Call  call = RealCall
        Call call = okHttpClient.newCall(request);
//        call.cancel();//取消请求
        //同步方法，我们需要自己开启子线程 耗时
//        try {
//            Response response = call.execute();
//            String string = response.body().string();
//            InputStream inputStream = response.body().byteStream();
//            Reader reader = response.body().charStream();
//        } catch (IOException e) {
//            e.printStackTrace();
//        }

        //异步方法
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                System.out.println("请求失败...");
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                String string = response.body().string();
                System.out.println("请求完成：" + string);
//                InputStream inputStream = response.body().byteStream();
//                Reader reader = response.body().charStream();
            }
        });
    }

    public static void main(String[] args) {
        okHttpUseAction();
    }
}

    • 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
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50

    2、OkHttp源码阅读之线程池详解

    /**
 * @Author: ly
 * @Date: 2023/9/3
 * @Description: 线程池的使用
 */
public class MyThreadPool {
    public static void main(String[] args) {
        //比较耗性能，开启子线程，然后回收
        new Thread() {
            @Override
            public void run() {
                super.run();
            }
        }.start();
        //java 1.5 线程如何复用  线程池复用
        //子线程
        //需要一份工作：招聘工作，员工完成工作后，解聘
        //需要一份工作：招聘工作，员工完成工作后，解聘
        //需要一份工作：招聘工作，员工完成工作后，解聘

        //线程池相当于以下
        //需要一份工作：招聘工作，员工完成工作后，继续执行其他工作，解雇

        //java 1.5 线程池复用,线程池(线程，如何让这么多线程复用，线程管理工作)
        //Executor
        //    --ExecutorService
        //        --AbstractExecutorService
        //          --ThreadPoolExecutor
        //ThreadPoolExecutor 学习此类

        //线程池里面，只有一个核心线程在跑任务
        /**
         * corePoolSize:核心线程数
         * maximumPoolSize：线程池非核心线程数，线程池规定大小
         * keepAliveTime:时间数值
         * unit：时间单位
         *       参数三和四作用：正在执行的任务Runnable 20 大于核心线程数  参数三和参数四才会起作用
         *       作用：Runnable1执行完毕后闲置60s，如果过了闲置60s，会回收掉Runnable1，如果在闲置时间60s内，复用此线程Runnable1
         * workQueue：队列
         *            作用：会把超出的任务加入到队列中，缓存起来
         */
//        ExecutorService executorService = new ThreadPoolExecutor(1, 1, 60, TimeUnit.SECONDS, new LinkedBlockingDeque<>());

        //Exception in thread "main" java.lang.IllegalArgumentException  会崩溃
//        ExecutorService executorService = new ThreadPoolExecutor(5,
//                1, 60, TimeUnit.SECONDS, new LinkedBlockingDeque<>());

//        ExecutorService executorService = new ThreadPoolExecutor(5,
//                10, 60, TimeUnit.SECONDS, new LinkedBlockingDeque<>());

        //想实现缓存，线程池方案
        /**
         * corePoolSize:核心线程数
         * maximumPoolSize：最大线程数。线程池非核心线程数，线程池规定大小
         * keepAliveTime:时间数值
         * unit：时间单位
         *       参数三和四作用：正在执行的任务Runnable 20 大于核心线程数  参数三和参数四才会起作用
         *       作用：Runnable1执行完毕后闲置60s，如果过了闲置60s，会回收掉Runnable1，如果在闲置时间60s内，复用此线程Runnable1
         * workQueue：队列
         *            作用：会把超出的任务加入到队列中，缓存起来
         */
//        ExecutorService executorService = new ThreadPoolExecutor(0,
//                Integer.MAX_VALUE, 60, TimeUnit.SECONDS, new LinkedBlockingDeque<>());

        ExecutorService executorService = new ThreadPoolExecutor(0,
                Integer.MAX_VALUE, 60, TimeUnit.SECONDS, new SynchronousQueue<>(),
                new ThreadFactory() {
                    @Override
                    public Thread newThread(Runnable r) {
                        Thread thread = new Thread();
                        thread.setName("MyOkHttp Dispatcher");
                        thread.setDaemon(false);//不是守护线程
                        return thread;
                    }
                });

        for (int i = 0; i < 20; i++) { //循环第二次，闲置60s，复用上一次任务
            executorService.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(1000);
                        System.out.println("当前线程，执行耗时任务，线程是：" + Thread.currentThread().getName());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }


        /**************************************JAVA提供了API***********************************************/

        //Java设计者考虑到了不用使用线程池的参数配置，提供了API
        ExecutorService executorService1 = Executors.newCachedThreadPool();
        executorService1.execute(new Runnable() {
            @Override
            public void run() {

            }
        });

        //线程池里面只有一个核心线程，最大线程也只有一个
        ExecutorService executorService2 = Executors.newSingleThreadExecutor();

        Executors.newFixedThreadPool(5); //指定固定大小线程池
    }
}


    • 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
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109

    3、守护线程详解

    /**
 * @Author: ly
 * @Date: 2023/9/3
 * @Description: 守护线程的使用
 */
public class MyThread {
    public static void main(String[] args) {
        Thread thread = new Thread() {
            @Override
            public void run() {
                super.run();
                while (true) {
//                    try {
//                        Thread.sleep(10);
//                    } catch (Exception e) {
//                        e.printStackTrace();
//                    } finally {
//                        System.out.println("run...");
//                    }
                    System.out.println("run...");
                }
            }
        };
        //守护线程
        thread.setDaemon(true);
        thread.start();
        //JVM main()所持有的进程该结束了
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

    • 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
    • 33
    • 34

    4、根据OkHttp中构建者模式写一个例子
    1.定义一个类HomeParam

    /**
 * @Author: ly
 * @Date: 2023/9/3
 * @Description: 房子的图纸
 */
public class HomeParam {
    private double width;
    private double height;
    private String color = "白色";

    public HomeParam() {
    }

    public HomeParam(double width, double height, String color) {
        this.width = width;
        this.height = height;
        this.color = color;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "画出来的图纸：HomeParam{" +
                "width=" + width +
                ", height=" + height +
                ", color='" + color + '\'' +
                '}';
    }
}

    • 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
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52

    2.定义一个类House

    /**
 * @Author: ly
 * @Date: 2023/9/3
 * @Description: 真实存在的房子
 */
public class House {
    private double width;
    private double height;
    private String color;

    public House() {
    }

    public House(double width, double height, String color) {
        this.width = width;
        this.height = height;
        this.color = color;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "具体建造出来的房子：House{" +
                "width=" + width +
                ", height=" + height +
                ", color='" + color + '\'' +
                '}';
    }
}


    • 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
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53

    3、定义一个类Worker

    /**
 * @Author: ly
 * @Date: 2023/9/3
 * @Description: 工人开始建造房子
 */
public class Worker {
    //拿到图纸
    private HomeParam mHomeParam;

    public void setHomeParam(HomeParam homeParam) {
        mHomeParam = homeParam;
    }

    //工作，盖房子
    public House buildHouse() {
        House house = new House();
        house.setHeight(mHomeParam.getHeight());
        house.setWidth(mHomeParam.getWidth());
        house.setColor(mHomeParam.getColor());
        return house;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    4、定义一个类DesignerPerson

    /**
 * @Author: ly
 * @Date: 2023/9/3
 * @Description: 设计师
 */
public class DesignerPerson {
    private HomeParam mHomeParam;
    private Worker mWorker;

    public DesignerPerson() {
        mHomeParam = new HomeParam();
        mWorker = new Worker();
    }

    /**
     * 增加楼层
     *
     * @param height 高度
     */
    public DesignerPerson addHeight(double height) {
        mHomeParam.setHeight(height);
        return this;
    }

    /**
     * 增加宽度
     *
     * @param width 宽度
     */
    public DesignerPerson addWidth(double width) {
        mHomeParam.setWidth(width);
        return this;
    }

    /**
     * 增加颜色
     *
     * @param color 颜色
     */
    public DesignerPerson addColor(String color) {
        mHomeParam.setColor(color);
        return this;
    }

    /**
     * 把图纸给工人
     * 员工说房子盖好了
     *
     * @return
     */
    public House build() {
        mWorker.setHomeParam(mHomeParam);
        return mWorker.buildHouse();
    }
}

    • 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
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55

    5.定义一个类UserClient

    /**
 * @Author: ly
 * @Date: 2023/9/3
 * @Description: 用户有一个需求盖房子
 */
public class UserClient {
//    public static void main(String[] args) {
    //第一版

    //找到建筑公司
//        DesignerPerson designerPerson = new DesignerPerson();
//        designerPerson.addHeight(4);
//        designerPerson.addWidth(120.0);
//        designerPerson.addColor("绿色");
//
//        designerPerson.addHeight(2);
//        designerPerson.addWidth(100.0);
//        designerPerson.addColor("红色");
//
//        designerPerson.addHeight(3);
//        designerPerson.addWidth(90.0);
//        designerPerson.addColor("黄色");
//
//        //复制的过程
//
//        House house = designerPerson.build();
//        System.out.println(house);
//    }

    public static void main(String[] args) {
        //第二版，链式调用
        House house = new DesignerPerson().addColor("白色")
                .addWidth(100)
                .addHeight(8)
                .build();
        System.out.println(house);
    }
}


    • 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
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    2、OkHttp主线流程源码阅读

    1.OSI七层模型,TCP/IP模型(四层),HTTP格式
  OSI七层参考模型  --> TCP/IP参考模型
  TCP/IP参考模型四层：
  应用层 --> HTTP,HTTPS
  传输层 --> Socket

  HTTP get(请求行,请求属性集) post(请求行,请求属性集,type(form表单提交，还是其他提交),len(长度)==请求体)

2.OkHttp源码的主线流程
OkHttp的使用

OkHttpClient 通过构建者设计模式得到OkHttpClient
Request  通过构建者设计模式得到Request
Call  实际得到的是final class RealCall implements Call
//异步方法
call.enqueue(new Callback()
//不能执行大于1次 enqueue 否则会抛出异常Exception in thread "main" java.lang.IllegalStateException: Already Executed
synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
//拿到调度器dispatcher执行enqueue()方法
client.dispatcher().enqueue(new AsyncCall(responseCallback));

Dispatcher{
 /** Ready async calls in the order they'll be run. */  等待队列
  private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();

   运行的队列
  /** Running asynchronous calls. Includes canceled calls that haven't finished yet. */
  private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();

  //最终会调用到Dispatcher类中的enqueue()方法
  synchronized void enqueue(AsyncCall call) {
      //同时运行的异步任务小于64&&同时访问(同一个)的服务器,不能超过5个  条件满足加入到运行队列中，然后执行
      if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
        runningAsyncCalls.add(call);
        executorService().execute(call); //执行
      } else {
        //加入到等待队列
        readyAsyncCalls.add(call);
      }
    }

  Deque双端队列：Deque（双端队列）是一种用于管理HTTP请求和响应拦截器的数据结构。
                Deque是"Double-ended Queue"的缩写，表示它可以在两端进行元素的插入和删除操作。

  AsyncCall 执行耗时任务
           signalledCallback 为true：这个错误是用户造成的，和OkHttp没有关系
                             为false：这个错误是OkHttp造成的。 onFailure

}

梳理主线流程：
OkHttpClient --> Request -> newCall  RealCall.enqueue(){不能重复执行} --> Dispatcher.enqueue(AsyncCall)-->
Dispatcher{if:先加入运行队列里面去，执行异步任务 else 直接加入等待队列} --> 异步任务 AsyncCall.execute()

分析OkHttp里面的线程池
executorService().execute(call);

public synchronized ExecutorService executorService() {
    if (executorService == null) {
      executorService = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60, TimeUnit.SECONDS,
          new SynchronousQueue<Runnable>(), Util.threadFactory("OkHttp Dispatcher", false));
    }
    return executorService;
}
分析结果：OkHttp里面的线程池，采用的是缓存方案+线程工厂 name  不是守护线程
总结：采用的是缓存方案+定义线程工程(设置线程名，设置不是守护线程)
缓存方案：参数1 == 0
         参数2 == Integer.MAX_VALUE
         参数3 == 60s闲置时间，只要Runnable > 大于参数1  起作用(60s 之内就会复用之前的任务，60s之内就会回收任务)

--------------------------------->
看OkHttp源码，发现OkHttp里面使用了构建者设计模式，所以才要学习构建者设计模式
OkHttpClient ---构建者模式
Request      ---构建者模式
开始学习构建者设计模式 -->盖房子的例子(根据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
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
  • 相关阅读:
    pnpm 是凭什么对 npm 和 yarn 降维打击的
    天梯赛 L2-046 天梯赛的赛场安排
    BreederDAO 第一项提案发布：DAO 组织的宪法章程
    《论文阅读》CAB：认知、情感和行为的共情对话生成 DASFAA 2023
    【教程】如何在服务器上部署豆瓣小组抢沙发聊天机器人
    设计模式入门
    离线数仓（7）：数仓理论之数据仓库建模
    Python函数
    【Python】输入输出与运算符
    电脑版剪映怎么倒放？
  • 原文地址：https://blog.csdn.net/lu202032/article/details/132640844