一、快取輔助類

import android.content.Context;
import android.content.SharedPreferences;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 *  
 * @date 建立時間：2018/11/7
 * @author Jiang zinc
 * @description 快取工具類
 *
 */

public class CacheHelper {

    private SharedPreferences cacheData;
 


    private final String LIMIT = "_limit";
    private final String DATA = "_data";

    // 1天
    public static final int DAY_TIMES = 60 * 60 * 24 * 1000;

    private static CacheHelper mInstance;
    private static Context appContext;

    /**
     * 在 Application 中需要進行初始化
     *
     * @param context 建議為 {@link android.app.Application}
     */
 

    public static void init(Context context) {
        appContext = context;
    }

    /**
     * 獲取 單例物件
     *
     * @return
     */
    public static CacheHelper getInstance() {
        if (mInstance == null) {
            synchronized (CacheHelper.class) {
                if (mInstance == null)
 
 {
                    mInstance = new CacheHelper();
                }
            }
        }
        return mInstance;
    }

    private CacheHelper() {
        try {
            if (appContext == null) {
                throw new Exception("CacheHelper not init in Application");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        if (cacheData == null) {
            cacheData = appContext.getSharedPreferences(getSpName(), Context.MODE_PRIVATE);
        }
    }

    /**
     * SharedPreferences儲存在sd卡中的檔名字
     */
    private static String getSpName() {
        return appContext.getPackageName() + "_preferences";
    }

    /**
     * 獲取 key值 對應的 內容
     *
     * @param key 鍵
     * @return 如果有值，且在時間內，則返回對應的內容；否則返回null
     */
    public String getCache(String key) {
        long deadline = cacheData.getLong(key + LIMIT, -1);
        if (deadline <= 0) {
            return cacheData.getString(key + DATA, null);
        } else {
            if (deadline < System.currentTimeMillis()) {
                return null;
            } else {
                return cacheData.getString(key + DATA, null);
            }
        }
    }

    /**
     * 儲存 鍵=值 ，不限定有效時間
     *
     * @param key   鍵
     * @param value 值
     */
    public void setCache(String key, String value) {
        SharedPreferences.Editor shareData = cacheData.edit();
        shareData.putString(key + DATA, value);
        SharedPreferencesCompat.apply(shareData);
    }

    /**
     * 儲存 鍵=值 ， 限定有效時間
     *
     * @param key   鍵
     * @param value 值
     * @param time  有效時間（需大於0，否則無效）
     */
    public void setCache(String key, String value, int time) {
        if (time > 0) {
            long limitTime = System.currentTimeMillis() + time;
            SharedPreferences.Editor shareData = cacheData.edit();
            shareData.putLong(key + LIMIT, limitTime);
            SharedPreferencesCompat.apply(shareData);
        }

        setCache(key, value);
    }

    /**
     * 是否已經存有該鍵 (過期的值算作存在)
     *
     * @param key 鍵
     * @return true：存在；false：不存在
     */
    public boolean isContains(String key) {
        return cacheData.contains(key + DATA);
    }

    /**
     * 清空 SharePreference 內容
     */
    public void clear() {
        SharedPreferences.Editor editor = cacheData.edit();
        editor.clear();
        SharedPreferencesCompat.apply(editor);
    }

    /**
     * 移除某個值
     *
     * @param key 鍵
     */
    public void removeCache(String key) {
        SharedPreferences.Editor shareData = cacheData.edit();
        shareData.remove(key + DATA);
        shareData.remove(key + LIMIT);
        SharedPreferencesCompat.apply(shareData);
    }

    /**
     * 建立一個解決SharedPreferencesCompat.apply方法的一個相容類
     */
    private static class SharedPreferencesCompat {

        // 避免每次都要進行反射
        private static final Method sApplyMethod = findApplyMethod();

        /**
         * 反射查詢apply的方法
         */
        @SuppressWarnings({"unchecked", "rawtypes"})
        private static Method findApplyMethod() {
            try {
                Class clz = SharedPreferences.Editor.class;
                return clz.getMethod("apply");
            } catch (NoSuchMethodException e) {
            }

            return null;
        }

        /**
         * 如果找到則使用apply執行，否則使用commit
         */
        public static void apply(SharedPreferences.Editor editor) {
            try {
                if (sApplyMethod != null) {
                    sApplyMethod.invoke(editor);
                    return;
                }
            } catch (IllegalArgumentException expected) {
            } catch (IllegalAccessException expected) {
            } catch (InvocationTargetException expected) {
            }

            editor.commit();
        }
    }

}

二、以物件形式儲存資料

其中使用的GsonUtils，可以檢視我的另外一篇Gson封裝工具類，或是將其替換成自己使用的Json轉換器便可。

public class UserCache {

    private static UserModel instance;
    private final static String TAG = "USER_INFO_CACHE";

    private UserCache() {
    }

    /**
     * 是否在快取中，已經存有
     *
     * @return true：存有；false：未存有
     */
    public static boolean hasInit() {
        return getDefault() != null;
    }

    /**
     * 獲取 UserModel（如果為第一次，會進行一次從SharePreference中獲取，具體看{@link #refresh}）
     *
     * @return
     */
    public static UserModel getDefault() {
        if (instance == null) {
            synchronized (UserCache.class) {
                if (instance == null) {
                    refresh();
                }
            }
        }
        return instance;
    }

    /**
     * 重新整理記憶體中的資料，重新從 SharePreference 獲取
     */
    public static void refresh() {
        synchronized (UserCache.class) {
            String json = CacheHelper.getInstance().getCache(TAG);
            if (TextUtils.isEmpty(json)) {
                instance = null;
            } else {
                instance = (UserModel) GsonUtils.getInstance().fromJson(json, UserModel.class);
            }
        }
    }

    /**
     * 移除使用者資訊記憶體，例如使用者退出時，呼叫
     */
    public static void remove() {
        CacheHelper.getInstance().removeCache(TAG);
        instance = null;
    }

    /**
     * 判斷是否為空
     *
     * @return true為空，false說明已有資料
     */
    public static boolean isEmpty() {
        return getDefault() == null;
    }

    /**
     * 儲存整個Object資料，會將其進行轉成json串
     *
     * @param userModel 使用者資料
     */
    public static void save(UserModel userModel) {
        instance = userModel;
        String json = GsonUtils.getGson().toJson(userModel);
        CacheHelper.getInstance().setCache(TAG, json);
    }

}