來吧，今天說說常用的網路框架OKHttp，也是現在Android所用的原生網路框架（Android 4.4開始，HttpURLConnection的底層實作被Google改成了OkHttp），GOGOGO！
- OKHttp有哪些攔截器，分別起什么作用
- OkHttp怎么實作連接池
- OkHttp里面用到了什么設計模式
OKHttp有哪些攔截器，分別起什么作用
OKHTTP的攔截器是把所有的攔截器放到一個list里，然后每次依次執行攔截器，并且在每個攔截器分成三部分：
- 預處理攔截器內容
- 通過
proceed方法把請求交給下一個攔截器 - 下一個攔截器處理完成并回傳，后續處理作業，
這樣依次下去就形成了一個鏈式呼叫，看看原始碼，具體有哪些攔截器：
Response getResponseWithInterceptorChain() throws IOException {
// Build a full stack of interceptors.
List<Interceptor> 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);
}
根據原始碼可知，一共七個攔截器：
addInterceptor(Interceptor)，這是由開發者設定的，會按照開發者的要求，在所有的攔截器處理之前進行最早的攔截處理，比如一些公共引數，Header都可以在這里添加，RetryAndFollowUpInterceptor，這里會對連接做一些初始化作業，以及請求失敗的充實作業，重定向的后續請求作業，跟他的名字一樣，就是做重試作業還有一些連接跟蹤作業，BridgeInterceptor，這里會為用戶構建一個能夠進行網路訪問的請求，同時后續作業將網路請求回來的回應Response轉化為用戶可用的Response，比如添加檔案型別，content-length計算添加，gzip解包，CacheInterceptor，這里主要是處理cache相關處理，會根據OkHttpClient物件的配置以及快取策略對請求值進行快取，而且如果本地有了可?的Cache，就可以在沒有網路互動的情況下就回傳快取結果，ConnectInterceptor，這里主要就是負責建立連接了，會建立TCP連接或者TLS連接，以及負責編碼解碼的HttpCodecnetworkInterceptors，這里也是開發者自己設定的，所以本質上和第一個攔截器差不多，但是由于位置不同，所以用處也不同，這個位置添加的攔截器可以看到請求和回應的資料了，所以可以做一些網路除錯，CallServerInterceptor，這里就是進行網路資料的請求和回應了，也就是實際的網路I/O操作，通過socket讀寫資料，
OkHttp怎么實作連接池
- 為什么需要連接池？
頻繁的進行建立Sokcet連接和斷開Socket是非常消耗網路資源和浪費時間的，所以HTTP中的keepalive連接對于降低延遲和提升速度有非常重要的作用，keepalive機制是什么呢？也就是可以在一次TCP連接中可以持續發送多份資料而不會斷開連接，所以連接的多次使用，也就是復用就變得格外重要了，而復用連接就需要對連接進行管理，于是就有了連接池的概念，
OkHttp中使用ConectionPool實作連接池，默認支持5個并發KeepAlive，默認鏈路生命為5分鐘，
- 怎么實作的？
1）首先，ConectionPool中維護了一個雙端佇列Deque，也就是兩端都可以進出的佇列，用來存盤連接，
2）然后在ConnectInterceptor，也就是負責建立連接的攔截器中，首先會找可用連接，也就是從連接池中去獲取連接，具體的就是會呼叫到ConectionPool的get方法，
RealConnection get(Address address, StreamAllocation streamAllocation, Route route) {
assert (Thread.holdsLock(this));
for (RealConnection connection : connections) {
if (connection.isEligible(address, route)) {
streamAllocation.acquire(connection, true);
return connection;
}
}
return null;
}
也就是遍歷了雙端佇列，如果連接有效，就會呼叫acquire方法計數并回傳這個連接，
3）如果沒找到可用連接，就會創建新連接，并會把這個建立的連接加入到雙端佇列中，同時開始運行執行緒池中的執行緒，其實就是呼叫了ConectionPool的put方法，
public final class ConnectionPool {
void put(RealConnection connection) {
if (!cleanupRunning) {
//沒有連接的時候呼叫
cleanupRunning = true;
executor.execute(cleanupRunnable);
}
connections.add(connection);
}
}
3）其實這個執行緒池中只有一個執行緒，是用來清理連接的，也就是上述的cleanupRunnable
private final Runnable cleanupRunnable = new Runnable() {
@Override
public void run() {
while (true) {
//執行清理，并回傳下次需要清理的時間，
long waitNanos = cleanup(System.nanoTime());
if (waitNanos == -1) return;
if (waitNanos > 0) {
long waitMillis = waitNanos / 1000000L;
waitNanos -= (waitMillis * 1000000L);
synchronized (ConnectionPool.this) {
//在timeout時間內釋放鎖
try {
ConnectionPool.this.wait(waitMillis, (int) waitNanos);
} catch (InterruptedException ignored) {
}
}
}
}
}
};
這個runnable會不停的呼叫cleanup方法清理執行緒池，并回傳下一次清理的時間間隔，然后進入wait等待，
怎么清理的呢？看看原始碼：
long cleanup(long now) {
synchronized (this) {
//遍歷連接
for (Iterator<RealConnection> i = connections.iterator(); i.hasNext(); ) {
RealConnection connection = i.next();
//檢查連接是否是空閑狀態，
//不是，則inUseConnectionCount + 1
//是 ，則idleConnectionCount + 1
if (pruneAndGetAllocationCount(connection, now) > 0) {
inUseConnectionCount++;
continue;
}
idleConnectionCount++;
// If the connection is ready to be evicted, we're done.
long idleDurationNs = now - connection.idleAtNanos;
if (idleDurationNs > longestIdleDurationNs) {
longestIdleDurationNs = idleDurationNs;
longestIdleConnection = connection;
}
}
//如果超過keepAliveDurationNs或maxIdleConnections，
//從雙端佇列connections中移除
if (longestIdleDurationNs >= this.keepAliveDurationNs
|| idleConnectionCount > this.maxIdleConnections) {
connections.remove(longestIdleConnection);
} else if (idleConnectionCount > 0) { //如果空閑連接次數>0,回傳將要到期的時間
// A connection will be ready to evict soon.
return keepAliveDurationNs - longestIdleDurationNs;
} else if (inUseConnectionCount > 0) {
// 連接依然在使用中，回傳保持連接的周期5分鐘
return keepAliveDurationNs;
} else {
// No connections, idle or in use.
cleanupRunning = false;
return -1;
}
}
closeQuietly(longestIdleConnection.socket());
// Cleanup again immediately.
return 0;
}
也就是當如果空閑連接maxIdleConnections超過5個或者keepalive時間大于5分鐘，則將該連接清理掉，
4）這里有個問題，怎樣屬于空閑連接？
其實就是有關剛才說到的一個方法acquire計數方法：
public void acquire(RealConnection connection, boolean reportedAcquired) {
assert (Thread.holdsLock(connectionPool));
if (this.connection != null) throw new IllegalStateException();
this.connection = connection;
this.reportedAcquired = reportedAcquired;
connection.allocations.add(new StreamAllocationReference(this, callStackTrace));
}
在RealConnection中，有一個StreamAllocation虛參考串列allocations，每創建一個連接，就會把連接對應的StreamAllocationReference添加進該串列中，如果連接關閉以后就將該物件移除，
5）連接池的作業就這么多，并不負責，主要就是管理雙端佇列Deque<RealConnection>，可以用的連接就直接用，然后定期清理連接，同時通過對StreamAllocation的參考計數實作自動回收，
OkHttp里面用到了什么設計模式
- 責任鏈模式
這個不要太明顯，可以說是okhttp的精髓所在了，主要體現就是攔截器的使用，具體代碼可以看看上述的攔截器介紹，
- 建造者模式
在Okhttp中，建造者模式也是用的挺多的，主要用處是將物件的創建與表示相分離，用Builder組裝各項配置，
比如Request：
public class Request {
public static class Builder {
@Nullable HttpUrl url;
String method;
Headers.Builder headers;
@Nullable RequestBody body;
public Request build() {
return new Request(this);
}
}
}
- 工廠模式
工廠模式和建造者模式類似，區別就在于工廠模式側重點在于物件的生成程序，而建造者模式主要是側重物件的各個引數配置，
例子有CacheInterceptor攔截器中又個CacheStrategy物件：
CacheStrategy strategy = new CacheStrategy.Factory(now, chain.request(), cacheCandidate).get();
public Factory(long nowMillis, Request request, Response cacheResponse) {
this.nowMillis = nowMillis;
this.request = request;
this.cacheResponse = cacheResponse;
if (cacheResponse != null) {
this.sentRequestMillis = cacheResponse.sentRequestAtMillis();
this.receivedResponseMillis = cacheResponse.receivedResponseAtMillis();
Headers headers = cacheResponse.headers();
for (int i = 0, size = headers.size(); i < size; i++) {
String fieldName = headers.name(i);
String value = https://www.cnblogs.com/jimuzz/archive/2020/11/06/headers.value(i);
if ("Date".equalsIgnoreCase(fieldName)) {
servedDate = HttpDate.parse(value);
servedDateString = value;
} else if ("Expires".equalsIgnoreCase(fieldName)) {
expires = HttpDate.parse(value);
} else if ("Last-Modified".equalsIgnoreCase(fieldName)) {
lastModified = HttpDate.parse(value);
lastModifiedString = value;
} else if ("ETag".equalsIgnoreCase(fieldName)) {
etag = value;
} else if ("Age".equalsIgnoreCase(fieldName)) {
ageSeconds = HttpHeaders.parseSeconds(value, -1);
}
}
}
}
- 觀察者模式
之前我寫過一篇文章，是關于Okhttp中websocket的使用，由于webSocket屬于長連接，所以需要進行監聽，這里是用到了觀察者模式：
final WebSocketListener listener;
@Override public void onReadMessage(String text) throws IOException {
listener.onMessage(this, text);
}
- 單例模式
這個就不舉例了，每個專案都會有
- 另外有的博客還說到了策略模式，門面模式等，這些大家可以網上搜搜，畢竟每個人的想法看法都會不同，細心找找可能就會發現，
拜拜
有一起學習的小伙伴可以關注下??我的公眾號——碼上積木，每天剖析一個知識點，我們一起積累知識，
轉載請註明出處，本文鏈接：https://www.uj5u.com/yidong/204541.html
標籤：其他