深入解析OkHttp执行机制

本文旨在通过对OkHttp源代码的深度剖析，帮助开发者更好地理解其内部工作机制，尤其是同步与异步请求的处理过程。同时，我们还将探讨OkHttp中的一个重要特性——拦截器链，了解它是如何影响请求的执行流程的。

首先，让我们来看一个简单的OkHttp使用示例：

OkHttpClient client = new OkHttpClient.Builder().build();
Request request = new Request.Builder().url("http://example.com").build();
Call call = client.newCall(request);
// 同步请求
try {
    Response respOnse= call.execute();
    System.out.println(response.body().string());
} catch (IOException e) {
    e.printStackTrace();
}
// 异步请求
call.enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {
        // 处理失败
    }

    @Override
    public void onResponse(Call call, Response response) throws IOException {
        // 处理响应
    }
});

从上述代码可以看出，OkHttp支持两种主要的数据请求方式：同步和异步。这两种方式都通过Call接口实现，但具体的执行是由RealCall类完成的。

同步请求处理

同步请求的处理相对简单，主要通过Call#execute()方法实现。该方法内部调用了getResponseWithInterceptorChain()方法，这是一个关键的方法，涉及到了OkHttp的核心功能之一——拦截器链。以下是execute()方法的部分代码：

public Response execute() throws IOException {
    ...
    Response response;
    try {
        respOnse= getResponseWithInterceptorChain();
    } catch (IOException e) {
        eventListener.callFailed(this, e);
        throw e;
    } finally {
        client.dispatcher().finished(this);
    }
    return response;
}

在同步请求中，一旦调用execute()方法，就会立即发起网络请求并阻塞当前线程，直到收到响应或发生异常。

异步请求处理

异步请求则通过Call#enqueue(Callback)方法实现。该方法将请求任务提交给一个异步线程池处理，避免阻塞主线程。具体实现如下：

public void enqueue(Callback responseCallback) {
    ...
    client.dispatcher().enqueue(new RealCall.AsyncCall(responseCallback));
}

在Dispatcher类中，有一个关于异步请求的重要细节：并不是所有的请求都会立即执行。系统设定了最大并发请求数量和每主机的最大请求数量限制。如果当前执行队列中的请求数量已经达到上限，则新请求会被放入等待队列中，直到有空闲资源为止。

synchronized void enqueue(AsyncCall call) {
    if (runningAsyncCalls.size()         runningAsyncCalls.add(call);
        executorService().execute(call);
    } else {
        readyAsyncCalls.add(call);
    }
}

每个异步请求任务都是通过AsyncCall类实现的，它继承自NamedRunnable，并在execute()方法中完成实际的请求操作和回调处理。

protected void execute() {
    boolean signalledCallback = false;
    try {
        Response respOnse= getResponseWithInterceptorChain();
        if (retryAndFollowUpInterceptor.isCanceled()) {
            signalledCallback = true;
            responseCallback.onFailure(this, new IOException("Canceled"));
        } else {
            signalledCallback = true;
            responseCallback.onResponse(this, response);
        }
    } catch (IOException e) {
        if (signalledCallback) {
            Platform.get().log(4, "Callback failure for " + toLoggableString(), e);
        } else {
            eventListener.callFailed(this, e);
            responseCallback.onFailure(this, e);
        }
    } finally {
        client.dispatcher().finished(this);
    }
}

无论是同步还是异步请求，OkHttp的核心功能之一——拦截器链——都是通过getResponseWithInterceptorChain()方法实现的。该方法构建了一个包含多个拦截器的链式结构，每个拦截器负责处理请求的不同阶段。

拦截器链的实现逻辑

拦截器链的实现逻辑如下所示：

Response getResponseWithInterceptorChain() throws IOException {
    List 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));
    Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0, originalRequest, this, eventListener, client.connectTimeoutMillis(), client.readTimeoutMillis(), client.writeTimeoutMillis());
    return chain.proceed(originalRequest);
}

OkHttp内置了多个标准拦截器，包括重试和跟随重定向、桥接、缓存、连接、网络和服务器调用拦截器。这些拦截器按照顺序排列，形成一个链式结构。每个拦截器通过调用proceed()方法传递控制权给下一个拦截器，直至最后一个拦截器完成实际的网络请求。

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

public Response proceed(Request request, StreamAllocation streamAllocation, HttpCodec httpCodec, RealConnection connection) throws IOException {
    RealInterceptorChain next = new RealInterceptorChain(interceptors, streamAllocation, httpCodec, connection, index + 1, request, call, eventListener, connectTimeout, readTimeout, writeTimeout);
    Interceptor interceptor = interceptors.get(index);
    Response respOnse= interceptor.intercept(next);
    return response;
}

每个拦截器实现Interceptor#intercept(Chain)方法，通过调用chain.proceed()方法继续执行链中的下一个拦截器。这种设计使得OkHttp能够灵活地处理各种复杂的网络请求场景。