Java Android SharedReferences最佳实践

在我一直在构建的一个应用程序中，我们非常依赖SharedReferences，这让我想到了访问SharedReferences的最佳实践是什么。例如，许多人说，访问它的适当方式是通过以下电话：

PreferenceManager.getDefaultSharedPreferences(Context context)

然而，这似乎是危险的。如果您有一个依赖SharedReference的大型应用程序，则可能会有密钥复制，尤其是在使用依赖SharedReference的第三方库的情况下。在我看来，更好的使用方法是：

Context.getSharedPreferences(String name, int mode)

这样，如果您有一个严重依赖SharedReferences的类，您可以创建一个仅由您的类使用的首选项文件。您可以使用类的完全限定名来确保文件很可能不会被其他人复制

同样基于这个SO问题，访问SharedReferences似乎应该在UI线程之外完成，这是有意义的

在应用程序中使用SharedReference时，Android开发人员还应该注意其他最佳实践吗？

这是我的方式

写

SharedPreferences settings = context.getSharedPreferences("prefs", 0);
SharedPreferences.Editor editore = settings.edit();
editore.putString("key", "some value");
editore.apply();

阅读

SharedPreferences settings = getSharedPreferences("prefs", 0);
Strings value = settings.getString("key", "");

如果您有一个依赖SharedReference的大型应用程序，则可能会有密钥复制，尤其是在使用依赖SharedReference的第三方库的情况下

库不应使用特定的

SharedReferences

。默认的

SharedReferences

只能由应用程序使用

这样，如果您有一个严重依赖SharedReferences的类，您可以创建一个仅由您的类使用的首选项文件

当然欢迎你这样做。在应用程序级别，我不会这样做，因为

SharedReferences

的主要原因是在应用程序中的组件之间共享它们。开发团队在管理这个名称空间时应该没有问题，就像他们在管理类、包、资源或其他项目级内容的名称时应该没有问题一样。此外，默认的

SharedReferences

是您的

PreferenceActivity

将使用的

但是，回到您的库的观点，可重用库应该只对其库使用单独的

SharedReferences

。我不会把它建立在类名的基础上，因为那样的话，你就离破坏你的应用程序只有一步之遥了。相反，选择一个唯一但稳定的名称（例如，基于库名称，例如

“com.commonware.cwac.wakeful.WakefulIntentService”

）

似乎访问SharedReference应该在UI线程之外完成，这是有意义的

理想情况下，是的。我最近发布了一个帮助解决这个问题的

在应用程序中使用SharedReference时，Android开发人员是否还应该了解其他最佳实践

---

不要过分依赖他们。它们存储在XML文件中，不是事务性的。数据库应该是您的主要数据存储，特别是对于您确实不想丢失的数据。

我写了一篇文章，也可以找到。它描述了什么是

SharedReferences

：

最佳实践：共享参考 Android提供了许多存储应用程序数据的方法。其中一种方法将我们引向SharedReferences对象，该对象用于以键值对存储私有原语数据

所有逻辑仅基于三个简单类：

共享引用

SharedReferences

是其中的主要内容。它负责获取（解析）存储的数据，提供获取

编辑器

对象的接口，以及添加和删除

OnSharedPreferenceChangeListener

• 要创建

  SharedReferences

  ，您需要

  上下文

  对象（可以是应用程序

  上下文

  ）

• getSharedReferences

  方法解析首选项文件并为其创建

  Map

  对象
• 您可以在上下文提供的几种模式中创建它。您应该始终使用MODE_PRIVATE，因为自API级别17以来，所有其他模式都已弃用

  // parse Preference file
  SharedPreferences preferences = context.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);
  
  // get values from Map
  preferences.getBoolean("key", defaultValue)
  preferences.get..("key", defaultValue)
  
  // you can get all Map but be careful you must not modify the collection returned by this
  // method, or alter any of its contents.
  Map<String, ?> all = preferences.getAll();
  
  // get Editor object
  SharedPreferences.Editor editor = preferences.edit();
  
  //add on Change Listener
  preferences.registerOnSharedPreferenceChangeListener(mListener);
  
  //remove on Change Listener
  preferences.unregisterOnSharedPreferenceChangeListener(mListener);
  
  // listener example
  SharedPreferences.OnSharedPreferenceChangeListener mOnSharedPreferenceChangeListener
      = new SharedPreferences.OnSharedPreferenceChangeListener() {
    @Override
    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
    }
  };
  

性能和提示

• SharedReferences

  是一个对象，因此您可以轻松获取所需的任意多个引用，它仅在您第一次调用

  GetSharedReferences

  时打开文件，或者仅为其创建一个引用

  // There are 1000 String values in preferences
  
  SharedPreferences first = context.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);
  // call time = 4 milliseconds
  
  SharedPreferences second = context.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);
  // call time = 0 milliseconds
  
  SharedPreferences third = context.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);
  // call time = 0 milliseconds
  

• 由于

  SharedReferences

  是一个对象，您可以更改它的任何实例，而不必担心它们的数据会有所不同

  first.edit().putInt("key",15).commit();
  
  int firstValue = first.getInt("key",0)); // firstValue is 15
  int secondValue = second.getInt("key",0)); // secondValue is also 15
  

• 请记住，首选项对象越大，

  获取

  ，

  提交

  ，

  应用

  ，

  删除

  和

  清除

  操作将越长。因此，强烈建议在不同的小对象中分离数据

• 应用程序更新后，您的首选项不会被删除。因此，有时您需要创建一些迁移方案。例如，您有一个在应用程序启动时解析本地JSON的应用程序，要在第一次启动后执行此操作，您决定保存布尔标志

  wasLocalDataLoaded

  。一段时间后，您更新了JSON并发布了新的应用程序版本。用户将更新他们的应用程序，但他们不会加载新的JSON，因为他们已经在第一个应用程序版本中完成了

  public class MigrationManager {
   private final static String KEY_PREFERENCES_VERSION = "key_preferences_version";
   private final static int PREFERENCES_VERSION = 2;
  
   public static void migrate(Context context) {
       SharedPreferences preferences = context.getSharedPreferences("pref", Context.MODE_PRIVATE);
       checkPreferences(preferences);
   }
  
   private static void checkPreferences(SharedPreferences thePreferences) {
       final double oldVersion = thePreferences.getInt(KEY_PREFERENCES_VERSION, 1);
  
       if (oldVersion < PREFERENCES_VERSION) {
           final SharedPreferences.Editor edit = thePreferences.edit();
           edit.clear();
           edit.putInt(KEY_PREFERENCES_VERSION, currentVersion);
           edit.commit();
       }
   }
  }
  

示例代码

---

让我们假设在一个项目中，有多个开发人员参与其中，他们在这样的活动中定义SharedReference：

SharedPreferences sharedPref = context.getSharedPreferences("prefName", 0);

有时，两个开发人员可以使用相同的名称定义SharedReference，或者插入等效的键-值对，这将导致使用键时出现问题

解决方案取决于两个选项，是否使用

使用字符串键的SharedReferences单例

共享引用单例t

// yours preferences
/data/data/YOUR_PACKAGE_NAME/shared_prefs/YOUR_PREFS_NAME.xml

// default preferences
/data/data/YOUR_PACKAGE_NAME/shared_prefs/YOUR_PACKAGE_NAME_preferences.xml

public class PreferencesManager {

    private static final String PREF_NAME = "com.example.app.PREF_NAME";
    private static final String KEY_VALUE = "com.example.app.KEY_VALUE";

    private static PreferencesManager sInstance;
    private final SharedPreferences mPref;

    private PreferencesManager(Context context) {
        mPref = context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE);
    }

    public static synchronized void initializeInstance(Context context) {
        if (sInstance == null) {
            sInstance = new PreferencesManager(context);
        }
    }

    public static synchronized PreferencesManager getInstance() {
        if (sInstance == null) {
            throw new IllegalStateException(PreferencesManager.class.getSimpleName() +
                    " is not initialized, call initializeInstance(..) method first.");
        }
        return sInstance;
    }

    public void setValue(long value) {
        mPref.edit()
                .putLong(KEY_VALUE, value)
                .commit();
    }

    public long getValue() {
        return mPref.getLong(KEY_VALUE, 0);
    }

    public void remove(String key) {
        mPref.edit()
                .remove(key)
                .commit();
    }

    public boolean clear() {
        return mPref.edit()
                .clear()
                .commit();
    }
}

SharedPreferences sharedPref = context.getSharedPreferences("prefName", 0);

class Prefs(context: Context) {

    companion object {
        private const val PREFS_FILENAME = "app_prefs"

        private const val KEY_MY_STRING = "my_string"
        private const val KEY_MY_BOOLEAN = "my_boolean"
        private const val KEY_MY_ARRAY = "string_array"
    }

    private val sharedPrefs: SharedPreferences =
        context.getSharedPreferences(PREFS_FILENAME, Context.MODE_PRIVATE)

    var myString: String
        get() = sharedPrefs.getString(KEY_MY_STRING, "") ?: ""
        set(value) = sharedPrefs.edit { putString(KEY_MY_STRING, value) }

    var myBoolean: Boolean
        get() = sharedPrefs.getBoolean(KEY_MY_BOOLEAN, false)
        set(value) = sharedPrefs.edit { putBoolean(KEY_MY_BOOLEAN, value) }

    var myStringArray: Array<String>
        get() = sharedPrefs.getStringSet(KEY_MY_ARRAY, emptySet())?.toTypedArray()
            ?: emptyArray()
        set(value) = sharedPrefs.edit { putStringSet(KEY_MY_ARRAY, value.toSet()) }

val prefs = Prefs(context)

val prefs: Prefs by lazy {
    Prefs(App.instance)
}

class App:Application() {
    companion object {
        lateinit var instance: App
    }

    override fun onCreate() {
        super.onCreate()
        instance = this
    }
}

// get stored value
val myString = prefs.myString

// store value
prefs.myString = "My String Value"

// get stored array
val myStringArray = prefs.myStringArray

// store array
prefs.myStringArray = arrayOf("String 1","String 2","String 3")