OkHttp执行流程分析

本人通过源码的解读,只是为了加深对其执行流程的理解,文章中不会对更细致的地方做过多的讲解,只是把握住开源框架的整体脉络。

首先放上一个简单使用的例子:

OkHttpClient client = new OkHttpClient.Builder().build();

Request request = new Request.Builder().url("http://www.baidu.com").build();

Call call = client.newCall(request);

//同步请求
try {
    Response response = call.execute();
    response.close();
} catch (IOException e) {
    e.printStackTrace();
}

//异步请求
call.enqueue(new Callback() {

    @Override
    public void onFailure(Call call, IOException e) {
        //todo failure
    }

    @Override
    public void onResponse(Call call, Response response) throws IOException {
        //todo response
    }
});

如上可以看到OkHttp有两种数据请求方式:同步和异步,其中请求Call是一个接口,实际由RealCall执行。

同步请求方式
public Response execute() throws IOException {
    ......

    Response var2;
    try {
        ...
        Response result = this.getResponseWithInterceptorChain();
        ...
        var2 = result;
    } catch (IOException var7) {
        this.eventListener.callFailed(this, var7);
        throw var7;
    } finally {
        this.client.dispatcher().finished(this);
    }

    return var2;
}

getResponseWithInterceptorChain是一个链式调用的一个方法,该方法是OkHttp的一个精华部分,暂且不讲。
整个同步请求方式还是比较简单的,Call通过execute方法直接请求数据,以及接受数据成功或者失败的回调。

异步请求方式
// RealCall.java
public void enqueue(Callback responseCallback) {
    ......
    this.client.dispatcher().enqueue(new RealCall.AsyncCall(responseCallback));
}

// Dispatcher.java
/**
* 这里有个小细节,异步请求不会是用多少请求就一定会立即会开始多少条请求,而是有个请求数量上限的。
* 只有执行队列的数量<最大请求数,并且正在请求的host数<最大请求host数时才会请求,否则就暂时放在就绪队列里缓存起来
*/
synchronized void enqueue(AsyncCall call) {
    if(this.runningAsyncCalls.size() < this.maxRequests 
        && this.runningCallsForHost(call) < this.maxRequestsPerHost) {
        this.runningAsyncCalls.add(call);
        this.executorService().execute(call);
    } else {
        this.readyAsyncCalls.add(call);
    }
}

final class AsyncCall extends NamedRunnable {
    private final Callback responseCallback;

    ......

    protected void execute() {
        boolean signalledCallback = false;

        try {
            // 1、请求结果
            Response response = RealCall.this.getResponseWithInterceptorChain();
            // 2、结果回调
            if(RealCall.this.retryAndFollowUpInterceptor.isCanceled()) {
                signalledCallback = true;
                this.responseCallback.onFailure(RealCall.this, new IOException("Canceled"));
            } else {
                signalledCallback = true;
                this.responseCallback.onResponse(RealCall.this, response);
            }
        } catch (IOException var6) {
            // 3、失败处理
            if(signalledCallback) {
                Platform.get().log(4, "Callback failure for " + RealCall.this.toLoggableString(), var6);
            } else {
                RealCall.this.eventListener.callFailed(RealCall.this, var6);
                this.responseCallback.onFailure(RealCall.this, var6);
            }
        } finally {
            // 4、结束
            RealCall.this.client.dispatcher().finished(this);
        }

    }
}

public abstract class NamedRunnable implements Runnable {

    public final void run() {
        ...
        this.execute();
        ...
    }

    protected abstract void execute();
}

如上流程可以看出,异步方式就是将RealCall通过包装成AsyncCall,然后在线程池中进行数据请求,然后执行返回数据成功或者失败的处理。

通过以上的分析可以看出,OkHttp无论同步还是异步数据请求,整体的逻辑还是比较简单的,同步就直接在主线程中进行数据请求,异步就是在异步线程池中进行数据请求

无论同步还是异步请求,都有一个非常重要的一个方法:getResponseWithInterceptorChain(),这个方法也是OkHttp的精髓所在。下面具体开始分析该方法的实现。

getResponseWithInterceptorChain方法的实现逻辑分析
Response getResponseWithInterceptorChain() throws IOException {
    List<Interceptor> interceptors = new ArrayList();
    // 用户自定义的拦截器列表
    interceptors.addAll(this.client.interceptors());
    interceptors.add(this.retryAndFollowUpInterceptor);
    interceptors.add(new BridgeInterceptor(this.client.cookieJar()));
    interceptors.add(new CacheInterceptor(this.client.internalCache()));
    interceptors.add(new ConnectInterceptor(this.client));
    if(!this.forWebSocket) {
        interceptors.addAll(this.client.networkInterceptors());
    }

    interceptors.add(new CallServerInterceptor(this.forWebSocket));
    // 注意第5个参数传递的是0
    Chain chain = new RealInterceptorChain(interceptors, (StreamAllocation)null, (HttpCodec)null, (RealConnection)null, 0, this.originalRequest, this, this.eventListener, this.client.connectTimeoutMillis(), this.client.readTimeoutMillis(), this.client.writeTimeoutMillis());
    return chain.proceed(this.originalRequest);
}

如上可以看出OkHttp除了用户自定义的拦截器之外,主要包括如下几个拦截器RetryAndFollowUpInterceptor、BridgeInterceptor、CacheInterceptor、ConnectInterceptor、NetworkInterceptor和CallServerInterceptor。这几大拦截器共同组成了一个拦截器链,并封装到RealInterceptorChain这个对象当中。
既然是个拦截链,那OkHttp又是如何一条链一条链来进行数据拦截的呢?
下面再看看它的proceed的实现:

public Response proceed(Request request) throws IOException {
    return this.proceed(request, this.streamAllocation, this.httpCodec, this.connection);
}

public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec, RealConnection connection) throws IOException {
    ...
    // 注意第5个参数为index+1
    RealInterceptorChain next = new RealInterceptorChain(this.interceptors, streamAllocation, httpCodec, connection, this.index + 1, request, this.call, this.eventListener, this.connectTimeout, this.readTimeout, this.writeTimeout);
    Interceptor interceptor = (Interceptor)this.interceptors.get(this.index);
    Response response = interceptor.intercept(next);
    ...
    return response;
}

这里大家只看到了其似乎只提取了一条拦截器,如何才能链式调用拦截器?这就是OkHttp设计的一个巧妙之处,正是通过interceptor.intercept(next)来不断的获取下一条拦截器进行数据拦截,然后返回最终的response。
Intercepter是一个接口,这里我拿RetryAndFollowUpInterceptor举例:

public Response intercept(Chain chain) throws IOException {
    ......
    RealInterceptorChain realChain = (RealInterceptorChain)chain;
    response = realChain.proceed(request, this.streamAllocation, (HttpCodec)null, (RealConnection)null);
    ......
    return response;
}

看到没有,类似这个拦截器一样,每个拦截器都会最终调用realChain.proceed来不断获取下一个拦截器对返回数据进行拦截处理,从而最终得到处理后成功或者失败的数据。

    原文作者:android_hcf
    原文地址: https://www.jianshu.com/p/56cb5ce89739
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞