结合之前两篇文章链式调用打造第三方的网络引擎
http://blog.csdn.net/qq_24675479/article/details/79277616
和 自己动手搭建数据库框架
http://blog.csdn.net/qq_24675479/article/details/79285849

首先逻辑处理:每次都会请求数据，但是为了保证用户体验，我们可以先去本地拿缓存，如果本地有则先显示，然后获取到后台返回数据后，如果数据一样则不做界面刷新，如果不一致，加入缓存

• 首先获取缓存数据和保存数据类工具类

public class CacheDataUtil {

    /**
     * 获取数据
     */
    public static String getCacheResultJson(String finalUrl) {
        final IDaoSupport<CacheData> dataDaoSupport = DaoSupportFactory.getFactory().getDao(CacheData.class);
        // 需要缓存，从数据库拿缓存，问题又来了，OkHttpEngine  BaseLibrary
        // 数据库缓存在 FrameLibrary
        List<CacheData> cacheDatas = dataDaoSupport.querySupport()
                // finalUrl http:w 报错  finalUrl -> MD5处理
                .selection("mUrlkey = ?").selectionArgs(MD5Util.string2MD5(finalUrl)).query();

        if (cacheDatas.size() != 0) {
            // 代表有数据
            CacheData cacheData = cacheDatas.get(0);
            String resultJson = cacheData.getResultJson();

            return resultJson;
        }
        return null;
    }

    /**
     * 缓存数据
     */
    public static long cacheData(String finalUrl, String resultJson) {
        final IDaoSupport<CacheData> dataDaoSupport = DaoSupportFactory.getFactory().
                getDao(CacheData.class);
        dataDaoSupport.delete("mUrlkey=?", MD5Util.string2MD5(finalUrl));
        long number = dataDaoSupport.insert(new CacheData(MD5Util.string2MD5(finalUrl), resultJson));
        Log.e("TAG", "number --> " + number);
        return number;
    }
}

• 对数据进行缓存的实体类

public class CacheData {
    //请求链接
    public  String mUrlkey;
    //后台返回的json
    public String mResultJson;

    public CacheData() {
    }

    public CacheData(String mUrlkey, String mResultJson) {
        this.mUrlkey = mUrlkey;
        this.mResultJson = mResultJson;
    }


    public String getResultJson() {
        return mResultJson;
    }
}

• 对OkHttpEngine进行的get方法修改

  @Override
    public void get(final boolean cache, Context context, String url, Map<String, Object> params, final EngineCallBack callBack) {
        // 请求路径  参数 + 路径代表唯一标识
        final String finalUrl = HttpUtils.jointParams(url, params);
        Log.e("Get请求路径：", finalUrl);

        // 1.判断需不需要缓存，然后判断有没有
        if (cache) {
            String resultJson = CacheDataUtil.getCacheResultJson(finalUrl);
            if (!TextUtils.isEmpty(resultJson)) {
                Log.e("TAG", "以读到缓存");
                // 需要缓存，而且数据库有缓存,直接就去执行，里面执行成功
                callBack.onSuccess(resultJson);
            }
        }

        Request.Builder requestBuilder = new Request.Builder().url(finalUrl).tag(context);
        //可以省略，默认是GET请求
        Request request = requestBuilder.build();

        mOkHttpClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                callBack.onError(e);
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                String resultJson = response.body().string();
                Log.e("TAG",resultJson);
                // 获取数据之后会执行成功方法
                if (cache) {
                    String cacheResultJson = CacheDataUtil.getCacheResultJson(finalUrl);
                    if (!TextUtils.isEmpty(resultJson)) {
                        Log.e("TAG",cacheResultJson.equals(resultJson)+"");

                        // 比对内容
                        if (resultJson.equals(cacheResultJson)) {
                            // 内容一样，不需要执行成功成功方法刷新界面
                            Log.e("数据和缓存一致：", resultJson);
                            return;
                        }
                    }
                }
                // 2.2 执行成功方法
                callBack.onSuccess(resultJson);
                Log.e("Get返回结果：", resultJson);
                if (cache) {
                    // 2.3 缓存数据
                    CacheDataUtil.cacheData(finalUrl, resultJson);
                }
            }
        });
    }