Okhttp3源码解析

川长思鸟来 2022-05-27 00:45 247阅读 0赞

--------------------

# 前言 #

# 基本使用方法 #

> 1.导入库

compile 'com.squareup.okhttp3:okhttp:3.10.0'

> 2.GET请求，首先创建个client(OkHttpClient)实例，然后创建request(Request)实例，接着通过client.newCall(request)得到一个任务，最后将该任务加入队列并创建个接口回调任务执行的结果。

private void reqGet() {
        String url = "http://www.wanandroid.com/friend/json";
        OkHttpClient.Builder builder = new OkHttpClient.Builder();
        OkHttpClient client = builder.build();
    
        Request.Builder requestBuilder = new Request.Builder();
        requestBuilder.url(url);
    
        final Request request = requestBuilder.build();
        Call call = client.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
    
            }
    
            @Override
            public void onResponse(Call call, Response response) throws IOException {
                Logger.d(response.message());
            }
        });
    }

# 流程分析 #

## OkHttpClient ##

> 通过该对象配置一些请求超时，ssl，代理服务器，域名验证等信息。client通过建造者模式创建，由50-52行代码看出也可以直接new来创建client。

OkHttpClient(OkHttpClient.Builder builder) {
            this.dispatcher = builder.dispatcher;
            this.proxy = builder.proxy;
            this.protocols = builder.protocols;
            this.connectionSpecs = builder.connectionSpecs;
            this.interceptors = Util.immutableList(builder.interceptors);
            this.networkInterceptors = Util.immutableList(builder.networkInterceptors);
            this.eventListenerFactory = builder.eventListenerFactory;
            this.proxySelector = builder.proxySelector;
            this.cookieJar = builder.cookieJar;
            this.cache = builder.cache;
            this.internalCache = builder.internalCache;
            this.socketFactory = builder.socketFactory;
            boolean isTLS = false;
    
            ConnectionSpec spec;
            for(Iterator var3 = this.connectionSpecs.iterator(); var3.hasNext(); isTLS = isTLS || spec.isTls()) {
                spec = (ConnectionSpec)var3.next();
            }
    
            if(builder.sslSocketFactory == null && isTLS) {
                X509TrustManager trustManager = this.systemDefaultTrustManager();
                this.sslSocketFactory = this.systemDefaultSslSocketFactory(trustManager);
                this.certificateChainCleaner = CertificateChainCleaner.get(trustManager);
            } else {
                this.sslSocketFactory = builder.sslSocketFactory;
                this.certificateChainCleaner = builder.certificateChainCleaner;
            }
    
            this.hostnameVerifier = builder.hostnameVerifier;
            this.certificatePinner = builder.certificatePinner.withCertificateChainCleaner(this.certificateChainCleaner);
            this.proxyAuthenticator = builder.proxyAuthenticator;
            this.authenticator = builder.authenticator;
            this.connectionPool = builder.connectionPool;
            this.dns = builder.dns;
            this.followSslRedirects = builder.followSslRedirects;
            this.followRedirects = builder.followRedirects;
            this.retryOnConnectionFailure = builder.retryOnConnectionFailure;
            this.connectTimeout = builder.connectTimeout;
            this.readTimeout = builder.readTimeout;
            this.writeTimeout = builder.writeTimeout;
            this.pingInterval = builder.pingInterval;
            if(this.interceptors.contains((Object)null)) {
                throw new IllegalStateException("Null interceptor: " + this.interceptors);
            } else if(this.networkInterceptors.contains((Object)null)) {
                throw new IllegalStateException("Null network interceptor: " + this.networkInterceptors);
            }
        }
    
    public OkHttpClient() {
        this(new OkHttpClient.Builder());
    }

## Request ##

> 通过request实例配置一些请求信息，比如请求头，请求体，请求方法等。该实例只能通过Builder.builder()建造者模式创建。

Request(Request.Builder builder) {
            this.url = builder.url;
            this.method = builder.method;
            this.headers = builder.headers.build();
            this.body = builder.body;
            this.tag = builder.tag != null?builder.tag:this;
        }

## Call call = client.newCall(request) ##

> 通过得到了OkHttpClient和Request对象，接着看通过2者怎么得到call对象的。由1-3行，okHttpClient.newCall(request)方法通过RealCall的newRealCall的静态方法得到call对象；由11-15行创建realCall实例的时候会创建RetryAndFollowUpInterceptor重试拦截器后面会提到。

public Call newCall(Request request) {
        return RealCall.newRealCall(this, request, false);
    }
    
    static RealCall newRealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
        RealCall call = new RealCall(client, originalRequest, forWebSocket);
        call.eventListener = client.eventListenerFactory().create(call);
        return call;
    }
    
    private RealCall(OkHttpClient client, Request originalRequest, boolean forWebSocket) {
        this.client = client;
        this.originalRequest = originalRequest;
        this.forWebSocket = forWebSocket;
        this.retryAndFollowUpInterceptor = new RetryAndFollowUpInterceptor(client, forWebSocket);
    }

## call.enqueue(new Callback() \{…\})异步请求 ##

> 由3-7行，首先代码块加锁，防止多线程不安全，如果该任务多次运行，则直接抛出异常；由11行，首先通过创建RealCall.AsyncCall(responseCallback)实例，再通过client.dispatcher()得到dispatcher实例(该实例是client实例化的时候创建的),最后通过asyncCall实例作为参数调用dispatcher.enquene(call)方法。

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

> 由上，dispatcher.enqueue(call)方法如下，第一个if判断runningAsyncCalls队列的容量是否小于maxRequests(请求最大数)(64)并且runningCallsForHost队列(每个域名下的请求)的容量是否小于maxRequestsPerHost(每个域名下请求的最大数)（5），如果满足if条件则call加入runningAsyncCalls队列，接着通过通过线程池执行线程call(AsyncCall); 我们看AsyncCall的父类NamedRunnable实现了Runnable接口，由36-44行，除了设置线程的信息等，还调用了抽象execute()方法，由11-33行子类AsycCall实现的execute()方法；

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 {
        protected void execute() {
                boolean signalledCallback = false;
                try {
                    Response response = RealCall.this.getResponseWithInterceptorChain();
                    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) {
                    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 {
                    RealCall.this.client.dispatcher().finished(this);
                }
    
            }
    }
    public abstract class NamedRunnable implements Runnable { 
        public final void run() {
            String oldName = Thread.currentThread().getName();
            Thread.currentThread().setName(this.name);
    
            try {
                this.execute();
            } finally {
                Thread.currentThread().setName(oldName);
            }
        }
    }

> 由上，AsyncCall.execute()方法通过RealCall.getResponseWithInterceptorChain()得到响应实例Response, 由2-12行，将用户自定义的和一些系统必须的拦截器保存到interceptors集合里；由13-14行创建RealInterceptorChain实例接着调用该实例的proceed(Request)方法；

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));
            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);
        }

> 由上, proceed(Request)方法调用自身的另一个重载方法，由15-17行，从interceptors集合取出index(当前为0)位置的拦截器并执行拦截器的intercept方法，由上知道，0位置的拦截器为RetryAndFollowUpInterceptor；

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 {
        if(this.index >= this.interceptors.size()) {
            throw new AssertionError();
        } else {
            ++this.calls;
            if(this.httpCodec != null && !this.connection.supportsUrl(request.url())) {
                throw new IllegalStateException("network interceptor " + this.interceptors.get(this.index - 1) + " must retain the same host and port");
            } else if(this.httpCodec != null && this.calls > 1) {
                throw new IllegalStateException("network interceptor " + this.interceptors.get(this.index - 1) + " must call proceed() exactly once");
            } else {
                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);
                if(httpCodec != null && this.index + 1 < this.interceptors.size() && next.calls != 1) {
                    throw new IllegalStateException("network interceptor " + interceptor + " must call proceed() exactly once");
                } else if(response == null) {
                    throw new NullPointerException("interceptor " + interceptor + " returned null");
                } else if(response.body() == null) {
                    throw new IllegalStateException("interceptor " + interceptor + " returned a response with no body");
                } else {
                    return response;
                }
            }
        }
    }

## 拦截器 ##

### RetryAndFollowUpInterceptor ###

> 由6-15行，首先创建了StreamAllocation实例(该实例封装了一些请求的地址等信息), 在把该实例通过realChain.proceed()方法传回RealInterceptorChain，我们再回到RealInterceptorChain，由23-25行，该实例的index现在为1了，再通过interceptors集合取拦截器，再次调用取到的拦截器的intercept(chain)方法；

public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            RealInterceptorChain realChain = (RealInterceptorChain)chain;
            Call call = realChain.call();
            EventListener eventListener = realChain.eventListener();
            StreamAllocation streamAllocation = new StreamAllocation(this.client.connectionPool(), this.createAddress(request.url()), call, eventListener, this.callStackTrace);
            this.streamAllocation = streamAllocation;
            int followUpCount = 0;
            Response priorResponse = null;
    
            while(!this.canceled) {
                boolean releaseConnection = true;
                Response response;
                try {
                    response = realChain.proceed(request, streamAllocation, (HttpCodec)null, (RealConnection)null);
                    releaseConnection = false;
                } catch (RouteException var17) {
            ....
        }
    }
    
    **关键代码**
     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);

### BridgeInterceptor ###

> 集合中第二个拦截器为BridgeInterceptor，该拦截器的intercept如下，由5-42行，设置一些请求头；由44行，跟第一个拦截器一样的逻辑，调用realChain.proceed()方法取出第三个拦截器并调用取出拦截器的intercept方法；

public Response intercept(Chain chain) throws IOException {
            Request userRequest = chain.request();
            Builder requestBuilder = userRequest.newBuilder();
            RequestBody body = userRequest.body();
            if(body != null) {
                MediaType contentType = body.contentType();
                if(contentType != null) {
                    requestBuilder.header("Content-Type", contentType.toString());
                }
    
                long contentLength = body.contentLength();
                if(contentLength != -1L) {
                    requestBuilder.header("Content-Length", Long.toString(contentLength));
                    requestBuilder.removeHeader("Transfer-Encoding");
                } else {
                    requestBuilder.header("Transfer-Encoding", "chunked");
                    requestBuilder.removeHeader("Content-Length");
                }
            }
    
            if(userRequest.header("Host") == null) {
                requestBuilder.header("Host", Util.hostHeader(userRequest.url(), false));
            }
    
            if(userRequest.header("Connection") == null) {
                requestBuilder.header("Connection", "Keep-Alive");
            }
    
            boolean transparentGzip = false;
            if(userRequest.header("Accept-Encoding") == null && userRequest.header("Range") == null) {
                transparentGzip = true;
                requestBuilder.header("Accept-Encoding", "gzip");
            }
    
            List<Cookie> cookies = this.cookieJar.loadForRequest(userRequest.url());
            if(!cookies.isEmpty()) {
                requestBuilder.header("Cookie", this.cookieHeader(cookies));
            }
    
            if(userRequest.header("User-Agent") == null) {
                requestBuilder.header("User-Agent", Version.userAgent());
            }
    
            Response networkResponse = chain.proceed(requestBuilder.build());
            .....
    
           // 得到response 会设置一些响应的头信息；
            ....
    }

### CacheInterceptor ###

> 集合中第三个拦截器为CacheInterceptor，该拦截器的intercept如下，首先处理缓存，接着由23行，跟前面的拦截器一样的逻辑，调用realChain.proceed()方法取出第四个拦截器并调用取出拦截器的intercept方法；

public Response intercept(Chain chain) throws IOException {
            Response cacheCandidate = this.cache != null?this.cache.get(chain.request()):null;
            long now = System.currentTimeMillis();
            CacheStrategy strategy = (new Factory(now, chain.request(), cacheCandidate)).get();
            Request networkRequest = strategy.networkRequest;
            Response cacheResponse = strategy.cacheResponse;
            if(this.cache != null) {
                this.cache.trackResponse(strategy);
            }
    
            if(cacheCandidate != null && cacheResponse == null) {
                Util.closeQuietly(cacheCandidate.body());
            }
    
            if(networkRequest == null && cacheResponse == null) {
                return (new Builder()).request(chain.request()).protocol(Protocol.HTTP_1_1).code(504).message("Unsatisfiable Request (only-if-cached)").body(Util.EMPTY_RESPONSE).sentRequestAtMillis(-1L).receivedResponseAtMillis(System.currentTimeMillis()).build();
            } else if(networkRequest == null) {
                return cacheResponse.newBuilder().cacheResponse(stripBody(cacheResponse)).build();
            } else {
                Response networkResponse = null;
    
                try {
                    networkResponse = chain.proceed(networkRequest);
                    }
                    ....
                }
    }

### ConnectInterceptor ###

> 集合中第四个拦截器为ConnectInterceptor，该拦截器的intercept如下，由6行，通过(拦截器RetryAndFollowUpInterceptor.intercept方法里创建的)streamAllocation.newStream方法得到连接流也是通过这行代码socket握手连接的。由8行，简介调用第五个拦截器的intercept方法；

public Response intercept(Chain chain) throws IOException {
            RealInterceptorChain realChain = (RealInterceptorChain)chain;
            Request request = realChain.request();
            StreamAllocation streamAllocation = realChain.streamAllocation();
            boolean doExtensiveHealthChecks = !request.method().equals("GET");
            HttpCodec httpCodec = streamAllocation.newStream(this.client, chain, doExtensiveHealthChecks);
            RealConnection connection = streamAllocation.connection();
            return realChain.proceed(request, streamAllocation, httpCodec, connection);
        }

### CallServerInterceptor ###

> 集合中最后一个拦截器为CallServerInterceptor，该拦截器的intercept如下，由18行得到response，由24行返回response；

RealInterceptorChain realChain = (RealInterceptorChain)chain;
            HttpCodec httpCodec = realChain.httpStream();
            StreamAllocation streamAllocation = realChain.streamAllocation();
            RealConnection connection = (RealConnection)realChain.connection();
            Request request = realChain.request();
            long sentRequestMillis = System.currentTimeMillis();
            realChain.eventListener().requestHeadersStart(realChain.call());
            httpCodec.writeRequestHeaders(request);
            realChain.eventListener().requestHeadersEnd(realChain.call(), request);
            Builder responseBuilder = null;
            ....
             httpCodec.finishRequest();
            if(responseBuilder == null) {
                realChain.eventListener().responseHeadersStart(realChain.call());
                responseBuilder = httpCodec.readResponseHeaders(false);
            }
    
            Response response = responseBuilder.request(request).handshake(streamAllocation.connection().handshake()).sentRequestAtMillis(sentRequestMillis).receivedResponseAtMillis(System.currentTimeMillis()).build();
            int code = response.code();
            ...
            if((code == 204 || code == 205) && response.body().contentLength() > 0L) {
                throw new ProtocolException("HTTP " + code + " had non-zero Content-Length: " + response.body().contentLength());
            } else {
                return response;
            }
    }

> 我们从最后的拦截器CallServerInterceptor得到response，继而第四个拦截器ConnectInterceptor得到response并返回，继而第三个拦截器CacheInterceptor得到response进行一些自身的操作然后返回response, 继而第二个拦截器BridgeInterceptor得到response进行一些自身的操作然后返回response, 继而第一个拦截器RetryAndFollowUpInterceptor得到response进行一些自身的操作然后返回response。我们一开始是从第4行代码一直分析下去的，最终AsyncCall类的execute方法得到response，接着将通过用户传入的接口回调结果。this.responseCallback.onResponse(RealCall.this, response);这是回调成功响应的结果。因为我们之前有执行任务之前有将该任务加到runningAsyncCalls队列中。由20行，调用dispatcher.finished(AsyncCall)方法首先将runningAsyncCalls队列的该任务删除掉，接着通过promoteCalls方法将readyAsyncCalls等待队列里的任务取出放出runningAsyncCalls执行队列并执行取出的任务。

protected void execute() {
            boolean signalledCallback = false;
            try {
                Response response = RealCall.this.getResponseWithInterceptorChain();
                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) {
                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 {
                RealCall.this.client.dispatcher().finished(this);
            }
    
        }

# 总结 #

> 1.创建client，配置client；  
> 2.创建request，配置request；  
> 3.通过1 2得到call，接下来可以进行同步或者异步任务；  
> 4.执行任务，通过拦截器依次得到response;  
> 5.接口回调，用户得到response。
> 
> **> 后期会分析拦截器的具体实现，以及OkIo的处理方式。**