Kotlin委托的常见使用场景

前言

在设计模式中，委托模式（Delegate Pattern）与代理模式都是我们常用的设计模式（Proxy Pattern），两者非常的相似，又有细小的区分。

委托模式中，委托对象和被委托对象都是同一类型的对象，委托对象将任务委托给被委托对象来完成。委托模式可以用于实现事件监听器、回调函数等功能。

代理模式中，代理对象与被代理对象是两种不同的对象，代理对象代表被代理对象的功能，代理对象可以控制客户对被代理对象的访问。代理模式可以用于实现远程代理、虚拟代理、安全代理等功能。

以类的委托与代理来举例，委托对象和被委托对象都实现了同一个接口或继承了同一个类，委托对象将任务委托给被委托对象来完成。代理模式中，代理对象与被代理对象实现了同一个接口或继承了同一个类，代理对象代表被代理对象，客户端通过代理对象来访问被代理对象。

两者的区别：

他们虽然都有同一个接口，主要区别在于委托模式中委托对象和被委托对象是同一类型的对象，而代理模式中代理对象与被代理对象是两种不同的对象。总的来说，委托模式是为了将方法的实现交给其他类去完成，而代理模式则是为了控制对象的访问，并在访问前后进行额外的操作。

而我们常用的委托模式怎么使用？在 Java 语言中需要我们手动的实现，而在 Kotlin 语言中直接通过关键字 by 就可以实现委托，其实现更加优雅、简洁了。

我们在开发一个 Android 应用中，常用到的委托分为：

1. 
   
2. 接口/类的委托
   
3. 属性的委托
   
4. 结合lazy的延迟委托
   
5. 观察者的委托
   
6. Map数据的委托
   

下面我们就一起看看不同种类的委托使用以及在 Android 常见的一些场景中的使用。

一、接口/类委托

我们可以选择使用接口来实现类似的效果，也可以直接传参，当然接口的方式更加的灵活，比如我们这里就以接口比如我定义一个攻击与防御的行为接口：

interface IUserAction {


    fun attack()


    fun defense()

}

定义了用户的行为，有攻击和防御两种操作！接下来我们就定义一个默认的实现类：

class UserActionImpl : IUserAction {


    override fun attack() {

        YYLogUtils.w("默认操作-开始执行攻击")

    }


    override fun defense() {

        YYLogUtils.w("默认操作-开始执行防御")

    }

}

都是很简单的代码，我们定义一些默认的操作，如果任意类想拥有攻击和防御的能力就直接实现这个接口，如果想自定义攻击和防御则重写对应的方法即可。

如果使用 Java 的方式实现委托，大致代码如下：

class UserDelegate1(private val action: IUserAction) : IUserAction {

    override fun attack() {

        YYLogUtils.w("UserDelegate1-需要自己实现攻击")

    }


    override fun defense() {

        YYLogUtils.w("UserDelegate1-需要自己实现防御")

    }

}

如果使用 Kotlin 的方式实现则是：

class UserDelegate2(private val action: IUserAction) : IUserAction by action

如果 Kotlin 的实现不想默认的实现也可以重写部分的操作：

class UserDelegate3(private val action: IUserAction) : IUserAction by action {


    override fun attack() {

        YYLogUtils.w("UserDelegate3 - 只重写了攻击")

    }

}

那么使用起来就是这样的：

    val actionImpl = UserActionImpl()


    UserDelegate1(actionImpl).run {

        attack()

        defense()

    }


    UserDelegate2(actionImpl).run {

        attack()

        defense()

    }


    UserDelegate3(actionImpl).run {

        attack()

        defense()

    }

打印日志如下：

其实在 Android 源码中也有不少委托的使用，例如生命周期的 Lifecycle 委托：

Lifecycle 通过委托机制实现其功能。具体来说，组件可以将自己的生命周期状态委托给 LifecycleOwner 对象，LifecycleOwner 对象则负责管理这些组件的生命周期。

例如，在一个 Activity 中，我们可以通过将 Activity 对象作为 LifecycleOwner 对象，并将该对象传递给需要注册生命周期的组件，从而实现组件的生命周期管理。 页面可以使用 getLifecycle() 方法来获取它所依赖的 LifecycleOwner 对象的 Lifecycle 实例，并在需要时将自身的生命周期状态委托给该 Lifecycle 实例。

通过这种委托机制，Lifecycle 实现了一种方便的方式来管理组件的生命周期，避免了手动管理生命周期带来的麻烦和错误。

class AnimUtil private constructor() : DefaultLifecycleObserver {


    ...


    private fun addLoopLifecycleObserver() {

        mOwner?.lifecycle?.addObserver(this)

    }


    // 退出页面的时候释放资源

    override fun onDestroy(owner: LifecycleOwner) {

        mAnim?.cancel()

        destory()

    }


}

除此之外委托还特别适用于一些可配置的功能，比如 Resutl-Api 的封装，如果当前页面需要开启 startActivityForResult 的功能，就实现这个接口，不需要这个功能就不实现接口，达到可配置的效果。

/**

 * 定义是否需要SAFLauncher

 */

interface ISAFLauncher {


    fun <T : ActivityResultCaller> T.initLauncher()


    fun getLauncher(): GetSAFLauncher?


}

由于代码是固定的实现，目标Activity也不需要重新实现，我们只需要实现默认的实现即可：

class SAFLauncher : ISAFLauncher {


    private var safLauncher: GetSAFLauncher? = null


    override fun <T : ActivityResultCaller> T.initLauncher() {

        safLauncher = GetSAFLauncher(this)

    }


    override fun getLauncher(): GetSAFLauncher? = safLauncher


}

使用起来我们直接用默认的实现即可：

class DemoActivity : BaseActivity, ISAFLauncher by SAFLauncher() {


    override fun init() {

        initLauncher()  // 实现了接口还需要初始化Launcher

    }


    fun gotoOtherPage() {

        //使用 Result Launcher 的方式启动，并获取到返回值

        getLauncher()?.launch<DemoCircleActivity> { result ->

            val result = result.data?.getStringExtra("text")

            toast("收到返回的数据：$result")

        }


    }


}

这样是不是就非常简单了呢？具体如何使用封装 Result Launcher 可以看看我去年的文章 【传送门】

二、属性委托

除了类与接口对象的委托，我们还常用于属性的委托。

我知道了！这么弄就行了。

    private val textStr by "123"

哎？怎么报错了？其实不是这么用的。

属性委托和类委托一样，属性的委托其实是对属性的 set/get 方法的委托。

需要我们把 set/get 方法委托给 setValue/getValue 方法,因此被委托类（真实类）需要提供 setValue/getValue 方法，val属性只需要提供 getValue 方法。

我们修改代码如下：

    private val textStr by TextDelegate()


    class TextDelegate {


        operator fun getValue(thisRef: Any?, property: KProperty<*>): String {

            return "我是赋值给与的文本"

        }


    }

打印的结果：

而我们定义一个可读写的属性则可以

  private var textStr by TextDelegate()


    class TextDelegate {


        operator fun getValue(thisRef: Any?, property: KProperty<*>): String {

            return "我是赋值给与的文本"

        }


        operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {

            YYLogUtils.w("设置的值为：$value")

        }


    }


    YYLogUtils.w("textStr:$textStr")

    textStr = "abc123"

打印则如下：

为了怕大家写错，我们其实可以用接口来限制，只读的和读写的属性，我们分别可以用 ReadOnlyProperty 与 ReadWriteProperty 来限制：

    class TextDelegate : ReadOnlyProperty<Any, String> {

        override fun getValue(thisRef: Any, property: KProperty<*>): String {

            return "我是赋值给与的文本"

        }

    }


    class TextDelegate : ReadWriteProperty<Any, String> {

        override fun getValue(thisRef: Any, property: KProperty<*>): String {

            return "我是赋值给与的文本"

        }


        override fun setValue(thisRef: Any, property: KProperty<*>, value: String) {

            YYLogUtils.w("设置的值为：$value")

        }

    }

那么实现的方式和上面自己实现的效果是一样的。如果要使用属性委托可以选用这种接口限制的方式实现。

我们的属性除了委托给类去实现，同时也能委托给其他属性（Kotlin 1.4+）来实现，例如：

    private var textStr by TextDelegate2()

    private var textStr2 by this::textStr

其实是内部委托了对象的 get 和 set 函数。相对委托对象而言性能更好一些。而委托对象去实现，不仅增加了一个委托类，而且还还在初始化时就创建了委托类的实例对象，算起来其实性能并不好。

所以属性的委托不要滥用，如果要用，可以选择委托现成的其他属性来完成，或者使用延迟委托Lazy实现，或者使用更简单的方式实现：

    private val industryName: String

        get() {

            return "abc123"

        }

对于只读的属性，这种方式也是我们常见的使用方式。

三、延迟委托

如果说使用类来实现委托不那么好的话，其实我们可以使用延迟委托。延迟关键字 lazy 接收一个 lambda 表达式，最后一行代表返回值给被推脱的属性。

默认的 Lazy 实现：

    val name: String by lazy {

        YYLogUtils.w("第一次调用初始化")

        "abc123"

    }


    YYLogUtils.w(name)

    YYLogUtils.w(name)

    YYLogUtils.w(name)

只有在第一次使用此属性的时候才会初始化，一旦初始化之后就可以直接获取到值。

日志打印：

它的内部其实也是使用的是类的委托实现。

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

最终的实现是由 SynchronizedLazyImpl 类生成并实现的：

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

    // 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

            }


            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)

}

我们可以直接看 value 的 get 方法,如果_v1 !== UNINITIALIZED_VALUE 则表明已经初始化过了，就直接返回 value ，否则表明没有初始化过，调用initializer方法，也就是 lazy 的 lambda 表达式返回属性的赋值。

跟我们自己实现类的委托类似，也是实现了getValue方法。只是多了判断是否初始化的一些相关逻辑。

lazy的参数分为三种类型：

1. 
   
2. SYNCHRONIZED:添加同步锁，使lazy延迟初始化线程安全
   
3. PUBLICATION：初始化的lambda表达式，可以在同一时间多次调用，但是只有第一次的返回值作为初始化值
   
4. NONE：没有同步锁，非线程安全
   

默认情况下，对于 lazy 属性的求值是同步锁的（synchronized)，是可以保证线程安全的，但是如果不需要线程安全和减少性能花销可以可以使用 lazy(LazyThreadSafetyMode.NONE){} 即可。

四、观察者委托

除了对属性的值进行委托，我们甚至还能对观察到这个变化过程：

使用 observable 委托监听值的变化：

    var values: String by Delegates.observable("默认值") { property, oldValue, newValue ->


        YYLogUtils.w("打印值: $oldValue -> $newValue ")

    }


    values = "第一次修改"

    values = "第二次修改"

    values = "第三次修改"

打印：

我们还能使用 vetoable 委托，和 observable 一样可以观察属性的变化，不同的是 vetoable 可以决定是否使用新值。

    var age: Int by Delegates.vetoable(18) { property, oldValue, newValue ->

        newValue > oldValue

    }


    YYLogUtils.w("age:$age")

    age = 14

    YYLogUtils.w("age:$age")

    age = 20

    YYLogUtils.w("age:$age")

    age = 22

    YYLogUtils.w("age:$age")

    age = 20

    YYLogUtils.w("age:$age")

我们需要返回 booble 值觉得是否使用新值，比如上述的例子就是当新值大于老值的时候才赋值。那么打印的日志就是如下：

虽然这种方式我们并不常用，一般我们都是使用类似 Flow 之类的工具在源头就处理了逻辑，使用这种方式我们就可以在属性的赋值过程中进行拦截了。在一些特定的场景下还是有用的。

五、Map委托

我们的属性不止可以使用类的委托，延迟的委托，观察的委托，还能委托Map来进行赋值。

当属性的值与 Map 中 key 相同的时候，我们可以把对应 key 的 value 取出来并赋值给属性：

class Member(private val map: Map<String, Any>) {


    val name: String by map

    val age: Int by map

    val dob: Long by map


    override fun toString(): String {

        return "Member(name='$name', age=$age, dob=$dob)"

    }


}

使用：

        val member = Member(mapOf("name" to "guanyu", "age" to 36, Pair("dob", 1234567890L)))

        YYLogUtils.w("member:$member")

打印的日志：

但是需要注意的是，map 中的 key 名字必须要和属性的名字一致才行，否则委托后运行解析时会抛出 NoSuchElementException 异常提示。

例如我们在 Member 对象中加入一个并不存在的 address 属性，再次运行就会报错。

而我们把 Int 的 age 属性赋值给为字符串也会报类型转换异常：

所以一定要一一对应才行哦，我怎么感觉有一点 TypeScript 结构赋值的那味道 - - ！

总结

委托虽好不要滥用。委托毕竟还是中间多了一个委托类，如果没必要可以直接赋值实现，而不需要多一个中间类占用内存。

我们可以通过接口委托来实现一些可选的配置。通过委托类实现属性的监听与赋值。可以减少一些模板代码，达到低耦合高内聚的效果，可以提高程序的可维护性、可扩展性和可重用性。

对于属性的类委托，我们可以将属性的读取和写入操作委托给另一个对象，或者另一个属性，或者使用延迟委托来推迟对象的创建直到第一次访问。

对于 map 的委托，我们需要仔细对应属性与 key 的一致性。以免出现错误，这是运行时的错误，有可能出现在生产环境上的。

那么大家都是怎么使用的呢？有没有更好的方式呢？或者你有遇到的坑也都可以在评论区交流一下，大家可以互相学习进步。如有本文有一些错漏的地方，希望同学们可以指出。

如果感觉本文对你有一点点的帮助，还望你能点赞支持一下，你的支持是我最大的动力。

本文的部分代码可以在我的 Kotlin 测试项目中看到，【传送门】。你也可以关注我的这个Kotlin项目，我有时间都会持续更新。

Ok,这一期就此完结。