SharedPreference的封装

转载 2017年01月03日 16:12:40

转载请标明出处:http://blog.csdn.net/changsimeng/article/details/53994654,本文出自:【changsimeng的博客】

对SharedPreference的使用做了建议的封装,对外公布出put,get,remove,clear等等方法;

注意一点,里面所有的commit操作使用了SharedPreferencesCompat.apply进行了替代,目的是尽可能的使用apply代替commit

首先说下为什么,因为commit方法是同步的,并且我们很多时候的commit操作都是UI线程中,毕竟是IO操作,尽可能异步;

所以我们使用apply进行替代,apply异步的进行写入;

但是apply相当于commit来说是new API呢,为了更好的兼容,我们做了适配;

SharedPreferencesCompat也可以给大家创建兼容类提供了一定的参考~~
  1.  import java.lang.reflect.InvocationTargetException;    
  2. import java.lang.reflect.Method;    
  3. import java.util.Map;    
  4.     
  5. import android.content.Context;    
  6. import android.content.SharedPreferences;    
  7.     
  8. public class SPUtils    
  9. {    
  10.     /**  
  11.      * 保存在手机里面的文件名  
  12.      */    
  13.     public static final String FILE_NAME = “share_data”;    
  14.     
  15.     /**  
  16.      * 保存数据的方法,我们需要拿到保存数据的具体类型,然后根据类型调用不同的保存方法  
  17.      *   
  18.      * @param context  
  19.      * @param key  
  20.      * @param object  
  21.      */    
  22.     public static void put(Context context, String key, Object object)    
  23.     {    
  24.     
  25.         SharedPreferences sp = context.getSharedPreferences(FILE_NAME,    
  26.                 Context.MODE_PRIVATE);    
  27.         SharedPreferences.Editor editor = sp.edit();    
  28.     
  29.         if (object instanceof String)    
  30.         {    
  31.             editor.putString(key, (String) object);    
  32.         } else if (object instanceof Integer)    
  33.         {    
  34.             editor.putInt(key, (Integer) object);    
  35.         } else if (object instanceof Boolean)    
  36.         {    
  37.             editor.putBoolean(key, (Boolean) object);    
  38.         } else if (object instanceof Float)    
  39.         {    
  40.             editor.putFloat(key, (Float) object);    
  41.         } else if (object instanceof Long)    
  42.         {    
  43.             editor.putLong(key, (Long) object);    
  44.         } else    
  45.         {    
  46.             editor.putString(key, object.toString());    
  47.         }    
  48.     
  49.         SharedPreferencesCompat.apply(editor);    
  50.     }    
  51.     
  52.     /**  
  53.      * 得到保存数据的方法,我们根据默认值得到保存的数据的具体类型,然后调用相对于的方法获取值  
  54.      *   
  55.      * @param context  
  56.      * @param key  
  57.      * @param defaultObject  
  58.      * @return  
  59.      */    
  60.     public static Object get(Context context, String key, Object defaultObject)    
  61.     {    
  62.         SharedPreferences sp = context.getSharedPreferences(FILE_NAME,    
  63.                 Context.MODE_PRIVATE);    
  64.     
  65.         if (defaultObject instanceof String)    
  66.         {    
  67.             return sp.getString(key, (String) defaultObject);    
  68.         } else if (defaultObject instanceof Integer)    
  69.         {    
  70.             return sp.getInt(key, (Integer) defaultObject);    
  71.         } else if (defaultObject instanceof Boolean)    
  72.         {    
  73.             return sp.getBoolean(key, (Boolean) defaultObject);    
  74.         } else if (defaultObject instanceof Float)    
  75.         {    
  76.             return sp.getFloat(key, (Float) defaultObject);    
  77.         } else if (defaultObject instanceof Long)    
  78.         {    
  79.             return sp.getLong(key, (Long) defaultObject);    
  80.         }    
  81.     
  82.         return null;    
  83.     }    
  84.     
  85.     /**  
  86.      * 移除某个key值已经对应的值  
  87.      * @param context  
  88.      * @param key  
  89.      */    
  90.     public static void remove(Context context, String key)    
  91.     {    
  92.         SharedPreferences sp = context.getSharedPreferences(FILE_NAME,    
  93.                 Context.MODE_PRIVATE);    
  94.         SharedPreferences.Editor editor = sp.edit();    
  95.         editor.remove(key);    
  96.         SharedPreferencesCompat.apply(editor);    
  97.     }    
  98.     
  99.     /**  
  100.      * 清除所有数据  
  101.      * @param context  
  102.      */    
  103.     public static void clear(Context context)    
  104.     {    
  105.         SharedPreferences sp = context.getSharedPreferences(FILE_NAME,    
  106.                 Context.MODE_PRIVATE);    
  107.         SharedPreferences.Editor editor = sp.edit();    
  108.         editor.clear();    
  109.         SharedPreferencesCompat.apply(editor);    
  110.     }    
  111.     
  112.     /**  
  113.      * 查询某个key是否已经存在  
  114.      * @param context  
  115.      * @param key  
  116.      * @return  
  117.      */    
  118.     public static boolean contains(Context context, String key)    
  119.     {    
  120.         SharedPreferences sp = context.getSharedPreferences(FILE_NAME,    
  121.                 Context.MODE_PRIVATE);    
  122.         return sp.contains(key);    
  123.     }    
  124.     
  125.     /**  
  126.      * 返回所有的键值对  
  127.      *   
  128.      * @param context  
  129.      * @return  
  130.      */    
  131.     public static Map<String, ?> getAll(Context context)    
  132.     {    
  133.         SharedPreferences sp = context.getSharedPreferences(FILE_NAME,    
  134.                 Context.MODE_PRIVATE);    
  135.         return sp.getAll();    
  136.     }    
  137.     
  138.     /**  
  139.      * 创建一个解决SharedPreferencesCompat.apply方法的一个兼容类  
  140.      *   
  141.      * @author zhy  
  142.      *   
  143.      */    
  144.     private static class SharedPreferencesCompat    
  145.     {    
  146.         private static final Method sApplyMethod = findApplyMethod();    
  147.     
  148.         /**  
  149.          * 反射查找apply的方法  
  150.          *   
  151.          * @return  
  152.          */    
  153.         @SuppressWarnings({ “unchecked”“rawtypes” })    
  154.         private static Method findApplyMethod()    
  155.         {    
  156.             try    
  157.             {    
  158.                 Class clz = SharedPreferences.Editor.class;    
  159.                 return clz.getMethod(“apply”);    
  160.             } catch (NoSuchMethodException e)    
  161.             {    
  162.             }    
  163.     
  164.             return null;    
  165.         }    
  166.     
  167.         /**  
  168.          * 如果找到则使用apply执行,否则使用commit  
  169.          *   
  170.          * @param editor  
  171.          */    
  172.         public static void apply(SharedPreferences.Editor editor)    
  173.         {    
  174.             try    
  175.             {    
  176.                 if (sApplyMethod != null)    
  177.                 {    
  178.                     sApplyMethod.invoke(editor);    
  179.                     return;    
  180.                 }    
  181.             } catch (IllegalArgumentException e)    
  182.             {    
  183.             } catch (IllegalAccessException e)    
  184.             {    
  185.             } catch (InvocationTargetException e)    
  186.             {    
  187.             }    
  188.             editor.commit();    
  189.         }    
  190.     }    
  191.     
  192. }    
 import java.lang.reflect.InvocationTargetException;  
import java.lang.reflect.Method;  
import java.util.Map;  

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

public class SPUtils  
{  
    /** 
     * 保存在手机里面的文件名 
     */  
    public static final String FILE_NAME = "share_data";  

    /** 
     * 保存数据的方法,我们需要拿到保存数据的具体类型,然后根据类型调用不同的保存方法 
     *  
     * @param context 
     * @param key 
     * @param object 
     */  
    public static void put(Context context, String key, Object object)  
    {  

        SharedPreferences sp = context.getSharedPreferences(FILE_NAME,  
                Context.MODE_PRIVATE);  
        SharedPreferences.Editor editor = sp.edit();  

        if (object instanceof String)  
        {  
            editor.putString(key, (String) object);  
        } else if (object instanceof Integer)  
        {  
            editor.putInt(key, (Integer) object);  
        } else if (object instanceof Boolean)  
        {  
            editor.putBoolean(key, (Boolean) object);  
        } else if (object instanceof Float)  
        {  
            editor.putFloat(key, (Float) object);  
        } else if (object instanceof Long)  
        {  
            editor.putLong(key, (Long) object);  
        } else  
        {  
            editor.putString(key, object.toString());  
        }  

        SharedPreferencesCompat.apply(editor);  
    }  

    /** 
     * 得到保存数据的方法,我们根据默认值得到保存的数据的具体类型,然后调用相对于的方法获取值 
     *  
     * @param context 
     * @param key 
     * @param defaultObject 
     * @return 
     */  
    public static Object get(Context context, String key, Object defaultObject)  
    {  
        SharedPreferences sp = context.getSharedPreferences(FILE_NAME,  
                Context.MODE_PRIVATE);  

        if (defaultObject instanceof String)  
        {  
            return sp.getString(key, (String) defaultObject);  
        } else if (defaultObject instanceof Integer)  
        {  
            return sp.getInt(key, (Integer) defaultObject);  
        } else if (defaultObject instanceof Boolean)  
        {  
            return sp.getBoolean(key, (Boolean) defaultObject);  
        } else if (defaultObject instanceof Float)  
        {  
            return sp.getFloat(key, (Float) defaultObject);  
        } else if (defaultObject instanceof Long)  
        {  
            return sp.getLong(key, (Long) defaultObject);  
        }  

        return null;  
    }  

    /** 
     * 移除某个key值已经对应的值 
     * @param context 
     * @param key 
     */  
    public static void remove(Context context, String key)  
    {  
        SharedPreferences sp = context.getSharedPreferences(FILE_NAME,  
                Context.MODE_PRIVATE);  
        SharedPreferences.Editor editor = sp.edit();  
        editor.remove(key);  
        SharedPreferencesCompat.apply(editor);  
    }  

    /** 
     * 清除所有数据 
     * @param context 
     */  
    public static void clear(Context context)  
    {  
        SharedPreferences sp = context.getSharedPreferences(FILE_NAME,  
                Context.MODE_PRIVATE);  
        SharedPreferences.Editor editor = sp.edit();  
        editor.clear();  
        SharedPreferencesCompat.apply(editor);  
    }  

    /** 
     * 查询某个key是否已经存在 
     * @param context 
     * @param key 
     * @return 
     */  
    public static boolean contains(Context context, String key)  
    {  
        SharedPreferences sp = context.getSharedPreferences(FILE_NAME,  
                Context.MODE_PRIVATE);  
        return sp.contains(key);  
    }  

    /** 
     * 返回所有的键值对 
     *  
     * @param context 
     * @return 
     */  
    public static Map<String, ?> getAll(Context context)  
    {  
        SharedPreferences sp = context.getSharedPreferences(FILE_NAME,  
                Context.MODE_PRIVATE);  
        return sp.getAll();  
    }  

    /** 
     * 创建一个解决SharedPreferencesCompat.apply方法的一个兼容类 
     *  
     * @author zhy 
     *  
     */  
    private static class SharedPreferencesCompat  
    {  
        private static final Method sApplyMethod = findApplyMethod();  

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

            return null;  
        }  

        /** 
         * 如果找到则使用apply执行,否则使用commit 
         *  
         * @param editor 
         */  
        public static void apply(SharedPreferences.Editor editor)  
        {  
            try  
            {  
                if (sApplyMethod != null)  
                {  
                    sApplyMethod.invoke(editor);  
                    return;  
                }  
            } catch (IllegalArgumentException e)  
            {  
            } catch (IllegalAccessException e)  
            {  
            } catch (InvocationTargetException e)  
            {  
            }  
            editor.commit();  
        }  
    }  

}  

Android笔记:SharedPreference封装常用的工具类(用于记住密码、自动登录、引导页、账号密码等)

SharePreference 数据库 File 存储 sqlite android 存储 封装 工具类 记住密码 自动登录 引导页 账号密码...

SharedPreference的封装

public class SPUtils { /** * 保存在手机里面的文件名 */ public static final String FIL...

android SharedPreference封装为工具类

import android.content.Context; import android.content.SharedPreferences;public class SharedPreferen...

SharedPreference

  • 2015年02月10日 14:51
  • 1012KB
  • 下载

一个null引发的SharedPreference惨案

序本周在安卓博客周刊里看到了一篇请不要滥用SharedPreference,感觉颇有收获。而我恰好在这周碰到了一个关于SharedPreference的bug,让我费了一番功夫才找出,所以在这里就写一...

sharedpreference使用demo源代码

  • 2014年02月09日 00:02
  • 1.37MB
  • 下载

SharedPreference文件操作代码例子

  • 2016年03月31日 11:18
  • 2.64MB
  • 下载

android SharedPreference的简单使用(登陆界面记住密码)

SharedPreference方面的内容还算是比较简单易懂的,在此还是主要贴上效果与代码,最后也是附上源码。 首先是输入账号admin,密码123,选择记住密码登陆。 登陆后就直接跳转页...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:SharedPreference的封装
举报原因:
原因补充:

(最多只允许输入30个字)