Kotlin 真的是一门漂亮的开发语言，她领有的一些很棒的个性使 Android 开发变成的乏味和令人兴奋。[委托属性]()就是其中之一,在这篇文章里咱们将会看到委托是如何把 Android 开发变得更加轻松的。
根底
首先，什么是委托？它又是如何工作的？尽管委托看起来很神奇，但它其实并没有设想中的那么简单。
委托就是一个类，这个类为属性提供值并且解决值的变动。这让咱们能够把属性的 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" )}代码当初看起来好多了，如果须要减少一个属性，一行代码就够了。
View 委托
假如咱们有一个自定义View，它蕴含三个文本字段——一个题目，一个子标题，还有形容——布局如下：
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="match_parent" android:layout_height="wrap_content" android:orientation="vertical"> <TextView android:id="@+id/tvTitle" android:layout_width="match_parent" android:layout_height="wrap_content" /> <TextView android:id="@+id/tvSubtitle" android:layout_width="match_parent" android:layout_height="wrap_content" /> <TextView android:id="@+id/tvDescription" android:layout_width="match_parent" android:layout_height="wrap_content" /></LinearLayout>咱们想要CustomView提供用于批改和获取三个字段的办法：
class CustomView @JvmOverloads constructor( context: Context, attrs: AttributeSet? = null) : FrameLayout(context, attrs) { var title: String get() = tvTitle.text.toString() set(value) { tvTitle.text = value } var subtitle: String get() = tvSubtitle.text.toString() set(value) { tvSubtitle.text = value } var description: String get() = tvDescription.text.toString() set(value) { tvDescription.text = value } init { inflate(context, R.layout.custom_view, this) }}这里咱们应用了Kotlin Android Extension的视图绑定来获取布局中的控件。
很显著有一些代码能够很容易的挪动到另一个类里，让咱们借助委托来实现。
让咱们写一个 TextView 的扩大函数，它返回一个委托用来解决它的文本内容：
fun TextView.text(): ReadWriteProperty<Any, String> = object : ReadWriteProperty<Any, String> { override fun getValue( thisRef: Any, property: KProperty<*> ): String = text.toString() override fun setValue( thisRef: Any, property: KProperty<*>, value: String ) { text = value } }而后在CustomView中应用它：
class CustomView @JvmOverloads constructor( context: Context, attrs: AttributeSet? = null) : FrameLayout(context, attrs) { init { inflate(context, R.layout.custom_view, this) } var title by tvTitle.text() var subtitle by tvSubtitle.text() var description by tvDescription.text()}确保在init办法渲染布局之后初始化属性，因为控件不能为null。
这跟源代码比起来可能并没有很大的改良，要害是展现委托的力量。除此之外，这写起来很乏味。
当然，不仅限于TextView。比方，这里有一个控件可见性的委托（keepBounds决定了当控件不可见时是否占用空间）:
fun View.isVisible(keepBounds: Boolean): ReadWriteProperty<Any, Boolean> = object : ReadWriteProperty<Any, Boolean> { override fun getValue( thisRef: Any, property: KProperty<*> ): Boolean = visibility == View.VISIBLE override fun setValue( thisRef: Any, property: KProperty<*>, value: Boolean ) { visibility = when { value -> View.VISIBLE keepBounds -> View.INVISIBLE else -> View.GONE } } }这里有一个ProgressBar进度的委托，返回从 0 到 1 的浮点数。
fun ProgressBar.progress(): ReadWriteProperty<Any, Float> = object : ReadWriteProperty<Any, Float> { override fun getValue( thisRef: Any, property: KProperty<*> ): Float = if (max == 0) 0f else progress / max.toFloat() override fun setValue( thisRef: Any, property: KProperty<*>, value: Float ) { progress = (value * max).toInt() } }上面是如果CustomView中有一个ProgressBar该如何应用它：
class CustomView @JvmOverloads constructor( context: Context, attrs: AttributeSet? = null) : FrameLayout(context, attrs) { init { inflate(context, R.layout.custom_view, this) } var title by tvTitle.text() var subtitle by tvSubtitle.text() var description by tvDescription.text() var progress by progressBar.progress() var isProgressVisible by progressBar.isVisible(keepBounds = false)如你所见，你能够给任何货色委托，没有限度。
总结
咱们看来一些在 Android 开发中应用 Kotlin 委托属性的例子。当然了，你也能够用别的形式来应用它。 这篇文章的指标是展现委托属性是如许弱小，以及咱们能够用它做什么。
心愿你当初曾经有了想要应用委托的想法了。
我的库存，须要的小伙伴请点击我的GitHub收费支付