OKHttp 原理

最新推荐文章于 2024-07-11 23:16:07 发布

置顶 little-sparrow

最新推荐文章于 2024-07-11 23:16:07 发布

阅读量9k

点赞数 3

CC 4.0 BY-SA版权

分类专栏：安卓技术栈文章标签： java

本文链接：https://blog.youkuaiyun.com/wangzihan91/article/details/87625986

安卓技术栈专栏收录该内容

43 篇文章

订阅专栏

OkHttp是一个高性能的网络库，支持HTTPS/HTTP1.1/HTTP2/WebSocket等底层协议，具备连接池、连接复用、缓存控制等功能。采用建造者、工厂、享元、责任链等设计模式，实现Request和Response的分层处理。同步和异步请求通过Dispatcher调度，利用拦截器链处理请求和响应。

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

OkHttp 是一个高性能的网络库，主要功能如下：

支持底层协议（HTTPS / HTTP1.1 / HTTP2 / WebSocket），包括连接池、连接复用、缓存控制等
维护任务队列线程池，支持友好并发访问
提供拦截器链，实现 Request 和 Response 分层处理

OkHttp 中涉及到的设计模式

建造者模式。构建 OkHttpClient
工厂模式。OkHttpClient 实现了 Call.Factory，用于生产 Call 产品（RealCall）
享元模式。通过线程池、连接池共享对象
责任链模式。将不同功能的拦截器形成一个链

同步请求

RealCall 表示被执行的请求，调用 execute 方法执行同步请求，最终会把 RealCall 放到 Dispatcher 的同步双端队列中顺序执行，执行结束后调用 finish 方法，把 RealCall 请求从 Dispatcher 中移除，无论是同步还是异步请求，最终都会调用 getResponseWithInterceptorChain 方法，在 OkHttp 中，拦截器链会依次完成相应功能

Call 对象只能执行一次，否则会抛出异常

 @Override public Response execute() throws IOException {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    client.dispatcher().executed(this);
    return getResponseWithInterceptorChain();
  }

  synchronized void executed(RealCall call) {
    runningSyncCalls.add(call);
  }

异步请求

AsyncCall 表示被执行的请求，调用 enqueue 方法执行异步请求，如果当前所有请求数（64）和单一 host 请求数（5）满足要求，则把 AsyncCall 放到 Dispatcher 的 Running 队列中顺序执行，否则放到 waiting 队列中，AsyncCall 执行结束后调用 finish 方法，把当前 AsyncCall 从 running 队列中移除并执行线程调度

 @Override public void enqueue(Callback responseCallback) {
   synchronized (this) {
     if (executed) throw new IllegalStateException("Already Executed");
     executed = true;
   }
   client.dispatcher().enqueue(new AsyncCall(responseCallback));
 }

 synchronized void enqueue(AsyncCall call) {
   if (runningAsyncCalls.size() < maxRequests
              && runningCallsForHost(call) < maxRequestsPerHost) {
     runningAsyncCalls.add(call);
     executorService().execute(call);
   } else {
     readyAsyncCalls.add(call);
   }
 }

  final class AsyncCall extends NamedRunnable {
    private final Callback responseCallback;
    AsyncCall(Callback responseCallback) {
      super("OkHttp %s", redactedUrl());
      this.responseCallback = responseCallback;
    }
    @Override protected void execute() {
      Response response = getResponseWithInterceptorChain();
      if (retryAndFollowUpInterceptor.isCanceled()) {
        responseCallback.onFailure(RealCall.this, new IOException("Canceled"));
      } else {
        responseCallback.onResponse(RealCall.this, response);
      }
    }
  }

Dispatcher 调度器：维护请求状态、维护线程池（减少创建线程的开销、减少线程过少造成 CPU 闲置、减少线程过多时内存和线程切换的开销）

  private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();
  private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();
  private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>();

  private <T> void finished(Deque<T> calls, T call, boolean promoteCalls) {
    synchronized (this) {
      calls.remove(call)
      if (promoteCalls) promoteCalls();
    }
  }

  private void promoteCalls() {
    if (runningAsyncCalls.size() >= maxRequests) return;
    if (readyAsyncCalls.isEmpty()) return;
    for (Iterator<AsyncCall> i = readyAsyncCalls.iterator(); i.hasNext();) {
      AsyncCall call = i.next();
      if (runningCallsForHost(call) < maxRequestsPerHost) {
        i.remove();
        runningAsyncCalls.add(call);
        executorService().execute(call);
      }
      if (runningAsyncCalls.size() >= maxRequests) return;
    }
  }

拦截器链

逻辑大致分为两部分：

创建一系列拦截器，并将其放入拦截器数组中。这部分拦截器即包括用户自定义的拦截器也包括框架内置的拦截器
创建一个拦截器链 RealInterceptorChain，并执行拦截器链的 proceed 方法

Response getResponseWithInterceptorChain() throws IOException {
    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);
    return chain.proceed(originalRequest);
}

public final class RealInterceptorChain implements Interceptor.Chain {
  private final List<Interceptor> interceptors;
  private final StreamAllocation streamAllocation;
  private final HttpCodec httpCodec;
  private final RealConnection connection;
  private final int index;
  private final Request request;
  private int calls;

  public RealInterceptorChain(List<Interceptor> interceptors,
                StreamAllocation streamAllocation, HttpCodec httpCodec,
                RealConnection connection, int index, Request request) {

  public Response proceed(Request request,
                  StreamAllocation streamAllocation, HttpCodec httpCodec,
                  RealConnection connection) throws IOException {

    ...

    RealInterceptorChain next = 
                  new RealInterceptorChain(interceptors, streamAllocation,
                  httpCodec, connection, index + 1, request);
    Interceptor interceptor = interceptors.get(index);
    Response response = interceptor.intercept(next);
    
    ...

    return response;
  }
}

Chain.proceed 方法做了两件事

创建下一个拦截链。传入 index + 1 使得下一个拦截器链只能从下一个拦截器开始访问
执行索引为 index 的 intercept 方法，并将下一个拦截器链传入该方法

拦截器的 intercept 方法所执行的逻辑大致分为三部分

在发起请求前对 request 进行处理
调用下一个拦截器，获取 response
对 response 进行处理，返回给上一个拦截器

Okhttp 中除了用户自定义的拦截器外还内置了若干核心拦截器，具体功能如下

RetryAndFollowUpInterceptor

在网络请求失败后进行重试
当服务器返回 3XX（重定向）时直接发起新的请求，并在条件允许情况下复用当前连接

BridgeInterceptor

设置内容长度，内容编码
设置 GZIP 压缩，并在接收到内容后进行解压。省去了应用层处理数据解压的麻烦
添加 Cookie
设置其他 Header 数据，如 User-Agent、Host、Connection = Keep-alive 等

CacheInterceptor

当网络请求有符合要求的 Cache 时直接返回 Cache
当服务器返回内容有改变时更新当前 cache
如果当前cache失效，删除

ConnectInterceptor

为当前请求找到合适的连接，可能复用已有连接也可能是重新创建的连接

CallServerInterceptor

负责向服务器发起真正的访问请求，并在接收到服务器返回后读取响应返回

HTTP2连接复用规则

RealConnection 描述一个物理 Socket 连接，连接池中维护多个 RealConnection 实例。由于HTTP2 支持多路复用，一个 RealConnection 可以支持多个网络访问请求，所以 OkHttp 又引入了 StreamAllocation 来描述一个实际的网络请求。通过 RealConnection 中的 StreamAllocation 弱引用队列是否为 0 来判断当前 RealConnection 是否空闲

通过 ConnectionPool 来管理连接池，ConnectionPool 有一个独立的线程 cleanupRunnable 来清理连接池，其触发时机有两个：当连接池新增连接时、当连接闲置时（connectionBecameIdle 接口被调用时）
搜集所有的空闲连接并记录 KeepAlive 时间，如果空闲连接超过 5 个或者某个连接的 KeepAlive 时间大于五分钟，就移除 KeepAlive 时间最长的连接，立刻再次扫描
如果目前空闲连接不多于 5 个且 KeepAlive 时间都不大于 5 分钟，就返回最大 KeepAlive 的剩余的时间，供下次清理
如果(全部都是活跃的连接)，就返回默认的 keep-alive 时间，也就是 5 分钟后再执行清理