kotlin委托属性

小鱼儿 2022-10-24 05:58 217阅读 0赞

# 委托属性 #

kotlin中除了可以委托类外，还可以委托属性。

## 委托属性 ##

语法如下：

class Person { 
        var name: String by Delegate()
    }

而Delegate类需要实现ReadWriteProperty接口，ReadWriteProperty接口的声明如下：

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

如果是只读属性（val属性），那么需要实现ReadOnlyProperty接口，ReadOnlyProperty接口的声明如下：

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

当然Delegate类不一定要实现ReadWriteProperty和ReadOnlyProperty接口，只需要保持方法的签名一直就行。

Delegate类的代码如下：

class Delegate : ReadWriteProperty<Person, String> { 
        override fun setValue(thisRef: Person, property: KProperty<*>, value: String) { 
            println("${ thisRef}, ${ property.name}, $value")
        }
    
        override fun getValue(thisRef: Person, property: KProperty<*>): String { 
            println("${ thisRef}, ${ property.name}")
            return "welcome"
        }
    }

这样对Person.name的读操作就会委托给Delegate.getValue()，对Person.name的写操作就会委托给Delegate.setValue()。

## 延迟属性 ##

延迟属性会在第一次被访问时才会计算，然后缓存起来供后续调用使用。

val lazyValue: String by lazy { 
        println("invoked")
        "hello"
    }
    
    fun main() { 
        println(lazyValue)
        println(lazyValue)
    }

lazy关键字其底层其实是一个函数，源代码如下，还有个重载的方法：

public actual fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)
    
    public actual fun <T> lazy(mode: LazyThreadSafetyMode, initializer: () -> T): Lazy<T> =
        when (mode) { 
            LazyThreadSafetyMode.SYNCHRONIZED -> SynchronizedLazyImpl(initializer)
            LazyThreadSafetyMode.PUBLICATION -> SafePublicationLazyImpl(initializer)
            LazyThreadSafetyMode.NONE -> UnsafeLazyImpl(initializer)
        }

mode参数有下面三种取值：

*  LazyThreadSafetyMode.SYNCHRONIZED：默认情况下，延迟属性的计算是同步的，值只会在一个线程中得到计算，所有的线程都会使用相同的结果。
 *  LazyThreadSafetyMode.PUBLICATION：如果不需要初始化延时属性的同步，这样多个线程就可以同时执行。
 *  LazyThreadSafetyMode.NONE：如果确定初始化操作只会在一个线程中执行，这样就能减少线程安全方面的开销。

## 非空属性 ##

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

class A { 
        var name by Delegates.notNull<String>()
    }

## 可观测属性 ##

可观测属性可以在属性的值发生变化时进行监听。

Delegates.observable在值发生变化后触发：

class B { 
        var name by Delegates.observable("hello") {  property, oldValue, newValue ->
            println("property: ${ property.name}, oldValue: $oldValue, newValue: $newValue")
        }
    }

Delegates.observable在值发生变化前触发，返回true就会设置属性，返回false不会设置属性：

class C { 
        var name by Delegates.vetoable("hi") {  property, oldValue, newValue ->
            println("property: ${ property.name}, oldValue: $oldValue, newValue: $newValue")
            true
        }
    }

## map属性 ##

通常在json中，我们将属性和值存在map中，可以将map作为属性的委托。

map只读属性：

class D(map: Map<String, Any>) { 
        val name: String by map
        val age: Int by map
    }
    
    fun main() { 
    
        var map = mapOf(
            "name" to "morris",
            "age" to 20
        )
        var d = D(map)
        println(d.name) // morris
        println(d.age) // 20
    }

map读写属性：

class E(map: MutableMap<String, Any>) { 
        var name: String by map
        var age: Int by map
    }
    
    fun main() { 
        var mutableMap: MutableMap<String, Any> = mutableMapOf(
            "name" to "morris",
            "age" to 20
        )
        var e = E(mutableMap)
        println(e.name) // morris
        println(e.age) // 20
    
        mutableMap["name"] = "Marry"
        println(e.name) // Marry
    }

注意对map中属性的修改会体现到对象的属性上。

## 委托另一个属性 ##

class F(name: String) { 
        var newName: String = name
        var oldName: String by this::newName
    }

委托的属性可以是以下三种：

1.  一个顶级属性（不包含在类中）
2.  同一个类中的成员或者扩展属性
3.  其他类中的成员或者扩展属性

## 转换规则 ##

kotlin编译器为每个委托属性提供了一个辅助的属性，对原属性的访问都会委托给这个辅助属性。例如对属性prop来说，kotlin编译器会生成辅助属性prop d e l e g a t e ， 对 p r o p 的 访 问 都 会 委 托 给 p r o p delegate，对prop的访问都会委托给prop delegate，对prop的访问都会委托给propdelegate。

## 提供委托 ##

通过定义providerDelegate operator，我们可以扩展委托的创建逻辑过程，如果对象定义了providerDelegate方法，那么该方法就会用来创建属性委托实例。

package com.morris.kotlin.delegationpropertiest
    
    import kotlin.properties.ReadOnlyProperty
    import kotlin.reflect.KProperty
    
    class PeopleDelegate: ReadOnlyProperty<People, String> { 
        override fun getValue(thisRef: People, property: KProperty<*>): String { 
            return "morris"
        }
    }
    
    class PeopleLauch { 
        operator fun provideDelegate(thisRef: People,prop: KProperty<*>): ReadOnlyProperty<People, String> { 
            when(prop.name) { 
                "name","address" -> return PeopleDelegate()
                else -> throw Exception("error property")
            }
        }
    }
    
    class People { 
        val name : String by PeopleLauch()
        val address: String by PeopleLauch()
    }
    
    fun main() { 
        var people = People()
        println(people.name) // morris
    }