搞懂Kotlin委托-六虎

1、托付是什么

托付是一种规划形式，它的根本理念是操作目标自己不会去处理某段逻辑，而是会把作业托付给别的一个辅佐目标去处理。也便是说在托付形式中，会有2个目标参加同一个恳求的处理，承受恳求的目标将恳求托付给另一个目标来处理。

托付形式中，有三个角色，束缚、托付目标和被托付目标。

托付形式其实不难了解，日子中有很多相似的当地。假设你手里有一套房子想要租出去，想要把房子租出去，联络房客、带人看房是必不行少的，假设让你自己来进行前面所说的作业，或许会占用你自己的业余日子时间，所以这种时分就能够把这些事托付给中介处理，接下来你不需求自己联络房客，也不需求亲身带人看房子，这些作业都由中介完结了，这其实便是一种托付形式。在这儿，束缚便是联络房客、看房子等一系列操作逻辑，托付目标是你，也便是房主，被托付目标是中介。

在Kotlin中将托付功用分为两种：类托付和特点托付。

1.1、类托付

类托付的中心思想是将一个类的详细完结托付给另一个类去完结。

以上面租房子的比如，咱们运用Kotlin的by关键字亲身完结一下托付形式。

首先，咱们来界说一下束缚类，界说租房子需求的事务：联络房客、看房子。

// 束缚类
interface IRentHouse {
    // 联络房客
    fun contact()
    // 带人看房
    fun showHouse()
}

接着，咱们来界说被托付类，也便是中介。

// 被托付类，中介
class HouseAgent(private val name: String): IRentHouse {
    override fun contact() {
        println("$name中介 联络房客")
    }
    override fun showHouse() {
        println("$name中介 带人看房")
    }
}

这儿咱们界说了一个被托付目标，它完结了束缚类的接口。

最终，界说托付类，也便是房主。

// 托付目标
class HouseOwner(private val agent: IRentHouse): IRentHouse by agent {
    // 签合同
    fun sign() {
        println("房主签合同")
    }
    // 带人看房
    override fun showHouse() {
        println("房主带人看房")
    }
}

这儿界说了一个托付类HouseOwner，一起把被托付目标作为托付目标的特点，经过结构办法传入。

在Kotlin中，托付用关键字by，by后边便是托付的目标，能够是一个表达式。

测验：

fun main() {
    val agent = HouseAgent("张三") // 初始化一个名叫张三的中介
    val owner = HouseOwner(agent) // 初始化房主，并把“中介”介绍给他
    owner.contact()
    owner.showHouse()
    owner.sign()
}

运行成果如下：

张三中介 联络房客
房东带人看房
房主签合同

能够看到，在整个租房过程中，房主的一些作业由中介帮着完结，例如联络房客。假设房东心血来潮，觉得自己更了解自己的房子，想把本来托付给中介的作业自己处理，也能够自己来进行，例如带人看房。最终签合同只需房主能处理，所以这是房主独有的操作。以上便是一个托付的简单应用。

而这也是托付形式的意义地点，便是让大部分的办法完结调用被托付目标中的办法，少部分的办法完结由自己来，乃至加入一些自己独有的办法，那么房东租房的整个逻辑就能顺利进行了。

有的人或许会说，这样的话不必by关键字我也能够完结托付。如下：

// 托付目标
class HouseOwner(private val agent: IRentHouse): IRentHouse {
    // 签合同
    fun sign() {
        println("房主签合同")
    }
    // 联络房客
    override fun contact() {
        agent.contact()
    }
    // 带人看房
    override fun showHouse() {
        println("房主带人看房")
    }
}

运行成果如下

张三中介 联络房客
房东带人看房
房主签合同

能够看到，与前面的输出成果相同。

可是这种写法是有必定坏处的，假设束缚接口中的待完结办法比较少还好，假设有几十乃至上百个办法的话就会呈现问题。

前面也说过托付形式的最大意义在于，大部分的托付类办法完结能够调用被托付目标中的办法。而既然运用托付形式，就阐明托付类中的大部分的办法完结是能够经过调用被托付目标中的办法完结的，这样的话每个都像“联络房客”那样去调用被托付目标中的相应办法完结，还不知道要写到驴年马月，而且会发生很多样板代码，很不高雅。

所以Kotlin供给了关键字by，在接口声明的后边运用by关键字，再接上被托付的辅佐目标，这样能够免除仅调用被托付目标办法的模版代码。

而假设要对某个办法进行从头完结，只需求单独重写那一个办法就能够了，其他的办法依然能够享用类托付所带来的便当。

假设想加入独有的办法逻辑，直接写一个办法即可。

这几种状况在前面的“租房”场景中都有体现。

1.2、特点托付

特点托付的中心思想是将一个特点的详细完结托付给另一个类去完结。

咱们来看一下托付特点的语法结构

class Test {
    // 特点托付
    var prop: Any by Delegate()
}

能够看到，这儿运用by关键字连接了左边的prop特点和右边的Delegate实例，这种写法就代表着将prop特点的详细完结托付给了Delegate类去完结。

1.2.1、什么是特点托付

前面也说了特点托付是将一个特点的详细完结托付给另一个类去完结。那么特点把什么托付了出去，被托付类又有哪些完结呢？

其实，特点托付出去的是其set/get办法，托付给了被托付类的setValue/getValue办法。

// 特点的get/set办法
var prop: Any
    get() {}
    set(value) {}
// 托付后
var prop: Any by Delegate()

留意这儿prop声明的是var，即可变变量，假设托付给Delegate类的话，则有必要完结getValue()和setValue()这两个办法，并且都要运用operator关键字进行声明。

class Delegate {
    private var propValue: String? = null
    operator fun getValue(thisRef: Any, property: KProperty<*>): String? {
        return propValue
    }
    operator fun setValue(thisRef: Any, property: KProperty<*>, value: String?) {
        propValue = value
    }
}

到这儿，特点托付现已完结了，这时分，当你点开by关键字的时分会呈现如下提示。

这就标明prop现已把详细完结托付给Delegate类完结。

当调用prop特点的时分会自动调用Delegate类的getValue()办法，当给prop特点赋值的时分会自动调用Delegate类的setValue()办法。

假设prop声明的是val，即不行变变量，则Delegate类只需求完结getValue()办法即可。

有些人第一次看到办法中的参数或许有点懵，但其实这是一种规范的代码完结样板，并且官方也供给了接口类协助咱们完结，详细的接口类下面会提到。

虽然是一套固定的样板，但咱们也要了解其间参数的意义。

thisRef：用于声明该Delegate类的托付功用能够在什么类中运用。有必要与特点地点类类型相同或者是它的父类，假设是扩展函数，则指的是扩展的类型。
property：KProperty是Kotlin中的一个特点操作类，可用于获取各种特点相关的值。大都状况下都不需求修正。
value：详细要赋值给托付特点的值，有必要与getValue的回来值相同。

那么为什么要运用特点托付呢？

假设想完结一个比较杂乱的特点，它们处理起来比把值保存在支持字段field中更杂乱，可是却不想在每个拜访器都重复这样的逻辑，所以把获取这个特点实例的作业托付给一个辅佐目标（类），这个辅佐目标便是被托付类。说白了，便是避免样板代码，避免呈现很多重复逻辑。

1.2.2、ReadOnlyProperty/ReadWriteProperty接口

前面提到，假设要完结特点托付，就有必要要完结getValue/setValue办法，能够看到getValue/setValue办法结构比较杂乱，很简单遗忘，为了解决这个问题，Kotlin 规范库中声明了2个含所需operator办法的 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)
}

val特点完结ReadOnlyProperty接口，var特点完结ReadWriteProperty接口。这样就能够避免自己写杂乱的完结办法了。

// val 特点托付完结
class Delegate1: ReadOnlyProperty<Any,String>{
    private var propValue: String = "zkl"
    override fun getValue(thisRef: Any, property: KProperty<*>): String {
        return propValue
    }
}
// var 特点托付完结
class Delegate2: ReadWriteProperty<Any,String?>{
    private var propValue: String? = null
    override fun getValue(thisRef: Any, property: KProperty<*>): String? {
        return  propValue
    }
    override fun setValue(thisRef: Any, property: KProperty<*>, value: String?) {
       propValue = value
    }
}

2、Kotlin规范库的几种托付

2.1、推迟特点 lazy

2.1.1、运用by lazy进行推迟初始化

运用by lazy()进行推迟初始化信任咱们都不生疏，在日常运用中也能信手拈来。如下，是DataStoreManager目标推迟初始化的比如。

//这儿运用by lazy慵懒初始化一个实例
val instance: DataStoreManager by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
    DataStoreManager(store) }

by lazy()代码块是Kotlin供给的一种懒加载技术，代码块中的代码一开始并不会履行，只需当变量（instance）首次被调用的时分才会履行，并且会将代码块中最终一行代码的回来值赋值给变量。调用如下：

fun main() {
    println(instance::class.java.simpleName)
    println(instance::class.java.simpleName)
    println(instance::class.java.simpleName)
}

打印成果如下：

第一次调用时履行
DataStoreManager
DataStoreManager
DataStoreManager

能够看到，只需第一次调用才会履行代码块中的逻辑，后续调用只会回来代码块的最终值。

那么什么时分合适运用by lazy进行推迟初始化呢？当初始化过程耗费很多资源并且在运用目标时并不总是需求数据时，就十分合适了。

当然，假设变量第一次初始化时抛出异常，那么lazy将尝试在下次拜访时从头初始化该变量。

2.1.2、拆解by lazy

或许咱们刚接触的时分会觉得by lazy本是一体运用的，其实不是，实际上，by lazy并不是连在一起的关键词，只需by才是Kotlin中的关键字，lazy只是一个规范库函数而已。

那么就把二者拆开看，先点开by关键字

@kotlin.internal.InlineOnly
public inline operator fun <T> Lazy<T>.getValue(thisRef: Any?, property: KProperty<*>): T = value

会发现它是Lazy 类的一个扩展函数，按照前面咱们对by的了解，它便是把被托付的特点的get函数和getValue进行配对，所以能够想象在Lazy类中，这个value便是回来的值。

//慵懒初始化类
public interface Lazy<out T> {
    //懒加载的值，一旦被赋值，将不会被改变
    public val value: T
    //表明是否现已初始化
    public fun isInitialized(): Boolean
}

接下来看一下lazy，这个便是一个高阶函数，用来创建lazy实例的。

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

能够看到，该办法中会把initializer，也便是代码块中的内容，传递给SynchronizedLazyImpl类进行初始化并回来。大部分状况咱们运用的都是这个办法。

当然咱们也能够设置mode，这样会调用下面的lazy办法，该办法中会依据mode类型来判断初始化那个类。如下

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)
    }
// 运用如下
val instance: DataStoreManager by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
    println("第一次调用时履行")
    DataStoreManager(store) 
}

三个mode解说如下：

LazyThreadSafetyMode.SYNCHRONIZED：添加同步锁，使lazy推迟初始化线程安全
LazyThreadSafetyMode. PUBLICATION：初始化的lambda表达式能够在同一时间被多次调用，可是只需第一个回来的值作为初始化的值。
LazyThreadSafetyMode. NONE：没有同步锁，多线程拜访时分，初始化的值是未知的，非线程安全，一般状况下，不引荐运用这种办法，除非你能确保初始化和特点一直在同一个线程

而第一个lazy不设置mode时默许的便是SYNCHRONIZED，也是最常用的mode，这儿咱们直接看一下对应类的代码：

//线程安全形式下的单例
private class SynchronizedLazyImpl<out T>(initializer: () -> T, lock: Any? = null) : Lazy<T>, Serializable {
    private var initializer: (() -> T)? = initializer
    //用来保存值，当现已被初始化时则不是默许值
    @Volatile private var _value: Any? = UNINITIALIZED_VALUE
    //锁
    private val lock = lock ?: this
    override val value: T
        //见分析1
        get() {
            //第一次判空，当实例存在则直接回来
            val _v1 = _value
            if (_v1 !== UNINITIALIZED_VALUE) {
                @Suppress("UNCHECKED_CAST")
                return _v1 as T
            }
            //运用锁进行同步
            return synchronized(lock) {
                //第2次判空
                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)
}

这个单例便是双重校验锁完结的。

2.2、可调查特点

Kotlin除了供给了lazy函数完结特点推迟加载外，还供给了Delegates.observable和Delegates.vetoable规范库函数来调查特点改变。先来看observable

2.2.1、observable函数

    public inline fun <T> observable(initialValue: T, crossinline onChange: (property: KProperty<*>, oldValue: T, newValue: T) -> Unit):
            ReadWriteProperty<Any?, T> =
        object : ObservableProperty<T>(initialValue) {
            override fun afterChange(property: KProperty<*>, oldValue: T, newValue: T) = onChange(property, oldValue, newValue)
        }

能够看到，该规范库函数接纳了两个参数initialValue、onChange

initialValue：初始值
onChange：特点值改变时的回调逻辑。回调有三个参数：property，oldValue，newValue，分别表明：特点、旧值、新值。

运用如下：

var observableProp: String by Delegates.observable("初始值") { property, oldValue, newValue ->
    println("特点：${property.name} 旧值：$oldValue 新值：$newValue")
}
// 测验
fun main() {
    observableProp = "第一次修正值"
    observableProp = "第2次修正值"
}

打印如下：

特点：observableProp 旧值：初始值 新值：第一次修正值
特点：observableProp 旧值：第一次修正值 新值：第2次修正值

能够看到，当把特点托付给Delegates.observable后，每一次赋值，都能调查到特点的改变。

2.2.2、vetoable函数

vetoable函数与observable相同，都能够调查特点值改变，不同的是，vetoable能够经过代码块逻辑决议特点值是否收效。

    public inline fun <T> vetoable(initialValue: T, crossinline onChange: (property: KProperty<*>, oldValue: T, newValue: T) -> Boolean):
            ReadWriteProperty<Any?, T> =
        object : ObservableProperty<T>(initialValue) {
            override fun beforeChange(property: KProperty<*>, oldValue: T, newValue: T): Boolean = onChange(property, oldValue, newValue)
        }

接纳的两个参数与observable函数简直相同，不同的是onChange回调有一个Boolean的回来值。

运用如下：

var vetoableProp: Int by Delegates.vetoable(0) { property, oldValue, newValue ->
    println("特点：${property.name} 旧值：$oldValue 新值：$newValue")
    newValue > 0
}
// 测验
fun main() {
    println("vetoableProp:$vetoableProp")
    vetoableProp = 2
    println("vetoableProp:$vetoableProp")
    vetoableProp = -1
    println("vetoableProp:$vetoableProp")
    vetoableProp = 3
    println("vetoableProp:$vetoableProp")
}

打印如下：

vetoableProp:0
特点：vetoableProp 旧值：0 新值：2
vetoableProp:2
特点：vetoableProp 旧值：2 新值：-1
vetoableProp:2
特点：vetoableProp 旧值：2 新值：3
vetoableProp:3

能够看到-1的赋值并没有收效。

那么详细的逻辑是什么呢？

回看observable和vetoable的源码能够发现，二者继承了ObservableProperty抽象类，不同的是observable重写了该类afterChange办法，vetoable重写了该类beforeChange办法，并且beforeChange会有一个Boolean的回来，回来的是咱们自己写的回调逻辑的回来值。

那么接着看setValue逻辑

protected open fun beforeChange(property: KProperty<*>, oldValue: V, newValue: V): Boolean = true
protected open fun afterChange(property: KProperty<*>, oldValue: V, newValue: V): Unit {}
public override fun setValue(thisRef: Any?, property: KProperty<*>, value: V) {
        val oldValue = this.value
        if (!beforeChange(property, oldValue, value)) {
            return
        }
        this.value = value
        afterChange(property, oldValue, value)
    }

能够看到会先履行beforeChange办法，假设beforeChange为false则直接回来，并且不会更新值，为true时才会更新值，接着履行afterChange办法。这儿beforeChange办法默许回来true。

其实只需查看这些函数源码能够发现，其内部调用的都是代理类，所以说白了这些都是特点托付。

3、总结

托付在Kotlin中有着至关重要的作用，可是也不能滥用，中间毕竟多了一个中间类，不合理的运用不但不会有协助，反而会占用内存。前面也说过类托付最大的意义在于，大部分的办法完结调用被托付目标中的办法，少部分的办法完结由自己来，乃至加入一些自己独有的办法。特点托付的意义在于，关于比较杂乱的一些特点，它们处理起来比把值保存在支持字段field中更杂乱，且它们的逻辑相同，为了避免呈现很多模版代码，能够运用特点托付。所以在运用托付前，咱们也能够按照上面的规范考虑一下，合理的运用托付能够削减很多样板代码，提高代码的可扩展性和可读性。

搞懂Kotlin委托

1、托付是什么

1.1、类托付

1.2、特点托付

1.2.1、什么是特点托付

1.2.2、ReadOnlyProperty/ReadWriteProperty接口

2、Kotlin规范库的几种托付

2.1、推迟特点 lazy

2.1.1、运用by lazy进行推迟初始化

2.1.2、拆解by lazy

2.2、可调查特点

2.2.1、observable函数

2.2.2、vetoable函数

3、总结

相关文章

TabLayout改造，支持对TabView扩展

生成kubeconfig并通过kubectl连接Kubernetes集群

上天入地 | 小鸟游戏在码上掘金的实现

Hadoop小文件解决方案-基于NameNode内存和MapReduce性能解决方案

作者信息