这篇文章主要介绍“Kotlin委托需要重视的哪些点”，在日常操作中，相信很多人在Kotlin委托需要重视的哪些点问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”Kotlin委托需要重视的哪些点”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！
委托模式是实现继承的一个很好的替代方式，也是Kotlin语言的一种特性，可以很优雅的实现委托模式。在开发过程中也少不了使用它，但常常都会被低估。所以今天就让它得到重视，去充分的掌握kotlin委托特性以及原理。
我们先完成一个委托类，常常用于实现类的委托模式，它的关键是通过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相当于是个包装，虽然也实现了base，但并不关心它怎么实现，通过by这个关键字，将接口的实现委托给了它的参数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函数，如果是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关键字的修饰。
再来看第一个参数thisRef,它的类型是要这个属性所有者的类型，或者是它的父类。当我们不确定属性会属于哪个类，就可以将thisRef的类型定义为Any？了。
接着看另一个参数property，它的类型是必须要KProperty<*>或其超类型，它的值则是前面的字段的名字prop。
最后一个参数，它的类型必须是委托属性的类型，或者是它的父类。也就是说例子中的 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.
在知道了委托属性怎么写之后，也可以根据需求来实现自己的属性委托。但是每次写都要写那么多模板代码，也是很麻烦的，所以官方也提供了接口类给我们快速实现：
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)
}现在被委托的类只要实现这个接口的其中一个就可以了。对于 val 变量使用 ReadOnlyProperty，而 var 变量实现ReadWriteProperty。我们现在就用ReadWriteProperty 接口来实现一个自定义委托：
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
}
}懒加载委托，也就是我们再对一些资源进行操作的时候，希望它在被访问的时候采取触发，避免不必要的消耗。官方已经帮我们提供了一个lazy()方法来快速创建懒加载委托：
val lazyData: String by lazy {
request()
}
fun request(): String {
println("执行网络请求")
return "网络数据"
}
fun main() {
println("开始")
println(lazyData)
println(lazyData)
}
//结果：
开始
执行网络请求
网络数据
网络数据可以看到只有第一次调用，才会执行lambda表达式里的逻辑，后面再调用只会返回lambda表达式的最终结果。
那么懒加载委托又是怎么实现的呢？ 现在来看下它的源代码：
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类型的参数，如果不传这个参数的话，就会默认使用SynchronizedLazyImpl方式。看解释就可以知道它是用来多线程同步的，而另外两个则不是多线程安全的。
LazyThreadSafetyMode.PUBLICATION：初始化方法可以被多次调用，但是值只是第一次返回时的返回值，也就是只有第一次的返回值可以赋值给初始化的值。
LazyThreadSafetyMode. NONE：如果初始化将总是发生在与属性使用位于相同的线程，这种情况下可以使用，但它没有同步锁。
我们现在主要来看下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,用于下次判断时，直接返回高级函数的返回值
_value = typedValue
initializer = null
typedValue
}
}
}
......
}通过上面代码，可以发现SynchronizedLazyImpl覆盖了lazy接口的返回值，并且重写了属性的访问器，具体逻辑是与Java的双重校验类似的。但Lazy接口又是怎么变成委托属性的？
在Lazy.kt文件中发现它声明了Lazy接口的getValue扩展属性，也就在最终赋值的时候会被调用，而我们在自定义委托中说过，对于val属性，我们需要提供一个getValue函数。
## Lazy.kt //此扩展允许使用 Lazy 的实例进行属性委托 public inline operator fun <T> Lazy<T>.getValue(thisRef: Any?, property: KProperty<*>): T = value
有了这个懒加载委托后，我们实现单例会变的更加简单：
class SingletonDemo private constructor() {
companion object {
val instance: SingletonDemo by lazy{
SingletonDemo() }
}
}如果你要观察一个属性的变化过程，可以将属性委托给Delegates.observable，它有三个参数：被赋值的属性、旧值和新值：
var name: String by Delegates.observable("<no name>") {
prop, old, new ->
println("$old -> $new")
}返回了一个ObservableProperty 对象，继承自 ReadWriteProperty。再来看下它的内部实现：
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是初始值，而另外个参数onChange是属性值被修改时的回调处理器。
一个常见的用例是在一个映射（map）里存储属性的值，它可以使用Map/MutableMap来实现属性委托：
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.") })
}所以在使用的时候要注意，必须要有映射值。
从 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。
这种用法在字段发生改变，又要保留原有的字段时非常有用。可以定义一个新字段，然后将其委托给原来的字段，这样就不用担心新老字段数值不一样的问题了。
如果要在绑定属性委托之前再做一些额外的判断工作要怎么办？我们可以定义provideDelegate来实现：
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> {
//根据属性委托的名字传入不同的初始值
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这里我们创建了一个新的SmartDelegator,通过对成员方法provideDelegate再套了一层，然后在里面进行一些逻辑判断，最后才把属性委托getStringDelegate。
这种拦截属性与其委托之间的绑定的能力，大大缩短了要实现相同功能，还要必须传递属性名的逻辑。
平时在针对Fragment传参，每次都要写一大段代码是不是很烦，现在有了委托这个法宝就来一起简化它，正常模式如下：
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)
}
}
}写了那么一大段，终于写好了传参的基本方法，在获取值的时候还要处理参数为空的情况，现在我们就抽取委托类用属性委托的方式重新实现上面功能：
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);
}
}看上去减少了大量代码，是不是很神奇，下面实现思路如下所示：
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)如果我们现在存取值可以这样做是不是很方便：
private var spResponse: String by PreferenceString(SP_KEY_RESPONSE, "") // 读取，展示缓存 display(spResponse) // 更新缓存 spResponse = response
答案是可以的，还是用委托属性来改造，下面就是具体的实现示例：
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()
}
}
}有了委托之后，在不用到DataBinding，数据与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写一个扩展函数，让它支持了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 关联到一起。
到此，关于“Kotlin委托需要重视的哪些点”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注亿速云网站，小编会继续努力为大家带来更多实用的文章！
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
