okhttp源码解析-阿里云开发者社区

开发者社区> 开发与运维> 正文

okhttp源码解析

简介: okhttp介绍 OkHttp是一个非常优秀的网络请求框架,已被谷歌加入到Android的源码中。目前比较流行的Retrofit也是默认使用OkHttp的。

okhttp介绍

OkHttp是一个非常优秀的网络请求框架,已被谷歌加入到Android的源码中。目前比较流行的Retrofit也是默认使用OkHttp的。所以OkHttp的源码是一个不容错过的学习资源,学习源码之前,务必熟练使用这个框架,否则就是跟自己过不去。

okhttp优点

  • 支持HTTP2/SPDY黑科技
  • socket自动选择最好路线,并支持自动重连
  • 拥有自动维护的socket连接池,减少握手次数
  • 拥有队列线程池,轻松写并发
  • 拥有Interceptors轻松处理请求与响应(比如透明GZIP压-
    缩,LOGGING)
  • 实现基于Headers的缓存策略

至于为什么有这么多优点,各位看官老爷在下面的源码解析中慢慢体会吧!

okhttp简单用法

既然是网络框架,那么先来看看它的post和get请求吧。总的来说,分为三步:

  1. 实例化一个OkHttpClient 对象;
  2. 构造Request请求体;
  3. 发请求,同步调用okHttpClient.newCall(request).execute();异步调用 okHttpClient.newCall(request).enqueue(new Callback())。
  • get(异步)请求
                OkHttpClient okHttpClient = new OkHttpClient();
                Request request = new Request.Builder().url(URL).build();

                    okHttpClient.newCall(request).enqueue(new Callback() {
                        @Override
                        public void onFailure(Call call, IOException e) {

                        }
                        @Override
                        public void onResponse(Call call, Response response) throws IOException {
                            String dataStr=response.body().string();
                            Log.e("info",dataStr);
                        }
                    });
  • get(同步)请求
OkHttpClient okHttpClient = new OkHttpClient();
Response  response = okHttpClient.newCall(request).execute();
String dataStr=response.body().string();
  • post(异步)请求
 OkHttpClient okHttpClient = new OkHttpClient();
                RequestBody requestBody = new FormBody
                        .Builder()
                        .add("name", "张士超")
                        .add("password", "123456")
                        .build();
                Request request = new Request
                        .Builder()
                        .url(URL)
                        .post(requestBody)
                        .build();
                    okHttpClient.newCall(request).enqueue(new Callback() {
                        @Override
                        public void onFailure(Call call, IOException e) {

                        }

                        @Override
                        public void onResponse(Call call, Response response) throws IOException {
                            String dataStr=response.body().string();
                            Log.e("info",dataStr);
                        }
                    });
  • post(同步)请求
                OkHttpClient okHttpClient = new OkHttpClient();
                RequestBody requestBody = new FormBody
                        .Builder()
                        .add("name", "张士超")
                        .add("password", "123456")
                        .build();
                Request request = new Request
                        .Builder()
                        .url(URL)
                        .post(requestBody)
                        .build();
                try {
                    Response  response =   okHttpClient.newCall(request).execute();
                    String dataStr=response.body().string();
                } catch (IOException e) {
                    e.printStackTrace();
                }
  • 总结:post与get请求区别在于需要构造一个RequestBody对象,同步和异步区别在于执行的是execute()还是enqueue(new Callback()),这也很好理解,异步需要回调接口反馈的请求数据对吧。

okhttp的源码深入

  • 好啦,步入正题,看看我们的okhttp同学是怎么样完成一个个请求的!

首先我们看看okhttp源码涉及到的几个类的源码:

  • Request请求类:
public final class Request {
  final HttpUrl url;
  final String method;
  final Headers headers;
  final @Nullable RequestBody body;
  final Object tag;
  private volatile CacheControl cacheControl; // Lazily initialized.

这里面比较重要的是url、method、header和RequestBody,分别代表request请求的请求URL、请求方法、请求头和请求体。

  • Response响应类
public final class Response implements Closeable {
  final Request request;
  final Protocol protocol;
  final int code;
  final String message;
  final @Nullable Handshake handshake;
  final Headers headers;
  final @Nullable ResponseBody body;
  final @Nullable Response networkResponse;
  final @Nullable Response cacheResponse;
  final @Nullable Response priorResponse;
  final long sentRequestAtMillis;
  final long receivedResponseAtMillis;

这里面比较重要的是code响应码、message响应信息、headers响应头和body响应体。

  • Okhttp类
  final Dispatcher dispatcher;
  final @Nullable Proxy proxy;
  final List<Protocol> protocols;
  final List<ConnectionSpec> connectionSpecs;
  final List<Interceptor> interceptors;
  final List<Interceptor> networkInterceptors;
  final EventListener.Factory eventListenerFactory;
  final ProxySelector proxySelector;
  final CookieJar cookieJar;
  final @Nullable Cache cache;
  final @Nullable InternalCache internalCache;
  final SocketFactory socketFactory;
  final @Nullable SSLSocketFactory sslSocketFactory;
  final @Nullable CertificateChainCleaner certificateChainCleaner;
  final HostnameVerifier hostnameVerifier;
  final CertificatePinner certificatePinner;
  final Authenticator proxyAuthenticator;
  final Authenticator authenticator;
  final ConnectionPool connectionPool;
  final Dns dns;
  final boolean followSslRedirects;
  final boolean followRedirects;
  final boolean retryOnConnectionFailure;
  final int connectTimeout;
  final int readTimeout;
  final int writeTimeout;
  final int pingInterval;

Okhttp包含的东西很多,这里我们需要重点关注的是dispatcher调度器,interceptors自定义应用拦截器和networkInterceptors自定义网络拦截器。

  • ok,比较重要的三个类介绍完了,接下来我们看一看同步和异步请求的源码解析,先放一张图(盗的别人的图hhhh),让看官老爷门大致上有一个印象,后面比较好理解。


    整个请求过程

    整个过程大致说一下吧,首先不管啥请求okHttpClient.newCall(request)这玩意实际上返回一个RealCall类,然后同步请求调用execute(),异步调用enqueue()之后给调度器,其实同步和异步都给了调度器,只是异步调用了调度器的execute()进行请求调度处理,下面给一张图就了解啦:


    调度器

    处理完之后通过一系列花里胡哨的拦截器之后返回一个response响应,就获得数据啦!

请求过程源码解析

以下面代码为例,看看源码都干了啥:

             OkHttpClient okHttpClient = new OkHttpClient();
                Request request = new Request.Builder().url(URL).build();
                    okHttpClient.newCall(request).enqueue(new Callback()/execute()

前面两句话就不说了,就是OkHttpClient和Request 对象的实例化,我们看看okHttpClient.newCall(request)这里都干了些啥:

 @Override public Call newCall(Request request) {
    return RealCall.newRealCall(this, request, false );
  }

进去newRealCall,看看:

  static RealCall newRealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
    RealCall call = new RealCall(client, originalRequest, forWebSocket);
    call.eventListener = client.eventListenerFactory().create(call);
    return call;
  }

总之就是工厂模式将request封装成一个RealCall对象,接着看okHttpClient.newCall(request).execute(),同步请求;

  @Override public Response execute() throws IOException {
    synchronized (this) {//1
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    eventListener.callStart(this);
    try {
      client.dispatcher().executed(this);//2
      Response result = getResponseWithInterceptorChain();//3
      if (result == null) throw new IOException("Canceled");
      return result;
    } catch (IOException e) {
      eventListener.callFailed(this, e);
      throw e;
    } finally {
      client.dispatcher().finished(this);//3
    }
  }

比较重要的是上面三处注释:

  1. 首先看这个请求有没有被执行,每个请求只能被执行一次;
  2. 若没有被执行,则将这个请求任务给调度器dispatcher,简单看看这个调度器做了些什么:
  synchronized void executed(RealCall call) {
    runningSyncCalls.add(call);
  }

将这个请求加入到runningSyncCalls队列中,后面详细说说这个调度器。

  1. 经过一系列花里胡哨的拦截器得到响应,这具体后再说怎么做的。
  2. 执行完之后调度器dispatcher结束这个请求任务,看看具体怎么做的:
  void finished(RealCall call) {
    finished(runningSyncCalls, call, false);
  }

将请求任务从runningSyncCalls队列中移除。

  • 这样整个同步请求流程就实现了,看下面这个图会清晰很多:


    同步请求任务.png

调度器

  • 上面可以知道,请求处理都交给调度器了,那我们来看看这个调度器是个什么鬼:
public final class Dispatcher {
  private int maxRequests = 64;
  private int maxRequestsPerHost = 5;
  private @Nullable Runnable idleCallback;
  private @Nullable ExecutorService executorService;
  private final Deque<AsyncCall> readyAsyncCalls = new ArrayDeque<>();
  private final Deque<AsyncCall> runningAsyncCalls = new ArrayDeque<>();
  private final Deque<RealCall> runningSyncCalls = new ArrayDeque<>();
  • 解释一下这几个参数啥子意思,第一个maxRequests最大请求数,表示最大并发数 ;maxRequestsPerHost 单个域名最大请求数 默认为 5 个。所以极端情况下,才会开启 64 个线程。这个场景非常罕见;readyAsyncCalls 表示异步请求的等待队列,runningAsyncCalls 正在执行的异步请求队列,AsyncCall队列;runningSyncCalls 正在执行的同步请求队列,因为是同步的,这也好理解,所以不需要等待队列。executorService这个就是调度器的线程池,java线程池我们都知道,我们看看这里的线程池怎么定义的:
  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;
  }
  • 可以知道,调度器的核心线程为0,非核心线程无数个,每个空线程的回收时间为60s。

异步请求

异步请求以下面这个为例,看看源码都怎么做的:

  OkHttpClient okHttpClient = new OkHttpClient();
                Request request = new Request.Builder().url(URL).build();
                    okHttpClient.newCall(request).enqueue(new Callback() {
                        @Override
                        public void onFailure(Call call, IOException e) {

                        }
                        @Override
                        public void onResponse(Call call, Response response) throws IOException {
                            String dataStr=response.body().string();
                            Log.e("info",dataStr);
                        }
                    });
  • 与同步请求的差距主要在于调用的是enqueue()函数,点进去看看与execute的区别

  @Override public void enqueue(Callback responseCallback) {
    synchronized (this) {
      if (executed) throw new IllegalStateException("Already Executed");
      executed = true;
    }
    captureCallStackTrace();
    eventListener.callStart(this);
    client.dispatcher().enqueue(new AsyncCall(responseCallback));
  }
  • 先判断有没有执行过,如果没有,这执行调度器dispatcher的enqueue()函数,点进去看看吧:
  synchronized void enqueue(AsyncCall call) {
    if (runningAsyncCalls.size() < maxRequests && runningCallsForHost(call) < maxRequestsPerHost) {
      runningAsyncCalls.add(call);
      executorService().execute(call);
    } else {
      readyAsyncCalls.add(call);
    }
  }
  • 这里就与我们之前讲的调度器队列有关系了,如果正在执行的异步队列runningAsyncCalls小于最大并发数,而且单域名的正在执行异步队列小于最大单域名最大请求数,则将这个请求放到正在执行的异步请求队列,并调用调度器的execute()方法,否则就放入等待异步队列。
  • 调度器线程池总结
  1. 调度线程池Disptcher实现了高并发,低阻塞的实现
  2. 采用Deque作为缓存,先进先出的顺序执行
  3. 任务在try/finally中调用了finished函数,控制任务队列的执行顺序,而不是采用锁,减少了编码复杂性提高性能

拦截器

  • 主要是getResponseWithInterceptorChain方法
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);
    return chain.proceed(originalRequest);
  }

1)在配置 OkHttpClient 时设置的 interceptors;
2)负责失败重试以及重定向的 RetryAndFollowUpInterceptor;
3)负责把用户构造的请求转换为发送到服务器的请求、把服务器返回的响应转换为用户友好的响应的 BridgeInterceptor;
4)负责读取缓存直接返回、更新缓存的 CacheInterceptor;
5)负责和服务器建立连接的 ConnectInterceptor;
6)配置 OkHttpClient 时设置的 networkInterceptors;
7)负责向服务器发送请求数据、从服务器读取响应数据的 CallServerInterceptor。

  • OkHttp的这种拦截器链采用的是责任链模式,这样的好处是将请求的发送和处理分开,并且可以动态添加中间的处理方实现对请求的处理、短路等操作。给个图加强理解:


    拦截器.png
  • 不多说了,结合图和源码理解吧,创作不易,给个小心心吧!

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

分享:
开发与运维
使用钉钉扫一扫加入圈子
+ 订阅

集结各类场景实战经验,助你开发运维畅行无忧

其他文章