阅读 1103

Kotlin | 委托机制 & 原理 & 应用

点赞关注,不再迷路,你的支持对我意义重大!

🔥 Hi,我是丑丑。本文 「Android 路线」| 导读 —— 从零到无穷大 已收录,这里有 Android 进阶成长路线笔记 & 博客,欢迎跟着彭丑丑一起成长。(联系方式在 GitHub)


前言

  • 委托(Delegate)是 Kotlin 的一种语言特性,用于更加优雅地实现委托模式;
  • 在这篇文章里,我将总结 Kotlin 委托机制的使用方法 & 原理,如果能帮上忙,请务必点赞加关注,这真的对我非常重要。

目录


1. 概述

  • 什么是委托: 一个对象将消息委托给另一个对象来处理。
  • Kotlin 委托解决了什么问题: Kotlin 通过 by 关键字可以更加优雅地实现委托。

2. Kotlin 委托基础

  • 类委托: 一个类的方法不在该类中定义,而是直接委托给另一个对象来处理。
  • 属性委托: 一个类的属性不在该类中定义,而是直接委托给另一个对象来处理。
  • 局部变量委托: 一个局部变量不在该方法中定义,而是直接委托给另一个对象来处理。

2.1 类委托

Kotlin 类委托的语法格式如下:

class <类名>(b : <基础接口>) : <基础接口> by <基础对象>
复制代码

举例:

// 基础接口
interface Base {   
    fun print()
}

// 基础对象
class BaseImpl(val x: Int) : Base {
    override fun print() { print(x) }
}

// 被委托类
class Derived(b: Base) : Base by b

fun main(args: Array<String>) {
    val b = BaseImpl(10)
    Derived(b).print() // 最终调用了 Base#print()
}
复制代码

基础类和被委托类都实现同一个接口,编译时生成的字节码中,继承自 Base 接口的方法都会委托给基础对象处理。

2.2 属性委托

Kotlin 属性委托的语法格式如下:

val/var <属性名> : <类型> by <基础对象>
复制代码

举例:

class Example {
    // 被委托属性
    var prop: String by Delegate() // 基础对象
}

// 基础类
class Delegate {
    private var _realValue: String = "彭"

    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        println("getValue")
        return _realValue
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        println("setValue")
        _realValue = value
    }
}

fun main(args: Array<String>) {
    val e = Example()
    println(e.prop)    // 最终调用 Delegate#getValue()
    e.prop = "Peng"    // 最终调用 Delegate#setValue()
    println(e.prop)    // 最终调用 Delegate#getValue()
}

输出:
getValue
彭
setValue
getValue
Peng
复制代码

基础类不需要实现任何接口,但必须提供 getValue() 方法,如果是委托可变属性,还需要提供 setValue()。在每个属性委托的实现的背后,Kotlin 编译器都会生成辅助属性并委托给它。 例如,对于属性 prop,会生成「辅助属性」 prop$delegate。 而 prop 的 getter() 和 setter() 方法只是简单地委托给辅助属性的 getValue() 和 setValue() 处理。

源码:
class Example {
    // 被委托属性
    var prop: String by Delegate() // 基础对象
}

--------------------------------------------------------
编译器生成的字节码:
class Example {
    private val prop$delegate = Delegate()
    // 被委托属性
    var prop: String
        get() = prop$delegate.getValue(this, this:prop)
        set(value : String) = prop$delegate.setValue(this, this:prop, value)
}
复制代码

注意事项:

  • thisRef —— 必须与属性所有者类型相同或者是它的超类型。
  • property —— 必须是类型 KProperty<*> 或其超类型。
  • value —— 必须和属性同类型或者是它的超类型。

2.3 局部变量委托

局部变量也可以声明委托,例如:

fun main(args: Array<String>) {
    val lazyValue: String by lazy {
        println("Lazy Init Completed!")
        "Hello World."
    }

    if (true/*someCondition*/) {
        println(lazyValue) // 首次调用
        println(lazyValue) // 后续调用

    }
}
输出:
Lazy Init Completed!
Hello World.
Hello World.
复制代码

3. Kotlin 委托进阶

3.1 延迟属性委托 lazy

lazy 是一个标准库函数,参数为一个 Lambda 表达式,返回值为一个 Lazy 实例,使用 lazy 可以实现延迟属性委托,在委托对象比较耗资源的场景会非常有用。首次访问属性是,会执行 lazy 函数的 lambda 表达式并将结果记录到「背域」,后续调用 getter() 方法只是直接返回「背域」的值。 例如:

val lazyValue: String by lazy {
    println("Lazy Init Completed!")
    "Hello World."
}

fun main(args: Array<String>) {
    println(lazyValue) // 首次调用
    println(lazyValue) // 后续调用
}

输出:
Lazy Init Completed!
Hello World.
Hello World.
复制代码

3.2 可观察属性 ObservableProperty

使用 Delegates.observable() 可以实现可观察属性,函数接受两个参数:第一个参数为初始值,第二个参数为属性值变化的回调。函数的返回值是 ObservableProperty 可观察属性,它在调用 setValue(...) 是触发回调。例如:

class User {
    var name: String by Delegates.observable("初始值") { prop, old, new ->
        println("旧值:$old -> 新值:$new")
    }
}

fun main(args: Array<String>) {
    val user = User()
    user.name = "第一次赋值"
    user.name = "第二次赋值"
}

输出:
旧值:初始值 -> 新值:第一次赋值
旧值:第一次赋值 -> 新值:第二次赋值
复制代码

3.3 使用 Map 存储属性值

Map / MutableMap 也可以用来实现属性委托,从而此时字段名是 Key,属性值是 Value。例如;

class User(val map: Map<String, Any?>) {
    val name: String by map
}

fun main(args: Array<String>) {
    val map = mutableMapOf(
        "name" to "彭"
    )
    val user = User(map)
    println(user.name)
    map["name"] = "peng"
    println(user.name)
}
输出:
彭
peng
复制代码

3.4 ReadOnlyProperty / ReadWriteProperty

实现属性委托或局部委托时,除了定义类 Delegate 外,还可以直接使用 Kotlin 标准库中的两个接口:ReadOnlyProperty / ReadWriteProperty。对于 val 变量使用 ReadOnlyProperty,而 var 变量实现ReadWriteProperty,使用这两个接口可以方便地让 IDE 帮你生成函数签名。例如:

val name by object : ReadOnlyProperty<Any?, String> {
    override fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return "Peng"
    }
}

var name by object : ReadWriteProperty<Any?, String> {
    override fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return "Peng"
    }

    override fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
    }
}
复制代码

4. 在 Android 中使用 Kotlin 委托

4.1 Kotlin 委托 + Fragment / Activity 传参

我们经常需要在 Activity / Fragment 之间传递参数,类似以下代码:

OrderDetailFragment.kt

class OrderDetailFragment : Fragment(R.layout.fragment_order_detail) {

    private var orderId: Int? = null
    private var orderType: Int? = null

    companion object {

        const val EXTRA_ORDER_ID = "orderId"
        const val EXTRA_ORDER_TYPE = "orderType";

        fun newInstance(orderId: Int, orderType: Int?) = OrderDetailFragment().apply {
            Bundle().apply {
                putInt(EXTRA_ORDER_ID, orderId)
                if (null != orderType) {
                    putInt(EXTRA_ORDER_TYPE, orderType)
                }
            }.also {
                arguments = it
            }
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        arguments?.let {
            orderId = it.getInt(EXTRA_ORDER_ID, 10000)
            orderType = it.getInt(EXTRA_ORDER_TYPE, 2)
        }
    }
}
复制代码

可以看到我们要为每个参数编写类似的模板代码,还要考虑参数为空的问题,而且 Int 基础类型不能使用 lateinit 关键字,你还不得不声明属性为可空类型,即使你可以确保它不会为空。

有没有办法收敛模板代码呢?这里就符合委托机制的应用场景了,我们可以把参数赋值和获取的代码抽取委托类,然后将 orderId 和 orderType 声明为「委托属性」。例如:

OrderDetailFragment.kt

class OrderDetailFragment : Fragment(R.layout.fragment_order_detail) {

    private lateinit var tvDisplay: TextView

    private var orderId: Int by fragmentArgument()
    private var orderType: Int? by fragmentArgumentNullable(2)

    companion object {
        fun newInstance(orderId: Int, orderType: Int?) = OrderDetailFragment().apply {
            this.orderId = orderId
            this.orderType = orderType
        }
    }

    override fun onViewCreated(root: View, savedInstanceState: Bundle?) {
        // Try to modify (UnExcepted)
        this.orderType = 3
        // Display Value
        tvDisplay = root.findViewById(R.id.tv_display)
        tvDisplay.text = "orderId = $orderId, orderType = $orderType"
    }
}
复制代码

干净清爽!相对于常规的写法,使用属性委托优势很明显:

  • 1、样板代码减少: 不再需要定义 Key 字符串,而是直接使用变量名作为 Key;不再需要编写向 Argument 设置参数和读取参数的代码;
  • 2、非空参数可以声明 val: 可空参数和非空参数区分两种委托,现在非空参数也可以声明为 val 了;
  • 3、清晰地设置可空参数默认值: 声明可空参数时可以顺便声明默认值。

除了 Fragment 传参,Activity 传参也可以使用委托属性。完整代码和演示工程你可以直接下载查看:下载路径,这里只展示部分核心代码如下:

ArgumentDelegate.kt

fun <T> fragmentArgument() = FragmentArgumentProperty<T>()

class FragmentArgumentProperty<T> : ReadWriteProperty<Fragment, T> {

    override fun getValue(thisRef: Fragment, property: KProperty<*>): T {
        return thisRef.arguments?.getValue(property.name) as? T
            ?: throw IllegalStateException("Property ${property.name} could not be read")
    }

    override fun setValue(thisRef: Fragment, property: KProperty<*>, value: T) {
        val arguments = thisRef.arguments ?: Bundle().also { thisRef.arguments = it }
        if (arguments.containsKey(property.name)) {
            // The Value is not expected to be modified
            return
        }
        arguments[property.name] = value
    }
}
复制代码

4.2 Kotlin 委托 + ViewBinding

ViewBinding 是 Android Gradle Plugin 3.6 中新增的特性,用于更加轻量地实现视图绑定,可以理解为轻量版本的 DataBinding。ViewBinding 的使用方法和实现原理都很好理解,但常规的使用方法存在一些局限性:

  • 1、创建和回收 ViewBinding 对象需要重复编写样板代码,特别是在 Fragment 中使用的案例;
  • 2、binding 属性是可空的,也是可变的,使用起来不方便。

使用 Kotlin 属性委托可以非常优雅地解决这两个问题,优化前后对比:

TestFragment.kt

class TestFragment : Fragment(R.layout.fragment_test) {

    private var _binding: FragmentTestBinding? = null

    private val binding get() = _binding!!

    override fun onViewCreated(root: View, savedInstanceState: Bundle?) {
        _binding = FragmentTestBinding.bind(root)

        binding.tvDisplay.text = "Hello World."
    }

    override fun onDestroyView() {
        super.onDestroyView()

        _binding = null
    }
}
复制代码

优化后:

TestFragment.kt

class TestFragment : Fragment(R.layout.fragment_test) {

    private val binding by viewBinding(FragmentTestBinding::bind)

    override fun onViewCreated(root: View, savedInstanceState: Bundle?) {
        binding.tvDisplay.text = "Hello World."
    }
}
复制代码

干净清爽!详细分析过程你直接看我的另一篇文章:Android | ViewBinding 与 Kotlin 委托双剑合璧


5. 总结

Kotlin 委托的语法关键字是 by,其本质上是面向编译器的语法糖,三种委托(类委托、对象委托和局部变量委托)在编译时都会转化为 “无糖语法”。例如类委托:编译器会实现基础接口的所有方法,并直接委托给基础对象来处理。例如对象委托和局部变量委托:在编译时会生成辅助属性(prop$degelate),而属性 / 变量的 getter() 和 setter() 方法只是简单地委托给辅助属性的 getValue() 和 setValue() 处理。


参考资料

  • Kotlin 委托 —— 菜鸟教程 著
  • Kotlin 实战(第 7 章)—— [俄] DmitryJeme 著

创作不易,你的「三连」是丑丑最大的动力,我们下次见!

文章分类
Android
文章标签