Kotlin 对委托模式的理解（by关键字的用法）

📢 前言：关于委托模式和代理模式的区别？

在Kotlin中，委托模式和代理模式还是有些许不同之处的，代理模式是类似于Retrofit这种库中Retrofit.create的Proxy.newProxyInstance这种写法，分为动态代理和静态代理。而Kotlin还提供了一种简便的代理方法，叫做“委托模式”。

Kotlin中 by关键字 主要有两个用法：一个是委托类，一个是委托属性。

🌟 第一种写法：委托类

// 比如说定义一些接口
interface Base {
    fun print()
}
// 因为业务关系写了一些实现类
class BaseImpl(private val x: Int) : Base {
    override fun print() {
        println(x)
    }
}
// 这个时候不想修改以前的实现类，但是又想改变原有的逻辑（因为以前的实现类是非常
// 基础的功能没有大问题，想修改），这样就可以使用by关键字（委派类）
class Proxy(private val baseImpl: Base): Base by baseImpl {
    /* 下面几行代码可写可不写！ */
    override fun print() {
        // 可以不重写，也可以重写来覆盖逻辑
        // 比如这里重写print逻辑
        println("HookProxy")
        baseImpl.print()
    }
}

fun main() {
    val proxy = Proxy(BaseImpl(6666))
    proxy.print()
    // 上面的代码使用一个新的Proxy类，这个Proxy类改写了BaseImpl中
    // 原有的逻辑，但是没有改动以前的代码，就是委托模式的很好体现。
    // 这种写法可以结合观察者模式写一些框架。
}

上述代码中，Proxy继承于Base，但是如果没有实现print方法，肯定就要“谁来代理”，但是这个“代理类”必须也是实现了Base的类（因为kt会找到没实现的方法，然后去代理类中找有没有实现嘛，所以肯定要实现同一个Base类），所以就有了这个写法：
class Proxy(private val baseImpl: Base): Base by baseImpl { }
这样对Proxy的访问其实都传递给了baseImpl这个对象。（用Kotlin的反编译看看jvm字节码看看生成了什么？）

🌟 第二种写法：委托属性

我们经常看到by lazy { }这种写法。这个就是委托属性的一个用法。
首先讲讲委托属性的基本用法：

import kotlin.reflect.KProperty
// 创建一个委托类，可以代理任何类型的读写
class Delegate<T>(var value: T) {
	// 必须要写getValue
    operator fun getValue(t: T?, property: KProperty<*>): T {
    	// 可以添加一些额外的逻辑，例如通知观察者，很多库都利用这种方法。
        println("read value")
        return value
    }
    // 如果value是var，则一定要写setValue，否则不用写。
    operator fun setValue(t: T?, property: KProperty<*>, newValue: T) {
        // 可以通知观察者
        println("write value")
        value = newValue
    }
}

fun main() {
	// 用Delegate代理string类型，初始值为hello world
    var str by Delegate("hello world")
    println(str)
    // 这次修改是通过Delegate的setValue修改，而不是直觉上的替换了一个新的对象
    str = "Hello"
    // 这时候Delegate中的value已经为Hello了
    // 而且如果Delegate如果里面写了通知观察者的逻辑，就已经执行了
    print(str)
}

使用str = "Hello"这种形式居然能够通知观察者，或者在背后可以添加更复杂的逻辑，这就是Kotlin的委托属性这种写法带来的优势。了解这种写法后，就可以去翻看更复杂的库啦。（逻辑肯定都在getValue和setValue里呀）

现在有了这些基础后，来想想by lazy实现方式（自己实现一个），有没有头绪呢？
非常简单：

import kotlin.reflect.KProperty

class Lazy<T> (val initialize: () -> T) {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): T {
        println("我初始化啦！")
        return initialize()
    }
}
fun main() {
    val str by Lazy { "Hello" }
    // 删掉下面一行代码查看“我初始化啦！”是否输出，就可以知道是否实现了Lazy的功能
    println(str)
}

知道上面的已经够了！
拓展下：回来再写一个ObservableDelegate，发现其中的set(newValue) {}的这种写法里面竟然也可以写“通知观察者”的逻辑，所以，上面说的“逻辑肯定都在getValue和setValue里呀”其实也有可能在getter/setter里hhhh，比如说Android Compose中的MutableState<T>，可以去看看源码。

import kotlin.reflect.KProperty
// 这是刚刚写的代码
open class Delegate<T>(open var value: T) {
    operator fun getValue(t: T?, property: KProperty<*>): T {
        println("委派属性模式：read value")
        return value
    }
    operator fun setValue(t: T?, property: KProperty<*>, newValue: T) {
        println("委派属性模式：write value")
        value = newValue
    }
}
// 这是新写的类
class ObservableDelegate<T>(value: T): Delegate<T>(value) {
    override var value: T
    	// getter和setter都可以通知观察者，因为底层走的也是getValue和setValue
        get() = super.value
        set(newValue) {
            println("通知观察者")
            // 下面这句话‘=’触发了setValue
            super.value = newValue
        }
}


fun main() {
    // 用Delegate代理string类型，初始值为hello world
    var str by Delegate("hello world")
    println(str)
    // 这次修改是通过Delegate的setValue修改，而不是直觉上的替换了一个新的对象
    str = "Hello"
    // 这时候Delegate中的value已经为Hello了
    // 而且如果Delegate如果里面写了通知观察者的逻辑，就已经执行了
    println(str)
    println("========新方法========")
    var number by ObservableDelegate(1)
    println(number)
    number = 2
    println(number)
}

---

如果有帮助记得点个赞收藏或者点个关注，谢谢：）🙏