一种简单粗暴的数据层网络缓存（二）实现方案

先贴出代码：

package com.cache;

import android.content.Context;
import android.text.TextUtils;
import android.util.Log;

import com.google.gson.Gson;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CacheHelper {

    private static final String TAG = "CacheHelper";

    private static final String SHARED_PREFERENCES_NAME = "web_content_cache";
    private static final String STORE_KEY_XXX = "STORE_KEY_XXX";

    private static final boolean NEED_LIMIT_MAX_CACHE_LENGTH = true;
    private static final int MAX_CACHE_LENGTH = 500000;

    private static CacheHelper sInstance;
    private ExecutorService mExecutorService;

    public static synchronized CacheHelper instance() {
        if (null == sInstance) {
            sInstance = new CacheHelper();
        }
        return sInstance;
    }

    private CacheHelper() {
        mExecutorService = Executors.newSingleThreadExecutor();

    }

    /**
     * 缓存某个场景下的数据。
     *
     * @param cacheValue
     */
    public synchronized void cacheXXXList(final List<XXXBean> cacheValue) {
        runCache(cacheValue, STORE_KEY_XXX);
    }

    /**
     * 获取某个场景下的数据缓存,回调在工作线程中执行。(如果有UI操作,请注意需要在post回UI线程执行。)
     *
     * @param callback
     */
    public synchronized void getCacheXXXList(final CacheXXXCallback callback) {
        if (null == callback) {
            return;
        }
        // 通过某种全局的Utils得到Context,如果没有这种方法,需要在获取实例的时候传入Context
        final Context appContext = AppUtils.getContext();
        if (null == appContext) {
            return;
        }
        checkThreadPool();
        mExecutorService.execute(new Runnable() {
            @Override
            public void run() {
                // 目前使用SharedPreference存储Json String,可以改成文件等其他方式
                final String cacheStr = appContext.getSharedPreferences(SHARED_PREFERENCES_NAME,
                        Context.MODE_PRIVATE).getString(STORE_KEY_XXX, null);
                final List<XXXBean> cacheValue = new CopyOnWriteArrayList<>();
                if (!TextUtils.isEmpty(cacheStr)) {
                    final Gson gson = new Gson();
                    final List<String> jsons = gson.fromJson(cacheStr, List.class);
                    for (String item : jsons) {
                        cacheValue.add(gson.fromJson(item, XXXBean.class));
                    }
                }
                callback.onGetXXXList(cacheValue);
            }
        });
    }

    public static interface CacheXXXCallback {
        public void onGetXXXList(List<XXXBean> cacheValue);
    }

    private <T> void runCache(final List<T> list, final String cacheKey) {
        // 通过某种全局的Utils得到Context,如果没有这种方法,需要在获取实例的时候传入Context
        final Context appContext = AppUtils.getContext();
        if (null == appContext) {
            return;
        }
        if (null == list || list.isEmpty()) {
            return;
        }
        final CopyOnWriteArrayList<T> copyList = new CopyOnWriteArrayList<>();
        copyList.addAll(list);
        if (copyList.isEmpty()) {
            return;
        }
        checkThreadPool();
        mExecutorService.execute(new Runnable() {
            @Override
            public void run() {
                final Gson gson = new Gson();
                final ArrayList<String> jsons = new ArrayList<>();
                for (T t : copyList) {
                    jsons.add(gson.toJson(t));
                }
                final String cacheStr = gson.toJson(jsons);
                if (NEED_LIMIT_MAX_CACHE_LENGTH) {
                    if (cacheStr.length() > MAX_CACHE_LENGTH) {
                        Log.e(TAG, "runCache() : cache value length over max limit.");
                        return;
                    }
                }
                // 目前使用SharedPreference存储Json String,可以改成文件等其他方式
                appContext.getSharedPreferences(SHARED_PREFERENCES_NAME, Context.MODE_PRIVATE)
                        .edit().putString(cacheKey, cacheStr).commit();
            }
        });
    }

    private void checkThreadPool() {
        if (null == mExecutorService || mExecutorService.isShutdown()
                || mExecutorService.isTerminated()) {
            mExecutorService = Executors.newSingleThreadExecutor();
        }
    }
}

说明几个地方：

（1）在helper类内部用线程池实现了异步。使用异步的原因第一，存储Json String的方式有可能是文件，有可能是SharedPreference，涉及到IO；第二，可能会频繁调用写cache和读cache，异步化可以降低调用线程的压力，另外在单一的工作线程（单一线程的线程池）中顺序执行读、写，实现同步。

（2）通过测试发现，对于数据实体对象，Gson无法将对象的List直接转成Json字符串，但大多数的应用场景都是List，所以采用先将List中的每一个对象转成Json String，组成一个List<String>，然后再将List<String>转成一个Json String，存储。在读缓存的时候，是以上过程的逆过程，先将存储的Json String转成List<String>，然后将List中的每一个String转成一个数据实体对象。

（3）存储的方式目前使用的是SharedPreference。关于SharedPreference在这个场景的使用，稍后有时间会有另一篇文章细聊。存储方式可以替换成文件等，只要将读写操作稍作抽象即可，不影响数据转化的逻辑。