类委托

所谓委托很好理解：本来叫A去做事，而A自己不去做它将其委托给B去做。下面先来看一下类委托：

interface MyInterface {
    fun myPrint()
}

class MyInterfaceImpl(val str: String) : MyInterface {
    override fun myPrint() {
        println("welcome " + str)
    }
}

class MyClass(myInterface: MyInterface) : MyInterface by myInterface  //委托类，没有类体

fun main(args: Array<String>) {
    val myInterfaceImpl = MyInterfaceImpl("zhangsan")
    MyClass(myInterfaceImpl).myPrint()
}

执行结果如下：

welcome zhangsan

Process finished with exit code 0

接下来再做一个实验，假如MyClass自己也定义了一个相同的myPrint()，那结果如何呢？下面试一下：

interface MyInterface {
    fun myPrint()
}

class MyInterfaceImpl(val str: String) : MyInterface {
    override fun myPrint() {
        println("welcome " + str)
    }
}

class MyClass(myInterface: MyInterface) : MyInterface by myInterface {
    override fun myPrint() {
        println("hello world")
    }
}

fun main(args: Array<String>) {
    val myInterfaceImpl = MyInterfaceImpl("zhangsan")
    MyClass(myInterfaceImpl).myPrint()
}

执行结果如下：

hello world

Process finished with exit code 0

可以看到，优先以自己实现的为准，若自己没有实现，则以委托类实现的为准。

属性委托

委托就是一个类，这个类为属性提供值并且处理值的变化。这让我们可以把属性的 getter-setter 逻辑从属性声明的地方移动到（或者说委托给）另一个类，以达到逻辑复用的目的。

比如我们有一个String类型的属性param，这个属性的值需要去掉首尾的空格(trim)。我们可以在属性的 setter 里这样做：

class Example {
    var param: String = ""
        set(value) {
            field = value.trim()
        }
}

如果对语法不熟悉，可以参考 Kotlin 文档的属性部分。

如果我们想要在其他类里复用这个逻辑呢？这就轮到委托登场了。

class TrimDelegate : ReadWriteProperty<Any?, String> {

    private var trimmedValue: String = ""

    override fun getValue(
        thisRef: Any?,
        property: KProperty<*>
    ): String {
        return trimmedValue
    }

    override fun setValue(
        thisRef: Any?,
        property: KProperty<*>, value: String
    ) {
        trimmedValue = value.trim()
    }
}

委托就是一个拥有两个方法（读取和设置属性的值）的类。更具体来说，KProperty类的实例代表被委托的属性，而thisRef就是拥有这个属性的对象。仅此而已。我们可以这样使用刚才创建的委托：

class Example {
    //使用 by 关键字
    var param: String by TrimDelegate()
}

上面的代码和下面的代码效果相同：

class Example {

    private val delegate = TrimDelegate()

    var param: String
        get() = delegate.getValue(this, ::param)
        set(value) {
            delegate.setValue(this, ::param, value)
        }
}

::param是一个操作符，他可以为属性返回一个KProperty实例。

如你所见，委托属性并没有什么神奇的。但是，它虽然简单，却非常有用，让我们来看一些在 Android 开发中的例子。

你可以在官方文档中了解更多关于委托属性的内容。

Fragment 传参委托

我们经常需要给 Fragment 传递一些参数，这通常看起来是这样：

class DemoFragment : Fragment() {
    private var param1: Int? = null
    private var param2: String? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        arguments?.let { args ->
            param1 = args.getInt(Args.PARAM1)
            param2 = args.getString(Args.PARAM2)
        }
    }
    companion object {
        private object Args {
            const val PARAM1 = "param1"
            const val PARAM2 = "param2"
        }

        fun newInstance(param1: Int, param2: String): DemoFragment =
            DemoFragment().apply {
                arguments = Bundle().apply {
                    putInt(Args.PARAM1, param1)
                    putString(Args.PARAM2, param2)
                }
            }
    }
}

我们把参数传递给用于创建 Fragment 实例的 newInstance方法，在方法里面把参数传递给 Fragment 的 arguments，以便可以在onCreate中获取。

我们可以把 arguments相关的逻辑移到属性的 getter 和 setter 中来代码变得更好看。

class DemoFragment : Fragment() {
    private var param1: Int?
        get() = arguments?.getInt(Args.PARAM1)
        set(value) {
            value?.let {
                arguments?.putInt(Args.PARAM1, it)
            } ?: arguments?.remove(Args.PARAM1)
        }
    private var param2: String?
        get() = arguments?.getString(Args.PARAM2)
        set(value) {
            arguments?.putString(Args.PARAM2, value)
        }
    companion object {
        private object Args {
            const val PARAM1 = "param1"
            const val PARAM2 = "param2"
        }
        fun newInstance(param1: Int, param2: String): DemoFragment =
            DemoFragment().apply {
                this.param1 = param1
                this.param2 = param2
            }
    }
}

但是我们还是要为每个属性写重复的代码，如果属性太多的话就太繁琐了，而且太多与arguments相关的代码看起来太乱了。

所以还有别的方法进一步美化代码吗？答案是有的。正如你猜的那样，我们将会用委托属性。

首先，我们需要做些准备。

Fragment的arguments用Bundle对象存储的,Bundle提供了很多方法用于存储不同类型的值。所以让我们来写一个扩展函数用于往Bundle 中存储某种类型的值，在类型不支持的时候抛出异常。

fun <T> Bundle.put(key: String, value: T) {
    when (value) {
        is Boolean -> putBoolean(key, value)
        is String -> putString(key, value)
        is Int -> putInt(key, value)
        is Short -> putShort(key, value)
        is Long -> putLong(key, value)
        is Byte -> putByte(key, value)
        is ByteArray -> putByteArray(key, value)
        is Char -> putChar(key, value)
        is CharArray -> putCharArray(key, value)
        is CharSequence -> putCharSequence(key, value)
        is Float -> putFloat(key, value)
        is Bundle -> putBundle(key, value)
        is Parcelable -> putParcelable(key, value)
        is Serializable -> putSerializable(key, value)
        else -> throw IllegalStateException("Type of property $key is not supported")
    }
}

接下来我们可以创建委托了。

class FragmentArgumentDelegate<T : Any> 
    :ReadWriteProperty<Fragment, T> {

    @Suppress("UNCHECKED_CAST")
    override fun getValue(
        thisRef: Fragment,
        property: KProperty<*>
    ): T {
        //key 为属性名
        val key = property.name
        return thisRef.arguments
            ?.get(key) as? T
            ?: throw IllegalStateException("Property ${property.name} could not be read")
    }

    override fun setValue(
        thisRef: Fragment,
        property: KProperty<*>, value: T
    ) {
        val args = thisRef.arguments
            ?: Bundle().also(thisRef::setArguments)
        val key = property.name
        args.put(key, value)
    }
}

委托从 Fragment 的 arguments 中读取值，当属性值改变时，它会获取Fragment的arguments（如果没有则会创建新的并设置给Fragment），然后通过刚才创建的扩展函数Bundle.put把新的值存储起来。

ReadWriteProperty 是一个接收两个类型参数的泛型接口。我们把第一个设置成Fragment，即保证这个委托只能用于Fragment的属性。这可以让我们通过thisRef来获取Fragment实例并管理它的 arguments。

由于我们使用属性的名称作为arguments存储时的键，所以我们不用再把键写成常量了。

ReadWriteProperty 第二个类型参数决定了这个属性可以拥有那些类型的值。我们把这个类型设为非空的，并且在不能读取时抛出了异常，这让我们可以在 Fragment 中获取非空的值，避免了空值检查。

但有时我们确实需要一些属性是可以为null的，所以让我们再创建一个委托，当在arguments中没有找到值时不抛出异常而是返回null。

class FragmentNullableArgumentDelegate<T : Any?> :
    ReadWriteProperty<Fragment, T?> {

    @Suppress("UNCHECKED_CAST")
    override fun getValue(
        thisRef: Fragment,
        property: KProperty<*>
    ): T? {
        val key = property.name
        return thisRef.arguments?.get(key) as? T
    }

    override fun setValue(
        thisRef: Fragment,
        property: KProperty<*>, value: T?
    ) {
        val args = thisRef.arguments
            ?: Bundle().also(thisRef::setArguments)
        val key = property.name
        value?.let { args.put(key, it) } ?: args.remove(key)
    }
}

接下来，为了方便使用我们创建一些函数（不是必须的，单纯为了美化代码）：

fun <T : Any> argument(): ReadWriteProperty<Fragment, T> =
    FragmentArgumentDelegate()

fun <T : Any> argumentNullable(): ReadWriteProperty<Fragment, T?> =
    FragmentNullableArgumentDelegate()

最后，我们来使用委托：

class DemoFragment : Fragment() {
    private var param1: Int by argument()
    private var param2: String by argument()
    companion object {
        fun newInstance(param1: Int, param2: String): DemoFragment =
            DemoFragment().apply {
                this.param1 = param1
                this.param2 = param2
            }
    }
}

SharedPreferences 委托

我们经常需要存储一些数据以便App下次启动时能够快速获取。例如，我们可能想存储一些用户偏好以便让用户自定义应用的功能。普遍采用的方式是使用 SharedPreferences 来存储键值对。

假设我们有一个类用户读取和存储三个参数：

class Settings(context: Context) {

    private val prefs: SharedPreferences = 
        PreferenceManager.getDefaultSharedPreferences(context)

    fun getParam1(): String? {
        return prefs.getString(PrefKeys.PARAM1, null)
    }

    fun saveParam1(param1: String?) {
        prefs.edit().putString(PrefKeys.PARAM1, param1).apply()
    }

    fun getParam2(): Int {
        return prefs.getInt(PrefKeys.PARAM2, 0)
    }

    fun saveParam2(param2: Int) {
        prefs.edit().putInt(PrefKeys.PARAM2, param2).apply()
    }

    fun getParam3(): String {
        return prefs.getString(PrefKeys.PARAM3, null) 
            ?: DefaulsValues.PARAM3
    }

    fun saveParam3(param3: String) {
        prefs.edit().putString(PrefKeys.PARAM2, param3).apply()
    }

    companion object {
        private object PrefKeys {
            const val PARAM1 = "param1"
            const val PARAM2 = "param2"
            const val PARAM3 = "special_key_param3"
        }

        private object DefaultValues {
            const val PARAM3 = "defaultParam3"
        }
    }
}

这里我们获取了默认的SharedPreferences并提供了方法用户读取和存储参数的值。我们还把param3变得特别一点——它使用了特别的键并且有一个非标准的默认值。

我们又一次看到我们写了重复的代码，我们当然可以重复的逻辑移到方法里，但还是会留下很笨重的代码。除此之外，如果我们想在别的类里复用这些逻辑呢？让我们来看看委托是如何简化代码的吧。

为了让事情变得有趣些，我们尝试一种稍微不同的方式。这次我们将会使用对象表达式并给SharedPreferences创建一个扩展函数。

fun SharedPreferences.string(
    defaultValue: String = "",
    key: (KProperty<*>) -> String = KProperty<*>::name
): ReadWriteProperty<Any, String> =
    object : ReadWriteProperty<Any, String> {
        override fun getValue(
            thisRef: Any,
            property: KProperty<*>
        ) = getString(key(property), defaultValue)

        override fun setValue(
            thisRef: Any,
            property: KProperty<*>,
            value: String
        ) = edit().putString(key(property), value).apply()
    }

这里我们创建了 SharedPreferences 的扩展函数，它返回了一个 ReadWriteProperty 子类的对象作为我们的委托。

这个委托用函数key提供的值作为键，从SharedPreferences读取String类型的值。默认情况下，键为属性的名字，所以我们不用维护和传递任何常量。同时，如果为了避免键冲突或者想访问该键，我们还可以提供一个自定义的键。我们还可以为属性提供一个默认值，以防在SharedPreferences没有找到值。

这个委托也可以使用相同的键来在SharedPreferences存储属性的新值。

为了让我们的例子能工作，我们还需要为String?和Int增加委托，这和前面是一样的：

fun SharedPreferences.stringNullable(
    defaultValue: String? = null,
    key: (KProperty<*>) -> String = KProperty<*>::name
): ReadWriteProperty<Any, String?> =
    object : ReadWriteProperty<Any, String?> {
        override fun getValue(
            thisRef: Any,
            property: KProperty<*>
        ) = getString(key(property), defaultValue)

        override fun setValue(
            thisRef: Any,
            property: KProperty<*>,
            value: String?
        ) = edit().putString(key(property), value).apply()
    }

fun SharedPreferences.int(
    defaultValue: Int = 0,
    key: (KProperty<*>) -> String = KProperty<*>::name
): ReadWriteProperty<Any, Int> =
    object : ReadWriteProperty<Any, Int> {
        override fun getValue(
            thisRef: Any,
            property: KProperty<*>
        ) = getInt(key(property), defaultValue)

        override fun setValue(
            thisRef: Any,
            property: KProperty<*>,
            value: Int
        ) = edit().putInt(key(property), value).apply()
    }

现在我们终于可以简化Settings类的代码了：

class Settings(context: Context) {

    private val prefs: SharedPreferences =
        PreferenceManager.getDefaultSharedPreferences(context)

    var param1 by prefs.stringNullable()
    var param2 by prefs.int()
    var param3 by prefs.string(
        key = { "KEY_PARAM3" },
        defaultValue = "default"
    )
}

代码现在看起来好多了，如果需要增加一个属性，一行代码就够了。