Android開發之Kotlin委托的原理與使用方法是什么

今天小編給大家分享一下Android開發之Kotlin委托的原理與使用方法是什么的相關知識點，內容詳細，邏輯清晰，相信大部分人都還太了解這方面的知識，所以分享這篇文章給大家參考一下，希望大家閱讀完這篇文章后有所收獲，下面我們一起來了解一下吧。

前言

在設計模式中，委托模式（Delegate Pattern）與代理模式都是我們常用的設計模式（Proxy Pattern），兩者非常的相似，又有細小的區分。

委托模式中，委托對象和被委托對象都是同一類型的對象，委托對象將任務委托給被委托對象來完成。委托模式可以用于實現事件監聽器、回調函數等功能。

代理模式中，代理對象與被代理對象是兩種不同的對象，代理對象代表被代理對象的功能，代理對象可以控制客戶對被代理對象的訪問。代理模式可以用于實現遠程代理、虛擬代理、安全代理等功能。

以類的委托與代理來舉例，委托對象和被委托對象都實現了同一個接口或繼承了同一個類，委托對象將任務委托給被委托對象來完成。代理模式中，代理對象與被代理對象實現了同一個接口或繼承了同一個類，代理對象代表被代理對象，客戶端通過代理對象來訪問被代理對象。

兩者的區別：

他們雖然都有同一個接口，主要區別在于委托模式中委托對象和被委托對象是同一類型的對象，而代理模式中代理對象與被代理對象是兩種不同的對象。總的來說，委托模式是為了將方法的實現交給其他類去完成，而代理模式則是為了控制對象的訪問，并在訪問前后進行額外的操作。

而我們常用的委托模式怎么使用？在 Java 語言中需要我們手動的實現，而在 Kotlin 語言中直接通過關鍵字 by 就可以實現委托，其實現更加優雅、簡潔了。

我們在開發一個 Android 應用中，常用到的委托分為：

• 接口/類的委托

• 屬性的委托

• 結合lazy的延遲委托

• 觀察者的委托

• Map數據的委托

一、接口/類委托

我們可以選擇使用接口來實現類似的效果，也可以直接傳參，當然接口的方式更加的靈活，比如我們這里就以接口比如我定義一個攻擊與防御的行為接口：

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的參數分為三種類型：

• SYNCHRONIZED:添加同步鎖，使lazy延遲初始化線程安全

• PUBLICATION：初始化的lambda表達式，可以在同一時間多次調用，但是只有第一次的返回值作為初始化值

• 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 結構賦值的那味道 - - ！

以上就是“Android開發之Kotlin委托的原理與使用方法是什么”這篇文章的所有內容，感謝各位的閱讀！相信大家閱讀完這篇文章都有很大的收獲，小編每天都會為大家更新不同的知識，如果還想學習更多的知識，請關注億速云行業資訊頻道。