关于OkHttp缓存post请求的问题
现有这样一个要求，使用Retorfit+okhttp需要在有网的时候能够连接服务器，读取相关信息；在没网络断开的时候需要读取Okhttp的缓存来达到离线的效果。
基于上述的需求，可以使用Okhttp的拦截器来实现：
//设置缓存目录
File cacheFile = new File(BaseApplication.getContext().getCacheDir(), "cache");
Cache cache = new Cache(cacheFile, 1024 * 1024 * 100); //100Mb
//配置okhttp
OkHttpClient okHttpClient = new OkHttpClient.Builder()
.readTimeout(READ_TIME_OUT, TimeUnit.MILLISECONDS)
.connectTimeout(CONNECT_TIME_OUT, TimeUnit.MILLISECONDS)
.addNetworkInterceptor(mRewriteCacheControlInterceptor)
.addInterceptor(headerInterceptor)
.addInterceptor(logInterceptor)
.cache(cache) //设置缓存
.build();
Gson gson = new GsonBuilder().setDateFormat("yyyy-MM-dd'T'HH:mm:ssZ").serializeNulls().create();
retrofit = new Retrofit.Builder()
.client(okHttpClient)
// .addConverterFactory(ScalarsConverterFactory.create())
.addConverterFactory(GsonConverterFactory.create(gson))
.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
.baseUrl(BASE_URL)
.build();//配置拦截器
private final Interceptor mRewriteCacheControlInterceptor = new Interceptor() {
@Override
public Response intercept(Chain chain) throws IOException {
Request request = chain.request();
String cacheControl = request.cacheControl().toString();
if (!NetWorkUtils.isNetConnected(BaseApplication.getContext())) {
request = request.newBuilder()
.cacheControl(TextUtils.isEmpty(cacheControl)? CacheControl.FORCE_CACHE:CacheControl.FORCE_NETWORK)
.build();
}
Response originalResponse = chain.proceed(request);
if (NetWorkUtils.isNetConnected(BaseApplication.getContext())) {
//有网的时候连接服务器请求,缓存一天
return originalResponse.newBuilder()
.header("Cache-Control", "public, max-age=" + MAX_AGE)
.removeHeader("Pragma")
.build();
} else {
//网络断开时读取缓存
return originalResponse.newBuilder()
.header("Cache-Control", "public, only-if-cached, max-stale=" + CACHE_STALE_SEC)
.removeHeader("Pragma")
.build();
}
}
};通过以上就可以实现缓存。
但是，在使用该拦截器去执行POST请求的时候，会发现，即使在log中看到了读取缓存，但是实际上缓存目录里什么都没有。实际上是因为get请求一般较为持久，而post需要携带参数，会经常改动，所以没必要缓存，这个机制从Okhttp的源码里也可以看到：
//Cache类的put方法
private CacheRequest put(Response response) throws IOException {
String requestMethod = response.request().method();
if (HttpMethod.invalidatesCache(response.request().method())) {
try {
remove(response.request());
} catch (IOException ignored) {
}
return null;
}
//如果请求方式不用get，就直接跳过了
if (!requestMethod.equals("GET")) {
return null;
}
//省略代码
}但是，有些情况下确实需要去缓存post请求，要怎么去实现呢？
- Sqlite
网络正常时缓存响应信息到数据库，在没有网络的时候读出数据。 - DiskLruCache
通过文件缓存到本地。
这里是通过Sqlite来实现，至于如果通过DiskLruCache可以参考手动缓存Retrofit+OkHttp响应体,不再局限于Get请求缓存 。
通过Sqlite，需要缓存的基本信息有URL，Params， Response（链接，参数，响应结果）。当然可能还会缓存一些期限时长之类的字段，可以用于清理过期的缓存等。这里以基本的信息来实现。
//创建数据库和表
public class MyDBHelper extends SQLiteOpenHelper{
private static final String DB_NAME = "test.db";
private static final int DB_VERSION = 1;
static final String CACHE_TABLE = "cache";
public MyDBHelper(Context context) {
super(context, DB_NAME, null, DB_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
String sql = "create table if not exists " + CACHE_TABLE +
" (url text, params text, response text)";
db.execSQL(sql);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
String sql = "DROP TABLE IF EXISTS " + CACHE_TABLE;
db.execSQL(sql);
onCreate(db);
}
}另外，还需创建一个数据库管理类CacheDao，用于增删该改查：
public class CacheDao {
private static volatile CacheDao cacheDao;
private MyDBHelper helper;
private SQLiteDatabase database;
private CacheDao(Context context){
helper = new MyDBHelper(context.getApplicationContext());
database = helper.getWritableDatabase();
}
public static CacheDao getInstance(Context context) {
if (cacheDao == null) {
synchronized (CacheDao.class) {
if (cacheDao == null) {
cacheDao = new CacheDao(context);
}
}
}
return cacheDao;
}
//查
public String queryResponse(String urlKey, String params) {
return null;
}
//增
public void insertResponse(String urlKey, String params, String value) {
}
//改
public void updateResponse(String urlKey, String params, String value) {
}
//删
public void deleteResponse(String urlKey, String params) {
}
}数据库创建完成后，关键是要和Okhttp的请求拦截串联起来使用：
private final Interceptor mRewriteCacheControlInterceptor = new Interceptor() {
@Override
public Response intercept(Chain chain) throws IOException {
Request request = chain.request();
String url = request.url().toString(); //获取请求URL
Buffer buffer = new Buffer();
request.body().writeTo(buffer);
String params = buffer.readString(Charset.forName("UTF-8")); //获取请求参数
Response response;
if (NetWorkUtils.isNetConnected(BaseApplication.getContext())) {
int maxAge = 60 * 60*24;
//如果网络正常，执行请求。
Response originalResponse = chain.proceed(request);
//获取MediaType，用于重新构建ResponseBody
MediaType type = originalResponse.body().contentType();
//获取body字节即响应，用于存入数据库和重新构建ResponseBody
byte[] bs = originalResponse.body().bytes();
response = originalResponse.newBuilder()
.removeHeader("Pragma")
.removeHeader("Cache-Control")
.header("Cache-Control", "public, max-age=" + maxAge)
//重新构建body，原因在于body只能调用一次，之后就关闭了。
.body(ResponseBody.create(type, bs))
.build();
//将响应插入数据库
cacheDao.insertResponse(url, params, new String(bs, "GB2312"));
} else {
//没有网络的时候，由于Okhttp没有缓存post请求，所以不要调用chain.proceed(request)，会导致连接不上服务器而抛出异常（504）
String b = cacheDao.queryResponse(url, params); //读出响应
Log.d("OkHttp", "request:" + url);
Log.d("OkHttp", "request method:" + request.method());
Log.d("OkHttp", "response body:" + b);
int maxStale = 60 * 60 * 24 * 28;
//构建一个新的response响应结果
response = new Response.Builder()
.removeHeader("Pragma")
.header("Cache-Control", "public, only-if-cached, max-stale=" + maxStale)
.body(ResponseBody.create(MediaType.parse("application/json"), b.getBytes()))
.request(request)
.protocol(Protocol.HTTP_1_1)
.code(200)
.build();
}
return response;
}
};由于在没有网络的时候不调用chain.proceed(request)，所以拦截器就在此中断，直接将response结果返回。
通过上述方式，即可实现post请求结果的缓存。