文档章节

OkHttp完全解析(十)源码解析三

k
 kim366
发布于 2016/05/13 19:08
字数 1126
阅读 11
收藏 0
publicvoid readResponse() throws IOException {
        if(this.userResponse == null) {
            if(this.networkRequest == null && this.cacheResponse == null) {
                thrownew IllegalStateException("call sendRequest() first!");
            } elseif(this.networkRequest != null) {
                Response networkResponse;
                if(this.forWebSocket) {
                    this.transport.writeRequestHeaders(this.networkRequest);
                    networkResponse = this.readNetworkResponse();
                } elseif(!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调用的代码

publicvoid finishRequest() throws IOException {
        this.httpConnection.flush();
    }
publicvoid 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);
        //最终返回一个输入流returnnew RealResponseBody(response.headers(), Okio.buffer(source));
    }

    private Source getTransferStream(Response response) throws IOException {
        if(!HttpEngine.hasBody(response)) {
            returnthis.httpConnection.newFixedLengthSource(0L);
        } elseif("chunked".equalsIgnoreCase(response.header("Transfer-Encoding"))) {
            returnthis.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,连接池的管理等方面的内容,如果有人有发现这方面介绍的好文章可以留言推荐给我看看,大家共同学习,共同进步。

本文转载自:http://blog.csdn.net/oyangyujun/article/details/50040007

共有 人打赏支持
k
粉丝 1
博文 129
码字总数 0
作品 0
朝阳
私信 提问
Android技能树 — 网络小结之 OkHttp超超超超超超超详细解析

前言: 本文也做了一次标题党,哈哈,其实写的还是很水,各位原谅我O(∩_∩)O。 介于自己的网络方面知识烂的一塌糊涂,所以准备写相关网络的文章,但是考虑全部写在一篇太长了,所以分开写,...

青蛙要fly
11/13
0
0
手写Android网络访问框架OkHttp(简易版)

开篇废话 趁着周末两天的时间,跟着大神的脚步,把我们经常使用的网络框架OkHttp的源码好好跟了一下,初次观看,确实非常容易钻进去,搞得云里雾里,在大神的指导下,才勉强把整个逻辑走通。...

进击的欧阳
05/06
0
0
Android中流行的第三方库资源收集

1、GSON GSON是将JSON解析成POJO的Java库。GSON也可以将POJO解析成JSON。 2、OkHttp OKHttp是Android版Http客户端。非常高效,支持SPDY、连接池、GZIP和 HTTP 缓存。默认情况下,OKHttp会自动...

jdroid
2014/05/02
0
0
OkHttp 3.x 源码解析之Interceptor 拦截器

Tamic / 开发者技术前线 OkHttp拦截器原理解析 在进行下文前,先说明一点,本文面向的是对Okhttp有一定基础的读者,Okhttp基础使用请阅读我的其他OKhttp+Retrofit+RxJava基础用法的文章: OK...

10/28
0
0
Android Okhttp缓存:精细化每一个Request的CacheControl缓存控制策略(二)

Android Okhttp缓存:精细化每一个Request的CacheControl缓存控制策略(二) 之前我写的附录文章1,只是简单的使用缺省的方法实现Okhttp的缓存。现在使用CacheControl,精细化到每一个Reque...

开开心心过
2017/10/24
0
0

没有更多内容

加载失败,请刷新页面

加载更多

Ext grid 渲染

// 单元格字体颜色渲染function renderer_Meta_useStatus(value, cellmeta, record,rowIndex, columnIndex, store){ var color = ""; if("空闲"==value){ color = "green";......

MoksMo
25分钟前
4
0
log4j2在spring中的配置

<?xml version="1.0" encoding="UTF-8"?><!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL --><!--Configuration后面的status,这个用于设置l......

TonyTaotao
30分钟前
3
0
java 中间变量缓存机制(i++,++i)

public class Test { public static void main(String[] args) { int i = 0; i = i ++ ; System.out.println(i); } } 答案是 0 如果是 i = ++......

shzwork
38分钟前
5
0
初识多线程及其原理-笔记

什么情况下应该使用多线程? 通过并行计算提高程序执行性能 需要等待网络、I/O响应导致耗费大量的执行时间, 可以采用异步线程的方式来减少阻塞 tomcat7 以前的io模型 客户端阻塞 线程级别阻...

Java搬砖工程师
49分钟前
2
0
webpack4 css打包、压缩、分离、去重等优化配置详解

Webpack 4 目前版本已经到了4.27 相较于前面的版本还是有一些改动的,具体可以参考升级指南 迁移到新版本 这里只介绍 css 的 打包、压缩、分离、去重 的方法; 不懂的或者有更优的方案,欢迎...

zerokb-小浪
53分钟前
1
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部