委托模式
委托模式也就是代理模式，它的原理基本如下图
代理模式
Subject：抽象主题类
该类的主要职责是声明真实主题与代理的共同接口方法，该类既可以是一个抽象类也可以是一个接口
RealSubject:真实主题类
该类也称为被委托活代理类，该类定义了代理所表示的真实对象，由其执行具体的业务逻辑方法，而客户端则通过代理类间接调用真实主题类的定义方法。
ProxySubject：代理类
该类也称为委托代理类，该类持有一个对真实主题类的引用，在其所实现的接口方法中调用真实主题类中相应的接口方法执行，以此起到代理作用。
Client：客户类，即使用代理类的实现。
类委托
interface Base {
fun print()
}
class BaseImpl(val x: Int) : Base {
override fun print() { print(x) }
}
class Derived(b: Base) : Base by b
fun main(args: Array<String>) {
val obj = BaseImpl(10)
Derived(obj).print() // 输出 10
}
上面的例子是官方给出。对于类委托我理解的也不是特别深刻，这里就简单说下我的理解。
kotlin中用by表示委托，这句话的意思是b会在Derived中保存，并且在Derived中将保存所有b能够调用的方法（本例中只有print()方法）。
我个人理解为生成了如下的代码：
class Derived(val b: Base) {
fun print(){
b.print()
}
//如果b还有其他方法的话，也会随着生成对应的函数
}
如果明白了这些之后就可以利用示例中的方式用Derived调用Base中定义的方法了
委托属性
委托属性就是对其属性值的操作不再依赖于其自身的getter()/setter()方法，是将其托付给一个代理类，从而每个使用类中的该属性可以通过代理类统一管理，再也不用在每个类中，对其声明重复的操作方法。
当我们使用属性的get或者set的时候，属性委托的getValue和setValue就会被调用。
自定义委托
为了更好的了解委托中getValue和setValue,我们先来看看自定义委托。
如果我们的委托属性是val，必须实现其中的getValue方法,如果是var，则getValue和setValue两个方法必须实现。如下
class MyDelegate{
//对var,val属性，如果被委托，必须实现这个方法
//它的类型必须和委托属性一致或其父类
//thisRel:被委托的属性，propety:对象的属性
//委托属性被调用get()时会自动调用getVale(:Any?,KProperty<*>)
operator fun getValue(thisRel: Any?,propety: KProperty<*>): String{
return propety.name
}
//var属性，如果被委托，必须实现这个方法
//thisRel:被委托的对象，propety:对象的属性,将被赋予的值.
//委托属性调用set()方法是调用setValue(Any?,: KProperty<*>,Any?)
operator fun setValue(thisRel: Any?,propety: KProperty<*>,value: String){
LogUtils.w(TAG,value)
}
}
为了以后测试各个常用的委托方便，我们在新建一个class
class DelegateTest(){
var myDelegate: String by MyDelegate()
}
测试
fun test(){
var demo = DelegateTest()
LogUtils.e(TAG,demo.myDelegate)
demo.myDelegate = "Delegate value"
}
结果
自定义委托.png
可以看到myDelegate的值从“myDelegate”变成了“Delegate value”
lazy
//lazy委托，只有在第一次调用的时候才真正的初始化，并且以后他的值不会再发生变化
//下面的参数是可选项
// SYNCHRONIZED：锁定，用于确保只有一个线程可以初始化[Lazy]实例。
// PUBLICATION：初始化函数可以在并发访问未初始化的[Lazy]实例值时调用几次，，但只有第一个返回的值将被用作[Lazy]实例的值。
// NONE：没有锁用于同步对[Lazy]实例值的访问; 如果从多个线程访问实例，是线程不安全的。此模式应仅在高性能至关重要，并且[Lazy]实例被保证永远不会从多个线程初始化时使用。
val lazySrc:String by lazy(/*LazyThreadSafetyMode.PUBLICATION*/){
"init done"
}
测试
LogUtils.d(TAG,"lazySrc = ${demo.lazySrc}\n")
结果
lazy委托
observable
//observable委托是一个observer模式的实现，每当委托属性发生变化，就能做一下事情
//两个参数：
// 初始值
// 一个lambda表达式（Unit）：属性，老值，新值
var observableSrc: String by Delegates.observable(
"initSrc",{
property: KProperty<*>, oldValue: String, newValue: String ->
LogUtils.d(TAG,"observableSrc old = $oldValue ,new = $newValue")
})
测试
demo.observableSrc = "init"
LogUtils.d(TAG,"observableSrc = ${demo.observableSrc}\n")
demo.observableSrc = "change"
LogUtils.d(TAG,"observableSrc = ${demo.observableSrc}\n")
结果
observable委托
vetoable
//vetoable
//它可以看做是observable的特例
// 两个参数：
// 初始值
// 一个lambda表达式(Boolean)：属性，老值，新值.最后的表达式是判断是否执行
var vetoableSrc: String by Delegates.vetoable(
"initSrc", {
property, oldValue, newValue ->
LogUtils.v(TAG, " vetoableSrc old = $oldValue ,new = $newValue")
newValue.contains("Rhett")
})
测试
demo.vetoableSrc = "Rhett "//赋值成功
LogUtils.v(TAG,"vetoableSrc = ${demo.vetoableSrc}\n")
demo.vetoableSrc = "change"//赋值失败
LogUtils.v(TAG,"vetoableSrc = ${demo.vetoableSrc}\n")
demo.vetoableSrc = "Rhett 2"//赋值成功
LogUtils.v(TAG,"vetoableSrc = ${demo.vetoableSrc}\n")
结果
vetoable委托
notNull
/**
* notNull
* 委托之后，他会在每次调用的时候自动检测是否为null,省去了每次手动检测的麻烦。如果我们能够获得它，就说明这个属性肯定不为null
*/
var instance: String /*= "1"*/ by Delegates.notNull()
测试
// LogUtils.i(TAG,"instance = "+demo.instance)//没有初始化，所以会报错
demo.instance = "11111111111 "//赋值成功
LogUtils.i(TAG,"instance = "+demo.instance)
结果
notNull委托
map
使用Gson解析Json时，可以获取到相应的实体类的实例，当然该实体类的属性名称与Json中的key是一一对应的。在Kotlin中，存在这么一种委托方式，类的构造器接受一个map实例作为参数，将map实例本身作为属性的委托，属性的名称与map中的key是一致的，也就是意味着我们可以很简单的从一个动态地map中创建一个对象实例。
class DelegateTest2(map: Map<String, Any?>){
val mapSrc: String by map
val mapInt: Int by map
}
测试
val demo2 = DelegateTest2(mapOf("mapSrc" to "1","mapInt" to 2))
LogUtils.i(TAG,"demo2.name = "+demo2.mapSrc)
LogUtils.i(TAG,"demo2.num = "+demo2.mapInt.toString())
结果
map委托
附上有关的所有代码
/**
* 属性委托------------------------------------------------------------------
*/
//自定义委托
class MyDelegate{
//对var,val属性，如果被委托，必须实现这个方法
//它的类型必须和委托属性一致或其父类
//thisRel:被委托的属性，propety:对象的属性
//委托属性被调用get()时会自动调用getVale(:Any?,KProperty<*>)
operator fun getValue(thisRel: Any?,propety: KProperty<*>): String{
return propety.name
}
//var属性，如果被委托，必须实现这个方法
//thisRel:被委托的对象，propety:对象的属性,将被赋予的值.
//委托属性调用set()方法是调用setValue(Any?,: KProperty<*>,Any?)
operator fun setValue(thisRel: Any?,propety: KProperty<*>,value: String){
LogUtils.w(TAG,value)
}
}
class DelegateTest(){
var myDelegate: String by MyDelegate()
//lazy委托，只有在第一次调用的时候才真正的初始化，并且以后他的值不会再发生变化
//下面的参数是可选项
// SYNCHRONIZED：锁定，用于确保只有一个线程可以初始化[Lazy]实例。
// PUBLICATION：初始化函数可以在并发访问未初始化的[Lazy]实例值时调用几次，，但只有第一个返回的值将被用作[Lazy]实例的值。
// NONE：没有锁用于同步对[Lazy]实例值的访问; 如果从多个线程访问实例，是线程不安全的。此模式应仅在高性能至关重要，并且[Lazy]实例被保证永远不会从多个线程初始化时使用。
val lazySrc:String by lazy(/*LazyThreadSafetyMode.PUBLICATION*/){
"init done"
}
//observable
//两个参数：
// 初始值
// 一个lambda表达式（Unit）：属性，老值，新值
var observableSrc: String by Delegates.observable(
"initSrc",{
property: KProperty<*>, oldValue: String, newValue: String ->
LogUtils.d(TAG,"observableSrc old = $oldValue ,new = $newValue")
})
//vetoable
//它可以看做是observable的特例
// 两个参数：
// 初始值
// 一个lambda表达式(Boolean)：属性，老值，新值.最后的表达式是判断是否执行
var vetoableSrc: String by Delegates.vetoable(
"initSrc", {
property, oldValue, newValue ->
LogUtils.v(TAG, " vetoableSrc old = $oldValue ,new = $newValue")
newValue.contains("Rhett")
})
/**
* notNull
* 委托之后，他会在每次调用的时候自动检测是否为null,省去了每次手动检测的麻烦。如果我们能够获得它，就说明这个属性肯定不为null
*/
var instance: String /*= "1"*/ by Delegates.notNull()
}
//
class DelegateTest2(map: Map<String, Any?>){
val mapSrc: String by map
val mapInt: Int by map
}
fun test(){
var demo = DelegateTest()
LogUtils.e(TAG,demo.myDelegate)
demo.myDelegate = "Delegate value"
LogUtils.d(TAG,"lazySrc = ${demo.lazySrc}\n")
demo.observableSrc = "init"
LogUtils.d(TAG,"observableSrc = ${demo.observableSrc}\n")
demo.observableSrc = "change"
LogUtils.d(TAG,"observableSrc = ${demo.observableSrc}\n")
demo.vetoableSrc = "Rhett "//赋值成功
LogUtils.v(TAG,"vetoableSrc = ${demo.vetoableSrc}\n")
demo.vetoableSrc = "change"//复制失败
LogUtils.v(TAG,"vetoableSrc = ${demo.vetoableSrc}\n")
demo.vetoableSrc = "Rhett 2"//复制成功
LogUtils.v(TAG,"vetoableSrc = ${demo.vetoableSrc}\n")
// LogUtils.i(TAG,"instance = "+demo.instance)//没有初始化，所以会报错
demo.instance = "11111111111 "//赋值成功
LogUtils.i(TAG,"instance = "+demo.instance)
val demo2 = DelegateTest2(mapOf("mapSrc" to "1","mapInt" to 2))
LogUtils.i(TAG,"demo2.name = "+demo2.mapSrc)
LogUtils.i(TAG,"demo2.num = "+demo2.mapInt.toString())
}
