OkHttp完全解析（八）源码解析一

最新推荐文章于 2024-02-21 15:20:18 发布
最新推荐文章于 2024-02-21 15:20:18 发布
阅读量1.8k 收藏 3
点赞数
分类专栏： Android开发
本文详细解析了 OKHttp 的工作原理，包括同步与异步请求处理过程、请求排队与执行机制、拦截器功能及其实现方式，以及最终如何发起网络请求。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

转自：

http://blog.youkuaiyun.com/chenzujie/article/details/47061095    OKHttp源码解析（一）

http://blog.youkuaiyun.com/chenzujie/article/details/47093723    OKHttp源码解析（二）

http://blog.youkuaiyun.com/chenzujie/article/details/47158645    OKHttp源码解析（三）


在上一篇博客中，我们介绍了OKHttp的基本用法，这一篇我们将从源码角度来看下OKHttp是如何完成一些列的网络的操作的。 
我们知道在okhttpclient同步请求和异步请求调用的接口不一样，但它们最后都是殊途同归地走到Call里面的

private Response getResponseWithInterceptorChain(boolean forWebSocket) throws IOException {
        Call.ApplicationInterceptorChain chain = new Call.ApplicationInterceptorChain(0, this.originalRequest, forWebSocket);
        return chain.proceed(this.originalRequest);
    }

首先我们来看看调用execute和enqueue是如何走到`getResponseWithInterceptorChain的。

public Response execute() throws IOException {
        synchronized(this) {
            //执行过不能再执行if(this.executed) {
                thrownew IllegalStateException("Already Executed");
            }

            this.executed = true;
        }

        Response var2;
        try {
            //把这次请求加入到分发器里this.client.getDispatcher().executed(this);
            Response result = this.getResponseWithInterceptorChain(false);
            if(result == null) {
                thrownew IOException("Canceled");
            }

            var2 = result;
        } finally {
        //this.client.getDispatcher().finished(this);
        }

        return var2;
    }

上面代码14行用到了一个从OkHttpClient获得的Dispatcher然后把它加入到分发器里面的队列 executedCalls中，在完成的时候会remove掉

synchronized void executed(Callcall) {
        this.executedCalls.add(call);
    }

    synchronized void finished(Callcall) {
        if(!this.executedCalls.remove(call)) {
            throw new AssertionError("Call wasn\'t in-flight!");
        }
    }
再来看看异步如何走到getResponseWithInterceptorChain
publicvoid enqueue(Callback responseCallback) {
        this.enqueue(responseCallback, false);
    }

    void enqueue(Callback responseCallback, boolean forWebSocket) {
        synchronized(this) {
            if(this.executed) {
                thrownew IllegalStateException("Already Executed");
            }

            this.executed = true;
        }

        this.client.getDispatcher().enqueue(new Call.AsyncCall(responseCallback, forWebSocket, null));
    }
是不是和同步很像，最后都是调用分发器的enqueue，但和同步不同的是，同步传入enqueue方法的参数是Call，异步传入的是AsyncCall，这个是什么呢，这个是Call里面的一个内部类，而且是一个继承了Runnable的内部类，我们先来看看这个execute怎么操作
synchronized void enqueue(AsyncCall call) {
        //判断当前运行的线程是否超过最大线程数，以及同一个请求是否要超过相同请求同时存在的最大数目
        if(this.runningCalls.size() < this.maxRequests && this.runningCallsForHost(call) < this.maxRequestsPerHost) {
            this.runningCalls.add(call);
            //将请求放到线程池里运行
            this.getExecutorService().execute(call);
        } else {
            //不满足运行条件放到后备队列里
            this.readyCalls.add(call);
        }

    }
从上面代码我们看到异步请求是有条件限制的，默认最多64个请求，而同一个请求默认最多同时存在5个
privateint runningCallsForHost(AsyncCall call) {
        int result = 0;
        Iterator var3 = this.runningCalls.iterator();

        while(var3.hasNext()) {
            AsyncCall c = (AsyncCall)var3.next();
            通过比较每个请求的url，一样代表同一个请求
            if(c.host().equals(call.host())) {
                ++result;
            }
        }

        return result;
    }
下面的两个参数可以通过从OKHttpClient getDispatch得到分发器，并根据分发器提提供的设置方法去修改，修改比较简单就不贴代码了 。
privateint maxRequests = 64;
    privateint maxRequestsPerHost = 5;
再来看看AsyncCall 的run里面的代码
publicfinalvoid run() {
        String oldName = Thread.currentThread().getName();
        Thread.currentThread().setName(this.name);

        try {
            this.execute();
        } finally {
            Thread.currentThread().setName(oldName);
        }

    }
显然AsyncCall的execute才是核心
protected void execute() {
            boolean signalledCallback = false;

            try {
                Response e = Call.this.getResponseWithInterceptorChain(this.forWebSocket);
                if(Call.this.canceled) {
                    signalledCallback = true;
//取消call调用onFailure回调                       this.responseCallback.onFailure(Call.this.originalRequest, new IOException("Canceled"));
                } else {
                    signalledCallback = true;
                    //请求成功，回调onResponse
                    this.responseCallback.onResponse(e);
                }
            } catch (IOException var6) {
                if(signalledCallback) {
                    Internal.logger.log(Level.INFO, "Callback failure for " + Call.this.toLoggableString(), var6);
                } else {
                    this.responseCallback.onFailure(Call.this.engine.getRequest(), var6);
                }
            } finally {
                //完成请求，调用finish，从队列中清空
                Call.this.client.getDispatcher().finished(this);
            }

        }
在代码第五行我们又看到了getResponseWithInterceptorChain。 

我们继续看getResponseWithInterceptorChain里面的实现

private Response getResponseWithInterceptorChain(boolean forWebSocket) throws IOException {
        Call.ApplicationInterceptorChain chain = new Call.ApplicationInterceptorChain(0, this.originalRequest, forWebSocket);
        return chain.proceed(this.originalRequest);
    }
创建了一个ApplicationInterceptorChain ，并且第一个参数传入0，这个0是有特殊用法的，涉及到OKHttp里面的一个功能叫做拦截器，从getResponseWithInterceptorChain这个名字里其实也能看出一二。先看看proceed做了什么
public Response proceed(Request request) throws IOException {
            //先判断是否每个拦截器都有对应的处理，没有的话先继续新建ApplicationInterceptorChain ，并执行当前拦截器的intercept方法
            if(this.index < Call.this.client.interceptors().size()) {
                Call.ApplicationInterceptorChain chain = Call.this.new ApplicationInterceptorChain(this.index + 1, request, this.forWebSocket);
                return ((Interceptor)Call.this.client.interceptors().get(this.index)).intercept(chain);
            } else {
                return Call.this.getResponse(request, this.forWebSocket);
            }
        }
这里碰到一个拦截器，OKHttp增加了一个拦截器机制，先来看看官方文档对Interceptors 的解释 

Interceptors are a powerful mechanism that can monitor, rewrite, and retry calls. 
解释下就是拦截器可以用来转换，重试，重写请求的机制，再来看看官方文档里提供的例子 
首先自定义一个拦截器用于打印一些发送信息

classLoggingInterceptorimplementsInterceptor {
  @Override public Response intercept(Chain chain) throws IOException {
    Request request = chain.request();

    long t1 = System.nanoTime();
    logger.info(String.format("Sending request %s on %s%n%s",
        request.url(), chain.connection(), request.headers()));

    Response response = chain.proceed(request);

    long t2 = System.nanoTime();
    logger.info(String.format("Received response for %s in %.1fms%n%s",
        response.request().url(), (t2 - t1) / 1e6d, response.headers()));

    return response;
  }
}
然后使用的时候把它添加到okhttpclient
OkHttpClient client = new OkHttpClient();
client.interceptors().add(new LoggingInterceptor());

Requestrequest = newRequest.Builder()
    .url("http://www.publicobject.com/helloworld.txt")
    .header("User-Agent", "OkHttp Example")
    .build();

Responseresponse = client.newCall(request).execute();
response.body().close();
当我们执行到proceed，就会去判断是否有拦截器有的话先执行拦截器里的intercept，而在intercept里一般会进行一些自定义操作并且调用procced去判断是否要继续执行拦截器操作还是直接去获取网络请求，我们看看procced做了什么
public Response proceed(Request request) throws IOException {
//判断还有拦截器需要执行不，生成新的ApplicationInterceptorChain并调用它的intercept去执行用户定义的操作
            if(this.index < Call.this.client.interceptors().size()) {
                Call.ApplicationInterceptorChain chain = Call.this.new ApplicationInterceptorChain(this.index + 1, request, this.forWebSocket);
                return ((Interceptor)Call.this.client.interceptors().get(this.index)).intercept(chain);
            } else {
                return Call.this.getResponse(request, this.forWebSocket);
            }
        }
上面的例子执行结果如下
INFO: Sending request http://www.publicobject.com/helloworld.txt on null
User-Agent: OkHttp Example

INFO: Received response for https://publicobject.com/helloworld.txt in 1179.7ms
Server: nginx/1.4.6 (Ubuntu)
Content-Type: text/plain
Content-Length: 1759
Connection: keep-alive
拦截器的整个机制如下图这里写图片描述

上图中把拦截器氛围应用拦截器和网络拦截器，其实这个取决于你在拦截器里做了哪方面的操作，比如改变了请求头部之类的就可以成为网络拦截器。

在处理完拦截器操作后，就进入到重要的getResponse方法，真正的去进行发送请求，处理请求，接收返回结果。

Response getResponse(Request request, boolean forWebSocket) throws IOException {
        RequestBody body = request.body();
        if(body != null) {
            //如果是post方式，处理一些头部信息
            Builder followUpCount = request.newBuilder();
            MediaType response = body.contentType();
            if(response != null) {
                followUpCount.header("Content-Type", response.toString());
            }

            long followUp = body.contentLength();
            if(followUp != -1L) {
                followUpCount.header("Content-Length", Long.toString(followUp));
                followUpCount.removeHeader("Transfer-Encoding");
            } else {
                followUpCount.header("Transfer-Encoding", "chunked");
                followUpCount.removeHeader("Content-Length");
            }
            request = followUpCount.build();
        }
        //新建HttpEngine，用于进行发送请求和读取答复的细节处理this.engine = new HttpEngine(this.client, request, false, false, forWebSocket, (Connection)null, (RouteSelector)null, (RetryableSink)null, (Response)null);
        int var11 = 0;

        while(!this.canceled) {
            HttpEngine var13;
            try {
                 //发送请求this.engine.sendRequest();
                //读取答复this.engine.readResponse();
            } catch (RequestException var8) {
                throw var8.getCause();
            } catch (RouteException var9) {
                var13 = this.engine.recover(var9);
                if(var13 != null) {
                    this.engine = var13;
                    continue;
                }

                throw var9.getLastConnectException();
            } catch (IOException var10) {
                var13 = this.engine.recover(var10, (Sink)null);
                if(var13 != null) {
                    this.engine = var13;
                    continue;
                }

                throw var10;
            }

            Response var12 = this.engine.getResponse();
            //得到该请求对应的后续请求，比如重定向之类的
            Request var14 = this.engine.followUpRequest();
            if(var14 == null) {
                if(!forWebSocket) {
                    this.engine.releaseConnection();
                }

                return var12;
            }

            ++var11;
            if(var11 > 20) {
                thrownew ProtocolException("Too many follow-up requests: " + var11);
            }

            if(!this.engine.sameConnection(var14.url())) {
                this.engine.releaseConnection();
            }

            Connection connection = this.engine.close();
            this.engine = new HttpEngine(this.client, var14, false, false, forWebSocket, connection, (RouteSelector)null, (RetryableSink)null, var12);
        }

        this.engine.releaseConnection();
        thrownew IOException("Canceled");
    }

可以看到如果是post请求，先做一定的头部处理，然后新建一个HttpEngine去处理具体的操作，通过sendRequest发送具体请求操作，readResponse对服务器的答复做一定处理，在代码52行处getResponse得到从服务器返回的Response，讲到这里，我们整个的流程大概疏通了，代码贴了很多，简单的可以用下面一张图概括 

整体看就是根据用户的请求Request放入到指定队列，并使用拦截器链的方式去执行我们的请求操作。 
上图中的sendRequest，缓存处理，readReponse，介于篇幅问题（本来想一篇写完的，结果发现篇幅好长，分几篇完成吧）将在后续的文章中继续介绍。


OkHttp源码解析（构建者模式、责任链模式、主线流程）
nufuli123的博客
02-20 523
在分析OkHttp的核心流程已经核心类之前，我们先搞清楚两个概念，一个是OkHttpClient和Request在创建时所使用的构建者模式；另外一个则是负责响应处理的拦截器模式； OkHttpClient/Request的构建者模式解析 基本概念 构建者（又称建造者）模式允许我们使用多个简单的对象一步一步构建成一个复杂的对象。 概念解释 如果你要装修房子，你就会要考虑这个房子的整体设计怎么做，用地中海风格？欧美风格？纯中式风格？墙面是刷白色的漆？贴瓷砖？还是用其他颜色？水电安装怎么处理？防水怎么处理？主卧怎
Android 网络框架之OkHttp源码解析
2501_90404872的博客
01-25 618
先来看一下这个成员变量，很少，就几个，但是从命名可以看出，这里面定义了请求的URL，请求的method，还有请求头headers，请求体body等参数；再往下看；从这里可以看出，源码里面也是定义了一些参数的赋值与获取，那么也是和bean类的逻辑差不多；这里面其实没没做啥特殊操作，主要是通过建造者模式，根据参数来创建Request类；看一下Request的Builder的逻辑:这里只用作示例，不必关心代码细节，我们只需要了解这个类的职责，就是根据请求的参数构建实体类；3，Response。
OKHttp源码解析（一）
热门推荐
chenzujie的博客
07-27 3万+
在上一篇博客中，我们介绍了OKHttp的基本用法，这一篇我们将从源码角度来看下OKHttp是如何完成一些列的网络的操作的。 我们知道在okhttpclient同步请求和异步请求调用的接口不一样，但它们最后都是殊途同归地走到Call里面的private Response getResponseWithInterceptorChain(boolean forWebSocket) throws IOEx
深入理解OkHttp源码（一）——提交请求
xingfeng_coder的博客
11-12 3520
本篇文章主要介绍OkHttp执行同步和异步请求的大体流程。主要流程如下图： 主要分析到getResponseWidthInterceptorChain方法，该方法为具体的根据请求获取响应部分，留着后面的博客再介绍。 Dispatcher类Dispatcher类负责异步任务的请求策略。首先看它的部分定义：public final class Dispatcher { private int
OkHttp源码解析
AdrianAndroid的专栏
03-28 2444
OkHttp源码解析 资料 OkHttp源码深度解析 OkHttp源码走心解析（很细 很长） 整体结果 拦截器(责任链模式) RetryAndFollowUpInterceptor – 失败和重定向拦截器 BridgeInterceptor – 封装request和response拦截器 CacheInterceptor – 缓存相关的过滤器，负责读取缓存直接返回、更新缓存 ConnectInterceptor – 连接服务，负责和服务器建立连接 这才是真正的请求网络 CallServerInterc
Okhttp 源码解析
Bull_DaGuanRen的博客
04-28 2655
Okhttp源码解析
Android之OKHttp源码解析
m0_62167422的博客
06-27 1255
基本的使用流程如下 二、使用流程源码分析 这里与同步请求的有些不同那异步请求流程中Dispatcher中做了什么？从上面的执行流程源码我们可以了解到在进行同步请求 时只是调用了Dispatcher的方法，将同步请求放置到同步双端队列中，这里并没有体现"分发"的作用，而在进行异步请求时，调用了Dispatcher的方法，这里接着看源码: 首先会将异步任务存储到等待队列中，其后会调用进行任务的分发，根据执行队列的请求数量最大阈值和请求相同host的数量进行一个条件判断，根据结果决定要不要把任务放置执行队
OKHttp 源码解析（一）
MarinaTsang的博客
03-16 575
目前大多数的网络框架都是使用 OKHttp ，Retrofit 也是基于 OKHttp，OKHttp 使用简单，但出现的问题不少，也借此机会了解一下 OKHttp 的源码。本文的 OKHttp 源码基于 3.4.2 版本。通过newCall访问RealCall如果是同步请求，调用execute如果是异步请求，调用enqueue以上都是通过Dispatcher将Call添加到队列调用遍历拦截器，执行请求获取结果将Call从 队列移除。
OkHttp源码解析（很细 很长）
jerechen的博客
11-22 3938
使用方法 使用方法十分简单，分别创建一个OkHttpClient对象，一个Request对象，然后利用他们创建一个Call对象，最后调用同步请求execute()方法或者异步请求enqueue()方法来拿到Response。 private final OkHttpClient client = new OkHttpClient(); Request request = new Request.Builder() .url("https://github.com/") .b
【网络编程】okhttp源码解析
xoliu的博客
02-21 1216
【网络编程】okhttp源码解析。
okhttp源码分析
weixin_41649874的博客
10-15 684
介绍： OkHttp是一款十分好用的Android网络框架，尽管官方提供了UrlConnection，但是OkHttp依然是最为广泛使用的网络请求方式。如果有一定程度的英语阅读能力，建议直接去官网阅读官方文档。前往Okhttp官网 作为一款优秀的网络框架，Okhttp有以下特性： 支持HTTP/2，允许所有同一个主机地址的请求共享同一个socket连接 连接池减少请求延时 透明的GZIP压缩减少响应数据的大小 缓存响应内容，避免一些完全重复的请求 OkHttp支持任何Android 2.3以上平台，并且
OKhttp源码分析
居家小男的博客
09-07 180
OKhttp源码分析 前言：本篇博客将对OKhttp的重点代码和框架流程进行分析，重点是对OKhttp的连接器链进行深入理解，同时文末将对整个流程进行总结提炼。 概述： OKhttp拦截器（interceptor）是OKhttp网络请求框架的精髓所在，通过框架对拦截器的逐个调用实现了高效灵活的网络请求，首先放一张图让大家对拦截器链有一个认识吧： 代码分析： 下面从一个最简单的网络请求开始分析OKhttp整个请求过程 String url = "http://wwww.baidu.com";
okhttp源码解析（一）
doctorzhong的博客
12-21 497
使用okhttp来作为项目的网络请求库，这个估计是很多android开发者的选择。怎么用okhttp发起一个请求的代码网上一大堆，很简单。但是要理解它是怎么完成一次网络请求过程的，就必须读人家的源码，它的代码量还是很大的，功能也很庞大。只有读过源码后，用起来才更踏实，也能知道在网络请求的时候，我们还可以对它怎么优化，作为一个知名项目，它的代码架构设计也是值得我们学习的地方。 看这种功能巨复杂的库，还
okhttp源码分析（三）
小强的博客
04-06 692
okhttp源码分析（一）okhttp源码分析（二）接着上一章分析request.body().writeTo(); public @Nullable RequestBody body() { return body; }public abstract class RequestBody { ............ /** Returns a new request bod...
源码解析_okhttp源码深入解析
weixin_35997503的博客
01-14 355
OkHttp是一个非常优秀的网络请求框架，已被谷歌加入到Android的源码中。目前比较流行的Retrofit也是默认使用OkHttp的。所以OkHttp的源码是一个不容错过的学习资源，学习源码之前，务必熟练使用这个框架，否则就是跟自己过不去。use -> running source code -> reading & learning the source cod...
超详细Okhttp 源码分析
xj-up的博客
08-18 987
文章目录前言创建OkhttpClient创建Requestbuild（）Request创建Request同步请求（单独部分）executed ①runningSyncCalls②异步请求（单独部分）enqueue①executorService ①①AsyncCall ②run()方法②①execute ②①①finished②①①①Dispatcher（Okhttp核心）分发器拦截器（Okhttp核心）proceed5个拦截器的简单总结 ：1. RetryAndFollowUpInterceptor重定
okhttp源码解析
最新发布
07-01
OkHttp 是一个广泛应用于 Android 开发中的网络请求框架，其设计精巧、性能优越，内部实现涉及多个核心组件和机制。以下是对 OkHttp 的源码分析及其工作原理的详细解析。 ### 核心类与架构 OkHttp 的架构由多个关键类组成，包括 `OkHttpClient`、`Request`、`Call`、`Dispatcher`、`ConnectionPool` 等。这些类协同工作，确保网络请求的高效执行。 - **OkHttpClient**：作为客户端的入口点，负责创建和管理 `Call` 对象。它通过建造者模式构建，允许用户自定义配置，如超时时间、拦截器链等。 - **Request**：表示 HTTP 请求，包含 URL、方法、头部信息等。 - **Call**：代表一次具体的网络请求，`RealCall` 是其实现类，负责实际的请求处理。 - **Dispatcher**：任务调度器，管理异步请求的执行，使用线程池来处理并发请求[^4]。 - **ConnectionPool**：连接池，用于复用 HTTP 连接，减少建立新连接的时间开销。默认情况下，OkHttp 使用一个清理线程池定期检查并移除空闲连接[^1]。 ### 请求流程 OkHttp 的请求流程可以分为以下几个步骤： 1. **构建请求**：通过 `OkHttpClient.Builder` 构建 `OkHttpClient` 实例，并设置相关参数。接着，使用 `Request.Builder` 创建 `Request` 对象，指定 URL、方法、头部等信息。 2. **发起请求**：调用 `OkHttpClient.newCall(request)` 创建 `Call` 对象，然后根据需求选择同步或异步请求方式： - **同步请求**：直接调用 `execute()` 方法，阻塞当前线程直到响应返回。 - **异步请求**：调用 `enqueue(Callback responseCallback)` 方法，将请求加入队列并在后台线程中执行，完成后回调 `onResponse` 或 `onFailure`。 3. **拦截器链**：无论是同步还是异步请求，最终都会调用 `getResponseWithInterceptorChain()` 方法，从拦截器链 `interceptors` 中获取结果。拦截器链包括重试、桥接、缓存、连接、网络五个阶段，每个阶段都可以对请求和响应进行处理[^4]。 ### 缓存机制 OkHttp 提供了内置的缓存支持，可以通过 `Cache` 类设置缓存目录和大小。当启用缓存后，OkHttp 会自动存储和读取响应数据，从而减少不必要的网络请求，提高应用性能[^1]。 ### 协议支持 OkHttp 支持多种协议，包括 HTTP/1.0、HTTP/1.1 和 HTTP/2。`protocols` 字段定义了 OkHttp 支持的协议列表，默认情况下，OkHttp 优先使用 HTTP/2。通过 `java.net.URI.getScheme()` 可以获取 URL 的协议（如 http、https），而 `Protocol.get()` 则提供了更具体的协议版本信息（如 http/1.0、http/1.1、h2）[^5]。 ### 示例代码 以下是一个简单的 OkHttp 同步请求示例： ```java OkHttpClient client = new OkHttpClient(); Request request = new Request.Builder() .url("https://api.example.com/data") .build(); try { Response response = client.newCall(request).execute(); if (response.isSuccessful()) { System.out.println(response.body().string()); } } catch (IOException e) { e.printStackTrace(); } ``` 对于异步请求，可以使用如下代码： ```java OkHttpClient client = new OkHttpClient(); Request request = new Request.Builder() .url("https://api.example.com/data") .build(); client.newCall(request).enqueue(new Callback() { @Override public void onFailure(Call call, IOException e) { e.printStackTrace(); } @Override public void onResponse(Call call, Response response) throws IOException { if (response.isSuccessful()) { System.out.println(response.body().string()); } } }); ``` ### 总结 OkHttp 以其高效的连接管理和灵活的拦截器机制，成为 Android 开发中最受欢迎的网络请求框架之一。通过对 `Dispatcher`、`ConnectionPool`、`Cache` 等核心组件的理解，开发者可以更好地优化网络请求，提升应用性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值