關于Kotlin委托你必須重視的幾個點
前言
委托模式是實現(xiàn)繼承的一個很好的替代方式，也是Kotlin語言的一種特性，可以很優(yōu)雅的實現(xiàn)委托模式。在開發(fā)過程中也少不了使用它，但常常都會被低估。所以今天就讓它得到重視，去充分的掌握kotlin委托特性以及原理。
一、委托類
我們先完成一個委托類，常常用于實現(xiàn)類的委托模式，它的關鍵是通過by關鍵字：
interface Base{
fun print()
}
class BaseImpl(val x: Int): Base{
override fun print() { print(x) }
}
class Derived(b: Base): Base by b
fun main(){
val b = BaseImpl(10)
Deriived(b).print()
}
//最后輸出了10在這個委托模式中Derived相當于是個包裝，雖然也實現(xiàn)了base，但并不關心它怎么實現(xiàn)，通過by這個關鍵字，將接口的實現(xiàn)委托給了它的參數(shù)db。
相當于Java代碼的結構：
class Derived implements Base{
Base b;
public Derived(Base b){ this.b = b}
}二、 委托屬性
前面講到Kotlin委托類是委托的是接口方法，委托屬性委托的，則是屬性的getter和setter方法。kotlin支持的委托屬性語法：
class Example {
var prop: String by Delegate()
}屬性對應的get()和set()會被委托給它的getValue和setValue方法。當然屬性的委托不是隨便寫的，對于與val屬性它必須要提供一個getValue函數(shù)，如果是var屬性的則要另外提供setValue屬性。先來看個官方提供的委托屬性Delegate：
class Delegate {
operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
return "$thisRef, thank you for delegating '${property.name}' to me!"
}
operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
println("$value has been assigned to '${property.name}' in $thisRef.")
}
}我們可以看到對于var修飾的屬性，必須要有getValue和setValue方法，同時這兩個方法必須有operator關鍵字的修飾。
再來看第一個參數(shù)thisRef,它的類型是要這個屬性所有者的類型，或者是它的父類。當我們不確定屬性會屬于哪個類，就可以將thisRef的類型定義為Any？了。
接著看另一個參數(shù)property，它的類型是必須要KProperty<*>或其超類型，它的值則是前面的字段的名字prop。
最后一個參數(shù)，它的類型必須是委托屬性的類型，或者是它的父類。也就是說例子中的 value: String 也可以換成 value: Any。
我們來測試下到底是不是這樣的：
fun main() {
println(Example().prop)
Example().prop = "Hello, World"
}則會看到輸出：
Example@5197848c, thank you for delegating 'prop' to me! Hello, World has been assigned to 'prop' in Example@17f052a3.
2.1 自定義委托
在知道了委托屬性怎么寫之后，也可以根據(jù)需求來實現(xiàn)自己的屬性委托。但是每次寫都要寫那么多模板代碼，也是很麻煩的，所以官方也提供了接口類給我們快速實現(xiàn)：
interface ReadOnlyProperty<in R, out T> {
operator fun getValue(thisRef: R, property: KProperty<*>): T
}
interface ReadWriteProperty<in R, T> {
operator fun getValue(thisRef: R, property: KProperty<*>): T
operator fun setValue(thisRef: R, property: KProperty<*>, value: T)
}現(xiàn)在被委托的類只要實現(xiàn)這個接口的其中一個就可以了。對于 val 變量使用 ReadOnlyProperty，而 var 變量實現(xiàn)ReadWriteProperty。我們現(xiàn)在就用ReadWriteProperty 接口來實現(xiàn)一個自定義委托：
class Owner {
var text: String by StringDelegate()
}
class StringDelegate(private var s: String = "Hello"): ReadWriteProperty<Owner, String> {
override operator fun getValue(thisRef: Owner, property: KProperty<*>): String {
return s
}
override operator fun setValue(thisRef: Owner, property: KProperty<*>, value: String) {
s = value
}
}三、委托進階
3.1 懶加載委托
懶加載委托，也就是我們再對一些資源進行操作的時候，希望它在被訪問的時候采取觸發(fā)，避免不必要的消耗。官方已經(jīng)幫我們提供了一個lazy()方法來快速創(chuàng)建懶加載委托：
val lazyData: String by lazy {
request()
}
fun request(): String {
println("執(zhí)行網(wǎng)絡請求")
return "網(wǎng)絡數(shù)據(jù)"
}
fun main() {
println("開始")
println(lazyData)
println(lazyData)
}
//結果：
開始
執(zhí)行網(wǎng)絡請求
網(wǎng)絡數(shù)據(jù)
網(wǎng)絡數(shù)據(jù)
復制代碼可以看到只有第一次調(diào)用，才會執(zhí)行l(wèi)ambda表達式里的邏輯，后面再調(diào)用只會返回lambda表達式的最終結果。
那么懶加載委托又是怎么實現(xiàn)的呢？ 現(xiàn)在來看下它的源代碼：
public actual fun <T> lazy(initializer: () -> T): Lazy<T> = SynchronizedLazyImpl(initializer)
public actual fun <T> lazy(mode: LazyThreadSafetyMode, initializer: () -> T): Lazy<T> =
when (mode) {
LazyThreadSafetyMode.SYNCHRONIZED -> SynchronizedLazyImpl(initializer)
LazyThreadSafetyMode.PUBLICATION -> SafePublicationLazyImpl(initializer)
LazyThreadSafetyMode.NONE -> UnsafeLazyImpl(initializer)
}在這個里面lazy()方法會接收一個LazyThreadSafetyMod類型的參數(shù)，如果不傳這個參數(shù)的話，就會默認使用SynchronizedLazyImpl方式。看解釋就可以知道它是用來多線程同步的，而另外兩個則不是多線程安全的。
LazyThreadSafetyMode.PUBLICATION：初始化方法可以被多次調(diào)用，但是值只是第一次返回時的返回值，也就是只有第一次的返回值可以賦值給初始化的值。
LazyThreadSafetyMode. NONE：如果初始化將總是發(fā)生在與屬性使用位于相同的線程，這種情況下可以使用，但它沒有同步鎖。
我們現(xiàn)在主要來看下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
//判斷是否已經(jīng)初始化過，如果初始化過直接返回，不在調(diào)用高級函數(shù)內(nèi)部邏輯
//如果這兩個值不相同，就說明當前的值已經(jīng)被加載過了，直接返回
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 {
//調(diào)用高級函數(shù)獲取其返回值
val typedValue = initializer!!()
//將返回值賦值給_value,用于下次判斷時，直接返回高級函數(shù)的返回值
_value = typedValue
initializer = null
typedValue
}
}
}
......
}通過上面代碼，可以發(fā)現(xiàn)SynchronizedLazyImpl覆蓋了lazy接口的返回值，并且重寫了屬性的訪問器，具體邏輯是與Java的雙重校驗類似的。但Lazy接口又是怎么變成委托屬性的？
在Lazy.kt文件中發(fā)現(xiàn)它聲明了Lazy接口的getValue擴展屬性，也就在最終賦值的時候會被調(diào)用，而我們在自定義委托中說過，對于val屬性，我們需要提供一個getValue函數(shù)。
## Lazy.kt //此擴展允許使用 Lazy 的實例進行屬性委托 public inline operator fun <T> Lazy<T>.getValue(thisRef: Any?, property: KProperty<*>): T = value
有了這個懶加載委托后，我們實現(xiàn)單例會變的更加簡單：
class SingletonDemo private constructor() {
companion object {
val instance: SingletonDemo by lazy{
SingletonDemo() }
}
}3.2 Delegates.observable 觀察者委托
如果你要觀察一個屬性的變化過程，可以將屬性委托給Delegates.observable，它有三個參數(shù)：被賦值的屬性、舊值和新值：
var name: String by Delegates.observable("<no name>") {
prop, old, new ->
println("$old -> $new")
}返回了一個ObservableProperty 對象，繼承自 ReadWriteProperty。再來看下它的內(nèi)部實現(xiàn)：
public inline fun <T> observable(initialValue: T, crossinline onChange: (property: KProperty<*>, oldValue: T, newValue: T) -> Unit):
ReadWriteProperty<Any?, T> =
object : ObservableProperty<T>(initialValue) {
override fun afterChange(property: KProperty<*>, oldValue: T, newValue: T) = onChange(property, oldValue, newValue)
}initialValue是初始值，而另外個參數(shù)onChange是屬性值被修改時的回調(diào)處理器。
3.3 by map 映射委托
一個常見的用例是在一個映射（map）里存儲屬性的值，它可以使用Map/MutableMap來實現(xiàn)屬性委托：
class User(val map: Map<String, Any?>) {
val name: String by map
}
fun main(args: Array<String>) {
val map = mutableMapOf(
"name" to "哈哈"
)
val user = User(map)
println(user.name)
map["name"] = "LOL"
println(user.name)
}
//輸出：
哈哈
LoL不過在使用過程中會有個問題，如果Map中不存在委托屬性名的映射值的時候，會再取值時拋異常：Key $key is missing in the map：
## MapAccessors.kt
public inline operator fun <V, V1 : V> MutableMap<in String, out @Exact V>.getValue(thisRef: Any?, property: KProperty<*>): V1 = (getOrImplicitDefault(property.name) as V1)
@kotlin.internal.InlineOnly
public inline operator fun <V> MutableMap<in String, in V>.setValue(thisRef: Any?, property: KProperty<*>, value: V) {
this.put(property.name, value)
}
## MapWithDefault.kt
internal fun <K, V> Map<K, V>.getOrImplicitDefault(key: K): V {
if (this is MapWithDefault)
return this.getOrImplicitDefault(key)
return getOrElseNullable(key, { throw NoSuchElementException("Key $key is missing in the map.") })
}所以在使用的時候要注意，必須要有映射值。
3.4 兩個屬性之間的直接委托
從 Kotlin 1.4 開始，我們可以直接在語法層面將“屬性 A”委托給“屬性 B”，就如下示例：
class Item {
var count: Int = 0
var total: Int by ::count
}上面代碼total的值與count完全一致，因為我們把total這個屬性的getter和setter都委托給了count。可以用代碼來解釋下具體的邏輯：
class Item {
var count: Int = 0
var total: Int
get() = count
set(value: Int) {
count = value
}
}在寫法上，委托名稱可以使用":"限定符，比如this::delegate 或MyClass::delegate。
這種用法在字段發(fā)生改變，又要保留原有的字段時非常有用?？梢远x一個新字段，然后將其委托給原來的字段，這樣就不用擔心新老字段數(shù)值不一樣的問題了。
3.5 提供委托
如果要在綁定屬性委托之前再做一些額外的判斷工作要怎么辦？我們可以定義provideDelegate來實現(xiàn)：
class StringDelegate(private var s: String = "Hello") {
operator fun getValue(thisRef: Owner, property: KProperty<*>): String {
return s
}
operator fun setValue(thisRef: Owner, property: KProperty<*>, value: String) {
s = value
}
}
class SmartDelegator {
operator fun provideDelegate(
thisRef: Owner,
prop: KProperty<*>
): ReadWriteProperty<Owner, String> {
//根據(jù)屬性委托的名字傳入不同的初始值
return if (prop.name.contains("log")) {
StringDelegate("log")
} else {
StringDelegate("normal")
}
}
}
class Owner {
var normalText: String by SmartDelegator()
var logText: String by SmartDelegator()
}
fun main() {
val owner = Owner()
println(owner.normalText)
println(owner.logText)
}
//結果：
normal
log這里我們創(chuàng)建了一個新的SmartDelegator,通過對成員方法provideDelegate再套了一層，然后在里面進行一些邏輯判斷，最后才把屬性委托getStringDelegate。
這種攔截屬性與其委托之間的綁定的能力，大大縮短了要實現(xiàn)相同功能，還要必須傳遞屬性名的邏輯。
四、委托栗子
4.1 簡化Fragment / Activity 傳參
平時在針對Fragment傳參，每次都要寫一大段代碼是不是很煩，現(xiàn)在有了委托這個法寶就來一起簡化它，正常模式如下：
class BookDetailFragment : Fragment(R.layout.fragment_book_detail) {
private var bookId: Int? = null
private var bookType: Int? = null
companion object {
const val EXTRA_BOOK_ID = "bookId"
const val EXTRA_BOOK_TYPE = "bookType";
fun newInstance(bookId: Int, bookType: Int?) = BookDetailFragment().apply {
Bundle().apply {
putInt(EXTRA_BOOK_ID, bookId)
if (null != bookType) {
putInt(EXTRA_BOOK_TYPE, bookType)
}
}.also {
arguments = it
}
}
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
arguments?.let {
bookId = it.getInt(EXTRA_book_ID, 123)
bookType = it.getInt(EXTRA_BOOK_TYPE, 1)
}
}
}寫了那么一大段，終于寫好了傳參的基本方法，在獲取值的時候還要處理參數(shù)為空的情況，現(xiàn)在我們就抽取委托類用屬性委托的方式重新實現(xiàn)上面功能：
class BookDetailFragment : Fragment(R.layout.fragment_book_detail) {
private var bookId: Int by argument()
companion object {
fun newInstance(bookId: Int, bookType: Int) = BookDetailFragment().apply {
this.bookId = bookId
}
}
override fun onViewCreated(root: View, savedInstanceState: Bundle?) {
Log.d("tag", "BOOKID:" + bookId);
}
}看上去減少了大量代碼，是不是很神奇，下面實現(xiàn)思路如下所示：
class FragmentArgumentProperty<T> : ReadWriteProperty<Fragment, T> {
override fun getValue(thisRef: Fragment, property: KProperty<*>): T {
//對Bunndle取值還要進行單獨處理
return thisRef.arguments?.getValue(property.name) as? T
?: throw IllegalStateException("Property ${property.name} could not be read")
}
override fun setValue(thisRef: Fragment, property: KProperty<*>, value: T) {
val arguments = thisRef.arguments ?: Bundle().also { thisRef.arguments = it }
if (arguments.containsKey(property.name)) {
// The Value is not expected to be modified
return
}
//對Bunndle設值還要進行單獨處理
arguments[property.name] = value
}
}
fun <T> Fragment.argument(defaultValue: T? = null) = FragmentArgumentProperty(defaultValue)4.2 簡化SharedPreferences存取值
如果我們現(xiàn)在存取值可以這樣做是不是很方便：
private var spResponse: String by PreferenceString(SP_KEY_RESPONSE, "") // 讀取，展示緩存 display(spResponse) // 更新緩存 spResponse = response
答案是可以的，還是用委托屬性來改造，下面就是具體的實現(xiàn)示例：
class PreDelegate<T>(
private val name: String,
private val default: T,
private val isCommit: Boolean = false,
private val prefs: SharedPreferences = App.prefs) {
operator fun getValue(thisRef: Any?, property: KProperty<*>): T {
return getPref(name, default) ?: default
}
operator fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
value?.let {
putPref(name, value)
}
}
private fun <T> getPref(name: String, default: T): T? = with(prefs) {
val result: Any? = when (default) {
is Long -> getLong(name, default)
is String -> getString(name, default)
is Int -> getInt(name, default)
is Boolean -> getBoolean(name, default)
is Float -> getFloat(name, default)
else -> throw IllegalArgumentException("This type is not supported")
}
result as? T
}
private fun <T> putPref(name: String, value: T) = with(prefs.edit()) {
when (value) {
is Long -> putLong(name, value)
is String -> putString(name, value)
is Int -> putInt(name, value)
is Boolean -> putBoolean(name, value)
is Float -> putFloat(name, value)
else -> throw IllegalArgumentException("This type is not supported")
}
if (isCommit) {
commit()
} else {
apply()
}
}
}4.3 數(shù)據(jù)與View的綁定
有了委托之后，在不用到DataBinding，數(shù)據(jù)與View之間也可以進行綁定。
operator fun TextView.provideDelegate(value: Any?, property: KProperty<*>) = object : ReadWriteProperty<Any?, String?> {
override fun getValue(thisRef: Any?, property: KProperty<*>): String? = text
override fun setValue(thisRef: Any?, property: KProperty<*>, value: String?) {
text = value
}
}給TextView寫一個擴展函數(shù)，讓它支持了String屬性的委托。
val textView = findViewById<textView>(R.id.textView) var message: String? by textView textView.text = "Hello" println(message) message = "World" println(textView.text) //結果： Hello World
我們通過委托的方式，將 message 委托給了 textView。這意味著，message 的 getter 和 setter 都將與 TextView 關聯(lián)到一起。
五、小結
主要講解了 Kotlin 委托的用法和本質(zhì)，總共有兩類委托類和委托屬性，特別是屬性委托要值得重視。在開發(fā)中其實有很多場景可以用委托來進行簡化，減少很多重復的樣板代碼，可以說跟擴展比起來也毫不遜色。
參考
Kotlin Jetpack 實戰(zhàn) | 07. Kotlin 委托
總結
到此這篇關于關于Kotlin委托的文章就介紹到這了,更多相關Kotlin委托重視的幾個點內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
Android?中?FrameLayout?布局及屬性的使用詳解
這篇文章主要介紹了Android?中?FrameLayout?布局及屬性的使用,FrameLayout?在實現(xiàn)簡單布局時非常方便,特別適用于疊加式布局,如顯示疊加的圖層或浮動按鈕等,需要的朋友可以參考下2024-03-03
解決eclipse啟動時報錯Failed to create the Java Virtural Machine.問題的
這篇文章主要介紹了解決eclipse啟動時報Failed to create the Java Virtural Machine.問題的方法，感興趣的小伙伴們可以參考一下2016-01-01
如何自定義Android菜單背景呢? 默認的情況下Android系統(tǒng)的菜單是白色的，下面的例子可以通過自定義的xml布局實現(xiàn)個性化的menu2013-01-01
這篇文章主要介紹了Android中關于遞歸和二分法的算法實例代碼的相關資料,需要的朋友可以參考下2016-10-10
本篇文章主要介紹了android如何設置Activity背景色為透明色，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2017-07-07
Android自定義EditText實現(xiàn)登錄界面
這篇文章主要為大家詳細介紹了Android自定義EditText實現(xiàn)登錄界面，具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-12-12
這篇文章主要給大家介紹了在使用RxJava中可能遇到的一些”坑“，文中總結的這些坑都是我在實踐中遇到的，現(xiàn)在分享出來給大家，希望大家能夠避免這個問題，需要的朋友們下面來一起看看吧。2017-05-05
Android數(shù)據(jù)流之Channel和Flow實現(xiàn)原理和技巧詳解
在 Android 應用程序的開發(fā)中,處理異步數(shù)據(jù)流是一個常見的需求,為了更好地應對這些需求,Kotlin 協(xié)程引入了 Channel 和 Flow,它們提供了強大的工具來處理數(shù)據(jù)流,本文將深入探討 Channel 和 Flow 的內(nèi)部實現(xiàn)原理、高級使用技巧以及如何在 Android 開發(fā)中充分利用它們2023-11-11
這篇文章主要介紹了常見Android編譯優(yōu)化問題梳理總結，文章圍繞主題展開詳細的內(nèi)容介紹，具有一定的參考價值，需要的小伙伴可以參考一下2022-08-08
這篇文章主要介紹了Android自定義view實現(xiàn)圓形進度條效果，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-05-05