Android 数据存储知识梳理(3) SharedPreference 源码解析

时间  2019-11-21
标签 android 数据 存储 知识 梳理 sharedpreference 源码 解析 栏目 Android 繁體版
原文   原文链接

1、概述

SharedPreferences在开发当中常被用做保存一些相似于配置项这类轻量级的数据，它采用键值对的格式，将数据存储在xml文件当中，并保存在data/data/{应用包名}/shared_prefs下： bash

今天咱们就来一块儿研究一下 SP的实现原理。

2、SP 源码解析

2.1 获取 SharedPreferences 对象

在经过SP进行读写操做时，首先须要得到一个SharedPreferences对象，SharedPreferences是一个接口，它定义了系列读写的接口，其实现类为SharedPreferencesImpl、在实际过程当中，咱们通常经过Application、Activity、Service的下面这个方法来获取SP对象：app

public SharedPreferences getSharedPreferences(String name, int mode)
复制代码

来获取SharedPreferences实例，而它们最终都是调用到ContextImpl的getSharedPreferences方法，下面是整个调用的结构： 异步

在 ContextImpl当中， SharedPreferences是以一个静态双重 ArrayMap的结构来保存的： 

private static ArrayMap<String, ArrayMap<String, SharedPreferencesImpl>> sSharedPrefs;
复制代码

下面，咱们看一下获取SP实例的过程：函数

public SharedPreferences getSharedPreferences(String name, int mode) {
        SharedPreferencesImpl sp;
        synchronized (ContextImpl.class) {
            if (sSharedPrefs == null) {
                sSharedPrefs = new ArrayMap<String, ArrayMap<String, SharedPreferencesImpl>>();
            }
            //1.第一个维度是包名.
            final String packageName = getPackageName();
            ArrayMap<String, SharedPreferencesImpl> packagePrefs = sSharedPrefs.get(packageName);
            if (packagePrefs == null) {
                packagePrefs = new ArrayMap<String, SharedPreferencesImpl>();
                sSharedPrefs.put(packageName, packagePrefs);
            }
            //2.第二个维度就是调用get方法时传入的name，而且若是已经存在了那么直接返回
            sp = packagePrefs.get(name);
            if (sp == null) {
                File prefsFile = getSharedPrefsFile(name);
                sp = new SharedPreferencesImpl(prefsFile, mode);
                packagePrefs.put(name, sp);
                return sp;
            }
        }

        return sp;
    }
复制代码

在上面，咱们看到SharedPreferencesImpl的构造传入了一个和name相关联的File，它就是咱们在第一节当中所说的xml文件，在构造函数中，会去预先读取这个xml文件当中的内容：post

SharedPreferencesImpl(File file, int mode) {
        //..
        startLoadFromDisk(); //读取xml文件的内容
}
复制代码

这里启动了一个异步的线程，须要注意的是这里会将标志位mLoad置为false，后面咱们会谈到这个标志的做用：ui

private void startLoadFromDisk() {
        synchronized (this) {
            mLoaded = false;
        }
        new Thread("SharedPreferencesImpl-load") {
            public void run() {
                synchronized (SharedPreferencesImpl.this) {
                    loadFromDiskLocked();
                }
            }
        }.start();
    }
复制代码

在loadFromDiskLocked中，将xml文件中的内容保存到Map当中，在读取完毕以后，唤醒以前有可能阻塞的读写线程：this

private Map<String, Object> mMap;

    private void loadFromDiskLocked() {
        //1.若是已经在加载，那么返回.
        if (mLoaded) {
            return;
        }

        //...
        //2.最终保存到map当中
        map = XmlUtils.readMapXml(str);
        mMap = map;

        //...
        //3.因为读写操做只有在mLoaded变量为true时才可进行，所以它们有可能阻塞在调用读写操做的方法上，所以这里须要唤醒它们。
        notifyAll();
    }
复制代码

从SP对象的获取过程来看，咱们能够得出下面几个结论：spa

  • 与某个name所对应的SP对象须要等到调用getSharedPreferences才会被建立
  • 对于同一进程而言，在Activity/Application/Service获取SP对象时，若是name相同，它们实际上获取到的是同一个SP对象
  • 因为使用的是静态容器来保存，所以即便Activity/Service销毁了，它以前建立的SP对象也不会被释放，而SP中的数据又是用Map来保存的，也就是说，咱们只要调用了某个name相关联的getSharedPreferences方法，那么和该name对应的xml文件中的数据都会被读到内存当中，而且一直到进程被结束。

2.2 经过 SharedPreferences 进行读取操做

读取的操做很简单，它其实就是从之间预先读取的mMap当中去取出对应的数据，以getBoolean为例：线程

public boolean getBoolean(String key, boolean defValue) {
        synchronized (this) {
            awaitLoadedLocked();
            Boolean v = (Boolean)mMap.get(key);
            return v != null ? v : defValue;
        }
    }
复制代码

这里惟一须要关心的是awaitLoadedLocked方法：code

private void awaitLoadedLocked() {
        //这里若是判断没有加载完毕，那么会进入无限等待状态
        while (!mLoaded) {
            try {
                wait();
            } catch (InterruptedException unused) {}
        }
    }
复制代码

在这个方法中，会去检查mLoaded标志位是否为true，若是不为true，那么说明没有加载完毕，该线程会释放它所持有的锁，进入等待状态，直到loadFromDiskLocked加载完xml文件中的内容调用notifyAll()后，该线程才被唤醒。

从读取操做来看，咱们能够得出如下两个结论：

  • 任什么时候刻读取操做，读取的都是内存中的值，而并非xml文件的值。
  • 在调用读取方法时，若是构造函数中的预读取线程没有执行完毕，那么将会致使读取的线程进入等待状态。

2.3 经过 SharedPreferences 进行写入操做

2.3.1 获取 EditorImpl

当咱们须要经过SharedPreferences写入信息时，那么首先须要经过.edit()得到一个Editor对象，这里和读取操做相似，都是须要等到预加载的线程执行完毕：

public Editor edit() {
        synchronized (this) {
            awaitLoadedLocked();
        }
        return new EditorImpl();
    }
复制代码

Editor的实现类为EditorImpl，以putString为例：

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.put(key, value);
                return this;
            }
        }
   }
复制代码

由上面的代码能够看出，当咱们调用Editor的putXXX方法时，实际上并无保存到SP的mMap当中，而仅仅是保存到经过.edit()返回的EditorImpl的临时变量当中。

2.3.2 apply 和 commit 方法

咱们经过editor写入的数据，最终须要等到调用editor的apply和commit方法，才会写入到内存和xml这两个地方。

(a) apply

下面，咱们先看比较经常使用的apply方法：

public void apply() {
            //1.将修改操做提交到内存当中.
            final MemoryCommitResult mcr = commitToMemory();
           
            //2.写入文件当中
            SharedPreferencesImpl.this.enqueueDiskWrite(mcr, postWriteRunnable); //postWriteRunnable在写入文件完成后进行一些收尾操做.
            
            //3.只要写入到内存当中，就通知监听者.
            notifyListeners(mcr);
        }
复制代码

整个apply分为三个步骤：

  • 经过commitToMemory写入到内存中
  • 经过enqueueDiskWrite写入到磁盘中
  • 通知监听者

其中第一个步骤很好理解，就是根据editor中的内容，肯定哪些是须要更新的数据，而后把SP当中的mMap变量进行更新，以后将变化的内容封装成MemoryCommitResult结构体。

咱们主要看一下第二步，是如何写入磁盘当中的：

private void enqueueDiskWrite(final MemoryCommitResult mcr,
                                  final Runnable postWriteRunnable) {
        //1.写入磁盘任务的runnable.
        final Runnable writeToDiskRunnable = new Runnable() {
                public void run() {
                    //1.1 写入磁盘
                    synchronized (mWritingToDiskLock) {
                        writeToFile(mcr);
                    }
                    //....执行收尾操做.
                    if (postWriteRunnable != null) {
                        postWriteRunnable.run();
                    }
                }
            };
        
        //2.这里若是是经过apply方法调用过来的，那么为false
        final boolean isFromSyncCommit = (postWriteRunnable == null);

        if (isFromSyncCommit) { //apply 方法不走这里
                //...
                writeToDiskRunnable.run();
                return;
        }

        QueuedWork.singleThreadExecutor().execute(writeToDiskRunnable);
    }
复制代码

能够看出，若是调用apply方法，那么对于xml文件的写入是在异步线程当中进行的。

(b) commit

若是调用的commit方法，那么执行的是以下操做：

public boolean commit() {
            //1.写入内存
            MemoryCommitResult mcr = commitToMemory();
            //2.写入文件
            SharedPreferencesImpl.this.enqueueDiskWrite(mcr, null); //因为是同步进行，因此把收尾操做放到Runnable当中.
            //在这里执行收尾操做..
            //3.通知监听
            notifyListeners(mcr);
            return mcr.writeToDiskResult;
        }
复制代码

当使用commit方法时，和apply相似，都是三步操做，只不过第二步在写入文件的时候，传入的Runnable为null，所以，对于写入文件的操做是同步的，所以，若是咱们在主线程当中调用了commit方法，那么其实是在主线程进行IO操做。

(c) 回调时机

  • 对于apply方法，因为它对于文件的写入是异步的，可是notifyListener方法不会等到真正写入完成时才通知监听者，所以监听者在收到回调或者apply返回时，对于SP数据的改变只是写入到了内存当中，并无写入到文件当中。
  • 对于commit方法，因为它对于文件的写入是同步的，所以能够保证监听者收到回调时或者commit方法返回后，改变已经被写入到了文件当中。

2.4 监听 SP 的变化

若是但愿监听SP的变化，那么能够经过下面的这两个方法：

public void registerOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener listener) {
        synchronized(this) {
            mListeners.put(listener, mContent);
        }
    }

    public void unregisterOnSharedPreferenceChangeListener(OnSharedPreferenceChangeListener listener) {
        synchronized(this) {
            mListeners.remove(listener);
        }
    }
复制代码

因为对应于Name的SP在进程中是其实是一个单例模式，所以，咱们能够作到在进程中的任何地方改变SP的数据，都能收到监听。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程