前言：前段时间在开发app的时候，经常出现由于用户设备环境的原因，拿不到从网络端获取的数据，所以在app端展现的结果总是一个空白的框，这种情况对于用户体验来讲是极其糟糕的，所以，苦思冥想决定对okhttp下手(因为我在项目中使用的网络请求框架就是okhttp)，则 写了这么一个网络数据缓存拦截器。
ok，那么我们决定开始写了，我先说一下思路：
思路篇
既然要写的是网络数据缓存拦截器，主要是利用了okhttp强大的拦截器功能，那么我们应该对哪些数据进行缓存呢，或者在哪些情况下启用数据进行缓存机制呢？
第一 ：支持post请求，因为官方已经提供了一个缓存拦截器,但是有一个缺点，就是只能对get请求的数据进行缓存，对post则不支持。
第二 ：网络正常的时候，则是去网络端取数据，如果网络异常，比如timeoutexception unknowhostexception 诸如此类的问题，那么我们就需要去缓存取出数据返回。
第三 ：如果从缓存中取出的数据是空的，那么我们还是需要让这次请求走剩下的正常的流程。
第四 ：调用者必须对缓存机制完全掌控，可以根据自己的业务需求选择性的对数据决定是否进行缓存。
第五 ：使用必须简单，这是最最最最重要的一点。
好，我们上面罗列了五点是我们的大概思路，现在来说一下代码部分：
代码篇
缓存框架 ：我这里使用的缓存框架是disklrucache https://github.com/jakewharton/disklrucache 这个缓存框架可以存储到本地，也经过谷歌认可，这也是选择这个框架的主要原因。我这里也对缓存框架进行封装了一个cachemanager类:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
|
import android.content.context;
import android.content.pm.packageinfo;
import android.content.pm.packagemanager;
import com.xiaolei.okhttpcacheinterceptor.log.log;
import java.io.bytearrayoutputstream;
import java.io.file;
import java.io.fileinputstream;
import java.io.ioexception;
import java.io.outputstream;
import java.io.unsupportedencodingexception;
import java.security.messagedigest;
import java.security.nosuchalgorithmexception;
/**
* created by xiaolei on 2017/5/17.
*/
public class cachemanager
{
public static final string tag = "cachemanager";
//max cache size 10mb
private static final long disk_cache_size = 1024 * 1024 * 10;
private static final int disk_cache_index = 0;
private static final string cache_dir = "responses";
private disklrucache mdisklrucache;
private volatile static cachemanager mcachemanager;
public static cachemanager getinstance(context context)
{
if (mcachemanager == null)
{
synchronized (cachemanager.class)
{
if (mcachemanager == null)
{
mcachemanager = new cachemanager(context);
}
}
}
return mcachemanager;
}
private cachemanager(context context)
{
file diskcachedir = getdiskcachedir(context, cache_dir);
if (!diskcachedir.exists())
{
boolean b = diskcachedir.mkdirs();
log.d(tag, "!diskcachedir.exists() --- diskcachedir.mkdirs()=" + b);
}
if (diskcachedir.getusablespace() > disk_cache_size)
{
try
{
mdisklrucache = disklrucache.open(diskcachedir,
getappversion(context), 1/*一个key对应多少个文件*/, disk_cache_size);
log.d(tag, "mdisklrucache created");
} catch (ioexception e)
{
e.printstacktrace();
}
}
}
/**
* 同步设置缓存
*/
public void putcache(string key, string value)
{
if (mdisklrucache == null) return;
outputstream os = null;
try
{
disklrucache.editor editor = mdisklrucache.edit(encryptmd5(key));
os = editor.newoutputstream(disk_cache_index);
os.write(value.getbytes());
os.flush();
editor.commit();
mdisklrucache.flush();
} catch (ioexception e)
{
e.printstacktrace();
} finally
{
if (os != null)
{
try
{
os.close();
} catch (ioexception e)
{
e.printstacktrace();
}
}
}
}
/**
* 异步设置缓存
*/
public void setcache(final string key, final string value)
{
new thread()
{
@override
public void run()
{
putcache(key, value);
}
}.start();
}
/**
* 同步获取缓存
*/
public string getcache(string key)
{
if (mdisklrucache == null)
{
return null;
}
fileinputstream fis = null;
bytearrayoutputstream bos = null;
try
{
disklrucache.snapshot snapshot = mdisklrucache.get(encryptmd5(key));
if (snapshot != null)
{
fis = (fileinputstream) snapshot.getinputstream(disk_cache_index);
bos = new bytearrayoutputstream();
byte[] buf = new byte[1024];
int len;
while ((len = fis.read(buf)) != -1)
{
bos.write(buf, 0, len);
}
byte[] data = bos.tobytearray();
return new string(data);
}
} catch (ioexception e)
{
e.printstacktrace();
} finally
{
if (fis != null)
{
try
{
fis.close();
} catch (ioexception e)
{
e.printstacktrace();
}
}
if (bos != null)
{
try
{
bos.close();
} catch (ioexception e)
{
e.printstacktrace();
}
}
}
return null;
}
/**
* 异步获取缓存
*/
public void getcache(final string key, final cachecallback callback)
{
new thread()
{
@override
public void run()
{
string cache = getcache(key);
callback.ongetcache(cache);
}
}.start();
}
/**
* 移除缓存
*/
public boolean removecache(string key)
{
if (mdisklrucache != null)
{
try
{
return mdisklrucache.remove(encryptmd5(key));
} catch (ioexception e)
{
e.printstacktrace();
}
}
return false;
}
/**
* 获取缓存目录
*/
private file getdiskcachedir(context context, string uniquename)
{
string cachepath = context.getcachedir().getpath();
return new file(cachepath + file.separator + uniquename);
}
/**
* 对字符串进行md5编码
*/
public static string encryptmd5(string string)
{
try
{
byte[] hash = messagedigest.getinstance("md5").digest(
string.getbytes("utf-8"));
stringbuilder hex = new stringbuilder(hash.length * 2);
for (byte b : hash)
{
if ((b & 0xff) < 0x10)
{
hex.append("0");
}
hex.append(integer.tohexstring(b & 0xff));
}
return hex.tostring();
} catch (nosuchalgorithmexception | unsupportedencodingexception e)
{
e.printstacktrace();
}
return string;
}
/**
* 获取app版本号
*/
private int getappversion(context context)
{
packagemanager pm = context.getpackagemanager();
try
{
packageinfo pi = pm.getpackageinfo(context.getpackagename(), 0);
return pi == null ? 0 : pi.versioncode;
} catch (packagemanager.namenotfoundexception e)
{
e.printstacktrace();
}
return 0;
}
}
|
缓存cacheinterceptor拦截器：利用okhttp的interceptor拦截器机制，智能判断缓存场景，以及网络情况，对不同的场景进行处理。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
import android.content.context;
import com.xiaolei.okhttpcacheinterceptor.catch.cachemanager;
import com.xiaolei.okhttpcacheinterceptor.log.log;
import java.io.ioexception;
import okhttp3.formbody;
import okhttp3.interceptor;
import okhttp3.protocol;
import okhttp3.request;
import okhttp3.response;
import okhttp3.responsebody;
/**
* 字符串的缓存类
* created by xiaolei on 2017/12/9.
*/
public class cacheinterceptor implements interceptor
{
private context context;
public void setcontext(context context)
{
this.context = context;
}
public cacheinterceptor(context context)
{
this.context = context;
}
@override
public response intercept(chain chain) throws ioexception
{
request request = chain.request();
string cachehead = request.header("cache");
string cache_control = request.header("cache-control");
if ("true".equals(cachehead) || // 意思是要缓存
(cache_control != null && !cache_control.isempty())) // 这里还支持web端协议的缓存头
{
long oldnow = system.currenttimemillis();
string url = request.url().url().tostring();
string responstr = null;
string reqbodystr = getpostparams(request);
try
{
response response = chain.proceed(request);
if (response.issuccessful()) // 只有在网络请求返回成功之后，才进行缓存处理，否则，404存进缓存，岂不笑话
{
responsebody responsebody = response.body();
if (responsebody != null)
{
responstr = responsebody.string();
if (responstr == null)
{
responstr = "";
}
cachemanager.getinstance(context).setcache(cachemanager.encryptmd5(url + reqbodystr), responstr);//存缓存，以链接+参数进行md5编码为key存
log.i("httpretrofit", "--> push cache:" + url + " :success");
}
return getonlineresponse(response, responstr);
} else
{
return chain.proceed(request);
}
} catch (exception e)
{
response response = getcacheresponse(request, oldnow); // 发生异常了，我这里就开始去缓存，但是有可能没有缓存，那么久需要丢给下一轮处理了
if (response == null)
{
return chain.proceed(request);//丢给下一轮处理
} else
{
return response;
}
}
} else
{
return chain.proceed(request);
}
}
private response getcacheresponse(request request, long oldnow)
{
log.i("httpretrofit", "--> try to get cache --------");
string url = request.url().url().tostring();
string params = getpostparams(request);
string cachestr = cachemanager.getinstance(context).getcache(cachemanager.encryptmd5(url + params));//取缓存，以链接+参数进行md5编码为key取
if (cachestr == null)
{
log.i("httpretrofit", "<-- get cache failure ---------");
return null;
}
response response = new response.builder()
.code(200)
.body(responsebody.create(null, cachestr))
.request(request)
.message("ok")
.protocol(protocol.http_1_0)
.build();
long usetime = system.currenttimemillis() - oldnow;
log.i("httpretrofit", "<-- get cache: " + response.code() + " " + response.message() + " " + url + " (" + usetime + "ms)");
log.i("httpretrofit", cachestr + "");
return response;
}
private response getonlineresponse(response response, string body)
{
responsebody responsebody = response.body();
return new response.builder()
.code(response.code())
.body(responsebody.create(responsebody == null ? null : responsebody.contenttype(), body))
.request(response.request())
.message(response.message())
.protocol(response.protocol())
.build();
}
/**
* 获取在post方式下。向服务器发送的参数
*
* @param request
* @return
*/
private string getpostparams(request request)
{
string reqbodystr = "";
string method = request.method();
if ("post".equals(method)) // 如果是post，则尽可能解析每个参数
{
stringbuilder sb = new stringbuilder();
if (request.body() instanceof formbody)
{
formbody body = (formbody) request.body();
if (body != null)
{
for (int i = 0; i < body.size(); i++)
{
sb.append(body.encodedname(i)).append("=").append(body.encodedvalue(i)).append(",");
}
sb.delete(sb.length() - 1, sb.length());
}
reqbodystr = sb.tostring();
sb.delete(0, sb.length());
}
}
return reqbodystr;
}
}
|
以上是主体思路，以及主要实现代码，现在来说一下使用方式
使用方式：
gradle使用：
|
1
|
compile 'com.xiaolei:okhttpcacheinterceptor:1.0.0'
|
由于是刚刚提交到jcenter，可能会出现拉不下来的情况(暂时还未过审核)，着急的读者可以再在你的project:build.gradle里的repositories里新增我maven的链接：
|
1
2
3
4
5
|
allprojects {
repositories {
maven{url 'https://dl.bintray.com/kavipyouxiang/maven'}
}
}
|
我们新建一个项目，项目截图是这样的：
项目截图
demo很简单，一个主页面，一个bean，一个retrofit，一个网络请求接口
注意，因为是网络，缓存，有关，所以，毫无疑问我们要在manifest里面添加网络请求权限，文件读写权限：
|
1
2
3
|
<uses-permission android:name="android.permission.internet" />
<uses-permission android:name="android.permission.read_external_storage" />
<uses-permission android:name="android.permission.write_external_storage" />
|
使用的时候，你只需要为你的okhttpclient添加一个interceptor：
|
1
2
3
4
5
|
client = new okhttpclient.builder()
.addinterceptor(new cacheinterceptor(context))//添加缓存拦截器，添加缓存的支持
.retryonconnectionfailure(true)//失败重连
.connecttimeout(30, timeunit.seconds)//网络请求超时时间单位为秒
.build();
|
如果你想哪个接口的数据缓存，那么久为你的网络接口，添加一个请求头cacheheaders.java这个类里包含了所有的情况，一般情况下只需要cacheheaders.normal就可以了
|
1
2
3
4
5
6
7
|
public interface net
{
@headers(cacheheaders.normal) // 这里是关键
@formurlencoded
@post("geocoding")
public call<databean> getindex(@field("a") string a);
}
|
业务代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
net net = retrofitbase.getretrofit().create(net.class);
call<databean> call = net.getindex("苏州市");
call.enqueue(new callback<databean>()
{
@override
public void onresponse(call<databean> call, response<databean> response)
{
databean data = response.body();
date date = new date();
textview.settext(date.getminutes() + " " + date.getseconds() + ":\n" + data + "");
}
@override
public void onfailure(call<databean> call, throwable t)
{
textview.settext("请求失败！");
}
});
|
我们这里对网络请求，成功了，则在界面上输出文字,加上当前时间，网络失败，则输出一个请求失败。
大概代码就是这样子的，详细代码，文章末尾将贴出demo地址
看效果:演示图
这里演示了，从网络正常，到网络不正常，再恢复到正常的情况。
结尾
以上篇章就是整个从思路，到代码，再到效果图的流程，这里贴一下demo的地址，喜欢的可以点个start
demo地址:https://github.com/xiaolei123/okhttpcacheinterceptor
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。
原文链接：http://www.jianshu.com/p/0c57d4856be1