Kotlin常用的by lazy你真的了解吗

·  阅读 5831

「这是我参与2022首次更文挑战的第10天,活动详情查看:2022首次更文挑战

前言

在使用Kotlin语言进行开发时,我相信很多开发者都信手拈来地使用by或者by lazy来简化你的属性初始化,但是by lazy涉及的知识点真的了解吗 假如让你实现这个功能,你会如何设计。

正文

话不多说,我们从简单的属性委托by来说起。

委托属性

什么是委托属性呢,比较官方的说法就是假如你想实现一个比较复杂的属性,它们处理起来比把值保存在支持字段中更复杂,但是却不想在每个访问器都重复这样的逻辑,于是把获取这个属性实例的工作交给了一个辅助对象,这个辅助对象就是委托。

比如可以把这个属性的值保存在数据库中,一个Map中等,而不是直接调用其访问器。

看完这个委托属性的定义,假如你不熟悉Kotlin也可以理解,就是我这个类的实例由另一个辅助类对象来提供,但是这时你可能会疑惑,上面定义中说的支持字段和访问器是什么呢,这里顺便给不熟悉Kotlin的同学普及一波。

Java的属性

当你定义一个Java类时,在定义字段时并不是所有字段都是属性,比如下面代码:

//Java类
public class Phone {
    
    //3个字段
    private String name;
    private int price;
    private int color;

    //name字段访问器
    private String getName() {
        return name;
    }

    private void setName(String name){
        this.name = name;
    }

    //price字段访问器
    private int getPrice() {
        return price;
    }

    private void setPrice(int price){
        this.price = price;
    }
}
复制代码

上面我在Phone类中定义了3个字段,但是只有name和price是Phone的属性,因为这2个字段有对应的get和set,也只有符合有getter和setter的字段才叫做属性。

这也能看出Java类的属性值是保存在字段中的,当然你也可以定义setXX函数和getXX函数,既然XX属性没有地方保存,XX也是类的属性。

Kotlin的属性

而对于Kotlin的类来说,属性定义就非常简单了,比如下面类:

class People(){
    val name: String? = null
    var age: Int? = null
}
复制代码

在Kotlin的类中只要使用val/var定义的字段,它就是类的属性,然后会自带getter和setter方法(val属性相当于Java的final变量,是没有set方法的),比如下面:

val people = People()
//调用name属性的getter方法
people.name
//调用age属性的setter方法
people.age = 12
复制代码

这时就有了疑问,为什么上面代码定义name时我在后面给他赋值了即null值,和Java一样不赋值可以吗 还有个疑问就是在Java中是把属性的值保存在字段中,那Kotlin呢,比如name这个属性的值就保存给它自己吗

带着问题,我们继续分析。

Kotlin属性访问器

前面我们可知Java中的属性是保存在字段中,或者不要字段,其实Kotlin也可以,这个就是给属性定义自定义setter方法和getter方法,如下代码:

class People(){
    val name: String? = null
    var age: Int = 0
    //定义了isAbove18这个属性
    var isAbove18: Boolean = false
        get() = age > 18
}
复制代码

比如这里自定义了get访问器,当再访问这个属性时,便会调用其get方法,然后进行返回值。

Kotlin属性支持字段field

这时一想那Kotlin的属性值保存在哪里呢,Kotlin会使用一个field的支持字段来保存属性。如下代码:

class People{
    val name: String? = null
    var age: Int = 0
        //返回field的值
        get() = field
        //设置field的值
        set(value){
            Log.i("People", "旧值是$field 新值是$value ")
            field = value
        }

    var isAbove18: Boolean = false
        get() = age > 18
}
复制代码

可以发现每个属性都会有个支持字段field来保存属性的值。

好了,为了介绍为什么Kotlin要有委托属性这个机制,假如我在一个类中,需要定义一个属性,这时获取属性的值如果使用get方法来获取,会在多个类都要写一遍,十分不符合代码设计,所以委托属性至关重要。

委托属性的实现

在前面说委托属性的概念时就说了,这个属性的值需要由一个新类来代理处理,这就是委托属性,那我们也可以大概猜出委托属性的底层逻辑,大致如下面代码:

class People{
    val name: String? = null
    var age: Int = 0
    val isAbove18: Boolean = false
    //email属性进行委托,把它委托给ProduceEmail类
    var email: String by ProduceEmail()
}
复制代码

假如People的email属性需要委托,上面代码编译器会编译成如下:

class People{
    val name: String? = null
    var age: Int = 0
    val isAbove18: Boolean = false
    //委托类的实例
    private val productEmail = ProduceEmail()
    //委托属性
    var email: String
        //访问器从委托类实例获取值
        get() = productEmail.getValue()
        //设置值把值设置进委托类实例
        set(value) = productEmail.setValue(value)
}
复制代码

当然上面代码是编译不过的,只是说一下委托的实现大致原理。那假如想使ProduceEmail类真的具有这个功能,需要如何实现呢。

by约定

其实我们经常使用 by 关键字它是一种约定,是对啥的约定呢 是对委托类的方法的约定,关于啥是约定,一句话说明白就是简化函数调用,具体可以查看我之前的文章:

# Kotlin invoke约定,让Kotlin代码更简洁

那这里的by约定简化了啥函数调用呢 其实也就是属性的get方法和set方法,当然委托类需要定义相应的函数,也就是下面这2个函数:

//by约定能正常使用的方法
class ProduceEmail(){
    
    private val emails = arrayListOf("111@qq.com")
    
    //对应于被委托属性的get函数
    operator fun getValue(people: People, property: KProperty<*>): String {
        Log.i("zyh", "getValue: 操作的属性名是 ${property.name}")
        return emails.last()
    }

    //对于被委托属性的get函数
    operator fun setValue(people: People, property: KProperty<*>, s: String) {
        emails.add(s)
    }

}
复制代码

定义完上面委托类,便可以进行委托属性了:

class People{
    val name: String? = null
    var age: Int = 0
    val isAbove18: Boolean = false
    //委托属性
    var email: String by ProduceEmail()
}
复制代码

然后看一下调用地方:

val people = People()
Log.i("zyh", "onCreate: ${people.email}")
people.email = "222@qq.com"
Log.i("zyh", "onCreate: ${people.email}")
复制代码

打印如下:

image.png

会发现每次调用email属性的访问器方法时,都会调用委托类的方法。

关于委托类中的方法,当你使用by关键字时,IDE会自动提醒,提醒如下:

image.png

比如getValue方法中的参数,第一个就是接收者了,你这个要委托的属性是哪个类的,第二个就是属性了,关于KProperty不熟悉的同学可以查看文章:

# Kotlin反射全解析3 -- 大展身手的KProperty

它就代表这属性,可以调用其中的一些方法来获取属性的信息。

而且方法必须使用operator关键字修饰,这是重载操作符的必须步骤,想使用约定,就必须这样干。

by lazy的实现

由前面明白了by的原理,我们接着来看一下我们经常使用的by lazy是个啥,直接看代码:

//这里使用by lazy惰性初始化一个实例
val instance: DataStoreManager by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
    DataStoreManager(store) }
复制代码

比如上面代码,使用惰性初始化初始了一个实例,我们来看一下这个by的实现:

//by代码
@kotlin.internal.InlineOnly
public inline operator fun <T> Lazy<T>.getValue(thisRef: Any?, property: KProperty<*>): T = value
复制代码

哦,会发现它是Lazy类的一个扩展函数,按照前面我们对by的理解,它就是把被委托的属性的get函数和getValue进行配对,所以可以想象在Lazy< T >类中,这个value便是返回的值,我们来看一下:

//惰性初始化类
public interface Lazy<out T> {
    
    //懒加载的值,一旦被赋值,将不会被改变
    public val value: T

    //表示是否已经初始化
    public fun isInitialized(): Boolean
}
复制代码

到这里我们注意一下 by lazy的lazy,这个就是一个高阶函数,来创建Lazy实例的,lazy源码:

//lazy源码
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)
    }
复制代码

这里会发现第一个参数便是线程同步的模式,第二个参数是初始化器,我们就直接看一下最常见的SYNCHRONIZED的模式代码:

//线程安全模式下的单例
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
    //锁
    private val lock = lock ?: this

    override val value: T
        //见分析1
        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)
}
复制代码

分析1:这个单例实现是不是有点眼熟,没错它就是双重校验锁实现的单例,假如你对双重校验锁的实现单例方式还不是很明白可以查看文章:

# Java双重校验锁单例原理 赶快看进来

这里实现懒加载单例的模式就是双重校验锁,2次判空以及volatile关键字都是有作用的,这里不再赘述。

总结

先搞明白by的原理,再理解by lazy就非常好理解了,虽然这些关键字我们经常使用,不过看一下其源码实现还是很舒爽的,尤其是Kotlin的高阶函数的一些SDK写法还是很值的学习。

分类:
Android
标签:
收藏成功!
已添加到「」, 点击更改