1、委托
在委托模式中,有两个对象参与处理同一个请求,接受请求的对象将请求委托给另一个对象来处理。
1.1. 委托实现
Derived 类可以通过将其所有公有成员都委托给指定对象来实现一个接口 Base
:
Derived 的超类型列表中的 by-子句表示 b 将会在 Derived 中内部存储
, 并且编译器将生成转发给 b 的所有 Base 的方法。
interface Base {
fun print()
}
class BaseImpl(val x: Int) : Base {
override fun print() {
print(x) }
}
class Derived(b: Base) : Base by b
fun main() {
val b = BaseImpl(10)
Derived(b).print()
}
1.2 覆盖委托的接口成员
interface Base {
fun printMessage()
fun printMessageLine()
}
class BaseImpl(val x: Int) : Base {
override fun printMessage() {
print(x) }
override fun printMessageLine() {
println(x) }
}
class Derived(b: Base) : Base by b {
override fun printMessage() {
print("abc") }
}
fun main() {
val b = BaseImpl(10)
//如果当前类 覆盖了接口的成员,就用覆盖的方法
Derived(b).printMessage()
//如果没有覆盖接口的方法,就使用接口的实现类
Derived(b).printMessageLine()
}
重写接口的属性
interface Base {
val message: String
fun print()
}
class BaseImpl(val x: Int) : Base {
override val message = "BaseImpl: x = $x"
override fun print() {
println(message) }
}
class Derived(b: Base) : Base by b {
// 在 b 的 `print` 实现中不会访问到这个属性
override val message = "Message of Derived"
}
fun main() {
val b = BaseImpl(10)
val derived = Derived(b)
derived.print()
println(derived.message)
}
2、委托属性
语法是: val/var <属性名>: <类型> by <表达式>
在 by 后面的表达式是该 委托, 因为属性对应的 get()(与 set())会被委托给它的 getValue() 与 setValue() 方法
class Example {
var p: String by Delegate()
}
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.")
}
}
result:
Example@33a17727, thank you for delegating ‘p’ to me!
当我们从委托到一个 Delegate 实例的 p 读取时,将调用 Delegate 中的 getValue() 函数, 所以它
第一个参数是读出 p 的对象、
第二个参数保存了对 p 自身的描述 (例如你可以取它的名字)
类似地,当我们给 p 赋值时,将调用 setValue() 函数。前两个参数相同,第三个参数保存将要被赋予的值:
e.p = "NEW"
result:
NEW has been assigned to ‘p’ in Example@33a17727.
2.1 延迟属性(lazy properties):
其值只在首次访问时计算;
lazy() 是接受一个 lambda 并返回一个 Lazy 实例的函数,返回的实例可以作为实现延迟属性的委托。
第一次调用 get() 会执行已传递给 lazy() 的 lambda 表达式并记录结果, 后续调用 get() 只是返回记录的结果。
//执行一次,下次就会保存到委托对象里。
val lazyValue: String by lazy {
println("computed!")
"Hello"
}
fun main() {
println(lazyValue)
println(lazyValue)
}
对于 lazy 属性的求值是同步锁的(synchronized)
:该值只在一个线程中计算,并且所有线程会看到相同的值。如果初始化委托的同步锁不是必需的,这样多个线程可以同时执行,那么将LazyThreadSafetyMode.PUBLICATION 作为参数传递给 lazy() 函数。
而如果你确定初始化将总是发生在与属性使用位于相同的线程, 那么可以使用 LazyThreadSafetyMode.NONE 模式:它不会有任何线程安全的保证以及相关的开销。
val lazyValue: String by lazy(LazyThreadSafetyMode.PUBLICATION) {
....
}
2.2 可观察属性(observable properties):
监听器会收到有关此属性变更的通知;
Delegates.observable() 接受两个参数:初始值与修改时处理程序(handler)。 每当我们给属性赋值时会调用该处理程序(在赋值后执行)。它有三个参数:被赋值的属性、旧值与新值:
import kotlin.properties.Delegates
class User {
var name: String by Delegates.observable("<no name>") {
prop, old, new ->
println("$old -> $new")
}
}
fun main() {
val user = User()
user.name = "first"
user.name = "second"
}
如果你想截获赋值并“否决”它们,那么使用 vetoable() 取代 observable()。 在属性被赋新值生效之前会调用传递给 vetoable 的处理程序。
2.3 委托给另一个属性
从 Kotlin 1.4 开始,一个属性可以把它的 getter 与 setter
委托给另一个属性。这种委托对于顶层和类的属性(成员和扩展)都可用。该委托属性可以为:
- 顶层属性
- 同一个类的成员或扩展属性
- 另一个类的成员或扩展属性
为将一个属性委托给另一个属性,应在委托名称中使用恰当的 :: 限定符
,例如,this::delegate 或 MyClass::delegate。
var topLevelInt: Int = 0
class ClassWithDelegate(val anotherClassInt: Int)
class MyClass(var memberInt: Int, val anotherClassInstance: ClassWithDelegate) {
//委托本类成员加 this::
var delegatedToMember: Int by this::memberInt
//委托文件内成员加::
var delegatedToTopLevel: Int by ::topLevelInt
//委托其他类成员加 类::成员
val delegatedToAnotherClass: Int by anotherClassInstance::anotherClassInt
}
//这是扩展属性
var MyClass.extDelegated: Int by ::topLevelInt
这是很有用的,例如,当想要以一种向后兼容的方式重命名一个属性的时候:引入一个新的属性、 使用 @Deprecated 注解来注解旧的属性、并委托其实现。
class MyClass {
var newName: Int = 0
@Deprecated("Use 'newName' instead", ReplaceWith("newName"))
var oldName: Int by this::newName
}
fun main() {
val myClass = MyClass()
// 通知:'oldName: Int' is deprecated.
// Use 'newName' instead
myClass.oldName = 42
println(myClass.newName) // 42
}
2.4 把多个属性储存在一个映射(map)中,
而不是每个存在单独的字段中。
这也适用于 var 属性,如果把只读的 Map 换成 MutableMap
class User(val map: Map<String, Any?>) {
val name: String by map
val age: Int by map
}
val user = User(mapOf(
"name" to "John Doe",
"age" to 25
))
println(user.name) // Prints "John Doe"
println(user.age) // Prints 25
2.5 局部委托属性
你可以将局部变量声明为委托属性。 例如,你可以使一个局部变量惰性初始化:
fun example(computeFoo: () -> Foo) {
val memoizedFoo by lazy(computeFoo)
if (someCondition && memoizedFoo.isValid()) {
memoizedFoo.doSomething()
}
}
memoizedFoo 变量只会在第一次访问时计算。 如果 someCondition 失败,那么该变量根本不会计算。
2.6 属性委托要求
对于一个只读属性(即 val 声明
的),委托必须提供一个操作符函数 getValue(),该函数具有以下参数:
thisRef —— 必须与 属性所有者 类型(对于扩展属性——指被扩展的类型)相同或者是其超类型。
property —— 必须是类型 KProperty<*> 或其超类型。
getValue() 必须返回与属性相同的类型(或其子类型)。
class Resource
class Owner {
val valResource: Resource by ResourceDelegate()
}
class ResourceDelegate {
operator fun getValue(thisRef: Owner, property: KProperty<*>): Resource {
return Resource()
}
}
对于一个可变属性(即 var 声明的
),委托必须额外提供一个操作符函数 setValue(), 该函数具有以下参数:
thisRef —— 必须与 属性所有者 类型(对于扩展属性——指被扩展的类型)相同或者是其超类型。
property —— 必须是类型 KProperty<*> 或其超类型。
value — 必须与属性类型相同(或者是其超类
型)。
class Resource
class Owner {
var varResource: Resource by ResourceDelegate()
}
class ResourceDelegate(private var resource: Resource = Resource()) {
operator fun getValue(thisRef: Owner, property: KProperty<*>): Resource {
return resource
}
operator fun setValue(thisRef: Owner, property: KProperty<*>, value: Any?) {
// 是否预期类型
if (value is Resource) {
resource = value
}
}
}
getValue() 或/与 setValue() 函数可以通过委托类的成员函数提供或者由扩展函数提供。 当你需要委托属性到原本未提供的这些函数的对象时后者会更便利。 两函数都需要用 operator 关键字来进行标记。
2.7 ReadWriteProperty
也可以自定义ReadWriteProperty 的匿名实现类,重写getValue() setValue()方法。
getValue() is declared in ReadOnlyProperty;
ReadWriteProperty extends it and adds setValue()
fun resourceDelegate(): ReadWriteProperty<Any?, Int> =
object : ReadWriteProperty<Any?, Int> {
var curValue = 0
override fun getValue(thisRef: Any?, property: KProperty<*>): Int = curValue
override fun setValue(thisRef: Any?, property: KProperty<*>, value: Int) {
curValue = value
}
}
val readOnly: Int by resourceDelegate() // ReadWriteProperty as val
var readWrite: Int by resourceDelegate()
2.8 委托原理
在每个委托属性的实现的背后,Kotlin 编译器都会生成辅助属性并委托给它
class xx{
var prop: MyDelegate by MyDelegate()
}
class MyDelegate{
operator fun getValue(xx: xx, property: KProperty<*>): MyDelegate {
return MyDelegate()
}
operator fun setValue(xx: xx, property: KProperty<*>, myDelegate: MyDelegate) {
}
}
经过编译后,为下面结构
为xx类,创建了 new MyDelegate(); ,然后执行getValue() setValue()方法。
public final class xx {
// $FF: synthetic field
static final KProperty[] $$delegatedProperties = new KProperty[]{
(KProperty)Reflection.mutableProperty1(new MutablePropertyReference1Impl(xx.class, "prop", "getProp()Lcom/example/kotlin_sample/objclass/MyDelegate;", 0))};
@NotNull
private final MyDelegate prop$delegate = new MyDelegate();
@NotNull
public final MyDelegate getProp() {
return this.prop$delegate.getValue(this, $$delegatedProperties[0]);
}
public final void setProp(@NotNull MyDelegate var1) {
Intrinsics.checkNotNullParameter(var1, "<set-?>");
this.prop$delegate.setValue(this, $$delegatedProperties[0], var1);
}
}