Kotlin 七 委托

委托模式是软件设计模式中的一项基本技巧。在委托模式中，有两个对象参与处理同一个请求，接受请求的对象将请求委托给另外一个对象来处理。

Kotlin 直接支持委托模式，更加优雅，简洁。Kotlin 经过关键字 by 实现委托。

---

类委托

类的委托即一个类中定义的方法实际是调用另外一个类的对象的方法来实现的。

如下实例中派生类 Derived 继承了接口 Base 全部方法，而且委托一个传入的 Base 类的对象来执行这些方法。

// 建立接口
interface Base {   
    fun print()
}

// 实现此接口的被委托的类
class BaseImpl(val x: Int) : Base {
    override fun print() { print(x) }
}

// 经过关键字 by 创建委托类
class Derived(b: Base) : Base by b

fun main(args: Array<String>) {
    val b = BaseImpl(10)
    Derived(b).print() // 输出 10
}

　在 Derived 声明中，by 子句表示，将 b 保存在 Derived 的对象实例内部，并且编译器将会生成继承自 Base 接口的全部方法, 并将调用转发给 b。

　

属性委托

属性委托指的是一个类的某个属性值不是在类中直接进行定义，而是将其托付给一个代理类，从而实现对该类的属性统一管理。

属性委托语法格式：

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

• var/val：属性类型(可变/只读)
• 属性名：属性名称
• 类型：属性的数据类型
• 表达式：委托代理类

by 关键字以后的表达式就是委托, 属性的 get() 方法(以及set() 方法)将被委托给这个对象的 getValue() 和 setValue() 方法。属性委托没必要实现任何接口, 但必须提供 getValue() 函数(对于 var属性,还须要 setValue() 函数)。

定义一个被委托的类

该类须要包含 getValue() 方法和 setValue() 方法，且参数 thisRef 为进行委托的类的对象，prop 为进行委托的属性的对象。

import kotlin.reflect.KProperty
// 定义包含属性委托的类
class Example {
    var p: String by Delegate()
}

// 委托的类
class Delegate {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return "$thisRef, 这里委托了 ${property.name} 属性"
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        println("$thisRef 的 ${property.name} 属性赋值为 $value")
    }
}
fun main(args: Array<String>) {
    val e = Example()
    println(e.p)     // 访问该属性，调用 getValue() 函数

    e.p = "Runoob"   // 调用 setValue() 函数
    println(e.p)
}

标准委托

Kotlin 的标准库中已经内置了不少工厂方法来实现属性的委托。

延迟属性 Lazy

lazy() 是一个函数, 接受一个 Lambda 表达式做为参数, 返回一个 Lazy <T> 实例的函数，返回的实例能够做为实现延迟属性的委托： 第一次调用 get() 会执行已传递给 lazy() 的 lamda 表达式并记录结果， 后续调用 get() 只是返回记录的结果。

　

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

fun main(args:Array<String>)
{
    println(lazyValue)// // 第一次执行，执行两次输出表达式
    println("-------------")
    println(lazyValue) // 第一次执行，执行两次输出表达式
}

　　

可观察属性 Observable

observable 能够用于实现观察者模式。

Delegates.observable() 函数接受两个参数: 第一个是初始化值, 第二个是属性值变化事件的响应器(handler)。

在属性赋值后会执行事件的响应器(handler)，它有三个参数：被赋值的属性、旧值和新值：

　

import kotlin.properties.Delegates

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

fun main(args:Array<String>)
{
    val user =User()

    user.name = "第一次赋值" //old:初始值 -> new :第一次赋值
    user.name = "第二次赋值" //old:第一次赋值 -> new :第二次赋值
}

运行结果：

old:初始值 -> new :第一次赋值
old:第一次赋值 -> new :第二次赋值

把属性储存在映射中

一个常见的用例是在一个映射（map）里存储属性的值。 这常常出如今像解析 JSON 或者作其余"动态"事情的应用中。 在这种状况下，你可使用映射实例自身做为委托来实现委托属性。

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

fun main(args:Array<String>)
{
    val site = Site(mapOf(
        "name" to "zhaosi",
        "url" to "http://www.zhaosi.com"
    ))

    println(site.name)
    println(site.url)
}

　若是使用 var 属性，须要把 Map 换成 MutableMap：　

class Site(val map: MutableMap<String, Any?>) {
    val name: String by map
    val url: String by map
}


fun main(args:Array<String>)
{
    var map:MutableMap<String,Any?> = mutableMapOf(
        "name" to "zhaosi",
        "url" to "www.zhaosi.com"
    )

    val sit = Site(map)

    println(sit.name)
    println(sit.url)

    println("------------")

    map.put("name","liuneng")
    map.put("url","www.liuneng.com")
    println(sit.name)
    println(sit.url)
}

　　

Not Null

notNull 适用于那些没法在初始化阶段就肯定属性值的场合。

import kotlin.properties.Delegates

class Foo{
    var notNullBar:String by Delegates.notNull<String>()
}

fun main(args:Array<String>)
{
    var foo = Foo()
    foo.notNullBar = "bar"
    println(foo.notNullBar)
}

　须要注意，若是属性在赋值前就被访问的话则会抛出异常。

局部委托属性

你能够将局部变量声明为委托属性。 例如，你可使一个局部变量惰性初始化：

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

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

memoizedFoo 变量只会在第一次访问时计算。 若是 someCondition 失败，那么该变量根本不会计算。　　

属性委托要求

对于只读属性(也就是说val属性), 它的委托必须提供一个名为getValue()的函数。该函数接受如下参数：

• thisRef —— 必须与属性全部者类型（对于扩展属性——指被扩展的类型）相同或者是它的超类型
• property —— 必须是类型 KProperty<*> 或其超类型

这个函数必须返回与属性相同的类型（或其子类型）。

对于一个值可变(mutable)属性(也就是说,var 属性),除 getValue()函数以外,它的委托还必须 另外再提供一个名为setValue()的函数, 这个函数接受如下参数:

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

翻译规则

在每一个委托属性的实现的背后，Kotlin 编译器都会生成辅助属性并委托给它。 例如，对于属性 prop，生成隐藏属性 prop$delegate，而访问器的代码只是简单地委托给这个附加属性：

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

// 这段是由编译器生成的相应代码：
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 自身。

提供委托

经过定义 provideDelegate 操做符，能够扩展建立属性实现所委托对象的逻辑。 若是 by 右侧所使用的对象将 provideDelegate 定义为成员或扩展函数，那么会调用该函数来 建立属性委托实例。

provideDelegate 的一个可能的使用场景是在建立属性时（而不只在其 getter 或 setter 中）检查属性一致性。

例如，若是要在绑定以前检查属性名称，能够这样写：

class ResourceLoader<T>(id: ResourceID<T>) {
    operator fun provideDelegate(
            thisRef: MyUI,
            prop: KProperty<*>
    ): ReadOnlyProperty<MyUI, T> {
        checkProperty(thisRef, prop.name)
        // 建立委托
    }

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

fun <T> bindResource(id: ResourceID<T>): ResourceLoader<T> { …… }

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

　　

provideDelegate 的参数与 getValue 相同：

• thisRef —— 必须与 属性全部者 类型（对于扩展属性——指被扩展的类型）相同或者是它的超类型
• property —— 必须是类型 KProperty<*> 或其超类型。

在建立 MyUI 实例期间，为每一个属性调用 provideDelegate 方法，并当即执行必要的验证。

若是没有这种拦截属性与其委托之间的绑定的能力，为了实现相同的功能， 你必须显式传递属性名，这不是很方便：

// 检查属性名称而不使用“provideDelegate”功能
class MyUI {
    val image 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)
   // 建立委托
}

在生成的代码中，会调用 provideDelegate 方法来初始化辅助的 prop$delegate 属性。 比较对于属性声明 val prop: Type by MyDelegate() 生成的代码与 上面（当 provideDelegate 方法不存在时）生成的代码：　　

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

// 这段代码是当“provideDelegate”功能可用时
// 由编译器生成的代码：
class C {
    // 调用“provideDelegate”来建立额外的“delegate”属性
    private val prop$delegate = MyDelegate().provideDelegate(this, this::prop)
    val prop: Type
        get() = prop$delegate.getValue(this, this::prop)
}

请注意，provideDelegate 方法只影响辅助属性的建立，并不会影响为 getter 或 setter 生成的代码。