注册

Kotlin委托的原理与使用,以及在Android开发中常用的几个场景

Kotlin委托的常见使用场景


前言


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


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


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


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


两者的区别:


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


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


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



  1. 接口/类的委托
  2. 属性的委托
  3. 结合lazy的延迟委托
  4. 观察者的委托
  5. 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()
}

打印日志如下:


image.png


其实在 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 "我是赋值给与的文本"
}

}

打印的结果:


image.png


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


  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"

打印则如下:


image.png


为了怕大家写错,我们其实可以用接口来限制,只读的和读写的属性,我们分别可以用 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)

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


日志打印:


image.png


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


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. SYNCHRONIZED:添加同步锁,使lazy延迟初始化线程安全
  2. PUBLICATION:初始化的lambda表达式,可以在同一时间多次调用,但是只有第一次的返回值作为初始化值
  3. NONE:没有同步锁,非线程安全

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


四、观察者委托


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


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


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

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

values = "第一次修改"
values = "第二次修改"
values = "第三次修改"

打印:


image.png


我们还能使用 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 值觉得是否使用新值,比如上述的例子就是当新值大于老值的时候才赋值。那么打印的日志就是如下:


image.png


虽然这种方式我们并不常用,一般我们都是使用类似 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")

打印的日志:


image.png


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


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


image.png


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


image.png


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


image.png


总结


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


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


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


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


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


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


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


Ok,这一期就此完结。




作者:newki
来源:juejin.cn/post/7213267574770090039

0 个评论

要回复文章请先登录注册