Kotlin | 10分钟搞定by委托机制

本文已同步发表于我的微信公众号，搜索 代码说 即可关注，欢迎与我沟通交流。

类委托

委托机制是一种非常灵活的语言特性，它可以让我们将对象的某些属性或方法委托给其他对象来处理。示例：

interface ISay {
    fun sayHello()
}

class DelegateImp : ISay {
    override fun sayHello() {
        println("sayHello from DelegateImp")
    }
}

//delegate传入DelegateImp()
class RealImp (val delegate : ISay) : ISay {
    override fun sayHello() {
        delegate.sayHello()
    }
}

• RealImp 类将 sayHello() 方法的实现委托给了 DelegateImp 对象，从而实现了代码复用和模块化。
• 当调用 RealImp 的 sayHello() 方法时，实际上是调用了 DelegateImp 对象的 sayHello()方法。

Kotlin 中通过使用 by 关键字进行委托，上述 RealImp 的实现方式可以直接通过下面的方式来替代：

class RealImp2 : ISay by DelegateImp()  //方式1
class RealImp3(delegate: ISay) : ISay by delegate //方式2

上述两种方式的结果是一样的，可以看到 by 关键字后面的表达式是为了得到 ISay 接口的实例对象。最后执行：

RealImp(DelegateImp()).sayHello() //方式1
RealImp2().sayHello() //方式2
RealImp3(DelegateImp()).sayHello() //方式3

上述执行结果都是一样的:

sayHello from DelegateImp

属性委托

除了上一节中的接口类委托，Kotlin 还支持属性委托，语法模板如下：

val/var <属性名>: <类型> by <表达式>

接口是把接口方法委托出去，那属性要委托什么呢？很简单，对于一个属性，无非有两个操作：获取属性以及修改属性，也就是对应的 get()/set() 。

属性委托即是将对应的 get()/set() 操作分发给指定委托对象的 getValue()/setValue() 方法执行；当然，如果是 val 修饰的属性，只需要提供 getValue() 即可。示例：

class Delegate {
    //对应属性中的get()，表示获取数据
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return "$thisRef，${property.name}"
    }

    //对应属性中的set()，表示设置数据，只有var的属性会有
    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        println("$thisRef , ${property.name} , $value")
    }
}

• thisRef： 请求其值的对象，即被委托对象的实例
• property： 被委托对象属性的元数据。包含了被委托对象属性的名称、类型、可见性等信息。
• value： setValue() 中要设置的值。

使用示例：

class DelegateProperty {
    var p1: String by Delegate()
}

fun main() {
   val property = DelegateProperty()
   println(property.p1) //getValue()
   property.p1 = "小马快跑" //setValue()
}

执行结果：
DelegateProperty@6d5380c2, p1  //getValue()
DelegateProperty@6d5380c2 , p1 , 小马快跑 //setValue()

上述 Delegate中的 getValue()/setValue()方法需要我们手动编写，有点麻烦，Kotlin为我们提供了ReadOnlyProperty、ReadWriteProperty接口：

//只读
public fun interface ReadOnlyProperty<in T, out V> {
    public operator fun getValue(thisRef: T, property: KProperty<*>): V
}

//读写都支持
public interface ReadWriteProperty<in T, V> : ReadOnlyProperty<T, V> {
    public override operator fun getValue(thisRef: T, property: KProperty<*>): V
    public operator fun setValue(thisRef: T, property: KProperty<*>, value: V)
}

使用示例：

class DelegateR : ReadOnlyProperty<Any, String> {
    override fun getValue(thisRef: Any, property: KProperty<*>): String {
        return "getValue：$thisRef，${property.name}"
    }
}
class DelegateRW : ReadWriteProperty<Any, String> {
    override fun getValue(thisRef: Any, property: KProperty<*>): String {
        return "getValue：$thisRef，${property.name}"
    }

    override fun setValue(thisRef: Any, property: KProperty<*>, value: String) {
        println("setValue：$thisRef，${property.name}，$value")
    }
}

class DelegateProperty {
    val p2: String by DelegateR()
    var p3: String by DelegateRW()
}

fun main() {
   val property = DelegateProperty()
   println(property.p2) //p2取值
   println(property.p3) //p3取值
   property.p3 = "小马快跑" //p3设值
}

执行结果：
getValue：DelegateProperty@77a567e1，p2
getValue：DelegateProperty@77a567e1，p3
setValue：DelegateProperty@77a567e1，p3，小马快跑

可以看到利用ReadOnlyProperty、ReadWriteProperty实现的结果跟手动实现的结果是一致的，但是对比手动编写更方便、更快捷。

延迟委托 （by lazy）

//1
public actual fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)

//2
public actual fun <T> lazy(mode: LazyThreadSafetyMode, initializer: () -> T): Lazy<T> =
    when (mode) {
        LazyThreadSafetyMode.SYNCHRONIZED -> SynchronizedLazyImpl(initializer)
        LazyThreadSafetyMode.PUBLICATION -> SafePublicationLazyImpl(initializer)
        LazyThreadSafetyMode.NONE -> UnsafeLazyImpl(initializer)
    }

lazy() 是接受一个 lambda 表达式， 并返回一个 Lazy <T> 实例的函数，返回的实例可以作为实现延迟属性的委托： 第一次调用属性的 get() 会执行已传递给 lazy() 的 lambda 表达式并记录结果； 后续调用直接返回已经记录的结果。示例：

val lazyView by lazy {
  println("我只有第一次初始化的时候才执行哟~")
  "Come on"
}

//调用:
println("第1次：${property.lazyView}")
println("第2次：${property.lazyView}")

//执行结果：
我只有第一次初始化的时候才执行哟~
第1次：Come on
第2次：Come on

从结果可以看出只有第一次执行时走到了 lambda 表达式中的逻辑，第二次执行时直接返回第一次生成的结果。 另外再调用 lazy() 函数时可以传入一个 LazyThreadSafetyMode 参数，有下面三个值，分别代表不同的意思：

• LazyThreadSafetyMode.SYNCHRONIZED：该值只在一个线程中计算，并且所有线程会看到相同的值。
• LazyThreadSafetyMode.PUBLICATION：可以在并发访问未初始化的Lazy实例值时调用多次，但只有第一次返回的值将被用作Lazy实例的值。
• LazyThreadSafetyMode.NONE：不会有任何线程安全的保证以及相关的开销，当初始化与使用总是位于相同线程中时使用。

如果lazy 属性的求值时不传 LazyThreadSafetyMode 参数，那么默认情况下走的是是LazyThreadSafetyMode.SYNCHRONIZED模式。

使用案例

先编写一个顶级扩展函数，注意其内部使用 lazy 包裹：

fun <T : View> Activity.id(id: Int) = lazy {
    findViewById<T>(id)
}

接下来就可以使用了：

//Activity
class ViewPager2DispatchActivity : AppCompatActivity() {
    //注意看是在这里使用的
    private val mTvTxNews: TextView by id(R.id.tv_tx_news)

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_view_pager2_dispatch)
        mTvTxNews.text = "我已经初始化好了，可以使用了"
    }
}

//XML中(activity_view_pager2_dispatch.xml)
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:id="@+id/tv_tx_news"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"/>
</androidx.constraintlayout.widget.ConstraintLayout>

可以看到通过private val mTvTxNews: TextView by id(R.id.tv_tx_news) 声明后，下面就可以正常使用该TextView了，其原理本质上就是通过 by lazy 延迟初始化了该属性，这种写法不需要每次去调用findViewById()了，跟我们使用ButterKnife 库的效果是一样的。同理，如果在Fragment中或其他场景中使用，继续写类似的扩展函数即可。 嗯，Kotlin 的语法糖真甜！

可观察属性（observable properties）

Delegates.observable()可以认为是一个属性监听器，当监听的属性变更时会收到通知。其接受两个参数：初始值initialValue与onChange()函数，当属性被赋值后就会触发onChange()，内部有三个参数：被赋值的属性、旧值与新值。

public inline fun <T> observable(initialValue: T, crossinline onChange: (property: KProperty<*>, oldValue: T, newValue: T) -> Unit): ReadWriteProperty<Any?, T> =
        object : ObservableProperty<T>(initialValue) {
            override fun afterChange(property: KProperty<*>, oldValue: T, newValue: T) = onChange(property, oldValue, newValue)
        }

Delegates.observable() 可以帮助我们在属性值发生变化时自动执行一些操作，例如更新UI、保存数据、防抖动等。它适用于需要对属性值进行监听和处理的场景。

使用案例

这里以实现一个防抖动功能为例：

class ExampleActivity : AppCompatActivity()  {
    private var lastClickTime by Delegates.observable(0L) { _, old, new ->
        // 在lastClickTime属性值发生变化时执行点击事件
        if (new - old > 1000) {
            onClick()
        }
    }

    override fun onClick(view: View) {
        //每次点击都会触发Delegates.observable()
        lastClickTime = System.currentTimeMillis()
    }

    private fun onClick() {
        // 点击事件代码
    }
}

上述代码中，在 lastClickTime 属性值发生变化时，判断两次点击时间的间隔是否大于 1 秒：如果是，则执行点击事件；如果不是，什么都不做。如此通过 Delegates.observable 便实现了防抖动能力。

注：在属性被赋新值生效之前想截获赋值，可以使用 vetoable() 取代 observable()，onChange()中会返回一个Boolean值来决定是否生效本次赋值。

属性之间的委托

从 Kotlin 1.4 开始，一个属性可以把它的 getter 与 setter 委托给另一个属性，被委托的属性属于顶层或普通类属性都可。

为将一个属性委托给另一个属性，可以使用 :: 限定符，例如，this::delegate 或 MyClass::delegate。

使用案例

class DelegateProperty {
    @Deprecated("Use [newName] instead", ReplaceWith("newName"))
    var oldName by this::newName //this可以省略
    var newName = ""
}

fun main() {
    val property = DelegateProperty()
    property.oldName = "2023"
    println("oldName: ${property.oldName}")
    println("newName: ${property.newName}")
}

//执行结果：
oldName: 2023
newName: 2023

当想要以一种向后兼容的方式重命名一个属性的时候：引入一个新的属性、 使用 @Deprecated 注解来注解旧的属性、并委托其实现。

欢迎扫描下方二维码或搜索微信公众号 代码说， 关注我的微信公众号查看最新文章~