前言

用来代替原生的 SharedPreferences，优点比较多，官网地址参考使用方法，或者查看博客Kotlin系列——封装MMKV及其相关Kotlin特性，本来使用方法就已经很简单方便了，这里再次封装处理一下，可以更方便使用。

方法列表

  1. mk            :初始化 MMKV，什么都不传得到默认值，可以传自定义 id,也可以设置是否能多进程使用
  2. encode        :保存数据
  3. decode        :获取保存的数据，只能识别基本数据类型
  4. decodeAny    :获取保存的对象类型数据
  5. decodeList    :获取保存的list类型数据
  7. int            :获取 int 类型数据
  8. long        :获取 long 类型数据
  9. float        :获取 float 类型数据
  10. string        :获取 String 类型数据
  11. double        :获取 Double 类型数据
  12. bool        :获取 Boolean 类型数据
  13. parcelable    :获取 parcelable
  14. bytes        :获取数组
  15. any            :获取对象
  16. array        :获取集合
  18. contain        :是否包含
  19. remove        :移除
  20. removes        :移除多个
  21. clear        :清空
  22. clearCache    :清除缓存

代码

  1. /**
  2.  *获取MMKV实例
  3.  * @param id 单独创建实例
  4.  * @param isMultiProcess 是否在多进程中使用
  5.  * @return
  6.  */
  7. fun Any?.mk(id: String? = null, isMultiProcess: Boolean = false): MMKV {
  8.     return if (id.isNullOrEmpty()) {
  9.         MMKV.defaultMMKV()
  10.     } else {
  11.         if (isMultiProcess) {
  12.             MMKV.mmkvWithID(id, MMKV.MULTI_PROCESS_MODE)
  13.         } else {
  14.             MMKV.mmkvWithID(id)
  15.         }
  16.     }
  17. }
  19. /**
  20.  *基本数据类型等常规数据的保存,使用默认的MMKV
  21.  * @param pair
  22.  */
  23. fun Any?.encode(vararg pair: Pair<String, Any?>) {
  24.     val mk = mk()
  25.     mk.encode(*pair)
  26. }
  28. /**
  29.  *基本数据类型等常规数据的保存
  30.  * @param pair
  31.  * @return
  32.  */
  33. fun MMKV.encode(vararg pair: Pair<String, Any?>) {
  34.     pair.forEach {
  35.         when (val value = it.second) {
  36.             null -> removeValueForKey(it.first)
  37.             is Int -> encode(it.first, value)
  38.             is Long -> encode(it.first, value)
  39.             is CharSequence -> encode(it.first, value.toString())
  40.             is String -> encode(it.first, value)
  41.             is Float -> encode(it.first, value)
  42.             is Double -> encode(it.first, value)
  43.             is Char -> encode(it.first, value.toString())
  44.             is Boolean -> encode(it.first, value)
  45.             is Parcelable -> encode(it.first, value)
  46.             is ByteArray -> encode(it.first, value)
  47.             is Set<*> -> encode(it.first, value as Set<String>)
  48.             is Array<*> -> encode(it.first, value.toJson())
  49.             is Serializable -> encode(it.first, value.toJson())
  50.         }
  51.     }
  52. }
  54. /**
  55.  *获取保存的数据，只能识别基本数据类型
  56.  * @param T
  57.  * @param key
  58.  * @return
  59.  */
  60. inline fun <reified T> Any?.decode(key: String): T? = null.decode(key)
  61. inline fun <reified T> MMKV?.decode(key: String): T? {
  62.     val mk = this ?: mk()
  63.     val java = T::class.java
  64.     return when {
  65.         java.isAssignableFrom(Int::class.java) -> mk.int(key) as T
  66.         java.isAssignableFrom(Long::class.java) -> mk.long(key) as T
  67.         java.isAssignableFrom(Float::class.java) -> mk.float(key) as T
  68.         java.isAssignableFrom(Double::class.java) -> mk.double(key) as T
  69.         java.isAssignableFrom(Boolean::class.java) -> mk.bool(key) as T
  70.         java.isAssignableFrom(String::class.java) -> mk.string(key) as T
  71.         else -> {
  72.             null
  73.         }
  74.     }
  75. }
  77. /**
  78.  *获取保存的对象类型数据
  79.  * @param T
  80.  * @param key
  81.  * @return
  82.  */
  83. inline fun <reified T> Any?.decodeAny(key: String): T? = null.decodeAny(key)
  84. inline fun <reified T> MMKV?.decodeAny(key: String): T? {
  85.     val mk = this ?: mk()
  86.     return mk.any(key)
  87. }
  89. /**
  90.  *获取保存的list类型数据
  91.  * @param T
  92.  * @param key
  93.  * @return
  94.  */
  95. inline fun <reified T> Any?.decodeList(key: String): List<T> = null.decodeList(key)
  96. inline fun <reified T> MMKV?.decodeList(key: String): List<T> {
  97.     val mk = this ?: mk()
  98.     return mk.list(key)
  99. }
  101. fun MMKV.int(key: String) = decodeInt(key)
  102. fun MMKV.long(key: String) = decodeLong(key)
  103. fun MMKV.float(key: String) = decodeFloat(key)
  104. fun MMKV.double(key: String) = decodeDouble(key)
  105. fun MMKV.bool(key: String) = decodeBool(key)
  106. fun MMKV.string(key: String) = decodeString(key)
  108. fun <T : Parcelable> MMKV.parcelable(key: String, clz: Class<T>) = decodeParcelable(key, clz)
  109. inline fun <reified T : Parcelable> MMKV.parcelable(key: String) =
  110.     decodeParcelable(key, T::class.java)
  112. fun MMKV.bytes(key: String) = decodeBytes(key)
  114. inline fun <reified T> MMKV.any(key: String): T? = decodeString(key).toAny()
  115. inline fun <reified T> MMKV.list(key: String): List<T> = decodeString(key).toList2()
  118. fun MMKV.contain(key: String) = containsKey(key)
  119. fun MMKV.remove(key: String) = removeValueForKey(key)
  120. fun MMKV.removes(keys: Array<String>) = removeValuesForKeys(keys)
  121. fun MMKV.clear() = clearAll()
  122. fun MMKV.clearCache() = clearMemoryCache()

使用

  • 获取 MMKV 实例

    1. /* 初始化MMKV，第一个参数，单独创建实例；第二个参数，是否在多进程中使用
    2.      * ，什么都不传获取默认的MMKV*/
    3.       val mmk = mk()

  • 保存数据，对象要序列化

    1.  //保存, 获取到MMKV后可以直接使用MMKV提供的方法
    2.       //优化封装方法
    3.       mmk.encode(
    4.           "string" to "stirng",
    5.           "int" to 9,
    6.           "double" to 90.0,
    7.           "bean" to TestBean(),
    8.           "list" to listOf(1,2,3)
    9.       )
    10.       //或者直接使用encode,直接使用默认就是什么都不传的MMKV
    11.       encode(
    12.           "string" to "stirng",
    13.           "int" to 9,
    14.           "double" to 90.0,
    15.           "bean" to TestBean(),
    16.           "list" to listOf(1,2,3)
    17.       )

  • 获取基本数据类型

    1.         //获取基本数据类型
    2.       val string = mmk.string("string")
    3.       val i= mmk.int("int")
    4.       //或使用decode
    5.       val st = decode<String>("string")
    6.       val ii = decode<Int>("int")

  • 获取对象

    1.        //获取对象
    2.       val bean = mmk.any<TestBean>("bean")
    3.       val bean2 = decodeAny<TestBean>("bean")

  • 获取集合

    1.       //获取list
    2.       val list = mmk.list<Int>("list")
    3.       val list2 = decodeList<Int>("list")