OKHttp3(支持Retrofit)的网络数据缓存Interceptor拦截器的实现

前言：前段时间在开发app的时候，经常出现由于用户设备环境的原因，拿不到从网络端获取的数据，所以在app端展现的结果总是一个空白的框，这种情况对于用户体验来讲是极其糟糕的，所以，苦思冥想决定对okhttp下手(因为我在项目中使用的网络请求框架就是okhttp)，则写了这么一个网络数据缓存拦截器。
ok，那么我们决定开始写了，我先说一下思路：

思路篇

既然要写的是网络数据缓存拦截器，主要是利用了okhttp强大的拦截器功能，那么我们应该对哪些数据进行缓存呢，或者在哪些情况下启用数据进行缓存机制呢？

第一：支持post请求，因为官方已经提供了一个缓存拦截器,但是有一个缺点，就是只能对get请求的数据进行缓存，对post则不支持。

第二：网络正常的时候，则是去网络端取数据，如果网络异常，比如timeoutexception unknowhostexception 诸如此类的问题，那么我们就需要去缓存取出数据返回。

第三：如果从缓存中取出的数据是空的，那么我们还是需要让这次请求走剩下的正常的流程。

第四：调用者必须对缓存机制完全掌控，可以根据自己的业务需求选择性的对数据决定是否进行缓存。

第五：使用必须简单，这是最最最最重要的一点。

好，我们上面罗列了五点是我们的大概思路，现在来说一下代码部分：

代码篇

缓存框架：我这里使用的缓存框架是disklrucache https://github.com/jakewharton/disklrucache 这个缓存框架可以存储到本地，也经过谷歌认可，这也是选择这个框架的主要原因。我这里也对缓存框架进行封装了一个cachemanager类:

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拦截器机制，智能判断缓存场景，以及网络情况，对不同的场景进行处理。

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使用：

OKHttp3(支持Retrofit)的网络数据缓存Interceptor拦截器的实现

相关文章

快网idc优惠网

相关文章

微信

快网idc优惠网

QQ交流群