在委托模式中，有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。

类委托

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val b = Bean("hello world")
        Delegation(b).delegate()
    }

}

interface IDelegateListener {
    fun delegate()
}

class Bean(val s: String) : IDelegateListener {
    override fun delegate() {
        println("bean ----> $s")
    }
}

class Delegation(delegateListener: IDelegateListener) : IDelegateListener by delegateListener

运行结果

由输出结果可以看到：Delegation类并没有实现 IDelegateListener 中的 delegate() 方法，而是通过by这个关键字，将本应该实现的方法委托给了Bean,由Bean来实现方法

委托属性

定义一个委托属性的语法是： val/var <property name>: <Type> by <expression> ,by后面的就是属性的委托。委托属性不需要实现接口，只需要用operator修饰的 setValue() getValue函数。如果是val属性 则不用提供setValue()

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val bean = Bean()
        println("bean ---> ${bean.string}")
        bean.string="2"
        println("bean ---> ${bean.string}")
    }

}


class Bean {
    var string: String by Delegator()
}

class Delegator {
    var temp = "1"

    operator fun getValue(ref: Any?, p: KProperty<*>): String {
        return "Delegator --> ${p.name} --> $temp"
    }

    operator fun setValue(ref: Any?, p: KProperty<*>, value: String) {
        temp = value
    }

}

运行结果

参数说明：

• ref 属性拥有者
• p 属性的描述
• value 属性的值

标准委托

延迟属性 lazy

通过lazy可以定义一个懒加载属性，只有val类型的属性才能延迟初始化，且只初始化一次，lazy()是接受一个 lambda 并返回一个 Lazy <T> 实例的函数，返回的实例可以作为实现延迟属性的委托： 第一次调用 get() 会执行已传递给 lazy() 的 lambda 表达式并记录结果， 后续调用 get() 只是返回记录的结果。

class MainActivity : AppCompatActivity() {

    val lazyValue:String by lazy {
        println("1 ---->赋值")
        "lazy"
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        println("2 ---->$lazyValue")
        println("3 ---->$lazyValue")
    }

}

运行结果

默认情况下，对于 lazy属性的求值是同步锁的（synchronized）：该值只在一个线程中计算，并且所有线程会看到相同的值。如果初始化委托的同步锁不是必需的，这样多个线程可以同时执行，那么将 LazyThreadSafetyMode.PUBLICATION作为参数传递给 lazy() 函数。 而如果你确定初始化将总是发生在单个线程，那么你可以使用 LazyThreadSafetyMode.NONE 模式， 它不会有任何线程安全的保证和相关的开销。

可观察属性 Observable

Delegates.observable()接受两个参数：初始值和修改时处理程序（handler）。 每当我们给属性赋值时会调用该处理程序（在赋值后执行）。它有三个参数：被赋值的属性、旧值和新值

class MainActivity : AppCompatActivity() {


    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        val observableUse = ObservableUse()
        observableUse.s = "1"
        observableUse.i = "2"
        println("observable ----> ${observableUse.s}")
        println("observable ----> ${observableUse.i}")
    }

}



class ObservableUse {

    var s: String by Delegates.observable("0") { property, oldValue, newValue ->
        println("observable ----> $property,$oldValue,$newValue")
    }

    var i: String by Delegates.vetoable("3") { property, oldValue, newValue ->
        newValue.length > oldValue.length
    }

}

运行结果

实际应用场景

通过委托，我们可以封装一些工具类，例如 Intent 取值 SharedPrefrences 取值等：

/**
 *  kotlin 委托传值工具
 */
class ExtraDelegator<out T>(private val extraKey:String , private val defaultValue:T) {
    private var extra: T? = null
    operator fun getValue(thisRef: AppCompatActivity, property: KProperty<*>): T {
        extra = getExtra(extra, extraKey, thisRef)
        return extra ?: defaultValue
    }

    operator fun getValue(thisRef: Fragment, property: KProperty<*>): T {
        extra = getExtra(extra, extraKey, thisRef)
        return extra ?: defaultValue
    }

    fun <T> extraDelegate(extra: String, default: T) = ExtrasDelegate(extra, default)

    fun extraDelegate(extra: String) = extraDelegate(extra, null)

    @Suppress("UNCHECKED_CAST")
    private fun <T> getExtra(oldExtra: T?, extraKey: String, thisRef: AppCompatActivity): T? =
            oldExtra ?: thisRef.intent?.extras?.get(extraKey) as T?

    @Suppress("UNCHECKED_CAST")
    private fun <T> getExtra(oldExtra: T?, extraKey: String, thisRef: Fragment): T? =
            oldExtra ?: thisRef.arguments?.get(extraKey) as T?
}

使用：

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        // 传值
        content_tv.setOnClickListener {
            val intent = Intent(this@MainActivity, TestActivity::class.java)
            intent.putExtra("string","value")
            startActivity(intent)
        }
    }

}

class TestActivity:AppCompatActivity(){
    val string:String? by extraDelegate("string") // 通过委托接收
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_test)
        println("TestActivity ------> $string")
    }
}

打印结果

结语

通过委托和扩展函数可以封装很多有趣的工具类，从Java 过度到Kotlin 的感觉就好像从 Eclipse 过渡到 Android Studio 一开始觉得麻烦，但是用一用就觉得：诶，还可以，到现在已经基本不想再用Java写了 ， 对于新的东西，还是要去敢于尝试。