kotlin-委托
[toc]
委托是什么
委托又可以称为代理。为其他对象提供一种代理以控制对这个对象的访问，简单的说就是在访问和被访问对象中间加上的一个间接层，以隔离访问者和被访问者的实现细节。
类委托
类委托其实对应于Java中的代理模式
interface Base{
fun text()
}
//被委托的类(真实的类)
class BaseImpl(val x :String ) : Base{
override fun text() {
println(x)
}
}
//委托类（代理类）
class Devices (b :Base) :Base by b
fun main(){
var b = BaseImpl("我是真实的类")
Devices(b).text()
}
输出
我是真实的类
可以看到，委托类(代理类)持有真实类的对象，然后委托类（代理类）调用真实类的同名方法，最终真正实现的是方法的是真实类，这其实就是代理模式
kotlin中委托实现借助于by关键字，by关键字后面就是被委托类，可以是一个表达式
接口委托
如果接口有很多方法，子类就必须全部实现。
interface Api{
fun a()
fun b()
fun c()
}
class ApiWrapper:Api{
override fun a() {
}
override fun b() {
}
override fun c() {
}
}
kotlin可以找个对象代替你实现它，我们只需要实现需要的方法即可。
class ApiWrapper(val api:Api):Api by api{
override fun a() {
println("判断是否登录")
api.a()
}
}
设计一个好玩的例子
class SupperArray<T>(val list: MutableList<T> = mutableListOf(), val map: MutableMap<String, T> = mutableMapOf()) :
MutableList<T> by list, MutableMap<String, T> by map{
override fun clear() {
list.clear()
map.clear()
}
override fun isEmpty(): Boolean {
return list.isEmpty() && map.isEmpty()
}
override val size: Int
get() = list.size+map.size
override fun toString(): String {
return "$list $map"
}
}
这是一个超级集合，包含一个list和一个map。这里用了代理，不需要实现全部的方法。只需要提供必要的方法。
fun main(args: Array<String>) {
val supperArray = SupperArray<String>()
supperArray["a"]= "hello"
supperArray.add("world")
println(supperArray.toString())
}
打印
[world] {a=hello}
属性委托
属性委托和类委托一样，属性的委托其实是对属性的==set/get==方法的委托,把set/get方法委托给==setValue/getValue==方法,因此被委托类（真实类）需要提供==setValue/getValue==方法，val属性只需要提供==setValue==方法
属性委托语法：
val/var <属性名>: <类型> by <表达式>
class B {
//委托属性
var a : String by Text()
}
//被委托类（真实类）
class Text {
operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
return "属性拥有者 = $thisRef, 属性的名字 = '${property.name}' 属性的值 "
}
operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
println("属性的值 = $value 属性的名字 = '${property.name}' 属性拥有者 = $thisRef")
}
}
fun main(){
var b = B()
println(b.a)
b.a = "ahaha"
}
输出
属性拥有者 = com.example.lib.weituo.B@27fa135a, 属性的名字 = 'a' 属性的值
属性的值 = ahaha 属性的名字 = 'a' 属性拥有者 = com.example.lib.weituo.B@27fa135a
上面的例子可以看到 ，属性a 委托给了Text,而且Text类中有setValue和getValue,所以当我们调用属性a的get/set方法时候，会委托到Text的setValue/getValue上,上面的例子可以看出来,里面有几个参数介绍一下：
thisRef：属性的拥有者
property：对属性的描述，是KProperty<*>类型或者父类
value：属性的值
更加简单的实现属性委托
每次实现委托都要写getValue/setValue方法,这就比较麻烦了，系统为我们提供了接口，方便我们重写这些方法,ReadOnlyProperty和ReadWriteProperty
interface ReadOnlyProperty<in R, out T> {
operator fun getValue(thisRef: R, property: KProperty<*>): T
}
interface ReadWriteProperty<in R, T> {
operator fun getValue(thisRef: R, property: KProperty<*>): T
operator fun setValue(thisRef: R, property: KProperty<*>, value: T)
}
Koltin 标准库中提供的几个委托
延迟属性（lazy properties）：其值只在访问时初始化，再次调用直接返回结果
可观察属性（observable properties）：监听器会收到此属性的变更通知
把多个属性映射到(Map)中，而不是存在单个字段
延迟属性lazy
lazy()接收一个lambda，返回Lazy实例，返回的实例可以作为实现延迟属性的委托，仅在第一次调用属性进行初始化
class Lazy {
val name :String by lazy {
println("第一次调用初始化")
"aa" }
}
fun main(){
var lazy =Lazy()
println(lazy.name)
println(lazy.name)
println(lazy.name)
}
输出
第一次调用初始化
aa
aa
aa
lazy委托参数
SYNCHRONIZED:添加同步锁，使lazy延迟初始化线程安全
PUBLICATION：初始化的lambda表达式，可以在同一时间多次调用，但是只有第一次的返回值作为初始化值
NONE：没有同步锁，非线程安全
1. by lazy是通过属性代理来实现的懒加载，只在第一次使用的时候才会去执行表达式，并且只会执行一次。
2. by lazy默认是线程安全的，内部通过双重判断锁来保证只执行一次代码块赋值
3. 当能够确定不会发生在多线程中的时候，可通过lazy(LazyThreadSafetyMode.NONE) { ... }来避免加锁。
lazy 原理
通过前面对属性委托的简单介绍，我们也明白了属性委托的机制。by后面跟着的肯定是一个对象，也就是委托对象，该对象负责属性的get/set，所以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)
}
public actual fun <T> lazy(lock: Any?, initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer, lock)
lazy方法一共有三个，我们最常用的是第一个。从代码中可以看出，lazy方法最终是创建的Lazy<T>的实例，这个实例也就是属性委托的对象。
public interface Lazy<out T> {
public val value: T
public fun isInitialized(): Boolean
}
Lazy一共有三个子类，其中我们使用的第一个方法返回的是SynchronizedLazyImpl，这是Lazy的其中一个实现。
internal object UNINITIALIZED_VALUE
private class SynchronizedLazyImpl<out T>(initializer: () -> T, lock: Any? = null) : Lazy<T>, Serializable {
private var initializer: (() -> T)? = initializer
// 委托的属性的值由_value记录，初始值是单例对象UNINITIALIZED_VALUE
@Volatile private var _value: Any? = UNINITIALIZED_VALUE
// final field is required to enable safe publication of constructed instance
private val lock = lock ?: this
override val value: T
get() {
val _v1 = _value
// 已初始化则直接返回对应值
if (_v1 !== UNINITIALIZED_VALUE) {
@Suppress("UNCHECKED_CAST")
return _v1 as T
}
// 未初始化的，执行传递进来的lambda参数进行赋值
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
}
}
}
override fun isInitialized(): Boolean = _value !== UNINITIALIZED_VALUE
override fun toString(): String = if (isInitialized()) value.toString() else "Lazy value not initialized yet."
private fun writeReplace(): Any = InitializedLazyImpl(value)
}
SynchronizedLazyImpl是Lazy的一个子类，可以看到在value属性的get方法中，会去判断是否已经初始化过，若是没有初始化，则会调用initializer去进行初始化，赋值给_value。若是已经初始化过，则会直接返回 _value的值。因此by lazy就能通过这种方式去实现懒加载，并且只加载一次。
从代码中可以看出，SynchronizedLazyImpl是保证了线程安全的。是通过DCL方式来保证的安全，能够确保在多线程下也只会执行一次代码块。
但是我们说过，要实现可读属性委托，必须实现getValue方法。而在SynchronizedLazyImpl中，并没有实现getValue方法，而是只有value属性的get方法。这里猜测编译器应该是对Lazy有特殊的处理，而通过实验，实现了Lazy接口的对象确实可以作为只读属性的委托对象。而其他接口即使与Lazy一模一样，实现它的对象也不能作为属性委托对象。
可观察属性Observable委托
可以观察一个属性的变化过程
class Lazy {
var a : String by Delegates.observable("默认值"){
property, oldValue, newValue ->
println( "$oldValue -> $newValue ")
}
}
fun main(){
var lazy =Lazy()
lazy.a = "第一次修改"
lazy.a = "第二次修改"
}
输出
默认值 -> 第一次修改
第一次修改 -> 第二次修改
vetoable委托
vetoable和Observable一样,可以观察属性的变化，不同的是vetoable可以决定是否使用新值
class C {
var age: Int by Delegates.vetoable(0) { property, oldValue, newValue ->
println("oldValue = $oldValue -> oldValue = $newValue" )
newValue > oldValue
}
}
fun main() {
var c = C()
c.age = 5
println(c.age)
c.age = 10
println(c.age)
c.age = 8
println(c.age)
c.age = 20
println(c.age)
}
输出
oldValue = 0 -> oldValue = 5
5
oldValue = 5 -> oldValue = 10
10
oldValue = 10 -> oldValue = 8
10
oldValue = 10 -> oldValue = 20
20
当新值小于旧值，那么就不生效，可以看到第三次设的值是8，小于10就没有生效
属性储存在Map中
class D(val map: Map<String, Any?>) {
val name: String by map
val age: Int by map
}
fun main(){
var d = D(mapOf(
"name" to "小明",
"age" to 12
))
println("name = ${d.name},age = ${d.age}")
}
输出
name = 小明,age = 12
