2. 程式人生 > >OKHttp原始碼解析（三）

OKHttp原始碼解析（三）

阿新 • • 發佈：2019-01-03 
public void readResponse() throws IOException {
        if(this.userResponse == null) {
            if(this.networkRequest == null && this.cacheResponse == null) {
                throw new IllegalStateException("call sendRequest() first!");
            } else if(this.networkRequest != null) {
                Response networkResponse;
                if
 
(this.forWebSocket) {
                    this.transport.writeRequestHeaders(this.networkRequest);
                    networkResponse = this.readNetworkResponse();
                } else if(!this.callerWritesRequestBody) {
                //利用攔截器方式去做答覆處理
                    networkResponse = (new HttpEngine.NetworkInterceptorChain(0
 
, this.networkRequest)).proceed(this.networkRequest);
                } else {
                    //這個else分句可以不看
                }
                this.receiveHeaders(networkResponse.headers());
                if(this.cacheResponse != null) {
                    if(validate(this.cacheResponse, networkResponse)) {
                        this
 
.userResponse = this.cacheResponse.newBuilder().request(this.userRequest).priorResponse(stripBody(this.priorResponse)).headers(combine(this.cacheResponse.headers(), networkResponse.headers())).cacheResponse(stripBody(this.cacheResponse)).networkResponse(stripBody(networkResponse)).build();
                        networkResponse.body().close();
                        this.releaseConnection();
                        InternalCache responseCache1 = Internal.instance.internalCache(this.client);
                        responseCache1.trackConditionalCacheHit();
                        responseCache1.update(this.cacheResponse, stripBody(this.userResponse));
                        this.userResponse = this.unzip(this.userResponse);
                        return;
                    }

                    Util.closeQuietly(this.cacheResponse.body());
                }

                this.userResponse = networkResponse.newBuilder().request(this.userRequest).priorResponse(stripBody(this.priorResponse)).cacheResponse(stripBody(this.cacheResponse)).networkResponse(stripBody(networkResponse)).build();
                if(hasBody(this.userResponse)) {
                    this.maybeCache();
                    this.userResponse = this.unzip(this.cacheWritingResponse(this.storeRequest, this.userResponse));
                }

            }
        }
    }

在上篇文章結尾OKHttp原始碼解析（二） 我們分析到這裡第10行的callerWritesRequestBody會為空，所以我會直接進去這個判斷，同樣在OKHttp原始碼解析（一） 我們分析過傳送請求時使用的攔截器模式，這裡對答覆的操作也用了同樣的方式，不同於請求呼叫的是intercept，這裡用的是proceed，我們就來看看這個方法做了什麼

public Response proceed(Request request) throws IOException {
            ++this.calls;
            if(this.index > 0) {
                Interceptor response = (Interceptor)HttpEngine.this.client.networkInterceptors().get(this.index - 1);
                Address code = this.connection().getRoute().getAddress();
                if(!request.url().getHost().equals(code.getUriHost()) || Util.getEffectivePort(request.url()) != code.getUriPort()) {
                    throw new IllegalStateException("network interceptor " + response + " must retain the same host and port");
                }

                if(this.calls > 1) {
                    throw new IllegalStateException("network interceptor " + response + " must call proceed() exactly once");
                }
            }

            if(this.index < HttpEngine.this.client.networkInterceptors().size()) {
            //根據攔截器的數目去相應取出攔截器並執行intercept裡面使用者自定義的處理方式
                HttpEngine.NetworkInterceptorChain var7 = HttpEngine.this.new NetworkInterceptorChain(this.index + 1, request);
                Interceptor var10 = (Interceptor)HttpEngine.this.client.networkInterceptors().get(this.index);
                Response interceptedResponse = var10.intercept(var7);
                if(var7.calls != 1) {
                    throw new IllegalStateException("network interceptor " + var10 + " must call proceed() exactly once");
                } else {
                    return interceptedResponse;
                }
            } else {
            //寫入請求頭部
                    HttpEngine.this.transport.writeRequestHeaders(request);
                HttpEngine.this.networkRequest = request;
                if(HttpEngine.this.permitsRequestBody() && request.body() != null) {
                //寫入一些請求體
                    Sink var5 = HttpEngine.this.transport.createRequestBody(request, request.body().contentLength());
                    BufferedSink var8 = Okio.buffer(var5);
                    request.body().writeTo(var8);
                    var8.close();
                }
                //將之前寫入的資料flush給socket並讀取伺服器答覆
                Response var6 = HttpEngine.this.readNetworkResponse();
                int var9 = var6.code();
                if((var9 == 204 || var9 == 205) && var6.body().contentLength() > 0L) {
                    throw new ProtocolException("HTTP " + var9 + " had non-zero Content-Length: " + var6.body().contentLength());
                } else {
                    return var6;
                }
            }
        }

我們先來看看27行的頭部寫入是怎麼一個寫法

public void writeRequestHeaders(Request request) throws IOException {
        this.httpEngine.writingRequestHeaders();
        //組裝請求的資訊，比如url，請求方式，請求協議
        String requestLine = RequestLine.get(request, this.httpEngine.getConnection().getRoute().getProxy().type(), this.httpEngine.getConnection().getProtocol());
        //將請求頭和請求體寫入socket
        this.httpConnection.writeRequest(request.headers(), requestLine);
    }

public void writeRequest(Headers headers, String requestLine) throws IOException {
        if(this.state != 0) {
            throw new IllegalStateException("state: " + this.state);
        } else {
            this.sink.writeUtf8(requestLine).writeUtf8("\r\n");
            int i = 0;

            for(int size = headers.size(); i < size; ++i) {
                this.sink.writeUtf8(headers.name(i)).writeUtf8(": ").writeUtf8(headers.value(i)).writeUtf8("\r\n");
            }

            this.sink.writeUtf8("\r\n");
            this.state = 1;
        }
    }

上面的sink就是socket的寫入流，在上篇文章我們分析過怎麼得到它的，將請求頭部和請求體寫入socket後，proceed的第37行就要進行flush操作了

private Response readNetworkResponse() throws IOException {
    //執行flush操作
        this.transport.finishRequest();
        //等待伺服器相應並讀取伺服器返回資訊組裝成我們需要的response
        Response networkResponse = this.transport.readResponseHeaders().request(this.networkRequest).handshake(this.connection.getHandshake()).header(OkHeaders.SENT_MILLIS, Long.toString(this.sentRequestMillis)).header(OkHeaders.RECEIVED_MILLIS, Long.toString(System.currentTimeMillis())).build();
        if(!this.forWebSocket) {
        //組裝response的body
            networkResponse = networkResponse.newBuilder().body(this.transport.openResponseBody(networkResponse)).build();
        }

        Internal.instance.setProtocol(this.connection, networkResponse.protocol());
        return networkResponse;
    }

先簡單看下第三行finishRequest呼叫的程式碼

public void finishRequest() throws IOException {
        this.httpConnection.flush();
    }
public void flush() throws IOException {
        this.sink.flush();
    }

再來看看第5行的組裝步驟

public Builder readResponseHeaders() throws IOException {
        return this.httpConnection.readResponse();
    }

public Builder readResponse() throws IOException {
        if(this.state != 1 && this.state != 3) {
            throw new IllegalStateException("state: " + this.state);
        } else {
            try {
                StatusLine e;
                Builder exception1;
                do {
                //從輸入流裡讀出答覆並組裝成答覆訊息
                    e = StatusLine.parse(this.source.readUtf8LineStrict());
                    exception1 = (new Builder()).protocol(e.protocol).code(e.code).message(e.message);
                    com.squareup.okhttp.Headers.Builder headersBuilder = new com.squareup.okhttp.Headers.Builder();
                    //答覆頭部的讀取
                    this.readHeaders(headersBuilder);
                    headersBuilder.add(OkHeaders.SELECTED_PROTOCOL, e.protocol.toString());
                    exception1.headers(headersBuilder.build());
                } while(e.code == 100);

                this.state = 4;
                return exception1;
            } catch (EOFException var4) {
                IOException exception = new IOException("unexpected end of stream on " + this.connection + " (recycle count=" + Internal.instance.recycleCount(this.connection) + ")");
                exception.initCause(var4);
                throw exception;
            }
        }
    }

上面的程式碼我們看到的是對答覆頭部的讀取整理，而readNetworkResponse()第8行則是對伺服器答覆的body進行整理組裝

public ResponseBody openResponseBody(Response response) throws IOException {
        Source source = this.getTransferStream(response);
        //最終返回一個輸入流
        return new RealResponseBody(response.headers(), Okio.buffer(source));
    }

    private Source getTransferStream(Response response) throws IOException {
        if(!HttpEngine.hasBody(response)) {
            return this.httpConnection.newFixedLengthSource(0L);
        } else if("chunked".equalsIgnoreCase(response.header("Transfer-Encoding"))) {
            return this.httpConnection.newChunkedSource(this.httpEngine);
        } else {
            long contentLength = OkHeaders.contentLength(response);
            return contentLength != -1L?this.httpConnection.newFixedLengthSource(contentLength):this.httpConnection.newUnknownLengthSource();
        }
    }

在經過這麼層層程式碼的深入（好多程式碼，看得都亂了吧），我們最終得到了伺服器返回的userResponse。。

最後的最後，我們要回到OKHttp原始碼解析（一） 最後一段程式碼getResponse的52行得到我們上面分析的userResponse，並關閉相應的連線池，關閉回收socket等”善後“處理。

三篇文章分析到現在，算是把整個OKHttp的流程分析了個大概，OkHttp還有其他的一些部分，比如handshake，連線池的管理等方面的內容，如果有人有發現這方面介紹的好文章可以留言推薦給我看看，大家共同學習，共同進步。

相關推薦

OKHttp原始碼解析（三）

public void readResponse() throws IOException { if(this.userResponse == null) { if(this.networkRequest == null

安卓面試清單----OKHttp原始碼解析（三）

sendRequest () 上篇文章我們講了sendRequest ()方法，這節接著來看readResponse方法： /**來自HttpEngine 類*/ public void readResponse() throws IOExcepti

OKHttp 3.10原始碼解析（三）：快取機制

本篇我們來講解OKhttp的快取處理，在網路請求中合理地利用本地快取能有效減少網路開銷，提高響應速度。HTTP報頭也定義了很多控制快取策略的域，我們先來認識一下HTTP的快取策略。 一.HTTP快取策略 HTTP快取有多種規則，根據是否需要向伺服器發起請求來分類，我們將其分為兩大類：強制

Spring原始碼解析（三）——元件註冊3

@Scope設定元件作用域 import com.ken.domain.Person; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Config

java集合原始碼解析（三）--List

今天給大家帶來有序集合的介面List，我想也應該是大家在工作中用的比較多的 先來看看介面的定義： public interface List<E> extends Collection<E>可以看出介面List直接繼承於介面Collection，並且一樣使用了

Spring原始碼解析（三）：父子容器的概念

　　相信大家現在在使用spring專案開發時可能不只是單單使用spring一個框架進行開發， 可能會用到現在主流的ssm，spring和springmvc一起使用。 　　而在一起使用的時候我就發現了一個問題，在web.xml配置spring容器初始化的時候存在一個問題。 　 　　一般我們在配置sprin

Redis5.0原始碼解析（三）----------字典（詳細）

基於Redis5.0 在字典中， 一個鍵（key）可以和一個值（value）進行關聯（或者說將鍵對映為值）， 這些關聯的鍵和值就被稱為鍵值對 字典中的每個鍵都是獨一無二的， 程式可以在字典中根據鍵查詢與之關聯的值， 或者通過鍵來更新值， 又或者根據鍵來刪除整個鍵值對

OkHttp原始碼解析（一）

簡單使用 OkHttpClient okHttpClient = new OkHttpClient.Builder().build(); Request request = new Request.Builder() .url("www.bai

OkHttp原始碼解析（二）

上一篇講到OkHttp的整體流程，但是裡面有一個很重要的方法getResponseWithInterceptorChain還沒有講到，這個方法裡面包括了整個okHttp最重要的攔截器鏈，所以我們今天來講解一下。 Response getResponseWithI

基於django 開發的框架 jumpserver 原始碼解析（三）

   基於 rest_framework 的 url 路由 跟 資料 跟 前端互動。   為了要讓 django 支援 RESTful 風格 的 介面 需要 用到 第三方元件，來 分析下rest_framework  對 request 做了什麼 ，又對

ElasticSearch原始碼解析（三）：索引建立

我們先來看看索引建立的事例程式碼： Directory directory = FSDirectory.getDirectory("/tmp/testindex"); // Use standard analyzer Analyzer analyzer = new

sqler sql 轉rest api 原始碼解析（三） rest協議

rest 服務說明 rest 協議主要是將配置檔案中的巨集暴露為rest 介面，使用了labstack/echo web 框架，同時基於context 模型 進行巨集管理物件的共享，同時進行了一些中介軟體的註冊 cors RemoveTrailingSlash gzip Recover rest 啟動

Android FM模組學習之四原始碼解析（三）

     由於最近一直忙專案，沒有時間來更新文件，今天抽空來寫一點，希望大家可以學習使用！      這一章當然還是來分析FM模組的原始碼。FmReceiver.java publicFmReceiver(String devicePath,FmRxEvCallbacks

okhttp原始碼分析（三）

接著上一章分析request.body().writeTo(); public @Nullable RequestBody body() { return body; }public abstract class RequestBody { ........

tomcat原始碼解析（三）——Digester類原始碼解析及Rule分析

在這篇文章中主要針對tomcat原始碼中Rule部分的解析；這部分功能主要涉及server.xml檔案載入和tomcat容器中各元件初始化的過程。在我之前的文章中《tomcat原始碼解析（一）——Bootstrap和Catalina啟動部分》和《tomcat原始碼解析（二）

Vue原始碼解析（三）

接下來呼叫eventsMixin方法，看名稱就知道是關於事件相關的，主要是在Vue的原型上加入$on,$once,$off,$emit方法。 Vue.prototype.$on = functio

MyBatis原始碼解析（三）——Transaction事務模組（轉）

1、回顧 　　之前介紹了Environment環境類，這其實是一個單例類，在MyBatis執行開啟後只會存在一個唯一的環境例項，雖然我們可以在Configuration配置檔案中配置多個環境，但是專案執行中只會存在其中的一個，一般專案會存在開發環境和測試環境、生產環境三

AOP原始碼解析（三）增強器的獲取

普通增強器的獲取邏輯通過getAdvisor方法實現，實現步驟包括對切點的註解的獲取及根據註解資訊生成增強。 public Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectIns

Spring基於註解形式的 AOP的原理流程及原始碼解析（三）

此篇部落格主要講解Spring如何驗證將要例項化的Bean是否應該被代理，生成代理物件的時機問題。 在第二篇部落格中，Spring對容器內所有的標識了@Aspect註解的的類的切面方法(標識了@Around, @Before, @After, @AfterRe

Spring的IOC的原始碼解析（三）

在《Spring的IOC的原始碼解析（二）》中完成了BFPP和BPP的處理分析；這篇接著分bean的例項化。在用bean工廠建立bean物件時，呼叫的是父類AbstractBeanFactory中提供的getBean的系列方法。往下，在AbstractAutowireCapa