关于android:Kotlin-Vocabulary-Kotlin-内建代理

代理能够帮忙您将工作委托给其余对象，从而带来更佳的代码复用性，您能够从咱们之前的文章理解到更多信息。Kotlin 不仅能够让您通过 by 关键字轻松实现代理，还在规范库中提供了像 lazy()、observable()、vetoable() 以及 notNull() 这样的内建代理。接下来就让咱们开始理解这些内建代理的应用，以及其外部的实现原理。

lazy()))) 函数是一个属性代理，它能够帮您在第一次拜访属性时对它们进行惰性初始化。这个函数在创立低廉对象时非常有用。

lazy() 函数接管两个参数，LazyThreadSafetyMode 枚举值与一个 lambda 表达式。

LazyThreadSafetyMode 用于指定初始化过程如何在不同线程间进行同步，它的默认值是 LazyThreadSafetyMode.SYNCHRONIZED。这意味着初始化操作是线程平安的，但代价是显式同步会对性能造成轻微影响。

lambda 表达式会在属性第一次被拜访时执行，而它的值将会被存储以用于接下来的拜访。

<!-- Copyright 2020 Google LLC.
SPDX-License-Identifier: Apache-2.0 -->

class Person(name: String, lastname: String) {val fullname: String by lazy() {name + lastname}
   //…
}

在查看反编译后的 Java 代码时，咱们能够看到 Kotlin 编译器为惰性 (lazy) 代理创立了一个 Lazy 类型的援用:

<!-- Copyright 2020 Google LLC.
SPDX-License-Identifier: Apache-2.0 -->

@NotNull
private final Lazy fullname$delegate;

这一代理通过调用 LazyKt.lazy() 函数，并传入您定义的 lambda 表达式与线程平安模式参数来进行初始化:

<!-- Copyright 2020 Google LLC.
SPDX-License-Identifier: Apache-2.0 -->

  this.fullname$delegate = LazyKt.lazy((Function0)(new Function0() {
     @NotNull
     public final String invoke() {return name + lastname;}
  }));

让咱们来察看 lazy() 的源码。因为 lazy() 函数默认应用 LazyThreadSafetyMode.SYNCHRONIZED 参数，因而它将返回一个 SynchronizedLazyImpl 类型的 Lazy 对象:

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

当属性代理第一次被拜访时，SynchronizedLazyImpl 的 getValue() 函数就会被调用，这个函数将会在一个 synchronized 块中对属性进行初始化：

 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 !== UNINITIALIZED_VALUE) {@Suppress("UNCHECKED_CAST") (_v2 as T)
           } else {val typedValue = initializer!!()
               _value = typedValue
               initializer = null
               typedValue
           }
       }
   }

这样就能保障惰性对象会以线程平安的形式初始化，但同时也引入了由 synchronized 块带来的额定开销。

留神: 如果您确定资源会在单线程中被初始化，您能够向 lazy() 传入 LazyThreadSafetyMode.NONE，这样函数就不会在惰性初始化时应用 synchronized 块。不过请记住，LazyThreadSafetyMode.NONE 不会扭转惰性初始化的同步个性。因为惰性初始化是同步的，所以在第一次拜访时仍会耗费与非惰性初始化过程雷同的工夫，这意味着那些初始化过程较为耗时的对象仍会在被拜访时阻塞 UI 线程。
1val lazyValue: String by lazy(LazyThreadSafetyMode.NONE) {“lazy”}

惰性初始化能够帮忙初始化低廉资源，但对于诸如 String 一类的简略对象，因为 lazy() 函数须要生成 Lazy 和 KProperty 这样的额定对象，反而会减少整个过程的开销。

Delegates.observable() 是另一个 Kotlin 规范库中内建的代理。观察者模式是一种设计模式，在这一模式中，一个对象会保护一个它的隶属者的列表，这些隶属者即被称为观察者。对象会在它本人的状态扭转时对观察者进行告诉。这一模式非常符合多个对象须要在某个值产生扭转时失去告诉的状况，能够防止实现为隶属对象周期调用和查看资源是否更新。

observable() 函数接管两个参数: 初始化值与一个当值产生扭转时会被调用的监听处理器。observable() 会创立一个 ObservableProperty 对象，用于在每次 setter 被调用时执行您传给代理的 lambda 表达式。

<!-- Copyright 2020 Google LLC.
SPDX-License-Identifier: Apache-2.0 -->

class Person {var address: String by Delegates.observable("not entered yet!") {
        property, oldValue, newValue ->
        // 执行更新操作
    }
}

通过观察反编译后的 Person 类型，咱们能够看到 Kotlin 编译器生成了一个继承 ObservableProperty 的类。这个类同时也实现了一个叫做 afterChange() 的函数，这个函数持有您传递给 observable 代理的 lambda 函数。

<!-- Copyright 2020 Google LLC.
SPDX-License-Identifier: Apache-2.0 -->

protected void afterChange(@NotNull KProperty property, Object oldValue, Object newValue) {// 执行更新操作}

afterChange() 函数由父 ObservableProperty 类的 setter 调用，这意味着每当调用者为 address 设置一个新的值，setter 就会主动调用 afterChange() 函数，后果就会使所有的监听器都会收到无关扭转的告诉。

<!-- Copyright 2020 Google LLC.
SPDX-License-Identifier: Apache-2.0 -->

class Person {var address: String by Delegates.observable("not entered yet!") {
        property, oldValue, newValue ->
        // 执行更新操作
    }
}

您还能够从反编译后的代码中看到 beforeChange() 函数的调用，observable 代理不会应用 beforeChange()。但对于您接下来会看到的 vetoable()，这一函数却是性能实现的根底。

vetoable() 是一个内建代理，属性将否决权委托给它的值。与 observable() 代理相似，vetoable() 同样承受两个参数: 初始值与监听器，当任何调用者想要批改属性值时，监听器就会被调用。

<!-- Copyright 2020 Google LLC.
SPDX-License-Identifier: Apache-2.0 -->

var address: String by Delegates.vetoable("") {
       property, oldValue, newValue ->
   newValue.length > 14
}

如果 lambda 表达式返回 true，属性值就会被批改，反之则放弃不变。在本例中，如果调用者尝试应用长度小于 15 个字符的字符串来更新地址的话，以后值就不会产生扭转。

察看反编译后的 Person 能够发现，Kotlin 新生成了一个继承 ObservableProperty 的类，该类中蕴含了咱们传入 beforeChange() 函数的 lambda 表达式，setter 会在每次值被设置之前调用 lambda 表达式。

 <!-- Copyright 2020 Google LLC.
 SPDX-License-Identifier: Apache-2.0 -->
 
 public final class Person$$special$$inlined$vetoable$1 extends ObservableProperty {protected boolean beforeChange(@NotNull KProperty property, Object oldValue, Object newValue) {Intrinsics.checkParameterIsNotNull(property, "property");
      String newValue = (String)newValue;
      String var10001 = (String)oldValue;
     int var7 = false;
     return newValue.length() > 14;}
}

Kotlin 规范库中所提供的最初一个内建代理是 Delegates.notNull()。notNull() 容许一个属性能够延后一段时间初始化，与 lateinit 相似。因为 notNull() 会为每个属性创立额定的对象，所以大多数状况下举荐应用 lateinit。不过，您能够将 notNull() 与原生类型一起应用，这点是 lateinit 所不反对的。

val fullname: String by Delegates.notNull<String>()

notNull() 应用一种非凡类型的 ReadWriteProperty: NotNullVar。

咱们能够查看反编译后的代码，上面的例子中应用 notNull() 函数初始化了 fullname 属性:

this.fullname$delegate = Delegates.INSTANCE.notNull();

该函数返回了一个 NotNullVar 对象:

public fun <T : Any> notNull(): ReadWriteProperty<Any?, T> = NotNullVar()

NotNullVar 类型持有一个泛型的可空外部援用，如果在初始化值之前有任何代码调用 getter，则抛出 IllegalStateException()。

 <!-- Copyright 2020 Google LLC.
 SPDX-License-Identifier: Apache-2.0 -->
 
 private class NotNullVar<T : Any>() : ReadWriteProperty<Any?, T> {
    private var value: T? = null
 
    public override fun getValue(thisRef: Any?, property: KProperty<*>): T {return value ?: throw IllegalStateException("Property ${property.name} should be initialized before get.")
    }

   public override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {this.value = value}
}

有了 Kotlin 规范库提供的这组内建代理，您无需再编写、保护与从新创造这些性能。这些内建代理能够帮您惰性初始化字段、容许原生类型提早加载、监听并在值产生扭转时取得告诉，甚至能够否决属性值更改。

lazy()

外部原理

Observable

vetoable

notNull