Skip to content
Permalink
Branch: master
Find file Copy path
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
293 lines (218 sloc) 10.6 KB

代理属性

有一些常见类型的属性,虽然我们可以在每次需要时去手动实现,但是更好的方式是只实现一次并对所有可用,然后封装成库。具体的例子有:

  • 懒属性:他们的值只在第一次访问时才被计算;
  • 可被观察的属性:监听器会接收到属性变化的通知;
  • 把属性存储在 map 中,无需每个属性都有一个单独的字段。

为了覆盖这些(以及其他的)case,Kotlin 支持代理属性

class Example {
    var p: String by Delegate()
}

语法是:val/var <property name>: <Type> by <expression>by 之后的表达式是代理,因为属性对应的 get()(以及 set())会被代理到它们的 getValue()setValue() 方法。属性代理无需实现任何接口,但是他们必须要要提供 getValue() 函数(以及 var 变量的 setValue())。例如:

class Delegate {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return "$thisRef, thank you for delegating '${property.name}' to me!"
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        println("$value has been assigned to '${property.name}' in $thisRef.")
    }
}

当我们读取 p (代理到一个 Delegate 的实例)时,会调用到 DelegategetValue() 函数,因此它的第一个参数是读取 p 所需的对象,第二个参数携带了 p 自身的描述(例如,可以获取它的名字)。例如:

val e = Example()
println(e.p)

打印结果:

Example@33a17727, thak you for delegating 'p' to me!

同样的,如果给 p 赋值,setValue() 函数也会被调用。前两个参数是一样的,第三个参数携带了将要赋的值:

e.p = "NEW"

打印结果:

NEW has been assigned to 'p' in Example@33a17727

代理对象的条件规格下面会讲到。

注意,从 Kotlin 1.1 开始,你可以在函数或者代码块内部声明一个代理属性,没必要是类成员。下面可以找到例子。

标准代理

Kotlin 的标准库为几种有用的代理类型提供了工厂方法。

懒(Lazy)

lazy() 是一个函数,参数是一个 lambda ,返回值是一个 Lazy<T> 实例,这个实例可以作为实现懒属性的代理:get() 的第一次调用会执行传给 lazy() 的 lambda 并且记录执行结果,后续的 get() 调用仅仅返回第一次记录的结果。

val lazyValue: String by lazy {
    println("computed!")
    "Hello"
}

fun main(args: Array<String>) {
    println(lazyValue)
    println(lazyValue)
}

打印结果:

computed!
Hello
Hello

默认情况下,懒属性的计算是同步的:值的计算只在一个线程里,所有线程可见的是同一个值。如果初始化代理的同步操作不是必需的,那么多个线程可以同时执行初始化,只需要把 LazyThreadSafetyMode.PUBLICATION 作为参数传给 lazy() 函数。如果初始化只会发生在一个线程里,可以使用 LazyThreadSafetyMode.NONE 模式,这样不会引发任何线程安全保证以及相关的开销。

可观察的

Delegates.observable() 有两个参数:初始值和变化改动的处理器。处理器的调用发生在每次给属性赋值时(在赋值执行之后)。它有三个参数:被赋值的属性,旧值和新值:

import kotlin.properties.Delegates

class User {
    var name: String by Delegates.observable("<no name>") {
        prop, old, new ->
        println("$old -> $new")
    }
}

fun main(args: Array<String>) {
    val user = User()
    user.name = "first"
    user.name = "second"
}

打印结果:

<no name> -> first
first -> second

如果想能够拦截一个赋值并且“否决”它的话,可以用 vetoable() 来代替 observable()。传入 vetoable 的处理器的调用发生在在新属性的赋值操作执行之前。

在 Map 中保存属性

一个常见使用场景是把属性的值保存在一个 map 中。经常会应用在一些像解析 JSON 或者做其他“动态”事情的应用中。这种情况下,可以使用 map 实例本身作为代理属性的代理。

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

在这个例子中,构造器接收一个 map:

val user = User(mapOf(
    "name" to "John Doe",
    "age" to 25
))

代理的属性会从 map 中取值(通过字符串型的 key —— 属性的名字):

println(user.name)  // Prints "John Doe"
println(user.age)   // Prints 25

如果把只读的 Map 替换成 MutableMapvar 属性也可以这么用:

class MutableUser(val map: MutableMap<String, Any?>) {
    var name: String    by map
    var age: Int        by map
}

本地代理属性(从 1.1 开始)

可以把代理属性声明为局部变量。例如,可以让一个局部变量懒执行:

fun example(computeFoo: () -> Foo) {
    val memoizedFoo by lazy(computeFoo)

    if (someCondition && meoizedFoo.isValid()) {
        memoizedFoo.doSomething()
    }
}

memoizedFoo 变量只有在第一次访问时才会被计算。如果 someCondition 失败了,这个变量根本就不会被计算。

属性代理的要求

这里我们总结了对对象进行代理的要求:

对于只读的属性(也就是,val 型),代理需要提供一个名为 getValue 的函数,其参数有:

  • thisRef —— 必须和*属性拥有者**一样或者是它的超类型(对于扩展属性,指的是被扩展的类型);
  • property —— 必须是 KProperty<*> 类型或者是它的超类型。

这个函数必须返回跟属性一样的类型(或者是它的超类型)。

对于可变属性(var 型),代理必须另外提供一个名为 setValue 的函数,参数如下:

  • thisRef —— 和 getValue() 一样;
  • property —— 和 getValue() 一样;
  • 新值 —— 必须是属性的类型或者它的超类型。

getValue() 以及/或者 setValue() 函数的提供方式可以是代理类的成员函数或者是扩展函数。在这种情况下后者会更好用:我们需要代理一个对象的属性,它原本也没有提供这些函数。这两种函数都需要用 operator 关键字来标记。

代理类可以实现接口 ReadOnlyPropertyReadWriteProperty 的其中之一,它们都包含了所需的 operator 方法。这些接口定义在 Kotlin 的标准库中:

interface ReadOnlyProperty<in R, out T> {
    operator fun getValue(thisRef: R, property: KProperty<*>): T
}

interface ReadWriteProperty<in R, T> {
    operator fun getValue(thisRef: R, property: KProperty<*>): T
    operator fun setValue(thisRef: R, property: KProperty<*>, value: T)
}

转换规则

底层代码中,对于每一个代理的属性,Kotlin 编译器会生成一个辅助属性并代理给它。例如,对于属性 prop 会生成一个隐藏的属性 prop$delegate,访问器的代码也只是代理到这个额外的属性上:

class C {
    var prop: Type by MyDelegate()
}

// this code is generated by the compiler instead:
class C {
    private val prop$delegate = MyDelegate()
    var prop: Type
        get() = prop$delegate.getValue(this, this::prop)
        set(value: Type) = prop$delegate.setValue(this, this::prop, value)
}

Kotlin 编译器会在参数中提供所有关于 prop 的必要信息:第一个参数 this 指向外部类 C 的实例,this::prop 是一个 KProperty 类型的反射对象,它描述了 prop 自身。

注意 this::prop 的用法,它可以直接在代码中指向一个受限的可调用引用,这个语法从 Kotlin 1.1 开始支持。

提供代理(从 1.1 开始)

通过定义 provideDelegate 操作符,我们可以扩展创建对象的逻辑,这个对象的属性实现是被代理的。如果用于 by 右侧的对象把 provideDelegate 定义为成员或扩展函数,那么这个函数就会用来创建属性代理的实例。

provideDelegate 可能的使用场景之一是在属性创建时检查属性的一致性,而不是只是在它的 getter 和 setter 中。

例如,如果你想在绑定之前检查属性名字,可以写成如下形式:

class ResourceDelegate<T>: ReadOnlyProperty<MyUI, T> {
    override fun getValue(thisRef: MyUI, property: KProperty<*>): T { ... }
}

class ResourceLoader<T>(id: ResourceID<T>) {
    operator fun provideDelegate(
        thisRef: MyUI,
        prop: KProperty<*>
    ): ReadOnlyProperty<MyUI, T> {
        checkProperty(thisRef, prop.name)
        // create delegate
        return ResourceDelegate()
    }

    private fun checkProperty(thisRef: MyUI, name: String) { ... }
}

class MyUI {
    fun <T> bindResource(id: ResourceID<T>): ResourceLoader<T> { ... }

    val image by bindResource(ResourceID.image_id)
    val text by bindResource(ResourceID.text_id)
}

provideDelegate 的参数和 getValue 一样:

  • thisRef —— 必须和*属性拥有者**一样或者是它的超类型(对于扩展属性,指的是被扩展的类型);
  • property —— 必须是 KProperty<*> 类型或者是它的超类型。

MyUI 实例创建期间,每个属性都会引起 provideDelegate 方法的调用,并且它会立即执行必要的验证。

如果没有能力来拦截属性和它的代理之间的绑定,要实现同样的功能,必须显示地传入属性名字,这样做非常不方便:

// Checking the property name without "provideDelegate" functionality
class MyUI {
    val iamge by bindResource(ResourceID.image_id, "image")
    val text by bindResource(ResourceID.text_id, "text")
}

fun <T> MyUI.bindResource(
    id: ResourceID<T>,
    propertyName: String
): ReadOnlyProperty(MyUI, T> {
    checkProperty(this, propertyName)
    // create delegate
}

生成的代码中会调用 provideDelegate 方法来初始化辅助的 prop$delegate 属性。可以把属性声明 val prop: Type by MyDelegate() 所生成的代码与上面生成的代码(不提供 provideDelegate 方法)做个比较:

class C {
    var prop: Type by MyDelegate()
}

// this code is generated by the compiler
// when the 'provideDelegate' function is available:
class C {
    // calling "provideDelegate" to create the additional "delegate" property
    private val prop$delegate = MyDelegate().provideDelegate(this, this::prop)
    val prop: Type
        get() = prop$delegate.getValue(this, this::prop)
}

注意,provideDelegate 方法只会影响辅助属性的创建,并不影响为 getter 和 setter 生成的代码。

You can’t perform that action at this time.