深入解析 SharedPreferences

一. 概述

SharedPreferences 是Android中很常用的数据存储方式，SP 采用 key-value形式, 主要用于：

• 轻量级的数据存储, 尤其适合保存应用的配置参数
• 不建议使用SP 来存储大规模的数据, 可能会降低性能

SP 采用 xml 文件格式来保存数据, 该文件所在目录位于 /data/data//shared_prefs/

1.1 使用示例

SharedPreferences sharedPreferences = context.getSharedPreferences("gityuan", Context.MODE_PRIVATE);

Editor editor = sharedPreferences.edit();
editor.putString("blog", "www.gityuan.com");
editor.putInt("years", 3);
editor.commit();

生成的 gityuan.xml 文件内容如下：

<?xml version='1.0' encoding='utf-8' standalone='yes' ?>
<map>
   <string name="blog">"www.gityuan.com</string>
   <int name="years" value="3" />
</map>

1.2 架构图

SharedPreferences 与 Editor 只是两个接口. SharedPreferencesImpl 和 EditorImpl 分别实现了对应接口. 另外, ContextImpl 记录着 SharedPreferences 的重要数据, 如下:

• sSharedPrefsCache: 以包名为 key, 二级 key 是以 SP 文件, 以 SharedPreferencesImpl 为value的嵌套 map 结构. 这里需要 sSharedPrefsCache 是静态类成员变量, 每个进程是保存唯一一份, 且由 ContextImpl.class 锁保护.
• mSharedPrefsPaths: 记录所有的 SP 文件, 以文件名为 key, 具体文件为 value 的 map 结构;
• mPreferencesDir: 是指 SP 所在目录, 是指 /data/data//shared_prefs/
  

图解:

• putxxx()操作: 把数据写入到 EditorImpl.mModified;
• apply() 或者 commit() 操作:
  • 先调用 commitToMemory(), 将数据同步到 SharedPreferencesImpl 的 mMap, 并保存到 MemoryCommitResult 的 mapToWriteToDisk,
  • 再调用 enqueueDiskWrite(), 写入到磁盘文件; 先之前把原有数据保存到 .bak 为后缀的文件,用于在写磁盘的过程出现任何异常可恢复数据;
• getxxx() 操作: 从 SharedPreferencesImpl.mMap 读取数据.

二. SharedPreferences

2.1 获取方式

2.1.1 getPreferences

• -> Activity.java

public SharedPreferences getPreferences(int mode) {
    //[见下文]
    return getSharedPreferences(getLocalClassName(), mode);
}

Activity.getPreferences(mode): 以当前 Activity 的类名作为 SP 的文件名. 即 xxxActivity.xml

2.1.2 getDefaultSharedPreferences

• -> PreferenceManager.java

public static SharedPreferences getDefaultSharedPreferences(Context context) {
    //[见下文]
    return context.getSharedPreferences(getDefaultSharedPreferencesName(context),
           getDefaultSharedPreferencesMode());
}

PreferenceManager.getDefaultSharedPreferences(Context): 以包名加上 _preferences 作为文件名, 以 MODE_PRIVATE 模式创建 SP 文件. 即 packgeName_preferences.xml

2.1.3 getSharedPreferences

当然也可以直接调用 Context.getSharedPreferences(name, mode), 以上所有的方法最终都是调用到如下方法:

• -> ContextImpl.java

class ContextImpl extends Context {
    private ArrayMap<String, File> mSharedPrefsPaths;

    public SharedPreferences getSharedPreferences(String name, int mode) {
        File file;
        synchronized (ContextImpl.class) {
            if (mSharedPrefsPaths == null) {
                mSharedPrefsPaths = new ArrayMap<>();
            }
            //先从mSharedPrefsPaths查询是否存在相应文件
            file = mSharedPrefsPaths.get(name);
            if (file == null) {
                //如果文件不存在, 则创建新的文件 [见小节2.1.4]
                file = getSharedPreferencesPath(name);
                mSharedPrefsPaths.put(name, file);
            }
        }
        //[见小节2.2]
        return getSharedPreferences(file, mode);
    }
}

2.1.4 getSharedPreferencesPath

• -> ContextImpl.java

public File getSharedPreferencesPath(String name) {
    return makeFilename(getPreferencesDir(), name + ".xml");
}

private File getPreferencesDir() {
    synchronized (mSync) {
        if (mPreferencesDir == null) {
            //创建目录/data/data/package name/shared_prefs/
            mPreferencesDir = new File(getDataDir(), "shared_prefs");
        }
        return ensurePrivateDirExists(mPreferencesDir);
    }
}

流程说明:

• 先从 mSharedPrefsPaths 查询是否存在相应文件;
• 如果文件不存在, 则创建新的 xml 文件; 如果目录也不存在, 则先创建目录创建目录 /data/data/package name/shared_prefs/
• 其中 mSharedPrefsPaths 用于记录所有的 SP 文件, 是以文件名为 key 的 Map数据结构

2.2 getSharedPreferences

• ContextImpl.java

public SharedPreferences getSharedPreferences(File file, int mode) {
    checkMode(mode); //[见小节2.2.1]
    SharedPreferencesImpl sp;
    synchronized (ContextImpl.class) {
        //[见小节2.2.2]
        final ArrayMap<File, SharedPreferencesImpl> cache = getSharedPreferencesCacheLocked();
        sp = cache.get(file);
        if (sp == null) {
            //创建SharedPreferencesImpl[见小节2.3]
            sp = new SharedPreferencesImpl(file, mode);
            cache.put(file, sp);
            return sp;
        }
    }

    //指定多进程模式, 则当文件被其他进程改变时,则会重新加载
    if ((mode & Context.MODE_MULTI_PROCESS) != 0 ||
        getApplicationInfo().targetSdkVersion < android.os.Build.VERSION_CODES.HONEYCOMB) {
        sp.startReloadIfChangedUnexpectedly();
    }
    return sp;
}

2.2.1 checkMode

• -> ContextImpl.java

private void checkMode(int mode) {
    if (getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.N) {
        if ((mode & MODE_WORLD_READABLE) != 0) {
            throw new SecurityException("MODE_WORLD_READABLE no longer supported");
        }
        if ((mode & MODE_WORLD_WRITEABLE) != 0) {
            throw new SecurityException("MODE_WORLD_WRITEABLE no longer supported");
        }
    }
}

从Android N开始, 创建的 SP 文件模式, 不允许 MODE_WORLD_READABLE 和MODE_WORLD_WRITEABLE 模块, 否则会直接抛出异常 SecurityException. 另外, 顺带说一下MODE_MULTI_PROCESS 这种多进程的方式也是 Google 不推荐的方式, 后续同样会不再支持, 强烈建议 App 不用使用该方式来实现多个进程实现 同一个 SP 文件.

当设置 MODE_MULTI_PROCESS模式, 则每次 getSharedPreferences 过程, 会检查SP文件上次修改时间和文件大小, 一旦所有修改则会重新从磁盘加载文件.

2.2.2 getSharedPreferencesCacheLocked

• -> ContextImpl.java

private ArrayMap<File, SharedPreferencesImpl> getSharedPreferencesCacheLocked() {
    if (sSharedPrefsCache == null) {
        sSharedPrefsCache = new ArrayMap<>();
    }

    final String packageName = getPackageName();
    ArrayMap<File, SharedPreferencesImpl> packagePrefs = sSharedPrefsCache.get(packageName);
    if (packagePrefs == null) {
        packagePrefs = new ArrayMap<>();
        sSharedPrefsCache.put(packageName, packagePrefs);
    }
    return packagePrefs;
}

2.3 SharedPreferencesImpl初始化

• -> SharedPreferencesImpl.java

SharedPreferencesImpl(File file, int mode) {
    mFile = file;
    //创建为.bak为后缀的备份文件
    mBackupFile = makeBackupFile(file);
    mMode = mode;
    mLoaded = false;
    mMap = null;
    startLoadFromDisk(); //[见小节2.3.1]
}

同名的 .bak 备份文件用于发生异常时, 可通过备份文件来恢复数据.

2.3.1 startLoadFromDisk

• -> SharedPreferencesImpl.java

private void startLoadFromDisk() {
    synchronized (this) {
        mLoaded = false;
    }
    new Thread("SharedPreferencesImpl-load") {
        public void run() {
            loadFromDisk(); //[见小节2.3.2]
        }
    }.start();
}

mLoaded 用于标记 SP 文件已加载到内存. 创建线程去实现从磁盘加载 sp 文件的工作.

2.3.2 loadFromDisk

• -> SharedPreferencesImpl.java

private void loadFromDisk() {
    synchronized (SharedPreferencesImpl.this) {
        if (mLoaded) {
            return;
        }
        if (mBackupFile.exists()) {
            mFile.delete();
            mBackupFile.renameTo(mFile);
        }
    }

    Map map = null;
    StructStat stat = null;
    try {
        stat = Os.stat(mFile.getPath());
        if (mFile.canRead()) {
            BufferedInputStream str = null;
            try {
                str = new BufferedInputStream(new FileInputStream(mFile), 16*1024);
                map = XmlUtils.readMapXml(str);
            } catch (XmlPullParserException | IOException e) {
                ...
            } finally {
                IoUtils.closeQuietly(str);
            }
        }
    } catch (ErrnoException e) {
        ...
    }

    synchronized (SharedPreferencesImpl.this) {
        mLoaded = true;
        if (map != null) {
            mMap = map; //从文件读取的信息保存到mMap
            mStatTimestamp = stat.st_mtime; //更新修改时间
            mStatSize = stat.st_size; //更新文件大小
        } else {
            mMap = new HashMap<>();
        }
        notifyAll(); //唤醒处于等待状态的线程
    }
}

整个获取 SharedPreferences 简单总结:

• 首次使用则创建相应 xml 文件;
• 异步加载文件内容到内存; 此时执行 getXXX() 和 setxxx() 以及 edit()方法都是阻塞等待的, 直到文件数据全部加载到内存;
• 一旦完全加载到内存, 后续的 getXXX() 则是直接访问内存.

2.4 查询数据

2.4.1 getString

• -> SharedPreferencesImpl.java

public String getString(String key, @Nullable String defValue) {
    synchronized (this) {
        //检查是否加载完成[见小节2.4.2]
        awaitLoadedLocked();
        String v = (String)mMap.get(key);
        return v != null ? v : defValue;
    }
}

• 当 loadFromDisk 没有执行完成, 则会阻塞查询操作;
• 当数据加载完成, 则直接从 mMap 来查询相应数据;

2.4.2 awaitLoadedLocked

• -> SharedPreferencesImpl.java

private void awaitLoadedLocked() {
    if (!mLoaded) {
        BlockGuard.getThreadPolicy().onReadFromDisk();
    }
    while (!mLoaded) {
        try {
            wait(); //当没有加载完成,则进入等待状态
        } catch (InterruptedException unused) {
        }
    }
}

三. Editor

3.1　edit

• -> SharedPreferencesImpl.java

public Editor edit() {
    synchronized (this) {
        awaitLoadedLocked(); //[见小节2.4.2]
    }

    return new EditorImpl(); //创建EditorImpl
}

该过程同样要等待 awaitLoadedLocked 完成, 然后创建 EditorImpl 对象. 而 EditorImpl 作为SharedPreferencesImpl 的内部类,其继承于 Editor 类

3.2 EditorImpl

• -> SharedPreferencesImpl.java::　EditorImpl

public final class EditorImpl implements Editor {
    private final Map<String, Object> mModified = Maps.newHashMap();
    private boolean mClear = false;

    //插入数据
    public Editor putString(String key, @Nullable String value) {
        synchronized (this) {
            //插入数据, 先暂存到mModified对象
            mModified.put(key, value);
            return this;
        }
    }
    //移除数据
    public Editor remove(String key) {
        synchronized (this) {
            mModified.put(key, this);
            return this;
        }
    }

    //清空全部数据
    public Editor clear() {
        synchronized (this) {
            mClear = true;
            return this;
        }
    }
}

从这里可以看出, 这些数据修改操作仅仅是修改 mModified 和 mClear. 直到数据提交 commit 或许 apply 过程, 才会真正的把数据更新到 SharedPreferencesImpl.

四. 数据提交

这里重点来说说数据提交的两个重要方法 commit() 和 apply()

4.1 commit

• -> SharedPreferencesImpl.java::　EditorImpl

public boolean commit() {
    //将数据更新到内存[见小节4.2]
    MemoryCommitResult mcr = commitToMemory();
    //将内存数据同步到文件[见小节4.3]
    SharedPreferencesImpl.this.enqueueDiskWrite(mcr, null);
    try {
        //进入等待状态, 直到写入文件的操作完成
        mcr.writtenToDiskLatch.await();
    } catch (InterruptedException e) {
        return false;
    }
    //通知监听则, 并在主线程回调onSharedPreferenceChanged()方法
    notifyListeners(mcr);
    // 返回文件操作的结果数据
    return mcr.writeToDiskResult;
}

4.2 commitToMemory

• -> SharedPreferencesImpl.java::　EditorImpl

private MemoryCommitResult commitToMemory() {
    MemoryCommitResult mcr = new MemoryCommitResult();
    synchronized (SharedPreferencesImpl.this) {
        if (mDiskWritesInFlight > 0) {
            mMap = new HashMap<String, Object>(mMap);
        }
        mcr.mapToWriteToDisk = mMap;
        mDiskWritesInFlight++;

        //是否有监听key改变的监听者
        boolean hasListeners = mListeners.size() > 0;
        if (hasListeners) {
            mcr.keysModified = new ArrayList<String>();
            mcr.listeners = new HashSet<OnSharedPreferenceChangeListener>(mListeners.keySet());
        }

        synchronized (this) {
            //当mClear为true, 则直接清空mMap
            if (mClear) {
                if (!mMap.isEmpty()) {
                    mcr.changesMade = true;
                    mMap.clear();
                }
                mClear = false;
            }

            for (Map.Entry<String, Object> e : mModified.entrySet()) {
                String k = e.getKey();
                Object v = e.getValue();
                //注意此处的this是个特殊值, 用于移除相应的key操作.
                if (v == this || v == null) {
                    if (!mMap.containsKey(k)) {
                        continue;
                    }
                    mMap.remove(k);
                } else {
                    if (mMap.containsKey(k)) {
                        Object existingValue = mMap.get(k);
                        if (existingValue != null && existingValue.equals(v)) {
                            continue;
                        }
                    }
                    mMap.put(k, v);
                }

                mcr.changesMade = true; // changesMade代表数据是否有改变
                if (hasListeners) {
                    mcr.keysModified.add(k); //记录发生改变的key
                }
            }
            mModified.clear(); //清空EditorImpl中的mModified数据
        }
    }
    return mcr;
}

该方法的主要功能: 把 EditorImpl数据更新到 SPI

• 将 mMap 信息赋值给 mapToWriteToDisk, 并 mDiskWritesInFlight 加 1;
• 当 mClear 为 true, 则直接清空 mMap;
• 当 value 值为 this 或 null, 则移除相应的 key;
• 当 value 值发生改变, 则会更新到 mMap;
• 只要有 key/value 发生改变(新增, 删除), 则设置 mcr.changesMade = true. 最后会清空EditorImpl 中的 mModified数据

4.3 enqueueDiskWrite

• -> SharedPreferencesImpl.java

private void enqueueDiskWrite(final MemoryCommitResult mcr, final Runnable postWriteRunnable) {
    final Runnable writeToDiskRunnable = new Runnable() {
            public void run() {
                synchronized (mWritingToDiskLock) {
                    //执行文件写入操作[见小节4.3.1]
                    writeToFile(mcr);
                }
                synchronized (SharedPreferencesImpl.this) {
                    mDiskWritesInFlight--;
                }
                //此时postWriteRunnable为null不执行该方法
                if (postWriteRunnable != null) {
                    postWriteRunnable.run();
                }
            }
        };

    final boolean isFromSyncCommit = (postWriteRunnable == null);

    if (isFromSyncCommit) { //commit方法会进入该分支
        boolean wasEmpty = false;
        synchronized (SharedPreferencesImpl.this) {
            //commitToMemory过程会加1,则wasEmpty=true
            wasEmpty = mDiskWritesInFlight == 1;
        }
        if (wasEmpty) {
            //跳转到上面
            writeToDiskRunnable.run();
            return;
        }
    }
    //不执行该方法
    QueuedWork.singleThreadExecutor().execute(writeToDiskRunnable);
}

4.3.1 writeToFile

private void writeToFile(MemoryCommitResult mcr) {
    if (mFile.exists()) {
        if (!mcr.changesMade) { //没有key发生改变, 则直接返回
            mcr.setDiskWriteResult(true);
            return;
        }
        if (!mBackupFile.exists()) {
            //当备份文件不存在, 则把mFile重命名为备份文件
            if (!mFile.renameTo(mBackupFile)) {
                mcr.setDiskWriteResult(false);
                return;
            }
        } else {
            mFile.delete(); //否则,直接删除mFile
        }
    }

    try {
        FileOutputStream str = createFileOutputStream(mFile);
        if (str == null) {
            mcr.setDiskWriteResult(false);
            return;
        }
        //将mMap全部信息写入文件
        XmlUtils.writeMapXml(mcr.mapToWriteToDisk, str);
        FileUtils.sync(str);
        str.close();
        ContextImpl.setFilePermissionsFromMode(mFile.getPath(), mMode, 0);
        try {
            final StructStat stat = Os.stat(mFile.getPath());
            synchronized (this) {
                mStatTimestamp = stat.st_mtime;
                mStatSize = stat.st_size;
            }
        } catch (ErrnoException e) {
            ...
        }
        //写入成功, 则删除备份文件
        mBackupFile.delete();
        //返回写入成功, 唤醒等待线程
        mcr.setDiskWriteResult(true);
        return;
    } catch (XmlPullParserException e) {
        ...
    } catch (IOException e) {
        ...
    }
    //如果写入文件的操作失败, 则删除未成功写入的文件
    if (mFile.exists()) {
        if (!mFile.delete()) {
            ...
        }
    }
    //返回写入失败, 唤醒等待线程
    mcr.setDiskWriteResult(false);
}

该方法的主要功能:

• 当没有 key 发生改变, 则直接返回; 否则执行 step2;
• 将 mMap 全部信息写入文件, 如果写入成功则删除备份文件,如果写入失败则删除 mFile.

可见, 每次 commit 是把全部数据更新到文件, 所以每个文件的数据量必须保证足够精简. 再来看看 apply 过程

4.4 apply

• -> SharedPreferencesImpl.java::　EditorImpl

public void apply() {
    //把数据更新到内存[见小节4.2]
    final MemoryCommitResult mcr = commitToMemory();
    final Runnable awaitCommit = new Runnable() {
            public void run() {
                try {
                    //进入等待状态
                    mcr.writtenToDiskLatch.await();
                } catch (InterruptedException ignored) {
                }
            }
        };

    //将awaitCommit添加到QueuedWork
    QueuedWork.add(awaitCommit);

    Runnable postWriteRunnable = new Runnable() {
            public void run() {
                awaitCommit.run();
                //从QueuedWork移除
                QueuedWork.remove(awaitCommit);
            }
        };

    //[见小节4.4.1]
    SharedPreferencesImpl.this.enqueueDiskWrite(mcr, postWriteRunnable);
    notifyListeners(mcr);
}

4.4.1 enqueueDiskWrite

• -> SharedPreferencesImpl.java

private void enqueueDiskWrite(final MemoryCommitResult mcr, final Runnable postWriteRunnable) {
    final Runnable writeToDiskRunnable = new Runnable() {
            public void run() {
                synchronized (mWritingToDiskLock) {
                    //执行文件写入操作[见小节4.3.1]
                    writeToFile(mcr);
                }
                synchronized (SharedPreferencesImpl.this) {
                    mDiskWritesInFlight--;
                }

                if (postWriteRunnable != null) {
                    postWriteRunnable.run();
                }
            }
        };

    final boolean isFromSyncCommit = (postWriteRunnable == null);
    if (isFromSyncCommit) {
        ... //postWriteRunnable不为空
    }
    //将任务放入单线程的线程池来执行
    QueuedWork.singleThreadExecutor().execute(writeToDiskRunnable);
}

4.4.2 QueuedWork

• -> QueuedWork.java

public class QueuedWork {

    private static final ConcurrentLinkedQueue<Runnable> sPendingWorkFinishers =
       new ConcurrentLinkedQueue<Runnable>();

    public static void add(Runnable finisher) {
        sPendingWorkFinishers.add(finisher);
    }

    public static void remove(Runnable finisher) {
        sPendingWorkFinishers.remove(finisher);
    }

    public static void waitToFinish() {
        Runnable toFinish;
        while ((toFinish = sPendingWorkFinishers.poll()) != null) {
            toFinish.run();
        }
    }

    public static boolean hasPendingWork() {
        return !sPendingWorkFinishers.isEmpty();
    }
}

可见, apply 跟 commit 的最大区别 在于 apply 的写入文件操作是在单线程的线程池来完成.

• apply 方法开始的时候, 会把 awaitCommit 放入 QueuedWork;
• 文件写入操作完成, 则会把相应的 awaitCommit 从 QueuedWork 中移除.

QueuedWork 在这里存在的价值主要是用于在 Stop Service, finish BroadcastReceiver 过程用于 判定是否处理完所有的异步 SP操作.

五. 总结

apply 与commit的对比

• apply 没有返回值, commit 有返回值能知道修改是否提交成功
• apply 是将修改提交到内存，再异步提交到磁盘文件; commit是同步的提交到磁盘文件;
• 多并发的提交 commit时，需等待正在处理的 commit数据更新到磁盘文件后才会继续往下执行，从而降低效率; 而apply只是原子更新到内存，后调用 apply函数会直接覆盖前面内存数据，从一定程度上提高很多效率。

获取SP与Editor:

• getSharedPreferences() 是从 ContextImpl.sSharedPrefsCache 唯一的 SPI 对象;
• edit() 每次都是创建新的 EditorImpl 对象.

优化建议:

• 强烈建议不要在 sp 里面存储特别大的 key/value, 有助于减少 卡顿/anr
• 请不要高频地使用 apply, 尽可能地批量提交; commit直接在主线程操作, 更要注意了
• 不要使用 MODE_MULTI_PROCESS;
• 高频写操作的 key 与高频读操作的 key 可以适当地拆分文件, 用于减少同步锁竞争;
• 不要一上来就执行 getSharedPreferences().edit(), 应该分成两大步骤来做, 中间可以执行其他代码.
• 不要连续多次 edit(), 应该获取一次获取 edit(),然后多次执行 putxxx(), 减少内存波动; 经常看到大家喜欢封装方法, 结果就导致这种情况的出现.
• 每次 commit 时会把全部的数据更新的文件, 所以整个文件是不应该过大的, 影响整体性能;

6. SPUtils 封装代码示例

package com.packagename;

import android.content.Context;
import android.content.SharedPreferences;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Map;

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();
        }
    }

}