数据本地缓存(不包含图片缓存)

数据本地缓存(不包含图片缓存)

本问阐述了保存需要缓存的数据的两种方法

• 方法一：通过SharedPreferences编写工具类存储数据
• 方法二：对继承Serializable的JavaBean类进行序列化存储

---

方法一

**通过SharedPreferences编写工具类存储数据：
首先需要介绍SharedPreferences获取的两种方式以及区别：
1 调用Context对象的getSharedPreferences()方法
2 调用Activity对象的getPreferences()方法
两种方式的区别:
调用Context对象的getSharedPreferences()方法获得的SharedPreferences对象可以被同一应用程序下的其他组件共享.
调用Activity对象的getPreferences()方法获得的SharedPreferences对象只能在该Activity中使用.

SharedPreferences的四种操作模式:
Context.MODE_PRIVATE
Context.MODE_APPEND
Context.MODE_WORLD_READABLE
Context.MODE_WORLD_WRITEABLE

Context.MODE_PRIVATE：为默认操作模式,代表该文件是私有数据,只能被应用本身访问,在该模式下,写入的内容会覆盖原文件的内容
Context.MODE_APPEND：模式会检查文件是否存在,存在就往文件追加内容,否则就创建新文件.
Context.MODE_WORLD_READABLE和Context.MODE_WORLD_WRITEABLE用来控制其他应用是否有权限读写该文件.

代码块

例如：

public class SpUtils {
    //编写一个工具类，定义缓存的SD卡中的文件名称
    private final static String SP_NAME = "sp_data";
    private static SharedPreferences sp;

    private static SharedPreferences getSp(Context context) {
    //获取SharedPreferences 对象
        if (sp == null) {
            sp = context.getSharedPreferences(SP_NAME, Context.MODE_PRIVATE);
        }
        return sp;
    }

    /**
     * 获取boolean 数据
     *
     * @param context
     * @param key
     * @return 如果没有值，返回false
     */
    public static boolean getBoolean(Context context, String key) {
        SharedPreferences sp = getSp(context);
        return sp.getBoolean(key, false);
    }

    /**
     * 获取boolean 数据
     *
     * @param context
     * @param key
     * @param defValue
     * @return
     */
    public static boolean getBoolean(Context context, String key, boolean defValue) {
        SharedPreferences sp = getSp(context);
        return sp.getBoolean(key, defValue);
    }

    /**
     * 存boolean缓存
     *
     * @param context
     * @param key
     * @param value
     */
    public static void setBoolean(Context context, String key, boolean value) {
        SharedPreferences sp = getSp(context);
        Editor editor = sp.edit();
        editor.putBoolean(key, value);
        editor.commit();
    }

    /**
     * 获取String 数据
     *
     * @param context
     * @param key
     * @return 如果没有值，返回null
     */
    public static String getString(Context context, String key) {
        SharedPreferences sp = getSp(context);
        return sp.getString(key, null);
    }

    /**
     * 获取String 数据
     *
     * @param context
     * @param key
     * @param defValue
     * @return
     */
    public static String getString(Context context, String key, String defValue) {
        SharedPreferences sp = getSp(context);
        return sp.getString(key, defValue);
    }

    /**
     * 存String缓存
     *
     * @param context
     * @param key
     * @param value
     */
    public static void setString(Context context, String key, String value) {
        SharedPreferences sp = getSp(context);
        Editor editor = sp.edit();
        editor.putString(key, value);
        editor.commit();
    }

    /**
     * 获取int 数据
     *
     * @param context
     * @param key
     * @return 如果没有值，返回-1
     */
    public static int getInt(Context context, String key) {
        SharedPreferences sp = getSp(context);
        return sp.getInt(key, -1);
    }

    /**
     * 获取int 数据
     *
     * @param context
     * @param key
     * @param defValue
     * @return
     */
    public static int getInt(Context context, String key, int defValue) {
        SharedPreferences sp = getSp(context);
        return sp.getInt(key, defValue);
    }

    /**
     * 存int缓存
     *
     * @param context
     * @param key
     * @param value
     */
    public static void setInt(Context context, String key, int value) {
        SharedPreferences sp = getSp(context);
        Editor editor = sp.edit();
        editor.putInt(key, value);
        editor.commit();
    }


    /**
     * 获取int 数据
     *
     * @param context
     * @param key
     * @return 如果没有值，返回-1
     */
    public static long getLong(Context context, String key) {
        SharedPreferences sp = getSp(context);
        return sp.getLong(key, -1);
    }

    /**
     * 获取int 数据
     *
     * @param context
     * @param key
     * @param defValue
     * @return
     */
    public static long getLong(Context context, String key, long defValue) {
        SharedPreferences sp = getSp(context);
        return sp.getLong(key, defValue);
    }

    /**
     * 存int缓存
     *
     * @param context
     * @param key
     * @param value
     */
    public static void setLong(Context context, String key, long value) {
        SharedPreferences sp = getSp(context);
        Editor editor = sp.edit();
        editor.putLong(key, value);
        editor.commit();
    }

    public static float getFloat(Context context, String key) {
        SharedPreferences sp = getSp(context);
        return sp.getFloat(key, 0);
    }

    /**
     * 获取int 数据
     *
     * @param context
     * @param key
     * @param defValue
     * @return
     */
    public static float getFloat(Context context, String key, float defValue) {
        SharedPreferences sp = getSp(context);
        return sp.getFloat(key, defValue);
    }

    /**
     * 存int缓存
     *
     * @param context
     * @param key
     * @param value
     */
    public static void setFloat(Context context, String key, float value) {
        SharedPreferences sp = getSp(context);
        Editor editor = sp.edit();
        editor.putFloat(key, value);
        editor.commit();
    }
    /**
        在SharedPreferences中保存对象的方法前提是需要导入第三方Gson今夕json数据解析*/
    /**
     * 保存对象
     *
     * @param context
     * @param object  保存的对象
     */
    public static void setObject(Context context, Object object, String key) {
        String strJson = "";
        Gson gson = new Gson();
        strJson = gson.toJson(object);
        SpUtils.setString(context, key, strJson);
    }

    /**
     * 获取对象
     *
     * @param context
     * @param key
     * @return
     */
    public static OpenBean getObject(Context context, String key, Class clazz) {
        OpenBean obj = null;
        String str = getSp(context).getString(key, "");
        if (str != null) {
            Gson gson = new Gson();
            obj = (Object) gson.fromJson(str, clazz);
        }
        return obj;
    }


    /**
     * 保存List对象集合
     * @param context
     * @param key
     * @param datas
     */
    /*public static void setListObj(Context context, String key, List<?> datas) {
        JSONArray mJsonArray = new JSONArray();
        for (int i = 0; i < datas.size(); i++) {
            Object bean = datas.get(i);
            mJsonArray.put(bean);
        }
        Editor editor = getSp(context).edit();
        editor.putString(key, mJsonArray.toString());
        editor.commit();
    }

    */

    /**
     * 获取本地List持久化数据
     *
     * @paramcontext
     * @paramkey
     * @return
     *//*
    public static List<?> getListObj(Context context , String key ){
        List<Object> list = new ArrayList<>();
        String result = getSp(context).getString(key, "");
        try {
            JSONArray jsonArray = new JSONArray(result);
            for(int i = 0; i <jsonArray.length(); i++){
                Object bean = jsonArray.get(i);
                list.add(bean);
            }
        } catch (JSONException e) {
            e.printStackTrace();
            ToastUtils.showMessage(context , "获取列表数据异常");
        }
        return list;
    }*/
    public static String setListString(List<Object> list)
            throws IOException {
        // 实例化一个ByteArrayOutputStream对象，用来装载压缩后的字节文件。
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        // 然后将得到的字符数据装载到ObjectOutputStream
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(
                byteArrayOutputStream);
        // writeObject 方法负责写入特定类的对象的状态，以便相应的 readObject 方法可以还原它
        objectOutputStream.writeObject(list);
        // 最后，用Base64.encode将字节文件转换成Base64编码保存在String中
        String SceneListString = new String(Base64.encode(
                byteArrayOutputStream.toByteArray(), Base64.DEFAULT));
        // 关闭objectOutputStream
        objectOutputStream.close();
        return SceneListString;
    }

    @SuppressWarnings("unchecked")
    public static List<Object> getListString(String string) throws StreamCorruptedException, IOException,
            ClassNotFoundException {
        byte[] mobileBytes = Base64.decode(string.getBytes(),Base64.DEFAULT);
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(mobileBytes);
        ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
        List SceneList = (List) objectInputStream.readObject();
        objectInputStream.close();
        return SceneList;
    }

/** 
        本文中的List对象集合保存同时也适用于多层List数据嵌套
        例如：List<List<List<Bean>>> 数据格式
        由于该对象本身不存在保存List数据格式，只能进行字符串String类型的存储，
        所有首先保存将List数据转换为String格式再进行存储操作
        在获取List数据的时候再将String格式的数据转换为List数据进行获取
    */

    /**
     * 保存list 数据
     * @param context
     * @param list
     * @param key
     */
    public static void setListObj(Context context , List list , String key){
        Editor editor = getSp(context).edit();
        try {
            String str = setListString(list);
            editor.putString(key , str);
            editor.commit();
        } catch (IOException e) {
            e.printStackTrace();
            ToastUtils.showMessage(context, "保存列表数据异常");
        }
    }

    /**
     * 获取保存的list对象
     * @param context
     * @param key
     * @return
     */
    public static List getListObj(Context context , String key){
        List list = new ArrayList();
        String str = getSp(context).getString(key , "");
        try {
            list = getListString(str);
            return list ;
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            ToastUtils.showMessage(context , "获取列表数据异常");
        }
        return null;
    }



    /**
     * 移除某一个key所对应的值
     *
     * @param context
     * @param key
     */
    public static void remove(Context context, String key) {
        Editor editor = getSp(context).edit();
        editor.remove(key);
        editor.commit();
    }

    /**
     * 移除Sp文件里面的所有数据
     *
     * @param context
     */
    public static void clear(Context context) {
        Editor editor = getSp(context).edit();
        editor.clear();
        editor.commit();
    }
}

方法一：SharedPreferences对象使用的总结

• 该对象会在本地的/data/data/(自己的工程名称目录下)/(对象保存的名称，在这里是sp_data)生成一个缓存的文件，可以导出用NotePad+++进行数据查看
• 通过设置对象的属性使本地缓存的数据只存在一个文件内，当工程进行卸载的时候，该缓存的数据也会一同消失

代码块

例如：
//进行List数据的存储
SpUtils.setListObj((当前的Activity对象) , (需要存储的List对象), (存储的名称Key));
//获取保存的List数据
SpUtils.getListObj((当前的Activity对象),(存储的名称Key));
//根据工具类中书写的需要的参数进行存储即可，顺序可能有些调度，但是总体的功能不变。

---

方法二

**对继承Serializable的JavaBean类进行序列化存储：

public static <T extends Serializable> boolean saveSerializable(String path, String filename, T obj) {
   /***首先判断是否有外部存储卡SD卡,接着此方法是将要存储的对象进行序列化存储，强制集成Serializable进行存储，同时也有会出现无法在进行外部存储时存储失败的情况，(大部分原因是因为读写SD卡的权限没有打开)在清单文件中配置好SD卡的读写权限即可*/
        if(!Environment.getExternalStorageState().equals("mounted")) {
            return false;
        } else {
            String root = Environment.getExternalStorageDirectory().getPath() + "/" + path;
            File file = new File(root);
            if(!file.exists() || !file.isDirectory()) {
                file.mkdirs();
            }
            if(!filename.startsWith("/")) {
                filename = "/" + filename;
            }

        file = new File(root + filename);
        if(!file.getParentFile().exists() && !file.getParentFile().mkdirs()) {
            return false;
        } else {
            ObjectOutputStream out = null;

            try {
                FileOutputStream e = new FileOutputStream(file);
                out = new ObjectOutputStream(e);
                out.writeObject(obj);
                out.flush();
                return true;
            } catch (FileNotFoundException var19) {
                LogCat.e("FeaturesUtils", "saveSerializable error", var19);
            } catch (IOException var20) {
                LogCat.e("FeaturesUtils", "saveSerializable error", var20);
            } catch (Exception var21) {
                LogCat.e("FeaturesUtils", "saveSerializable error", var21);
            } finally {
                if(out != null) {
                    try {
                        out.close();
                    } catch (Exception var18) {
                        ;
                    }
                }

            }

            return false;
        }
    }
}

//获取序列化数据代码示例:

     public static <T extends Serializable> T readSerializable(String filename, boolean needDelete) {
            if(!Environment.getExternalStorageState().equals("mounted")) {
                return null;
            } else {
                String root = Environment.getExternalStorageDirectory().getPath();
                if(!filename.startsWith("/")) {
                    filename = "/" + filename;
                }
        File file = new File(root + filename);
        if(!file.exists()) {
            return null;
        } else {
            ObjectInputStream oin = null;

            try {
                FileInputStream e = new FileInputStream(file);
                oin = new ObjectInputStream(e);
                Object tmp = oin.readObject();
                Serializable obj = (Serializable)tmp;
                Serializable var9 = obj;
                return var9;
            } catch (FileNotFoundException var17) {
                LogCat.e("FeaturesUtils", "readSerializable error", var17);
            } catch (OptionalDataException var18) {
                LogCat.e("FeaturesUtils", "readSerializable error", var18);
            } catch (ClassNotFoundException var19) {
                LogCat.e("FeaturesUtils", "readSerializable error", var19);
            } catch (IOException var20) {
                LogCat.e("FeaturesUtils", "readSerializable error", var20);
            } catch (ClassCastException var21) {
                LogCat.e("FeaturesUtils", "readSerializable error", var21);
            } catch (Exception var22) {
                LogCat.e("FeaturesUtils", "readSerializable error", var22);
            } finally {
                if(needDelete) {
                //如果读写完毕不需要改文件就删除
                    file.delete();
                }

            }

            return null;
        }
    }
}

//序列化本地存储代码示例:

public class DataCacheManager {
//实例化对象
 private static DataCacheManager dataCacheManager;
 //每次保存一个对象就需要在构造函数中进行书写一个保存的地址
 //缺点：序列化存储会在SD卡中每次都进行文件的创建，需要手动清楚文件
    private String bigCat;
    public DataCacheManager() {

    //在构造函数中初始化需要保存的对象的地址
       bigCat = "/_b_bigCat_data.dat";
    }

    public static synchronized DataCacheManager getInstance() {
    //初始化静态对象
        if (dataCacheManager == null) {
            dataCacheManager = new DataCacheManager();
        }
        return dataCacheManager;
    }
    /**
     *  进行序列化存储
     * @param mainBusList
       */
    public void saveBigCat(List<(需要存储的对象)> mainBusList) {
        if (isEmpty(mainBusList)) {
            return;
        }
        //将List数据保存在本地
       saveSerializable(bigCat, mainBusList);
    }
 /**
 * 获取序列化的数据
 */
public OpenList<(获取的对象)> getBigCat() {
    return readSerializable(bigCat,false);
}
//判断存储的List数据是否为空
    public static boolean isEmpty(List<?> list) {
    return list == null || list.size() == 0;
}
     }

总结：

在平时的存储中应该将两种存储方式进行结合使用,当涉及的是简单的字符串，boolean，int等简单类型进行存储的时候就可以用Sp进行存储，避免文件创建过多消耗内存。当进行对象存储的时候或者List<？>对象存储的时候使用序列化存储，当不需要的时候就进行文件的删除操作。