背景

目前各大技术论坛出现各式各样的缓存方案，很多ORM框架，如GreenDao,但真正在项目中使用并不需要那么多功能，很多功能都是冗余的，这样增加了apk的大小，而且集成起来也比较费劲，让人很费解。

目的

做一个轻量的缓存方案

主题

目前网络请求拿到的数据主流是json数据，然后通过Gson、json、jackjson等框架解析出来的可用数据基本上会映射到一个java对象上，这样对java对象的缓存已成主流，有时会是一个java对象的列表。

接下来笔者就说说如何实现一个轻量的对象缓存方案，既能缓存对象，又能缓存对象列表。

保存缓存是通过将对象序列化后再base64Encode处理转成字符串然后通过SharedPreferences保存到以对象类名命名的key上。
代码如下:

    /**
     * Save the data to the local cache.
     * @author leibing
     * @createTime 2016/08/26
     * @lastModify 2016/08/26
     * @param context 上下文
     * @param data 数据源
     * @return
     */
    public void save(final Context context, final T data){
                ThreadManager.getInstance().getNewCachedThreadPool().execute(new Runnable() {
                    @Override
                    public void run() {
                        synchronized (SpLocalCache.class) {
                            final SharedPreferences spLc = context.getSharedPreferences(
                                    cacheName,
                                    Context.MODE_PRIVATE
                            );
                            String strData = base64Encode(data);
                            if (strData != null)
                                spLc.edit()
                                        .putString(KEY_DATA, base64Encode(data))
                                        .commit();
                            SharePreferenceUtil.getInstance(context).setSpLocalCache(cacheName);
                        }
                    }
                });
    }

读取缓存是通过从以对象类名命名key值上拿到字符串数据，经过base64Decode处理再反序列化后拿到对象数据，所以在写需要缓存的对象类时，记得一定要写serialVersionUID，这是为了反序列化，代码如下：

    /**
     * Read the data from the local cache
     * @author leibing
     * @createTime 2016/08/26
     * @lastModify 2016/08/26
     * @param context 上下文
     * @param localCacheCallBack 回调
     * @return
     */
    public void read(final Context context,  final LocalCacheCallBack localCacheCallBack){
        ThreadManager.getInstance().getNewCachedThreadPool().execute(new Runnable() {
            @Override
            public void run() {
                synchronized (SpLocalCache.class) {
                    SharedPreferences spLc = context.getSharedPreferences(
                            cacheName,
                            Context.MODE_PRIVATE
                    );
                    final String strData = spLc.getString(KEY_DATA, null);
                    if (StringUtil.isNotEmpty(strData)) {
                        final Object obj = base64Decode(strData);
                        mHandler.post(new Runnable() {
                            @Override
                            public void run() {
                                if (localCacheCallBack != null)
                                    localCacheCallBack.readCacheComplete(obj);
                            }
                        });
                    }
                }
            }
        });
    }

缓存对象列表其实很简单，只需要写一个固定的列表缓存对象类，里面包含一个内容为泛型的列表即可，代码如下：

/**
 * @className: ListCache
 * @classDescription: 列表缓存(用于缓存列表数据,减弱对sqlite的依赖)
 * @author: leibing
 * @createTime: 2016/08/26
 */
public class ListCache<T> implements Serializable{
    // 序列化UID 当需要反序列化的时候,此UID必须要.
    private static final long serialVersionUID = -3276096981990292013L;
    // 对象列表(用于存储需要缓存下来的列表)
    private ArrayList<T> objList;

    public ArrayList<T> getObjList() {
        return objList;
    }

    public void setObjList(ArrayList<T> objList) {
        this.objList = objList;
    }
}

童鞋们，是不是很简单？

本项目已在github开源，地址：CustomCache

如有疑问，请联系。

• QQ：872721111
• email：leibing1989@126.com