Retrofit和OkHttp使用网络缓存数据
2018-11-10 本文已影响20人
Weechan_
OkHttp缓存优化你的应用
Okhttp缓存原理
我们先从HTTP协议开始入手,关于缓存的HTTP请求/返回头由以下几个,我列了张表格一一解释
| 请求头/返回头 | 含义 |
|---|---|
| Cache-Control | 这个字段用于指定所有缓存机制在整个请求/响应链中必须服从的指令。 |
| Pragma | 与Cache-Control一样,是兼容HTTP1.0的头部 |
| Expires | 资源过期时间 |
| Last-Modified | 资源最后修改的时间 |
| If-Modified-Since | 在请求头中指定一个日期,若资源最后更新时间超过该日期, 则服务器接受请求,相反的头为If-Unmodified-Since |
| ETag | 识别内容版本的唯一字符串,与资源关联的记号 |
与缓存最相关的Cache-Control有多条指令,并且在请求或返回头中的效果不一样
在请求头中Cache-Control的指令
| 指令 | 参数 | 说明 |
|---|---|---|
| no-cache | 无 | 缓存必须向服务器确认是否过期候才能使用,即不接受过期缓存,并非不缓存 |
| no-store | 无 | 真正意义上的不缓存 |
| max-age=[秒] | 必须 | 响应的最大age值 |
| max-stale=[秒] | 可忽略 | 可接受的最大过期时间 |
| min-fresh=[秒] | 必须 | 询问再过[秒]时间后资源是否过期,若过期则不返回 |
| only-if-cached | 无 | 只获取缓存的资源而不联网获取 |
在返回头中Cache-Control的指令
| 指令 | 参数 | 说明 |
|---|---|---|
| public | 无 | 可向任意方提供响应的缓存 |
| private | 无 | 向特定用户提供响应缓存 |
| no-cache | 可省略 | 不缓存 |
| no-store | 无 | 不缓存 |
| max-age=[秒] | 必须 | 响应的最大age值 |
| max-stale=[秒] | 可忽略 | 可接受的最大过期时间 |
| min-fresh=[秒] | 必须 | 询问再过[秒]时间后资源是否过期,若过期则不返回 |
| only-if-cached | 无 | 只获取缓存的资源而不联网获取 |
假设Okhttp完全遵守HTTP协议(实际上应该也是),利用Cache-Control我们可以缓存某些必要的资源.
1.有网络的时候:短时间内频繁的请求,后面的请求使用缓存中的资源.
2.无网络的时候:获取之前缓存的数据进行暂时的页面显示,当网络更新时对当前activity的数据进行刷新,刷新界面,避免界面空白的场景.
编写OKHTTP网络拦截器
class CacheNetworkInterceptor implements Interceptor {
public Response intercept(Interceptor.Chain chain) throws IOException {
//无缓存,进行缓存
return chain.proceed(chain.request()).newBuilder()
.removeHeader("Pragma")
//对请求进行最大60秒的缓存
.addHeader("Cache-Control", "max-age=60")
.build();
}
}
static class CacheInterceptor implements Interceptor {
public Response intercept(Interceptor.Chain chain) throws IOException {
Response resp;
Request req;
if (ok) {
//有网络,检查10秒内的缓存
req = chain.request()
.newBuilder()
.cacheControl(new CacheControl
.Builder()
.maxAge(10, TimeUnit.SECONDS)
.build())
.build();
} else {
//无网络,检查30天内的缓存,即使是过期的缓存
req = chain.request().newBuilder()
.cacheControl(new CacheControl.Builder()
.onlyIfCached()
.maxStale(30, TimeUnit.SECONDS)
.build())
.build();
}
resp = chain.proceed(req);
return resp.newBuilder().build();
}
}
配置OKHTTP中的Cache
int cacheSize = 10 * 1024 * 1024; // 10 MiB
Cache cache = new Cache(httpCacheDirectory, cacheSize);
OkHttpClient client = new OkHttpClient.Builder()
.cache(cache)
//加入拦截器,注意Network与非Network的区别
.addInterceptor(new CacheInterceptor())
.addNetworkInterceptor(new CacheNetworkInterceptor())
.connectTimeout(10, TimeUnit.SECONDS)
.readTimeout(10, TimeUnit.SECONDS)
.build();
//最后通过使用该HTTP Client进行网络请求, 就实现上述利用缓存优化应用的需求
在retrofit中使用只要将retrofit的okhttpclient换成这个带缓存的okhttpclient即可
private val okhttpClient = OkHttpClient.Builder()
.connectTimeout(timeout, TimeUnit.MILLISECONDS)
.readTimeout(timeout, TimeUnit.MILLISECONDS)
.writeTimeout(timeout, TimeUnit.MILLISECONDS)
.retryOnConnectionFailure(true)
.addInterceptor(HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BODY))
.addInterceptor(CacheInterceptor())
.addNetworkInterceptor(CacheNetworkInterceptor())
.cache(Cache(File(App.app.externalCacheDir, "ok-cache"), 1024 * 1024 * 30L))
.build()
var retrofit2 = Retrofit.Builder().baseUrl(baseURL)
.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
.addConverterFactory(GsonConverterFactory.create())
.client(okhttpClient)
.build()
解释一下上面的代码,
CacheInterceptor主要的作用是判断当前网络是否有效,如果有效,则创建一个请求,
该请求能获取一个10秒内未过期的缓存,否则强制获取一个缓存(过期了30天也允许).
而CacheNetworkInterceptor 主要是在缓存没命中的情况下,请求网络后,修改返回头,加上Cache-Control,告知OKHTTP对该请求进行一个60秒的缓存.
因此,当频繁请求的时候,OKHTTP使用10秒之内的缓存而不重复请求网络.
当没网络的时候,请求会获取30天内的缓存,避免界面白屏.
OKHTTP关于Cache的源码分析
分析源码之前先看下Cache的策略
Cache.png
Response getResponseWithInterceptorChain() throws IOException {
// Okhttp获取Response的入口
// 采用责任链模式,一层层按顺序转交Request并处理Response
List<Interceptor> interceptors = new ArrayList<>();
// 用户定义的拦截器
interceptors.addAll(client.interceptors());
interceptors.add(retryAndFollowUpInterceptor);
interceptors.add(new BridgeInterceptor(client.cookieJar()));
//CacheInterceptor主要用于做缓存控制
interceptors.add(new CacheInterceptor(client.internalCache()));
interceptors.add(new ConnectInterceptor(client));
if (!forWebSocket) {
//用户定义的Network拦截器
interceptors.addAll(client.networkInterceptors());
}
// 发起实际请求的拦截器
interceptors.add(new CallServerInterceptor(forWebSocket));
Interceptor.Chain chain = new RealInterceptorChain(interceptors, null, null, null, 0,
originalRequest, this, eventListener, client.connectTimeoutMillis(),
client.readTimeoutMillis(), client.writeTimeoutMillis());
return chain.proceed(originalRequest);
}
这里我们主要看CacheInterceptor的实现
CacheInterceptor代码比较长,我们分段来解释
@Override public Response intercept(Chain chain) throws IOException {
Response cacheCandidate = cache != null
? cache.get(chain.request())
: null;
// 实际上是类似map,将返回内容的URL的MD5的值当key,返回内容当response
// 然后从cache文件里面查询是否存在该缓存
long now = System.currentTimeMillis();
//根据当前的时间,以及缓存策略,来获取response
CacheStrategy strategy = new CacheStrategy.Factory(now, chain.request(), cacheCandidate).get();
Request networkRequest = strategy.networkRequest;
Response cacheResponse = strategy.cacheResponse;
// 根据策略得到cacheReposne 与 NetworkRequest
// 之后的代码就是根据这两个东西设置返回头
// 不进行网络请求,且缓存以及过期了,返回504错误
if (networkRequest == null && cacheResponse == null) {
return new Response.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();
}
// 不进行网络请求,此时缓存命中,直接返回缓存,后面的拦截器也不会调用了
if (networkRequest == null) {
return cacheResponse.newBuilder()
.cacheResponse(stripBody(cacheResponse))
.build();
}
// 否则需要请求网络,继续调用责任链后面的拦截器,请求网络并获取response
Response networkResponse = null;
try {
networkResponse = chain.proceed(networkRequest);
} finally {
// 请求异常,关闭缓存避免泄漏
if (networkResponse == null && cacheCandidate != null) {
closeQuietly(cacheCandidate.body());
}
}
// 请求了网络的同时,缓存其实也找到的情况
// (比如 需要向服务器确认缓存是否可用的情况)
if (cacheResponse != null) {
// 返回了304, 我们都知道304的返回时不带body的,此时必须向获取cache的body
if (networkResponse.code() == HTTP_NOT_MODIFIED) {
Response response = cacheResponse.newBuilder()
.headers(combine(cacheResponse.headers(), networkResponse.headers()))
.sentRequestAtMillis(networkResponse.sentRequestAtMillis())
.receivedResponseAtMillis(networkResponse.receivedResponseAtMillis())
.cacheResponse(stripBody(cacheResponse))
.networkResponse(stripBody(networkResponse))
.build();
networkResponse.body().close();
// Update the cache after combining headers but before stripping the
// Content-Encoding header (as performed by initContentStream()).
cache.trackConditionalCacheHit();
cache.update(cacheResponse, response);
return response;
} else {
closeQuietly(cacheResponse.body());
}
}
//省略---------
}
// 缓存策略CacheStrategy主要的策略写在该方法下
private CacheStrategy getCandidate() {
// 没有缓存!
if (cacheResponse == null) {
return new CacheStrategy(request, null);
}
// 当请求的协议是https的时候,如果cache没有hansake就丢弃缓存
if (request.isHttps() && cacheResponse.handshake() == null) {
return new CacheStrategy(request, null);
}
/// -- 省略一些代码
// 根据缓存的缓存时间,缓存可接受最大过期时间等等HTTP协议上的规范
// 来判断缓存是否可用,
if (!responseCaching.noCache() && ageMillis + minFreshMillis < freshMillis + maxStaleMillis) {
Response.Builder builder = cacheResponse.newBuilder();
if (ageMillis + minFreshMillis >= freshMillis) {
builder.addHeader("Warning", "110 HttpURLConnection \"Response is stale\"");
}
long oneDayMillis = 24 * 60 * 60 * 1000L;
if (ageMillis > oneDayMillis && isFreshnessLifetimeHeuristic()) {
builder.addHeader("Warning", "113 HttpURLConnection \"Heuristic expiration\"");
}
return new CacheStrategy(null, builder.build());
}
}
// 请求条件, 当etag,lastModified,servedDate这三种属性存在时
//需要向服务器确认缓存的有效性
String conditionName;
String conditionValue;
if (etag != null) {
conditionName = "If-None-Match";
conditionValue = etag;
} else if (lastModified != null) {
conditionName = "If-Modified-Since";
conditionValue = lastModifiedString;
} else if (servedDate != null) {
conditionName = "If-Modified-Since";
conditionValue = servedDateString;
} else {
return new CacheStrategy(request, null); // 不存在的时候,按流程进行请求
}
Headers.Builder conditionalRequestHeaders = request.headers().newBuilder();
Internal.instance.addLenient(conditionalRequestHeaders, conditionName, conditionValue);
// 构造一个请求询问服务器资源是否过期
Request conditionalRequest = request.newBuilder()
.headers(conditionalRequestHeaders.build())
.build();
return new CacheStrategy(conditionalRequest, cacheResponse);
借用一张图来说明http的整个工作流程
image
流程也很清晰明了了,简单的说及时通过Request创建RealCall对象,
经过层层interceptor之后最终产生一个response.
不过值得注意的是,当CacheInterceptor命中缓存之后, 后面的拦截器将不再执行.
这也是addInterceptor 与 addNetworkInterceptor之间的区别
最后附上当网络可用的时候,自动重新请求的一个基于MVP模式的实现方案
NetStatusMonitor是一个单例,用于监听整个应用程序的网络状态
ActivityManager也是一个单例,用来管理应用程序的活动栈,原理Application注册关于活动的生命周期监听.
基于MVP模式,给presenter的抽象基类定义一个refresh的方法
当断网时间超过XX秒的时候,调用在栈顶的activity的presenter进行刷新页面
如有不足请各位大佬指正
NetStatusMonitor.setNetStatusListener(object: NetStatusMonitor.Listener {
var lostTime = 0L
override fun onLost() {
lostTime = System.currentTimeMillis()
}
override fun onAvailable() {
with(ActivityManager.peek() as BaseView<*>){
//当栈顶活动位于前台
if(this.lifecycle.currentState == Lifecycle.State.RESUMED){
// 获取ForegroundActivity进行刷新
// 断线时间超过30秒重连再刷新一次
if(System.currentTimeMillis() - lostTime > 1000 * 30){
// 通知presenter刷新数据
this.presenter.refresh()
}
}
}
}
override fun onNetStateChange(oldState: Int, newState: Int) {
if(newState == NetStatusMonitor.MOBILE){
showToast("正在使用移动网络")
}
}
})
object NetStatusMonitor {
interface Listener{
fun onLost()
fun onAvailable()
fun onNetStateChange(oldState: Int, newState: Int)
}
val WIFI = 1;
val MOBILE = 2;
val WIFI_MOBILE = 3;
val UNKNOW = 0
var available = false
var netState: Int by Delegates.observable(UNKNOW) { property, oldValue, newValue ->
listener?.onNetStateChange(oldValue, newValue)
}
private var listener : Listener? = null
fun setNetStatusListener(listener: Listener){
this.listener = listener
}
init {
val cm = Utils.app.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
fun setType() {
val activeNetwork = cm.activeNetworkInfo
val isMobile = activeNetwork.type == ConnectivityManager.TYPE_MOBILE
val isWifi = cm.getNetworkInfo(ConnectivityManager.TYPE_WIFI).isAvailable
if (isWifi && isMobile)
netState = WIFI_MOBILE
else if (isWifi && !isMobile)
netState = WIFI
else if (isMobile && !isWifi)
netState = MOBILE
else
netState = UNKNOW
}
cm.requestNetwork(NetworkRequest.Builder().build(), object : ConnectivityManager.NetworkCallback() {
override fun onAvailable(network: Network?) {
available = true
setType()
listener?.onAvailable()
}
override fun onLost(network: Network?) {
available = false
listener?.onLost()
}
})
}
}
