okhttp 服务器性能,OkHttp网络请求分析
http请求.gif
http请求如上所示：一个请求对应一个响应，一来一回。是一个上层协议，隐藏了许多细节。下面大概流程为：
地址解析 : 解析出协议，端口，主机IP
封装HTTP请求数据包
封装成TCP包，建立TCP连接(tcp三次握手)
客户机发送请求命令
服务器响应
服务器关闭TCP连接
头信息加入了这行代码 Connection:keep-alive TCP连接在发送后将仍然保持打开状态，于是，浏览器可以继续通过相同的连接发送请求。保持连接节省了为每个请求建立新连接所需的时间，还节约了网络带宽。
注意:http协议中基于tcp/ip
OkHttp对以上步骤的实现解析
okhttp2.gif
RetryAndFollowUpInterceptor创建StreamAllocation对象，处理http的重定向及出错重试。对后续Interceptor的执行的影响为修改Request并创建StreamAllocation对象。
BridgeInterceptor补全缺失的一些http header。对后续Interceptor的执行的影响主要为修改了Request。Connection:keep-alive这里被默认添加
CacheInterceptor处理http缓存。对后续Interceptor的执行的影响为，若缓存中有所需请求的响应，则后续Interceptor不再执行。
ConnectInterceptor借助于前面分配的StreamAllocation对象建立与服务器之间的连接，并选定交互所用的协议是HTTP 1.1还是HTTP 2。对后续Interceptor的执行的影响为，创建了HttpStream和connection。
CallServerInterceptor作为Interceptor链中的最后一个Interceptor，用于处理IO，与服务器进行数据交换。
https://www.jianshu.com/p/5c98999bc34f
使用方法
//1.初始化OKHttp
OkHttpClient okHttpClient = new OkHttpClient()
.newBuilder()
.build();
//2.构建request
final Request request = new Request.Builder()
.get()
.url(HttpUrl.parse("http://www.baidu.com/"))
.build();
//3.发送请求(这里并没有执行，只是构建了`RealCall`对象)
Call call = okHttpClient.newCall(request);
//4.接收响应(请求执行，并得到响应结果)
Response execute = call.execute();
//5.输出
System.out.println(execute.body().string());
分析
着重分析步骤3与4，步骤3是为了返回RealCall对象，步骤4则执行的是RealCall.execute()
RealCall.execute
@Override public Response execute() throws IOException {
synchronized (this) {
if (executed) throw new IllegalStateException("Already Executed");
executed = true;
}
captureCallStackTrace();
try {
client.dispatcher().executed(this);
Response result = getResponseWithInterceptorChain();
if (result == null) throw new IOException("Canceled");
return result;
} finally {
client.dispatcher().finished(this);
}
}
RealCall.getResponseWithInterceptorChain
Response getResponseWithInterceptorChain() throws IOException {
// Build a full stack of interceptors.
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));
Interceptor.Chain chain = new RealInterceptorChain(
interceptors, null, null, null, 0, originalRequest);
return chain.proceed(originalRequest);
}
.okhttp 地址解析
//解析得到host --- BridgeInterceptor
requestBuilder.header("Host", hostHeader(userRequest.url(), false));
//解析得到主机ip --- StreamAllocation#findConnection
1. StreamAllocation#newStream()
RealConnection resultConnection = findHealthyConnection(connectTimeout, readTimeout,
writeTimeout, pingIntervalMillis, connectionRetryEnabled, doExtensiveHealthChecks);
2.StreamAllocation#findHealthyConnection()
RealConnection candidate = findConnection(connectTimeout, readTimeout, writeTimeout,
pingIntervalMillis, connectionRetryEnabled);
3.StreamAllocation#findConnection()
if (selectedRoute == null && (routeSelection == null || !routeSelection.hasNext())) {
newRouteSelection = true;
routeSelection = routeSelector.next();
}
4.RouteSelector#next()
public Selection next() throws IOException {
...
Proxy proxy = nextProxy();
...
return new Selection(routes);
}
5.RouteSelector#nextProxy()
private Proxy nextProxy() throws IOException {
if (!hasNextProxy()) {
throw new SocketException("No route to " + address.url().host()
+ "; exhausted proxy configurations: " + proxies);
}
Proxy result = proxies.get(nextProxyIndex++);
resetNextInetSocketAddress(result);
return result;
}
6.RouteSelector#resetNextInetSocketAddress()
socketHost = getHostString(proxySocketAddress);
与服务器tcp连接
ConnectInterceptor#intercept
HttpCodec httpCodec = streamAllocation.newStream(client, chain, doExtensiveHealthChecks);
findHealthyConnection -> findConnection -> RealConnection#connect -> connectSocket ->
private void connectSocket(int connectTimeout, int readTimeout, Call call,
EventListener eventListener) throws IOException {
Proxy proxy = route.proxy();
Address address = route.address();
rawSocket = proxy.type() == Proxy.Type.DIRECT || proxy.type() == Proxy.Type.HTTP
? address.socketFactory().createSocket()
: new Socket(proxy);
eventListener.connectStart(call, route.socketAddress(), proxy);
rawSocket.setSoTimeout(readTimeout);
try {
Platform.get().connectSocket(rawSocket, route.socketAddress(), connectTimeout);
} catch (ConnectException e) {
ConnectException ce = new ConnectException("Failed to connect to " + route.socketAddress());
ce.initCause(e);
throw ce;
}
设置okhttp的超时，这里就可以看得很明白了，其实是设置socket的连接超时与读写超时
.connectTimeout(30*1000, TimeUnit.MILLISECONDS) .readTimeout(30*1000,TimeUnit.MILLISECONDS) .writeTimeout(30*1000,TimeUnit.MILLISECONDS)
发送请求命令
CallServerInterceptor#intercept 这是okhttp中的最后一个入拦截器，主要作用是 与服务器进行数据交换
httpCodec.writeRequestHeaders(request);
Http1Codec#writeRequestHeaders
public void writeRequest(Headers headers, String requestLine) throws IOException {
if (state != STATE_IDLE) throw new IllegalStateException("state: " + state);
sink.writeUtf8(requestLine).writeUtf8("\r\n");
for (int i = 0, size = headers.size(); i < size; i++) {
sink.writeUtf8(headers.name(i))
.writeUtf8(": ")
.writeUtf8(headers.value(i))
.writeUtf8("\r\n");
}
sink.writeUtf8("\r\n");
state = STATE_OPEN_REQUEST_BODY;
}
这里的IO操作都是OKIO实现