聊聊kotlin属性委托源码解析（三）

1. 什么是属性委托

属性委托就是在一个类中，生成一个委托对象来保存被委托的属性。委托对象要求：拥有被 operator修饰的 getValue 和 setValue 函数，当获取属性或者为属性赋值的时候，会自动调用委托对象的getValue 和 setValue 函数。属性委托可以和val、var配合使用，主要是看委托的对象有没有getValue和setValue方法，Delegates.notNull() 返回的ReadWriteProperty对象两个方法都有，所以可以和var、val搭配使用。lazy方法返回的委托对象SynchronizedLazyImpl没有setValue方法，所以只能和val搭配使用。

2. 属性委托转换规则

先来自己定义一个属性委托的对象：

class Person {
    var age: Int by AgeDelegate()
}

class AgeDelegate {
    private var age: Int = 0

    operator fun getValue(thisRef: Any?, property: KProperty<*>): Int {
        return age
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: Int) {
        age = value
    }
}

上边的代码，当获取Person对象的age属性或者为age属性赋值时，kotlin就会自动调用 AgeDelegate对象的 getValue 和 setValue 方法，编译器实际生成的代码如下：

class Person {
    private var ageDelegate: AgeDelegate = AgeDelegate()
    var age: Int
        get() = ageDelegate.getValue(this, ::age)
        set(value) = ageDelegate.setValue(this, ::age, value)
}

通过这个例子就可以看出，其实属性委托的原理非常简单，就是用一个委托的对象管理属性。kotlin利用这个特质，给出了属性委托常用的两个场景：惰性初始化 和 属性监听

3. 惰性初始化 lazy标准函数源码解析

直接看 lazy函数 的源码：

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

lazy 函数接收一个函数类型作为参数，他的最终返回值是 SynchronizedLazyImpl 的实例：

private class SynchronizedLazyImpl<out T>(initializer: () -> T, lock: Any? = null) : Lazy<T>, Serializable {
    private var initializer: (() -> T)? = initializer
    @Volatile private var _value: Any? = UNINITIALIZED_VALUE

    private val lock = lock ?: this

    override val value: T
        get() {
            val _v1 = _value
            if (_v1 !== UNINITIALIZED_VALUE) {
                @Suppress("UNCHECKED_CAST")
                return _v1 as T
            }

            return synchronized(lock) {
                val _v2 = _value
                if (_v2 !== UNIN
                ITIALIZED_VALUE) {
                    @Suppress("UNCHECKED_CAST") (_v2 as T)
                } else {
                    val typedValue = initializer!!()
                    _value = typedValue
                    initializer = null
                    typedValue
                }
            }
        }
}



public interface Lazy<out T> {
    public val value: T

    public fun isInitialized(): Boolean
}

SynchronizedLazyImpl 类实现了 Lazy 接口，它内部实现了 value 属性并且重写了 get 方法。get 方法很简单，就是先判断 _value 是否已经初始化，如果初始化了直接返回，如果没有初始化，这里加上了同步锁来保证多线程安全，直接调用外部传进来的 initializer 方法来创建一个实例保存并返回。结束了吗？到这里我们似乎并没有看到被 operator 修饰的 getValue 方法啊？上边不是说属性委托要求委托对象有特定的方法吗？
其实是这样的：kotlin为Lazy添加了拓展方法，方法直接返回value属性，从而调用了上边的get方法。

public inline operator fun <T> Lazy<T>.getValue(thisRef: Any?, property: KProperty<*>): T = value

4. 属性监听 Delegates.observable 源码解析

属性监听是属性委托的另一大应用，先来看一段代码：

class Person {
    var age: Int by Delegates.observable(
        1,
        { property, oldValue, newValue -> print("newAge is $newValue") }
    )
}

age的默认值为1，每当 age 改变的时候，lambda表达式就会被执行，打印出 newAge，实现属性监听的效果。直接看Delegates.observable的源码：

    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)
    }
        
public abstract class ObservableProperty<T>(initialValue: T) : ReadWriteProperty<Any?, T> {
    private var value = initialValue

    protected open fun beforeChange(property: KProperty<*>, oldValue: T, newValue: T): Boolean = true

    protected open fun afterChange(property: KProperty<*>, oldValue: T, newValue: T): Unit {}

    public override fun getValue(thisRef: Any?, property: KProperty<*>): T {
        return value
    }

    public override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
        val oldValue = this.value
        if (!beforeChange(property, oldValue, value)) {
            return
        }
        this.value = value
        afterChange(property, oldValue, value)
    }
}

可以看到 observable 方法实际上是返回了一个继承 ObservableProperty类的匿名对象，ObservableProperty对象中我们看到了 getValue 和 setValue 方法。在 setValue方法中，最后会执行 afterChange 方法，在匿名对象中重写了 afterChange 方法，并且会调用 observable 方法传进来的 onChange 参数，这样每次属性改变，就会回调 onChange 方法，从而达到监听的目的。

ok，关于属性委托就这么多！