Kotlin系列——封装MMKV及其相关Kotlin特性

这篇文章主要是对MMKV进行封装，由此了解一些Kotlin特性，建议对着示例代码阅读文章，示例代码如下：

MMKVDemo

MMKV简单介绍

其实在MMKV的Wiki中已经有很详细的介绍了，地址如下：

MMKV for Android官方Wiki

MMKV是基于mmap内存映射的key-value组件，底层序列化/反序列化使用protobuf实现，性能高，稳定性强，而且Android这边还支持多进程。

单线程性能对比

MMKVSingleProcessPerformanceComparison.png

• 写入性能

  MMKV远超于SharedPreferences和SQLite。

• 读取性能

  MMKV与SharedPreferences相近，好于SQLite。

多进程性能对比

MMKVMultipleProcessPerformanceComparison.png

• 写入性能

  MMKV远超于MultiProcessSharedPreferences和SQLite。

• 读取性能

  MMKV远超于MultiProcessSharedPreferences和SQLite。

mmap简单介绍

mmap是一种内存映射的方法，它可以将对象或者文件映射到地址空间，实现文件磁盘地址和进程虚拟地址空间中的一段虚拟地址的一一对映关系，实现了这种映射关系后，进程可以采用指针的方式读写操作一段内存，而系统会自动回写脏页面到对应的文件磁盘上，这样就完成了对文件的操作，而不需要再去调用write、read等系统调用函数，同时内核空间对这段区域的修改也直接反映用户空间，从而可以实现不同进程间的文件共享。

封装MMKV

Preferences.kt，代码如下：

package com.tanjiajun.mmkvdemo.utils

import android.os.Parcelable
import com.tencent.mmkv.MMKV
import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty

/**
 * Created by TanJiaJun on 2020-01-11.
 */
private inline fun  MMKV.delegate(
    key: String? = null,
    defaultValue: T,
    crossinline getter: MMKV.(String, T) -> T,
    crossinline setter: MMKV.(String, T) -> Boolean
): ReadWriteProperty =
    object : ReadWriteProperty {
        override fun getValue(thisRef: Any, property: KProperty<*>): T =
            getter(key ?: property.name, defaultValue)

        override fun setValue(thisRef: Any, property: KProperty<*>, value: T) {
            setter(key ?: property.name, value)
        }
    }

fun MMKV.boolean(
    key: String? = null,
    defaultValue: Boolean = false
): ReadWriteProperty =
    delegate(key, defaultValue, MMKV::decodeBool, MMKV::encode)

fun MMKV.int(key: String? = null, defaultValue: Int = 0): ReadWriteProperty =
    delegate(key, defaultValue, MMKV::decodeInt, MMKV::encode)

fun MMKV.long(key: String? = null, defaultValue: Long = 0L): ReadWriteProperty =
    delegate(key, defaultValue, MMKV::decodeLong, MMKV::encode)

fun MMKV.float(key: String? = null, defaultValue: Float = 0.0F): ReadWriteProperty =
    delegate(key, defaultValue, MMKV::decodeFloat, MMKV::encode)

fun MMKV.double(key: String? = null, defaultValue: Double = 0.0): ReadWriteProperty =
    delegate(key, defaultValue, MMKV::decodeDouble, MMKV::encode)

private inline fun  MMKV.nullableDefaultValueDelegate(
    key: String? = null,
    defaultValue: T?,
    crossinline getter: MMKV.(String, T?) -> T,
    crossinline setter: MMKV.(String, T) -> Boolean
): ReadWriteProperty =
    object : ReadWriteProperty {
        override fun getValue(thisRef: Any, property: KProperty<*>): T =
            getter(key ?: property.name, defaultValue)

        override fun setValue(thisRef: Any, property: KProperty<*>, value: T) {
            setter(key ?: property.name, value)
        }
    }

fun MMKV.byteArray(
    key: String? = null,
    defaultValue: ByteArray? = null
): ReadWriteProperty =
    nullableDefaultValueDelegate(key, defaultValue, MMKV::decodeBytes, MMKV::encode)

fun MMKV.string(key: String? = null, defaultValue: String? = null): ReadWriteProperty =
    nullableDefaultValueDelegate(key, defaultValue, MMKV::decodeString, MMKV::encode)

fun MMKV.stringSet(
    key: String? = null,
    defaultValue: Set? = null
): ReadWriteProperty> =
    nullableDefaultValueDelegate(key, defaultValue, MMKV::decodeStringSet, MMKV::encode)

inline fun  MMKV.parcelable(
    key: String? = null,
    defaultValue: T? = null
): ReadWriteProperty =
    object : ReadWriteProperty {
        override fun getValue(thisRef: Any, property: KProperty<*>): T =
            decodeParcelable(key ?: property.name, T::class.java, defaultValue)

        override fun setValue(thisRef: Any, property: KProperty<*>, value: T) {
            encode(key ?: property.name, value)
        }
    }

用法如下：

package com.tanjiajun.mmkvdemo.ui.activity

import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import com.tanjiajun.mmkvdemo.R
import com.tanjiajun.mmkvdemo.data.model.UserData
import com.tanjiajun.mmkvdemo.utils.*
import com.tencent.mmkv.MMKV

/**
 * Created by TanJiaJun on 2020-01-14.
 */
class MainActivity : AppCompatActivity() {

    private val mmkv: MMKV by lazy { MMKV.defaultMMKV() }

    private var boolean by mmkv.boolean(key = "boolean", defaultValue = false)
    private var int by mmkv.int(key = "int", defaultValue = 0)
    private var long by mmkv.long("long", 0L)
    private var float by mmkv.float(key = "float", defaultValue = 0.0F)
    private var double by mmkv.double(key = "double", defaultValue = 0.0)
    private var byteArray by mmkv.byteArray(key = "byteArray")
    private var string by mmkv.string(key = "string")
    private var stringSet by mmkv.stringSet(key = "stringSet")
    private var parcelable by mmkv.parcelable("parcelable")

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        boolean = true
        int = 100
        long = 100L
        float = 100F
        double = 100.0
        byteArray = ByteArray(100).apply {
            for (i in 0 until 100) {
                set(i, i.toByte())
            }
        }
        string = "谭嘉俊"
        stringSet = HashSet().apply {
            for (i in 0 until 100) {
                add("第($i)个")
            }
        }
        parcelable = UserData(name = "谭嘉俊", gender = "男", age = 26)

        Log.i(TAG, "boolean:$boolean")
        Log.i(TAG, "int:$int")
        Log.i(TAG, "long:$long")
        Log.i(TAG, "float:$float")
        Log.i(TAG, "double:$double")
        Log.i(TAG, "byteArray:$byteArray")
        Log.i(TAG, "string:$string")
        Log.i(TAG, "stringSet:$stringSet")
        Log.i(TAG, "parcelable:$parcelable")
    }

    private companion object {
        const val TAG = "TanJiaJun"
    }

}

Kotlin特性

挑几个语法讲解一下：

内联函数

在示例代码中我创建几个内联的代理函数，那什么是内联函数呢？为什么要用内联函数？

内联函数的原理是编译器把实现内联函数的字节码动态插入到每次的调用处。

使用高阶函数会带来一些运行时的效率损失，因为在Kotlin中，每一个函数都是一个对象，并且会捕获一个闭包，即那些在函数体内会访问到的变量。内存分配和虚拟调用都会增加开销，在很多情况下，使用内联化Lambda表达式可以消除这类开销，举个例子，有这样一个函数：

fun add(list: MutableList, block: () -> String): String {
    list.add("谭嘉俊")
    return block()
}

然后是这样调用的：

add(mutableListOf("MutableList")) { "谭嘉俊" }

刚刚也说了，每一个函数都是一个对象，所以后面这段Lambda表达式它也是一个对象，所以调用的时候，其实它会调用block方法，Kotlin是基于JVM的编程语言，所以调用一个方法，其实就是将这个方法入栈的操作，调用结束后就会将这个方法出栈，入栈和出栈都会有性能的开销，所以我们可以使用内联函数，代码如下：

inline fun add(list: MutableList, block: () -> String): String {
    list.add("谭嘉俊")
    return block()
}

用上内联函数后，编译器就会将block方法里的代码内联到调用的地方，而不会再去调用block方法，从而减少了性能的开销，就像如下代码：

inline fun add(list: MutableList, block: () -> String): String {
    list.add("谭嘉俊")
    return "谭嘉俊"
}

crossinline

在示例代码中，我用crossinline修饰了getter和setter这两个参数，crossinline是修饰符关键字，它要在内联函数中使用，可以禁止传递内联函数的Lambda表达式中的非局部返回。

那什么是非局部返回呢？在Kotlin中，我们只能对具名函数或者匿名函数使用非限定的return来退出，所以我们在退出一个Lambda表达式就必须使用一个标签，并且在Lambda表达式内部禁止使用裸return，因为Lambda表达式不能使包含它的函数return，代码如下：

fun function(block: () -> Unit) =
    print("谭嘉俊")

fun add(list: MutableList) {
    list.add("谭嘉俊")
    function {
        // 不能使add函数在此处return
        return
    }
}

但是如果Lambda表达式传给的函数是内联的，return也可以是内联的，代码如下：

inline fun function(block: () -> Unit) =
    print("谭嘉俊")

fun add(list: MutableList) {
    list.add("谭嘉俊")
    function {
        // 可以使add函数在此处return
        return
    }
}

这种位于Lambda表达式中，但退出的是包含它的函数叫做非局部返回，就像我们经常用到的forEach就是个内联函数，代码如下：

fun function(list: List): Boolean {
    list.forEach {
        if (it == "谭嘉俊") return true // function函数return
    }
    return false
}

如果只是想局部返回到forEach的话，可以像如下那样写：

fun function(list: List): Boolean {
    list.forEach {
        if (it == "谭嘉俊") return@forEach // 使用forEach隐式标签，局部返回到forEach
    }
    return false
}

一些内联函数可能调用的参数不是直接来自函数体，而是来自另一个执行上下文的Lambda表达式，例如：来自局部对象或者嵌套函数，在这种情况下，这个Lambda表达式中也不允许非局部返回，为了标识这种情况，这个Lambda表达式需要用crossinline修饰符标记，在上面的Preferences.kt文件中，getter参数和setter参数就用到crossinline修饰符，因为是局部对象ReadWriteProperty的getValue方法和setValue方法调用了getter参数和setter参数，代码就不再贴出来了。

具体化的类型参数

在示例代码中，我用到了Kotlin的reified修饰符，在说这个之前，我们大概了解下Java的泛型：

我们知道Java的 泛型是”伪泛型“，它会在编译阶段进行类型擦除。

泛型的类型擦除的原则有以下几点：

• 擦除类型参数，即擦除<>和里面的内容。
• 根据类型参数的上下界推断并且替换成原生态类型，例如List的原生态类型是List。
• 为了保证类型安全，必要时插入强制类型转换代码。
• Java编译器自动产生桥接方法来保证类型擦除后仍然具有泛型的多态性。

类型参数无限制

当类或者方法定义中的类型参数没有限制时，例如：或者都被替换成Object，示例代码如下：

类型擦除前：

public class Generic {

    private T value;
    private List list;

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }

    public void setList(List list) {
        this.list = list;
    }

}

类型擦除后：

public class Generic {

    // T替换成Object
    private Object value;
    // List替换成原生态类型List
    private List list;

    public Object getValue() {
        return value;
    }

    public void setValue(Object value) {
        this.value = value;
    }

    public void setList(List list) {
        this.list = list;
    }

}

类型参数有限制

当类或者方法定义中的类型参数存在上界的时候，都被替换成它的上界，例如：和都会被替换成Number；当类或者方法定义中的类型参数存在下界的时候，都被替换成它的下界，例如：会被替换成Object。示例代码如下：

类型擦除前：

public class Generic {

    private T value;
    private List extendsList;
    private List superList;

    public T getValue() {
        return value;
    }

    public void setValue(T value) {
        this.value = value;
    }

    public void setExtendsList(List extendsList) {
        this.extendsList = extendsList;
    }

    public void setSuperList(List superList) {
        this.superList = superList;
    }

}

类型擦除后：

public class Generic {

    // 替换成Number
    private Number value;
    // 替换成Number
    private List extendsList;
    // 替换成Object
    private List