Kotlin – 属性代理

自定义属性代理

代理也叫委托，Kotlin 支持属性代理，把一个属性的获取与赋值交给一个“中介”(下称 Delegate)去管理，属性代理的语法是： val/var <属性名>: <类型> by <表达式> ，by 后面是 Delegate 对象，被代理属性的 get()和 set() 会给 Delegate 对象对应的 getValue() 和 setVajv马总lue() 分别代理，因此 Delegete 可以这么写：

注意：Delegate 并不需要实现任何接口，仅需提供 getValue() 和 setValue() 即可。

class Delegate {
private var _redis持久化value: String? = null
operator fun getValue(thisRef: Any?, property: KProperty<*>): String {kotlin面试题
println("getValue() thisRef=$thisRef, property=${redis持久化property.name}")
return _value ?: ""
}
operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
println(源码网站"setValue() thisRef=$this源码编程器appRef, property=${property.name}, value=$value")
_valkotlin为什么流行不起来ue = value
}
}

该 Delegate 的 getValue(jvm垃圾回收机制) 和 setValue()JVM 方法对自己的 _valuekotlin教程 属性进行获取与赋值，并jv马总分别在这 2 个方法中打印输出各参数值，下面我们将一个类成员属性交给 Delegate 对象代理：

class Animal {
var源码之家 name: String by Delegate()
}
fun main() {
val animal = Animal()
animal.name = "旺财" // setValue() thisRef=com.charylin.kotlinlearn.Animal@1b28cdfa, property=name, value=旺财
println(animal.name) // getValue() thisRef=com.charylin.kotlinlearn.Animal@1b28cdfa, property=name
　　　// 旺财
}

当代理属性被赋值与访问时，就jvm调优会输出 Delegate 对象 setValue(源码超市) 和 getValue() 中的日志，从输出的日志可以看出，thisRef 是代理属性的实例对象，property 是代理属性的包装。可见源码交易网站源码，属性代理相比单纯的属性操作更加强大，在某些场景下，属性值的访问会比较复杂，如文件或 Redis，属性代源码编辑器理可以将文件或源码编辑器 Redis 的操作全部交给 Delegate 完成，而业务代码不需要知道具体实现，这对代码解耦与简化很有kotlin发音帮助。

延迟源码超市属性 lazy

Kotlin 官方提供了 lazy 代理，可以延迟初始化 val 常量，且只会初始化一次：

class Animal {
val age: Int by lazy {
pr源码分享网intln("jvm内存模型设置age")
18　// lambda表达式会把最后语句的执行结果作为返回值
}
}
fun main() {
val animal = Animal()
println(animal.age) // 设置age
// 18
println(animal.age) // 18
}

可以看到 println("设置age") 只被输出了一次，这是怎么办到的呢？按住 ctrl ＋鼠标左键，点击 lazy 查看源代码：

// LazyJVM.kt
publijvm调优c actual fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)

lazy() 函数需要传入一个 lambda 表达式，返回值是 Lazy<T>，返回结果 SynchronizedLazyImpl(initializer) 就是 Lazy<T> 的实现类对象，我们知道 by 后面接的是 Delegate 对象，lazykotlin下载() 函数返回的 SynchronizedLazyImpl 就是真正的 Delegaredistte ，再来看看 Lazy 与 Synchronizjvm内存模型edLazyImpl 的源代码：

// Lazy.kt
public interface Lazy<oredistut T&jvm内存模型gt; {
publJVMic val value: T
...
}
// LazyJVM.jvm原理kt
private class SynchronizedLazyImpl<out T>(initializer: () -> T, lock: Any? = null) : Lazy<T>, Serializable {
privatejvm调优 var initializer: (() -> T)? = initikotlin教程alkotlin发音izerredis面试题
@Volatile private var _value: Any? = UNINITIALIZED_VALUE
...
override val value: T
get() {
val _v1 = _value
if (_v1 !== UNINITIALIZED_VALUE) {
// 已经初始化过了源码编辑器，直接返回
re源码超市turn _v1 as T
}
return synchronized(lock) {
...
//jvm内存结构 执行initializer()初始化_value值
val ty源码时代pedValredis面试题ue = initializer!!()
_value = typedValue
initializer = null
}
}
...
}

SynchronizedLazyImpl 重写了 value 属性的 getter 方法，其中会判断 value 是否源码分享网有初始化过，已经初jvm内存模型始化就直接返回结果，未初始化才执行 initializer，所以，这就是 by lazy{} 的初始化逻辑只会执行一次的原因kotlin为什么流行不起来。前面说过，Delegate 对象需要有 getValueredis数据结构() 和 setValue() 方法，那么 Lazy 的这 2 个方法在哪呢？按住 ctrl ＋鼠标左redis数据结构键，点击 by 可以找到：

// Lazy.kt
@kotlin.internal.InlineOnjvm内存模型ly
public inline operatoRedisr fun <T> Lazy<T>.getValue(thisredis命令Ref: Any?, property: KProperty<*&gredis集群t;): T = value

发现，Lazy 只有 getValue()，没有 setValue()，这不难理解，var 变量延迟初始化使用的是 lateinit，val 常量使用的 by lkotlin面试题azy，val 常量不可修改，所以不需要提供 setValue()。

可观察属性 Observable

除了 by lazy 外，Kotlin 为还提供了可观察属性 Observable，这个属性代理可以监听属性值的变化，需要通过 by Delegates.observable() 来设置，这是 Delegates.jvm调优参数observable() 的源码，具体实现就不深入了，该函数要求传入 2 个参数，分别是初始值 initialValue 和用于监听值变化的 lambda 表达式：

// Delegates.kt
public object DelegatRedises {
/**
* Returns a property delegate for a read/write property that calls a specified callback function when changedkotlin为什么流行不起来.
* @para源码网站m initialValue the initial value of the property.
* @param onChange th源码编辑器e callbaredis面试题ck which is called after the change of the property is maderedis数据结构.redis分布式锁 The value of the property
*  has already been changed when tredis集群his callback is invoked.
*
*  @sample samples.propertikotlin语言es.Dkotlin ?.作用elegates.obsekotlin协程rvableDelegate
*/
public inredis数据结构linjvm调优参数e fun <T> observ源码able(initialValukotlin极简教程e: T, crossinline onChan源码编辑器编程猫下载ge: (property: KProperty<*>, oldValue: T, newValue: T) -> Unijvm内存结构t):
ReadWriteProperty&lredis持久化t;Any?, T> =
object : Obsejvm垃圾回收机制rvableProperty<T&redis集群gt;(initialValue) {
override fun afterChange(property: KProperty<*>, oldValue: T, newValue: T) = onChange(propjvm调优面试题erty, oldValue, newVjv马总alue)jvm原理
}
...
}

下面我们来使用 Delegates.obserkotlin极简教程vable() 监听属性值的变化：

class Animal {
var genredis集群der: Boole源码分享网an by Delegates.observable(jvm调优参数true) { prop, old, new ->
println("prop = ${prop.name}Redis, old = $old, new = $new")
}
}
fun main() {
val animal = Animal()
println(animal.gender) // true
animal.gender = false // prop = gender, old = true, ne源码编辑器编程猫下载w = false
println(animal.gender) // false
}

可JVM以看到，当修改了属性值时，会触发 Delegates.obkotlin为什么流行不起来servable() 参数 2 的 lambda 表达式，输出了相应的日志信息，随后属性值也发生了改变。Kotlin 还提供了 Delegates.vetoable() 可观察属性代理，vetoable 比 observable 要强大一点，它除了能监听属性值变化，还可以控制属性是否要修改，通过查看 Delegates.vetoable() 源码注释可以知道，其参数 2 的 lambda 表达式（也就是 callback）返回值将决定属性值是否被更新：

// Delegjvm调优面试题atekotlin实战s.kt
public object Delegates {
/**
* Returns a properjv马总ty delegate for a read/wri源码交易网站源码te property that calls a specified c源码交易网站源码allback function when changed,
* allowing the callback to veto the modification.
* @paramrediscover initialValredis持久化ue the initial value of the property.
* @param onChange the callba源码编辑器ck which is called before a change tredisto the property value is attempted.
*  The valredis集群ue of the property hasn't been changed yet, when this callback is invoked.
*  If the callback returns `true` the value of the propertyredis命令 is being set to the new value,
*  ankotlin实战d if the callback returns `redis持久化false` the new value is discarded and the property remains its old value.
*
*  @samredis缓存ple samples.properties.Dkotlin下载elegates.vetoableDelegate
*  @sample sampleskotlin协程.properties.Delegatekotlin协程s.throwVetoableDelegate
*/
public inline fun <T> vetoable(initialValue: T, crossinline onChjvm内存模型ange: (property: KProperty<*>, oldValue: T, newValue: T) -> Boolean):
ReadWriteProperty<Any?,kotlin发音 T> =
object : Obse源码之家rvableProperty<T>(initialValue) {
override funkotlin实战 beforeChange(property: KPro源码超市perty<*>, oldValue: T, newValue: T): Boolea源码超市n = onChange(property,jvm调优 oldValue, newValue)
}
...
}

我们jvm内存模型将上面例子中的 gender 属性代理修改成 Delekotlin实战gates.vetoable()，并在 callback 中返回 false，以阻止属性值的修改：

class Animal {
var gender: Boolean by Delegates.vetoable(true) {redis持久化 prop, old, new ->
println("prop = ${prop.name}, old =JVM $old, new = $new")
false // lambda表达式最后语句redist的结果作为返回值
}
}
fun main()jvm调优 {
val animal = Animal()
println(animal.gender) // true
animal.gender = false // prop = gender,redis数据结构 old = true, new = false
println(animal.gender) // true
}

至此属性代理的原理及常用属性代理就讲解完了，如需了解更多属性代理的应用，请点击：www.kotlincn.net/docs/refere…