Kotlin委托属性-简化数据访问

简介:

一、概述

Kotlin有很多语法糖,最近看了委托属性, 用于改造笔者的开源组件LightKV, 确实提高了不少易用性。
关于LightKV,笔者在上一篇文章《LightKV-高性能key-value存储组件》中有介绍其原理,有兴趣的读者可以了解一下。

LightKV的用法和SharePreferences类似,都是key-value结构,通过指定key读写value。
key-value 的 API 适用于存储统计,缓存,配置......等各种信息,
随着APP的迭代,必然会有越来越多的信息需要存储,对应用开发而言,key-value的存储不可或缺。

笔者上一篇文章中,有热心网友提到:“想法很好,不过感觉用处不大,如果要存的数据很少那就sp …… ”
诚然,SDK已经提供了SharePreferences了,而且当用SharePreferences还没遇到性能瓶颈时,也就没有尝试别的组件的的动力了。

而且,之前的那一版,只做到了“高效”,没有做到“易用”。


二、旧版用法

public class AppData {
    private static final SyncKV DATA =
            new LightKV.Builder(GlobalConfig.getAppContext(), "app_data")
                    .logger(AppLogger.getInstance())
                    .executor(AsyncTask.THREAD_POOL_EXECUTOR)
                    .keys(Keys.class)
                    .encoder(new ConfuseEncoder())
                    .sync();

    // keys define
    public interface Keys {
        int SHOW_COUNT = 1 | DataType.INT;
        int ACCOUNT = 2 | DataType.STRING ;
        int TOKEN = 3 | DataType.STRING;
        int SECRET = 4 | DataType.ARRAY | DataType.ENCODE;
    }

    public static SyncKV data() {
        return DATA;
    }

    public static String getString(int key) {
        return DATA.getString(key);
    }

    public static void putString(int key, String value) {
        DATA.putString(key, value);
        DATA.commit();
    }

    public static byte[] getArray(int key) {
        return DATA.getArray(key);
    }

    public static void putArray(int key, byte[] value) {
        DATA.putArray(key, value);
        DATA.commit();
    }

    // ......
}
val account = AppData.getString(AppData.Keys.ACCOUNT)
if(TextUtils.isEmpty(account)){
      AppData.putString(AppData.Keys.ACCOUNT, "foo@gmail.com")
}

该用法的复杂度在于:
如果想用静态方法(调用时简单一些),则每一个数据存储类都需要实现一份各种类型的get和set;
如果直接返回data()来读写, 写起来会比较长:

val account = AppData2.data().getString(Keys.ACCOUNT)
if(TextUtils.isEmpty(account)){
     AppData2.data().putString(Keys.ACCOUNT, "foo@gmail.com")
}

直到后来了解了Kotlin委托, 仿佛看到了曙光……


三、新版用法

object AppData : KVData() {
    override fun createInstance(): LightKV {
        return LightKV.Builder(GlobalConfig.appContext, "app_data")
                .logger(AppLogger)
                .executor(AsyncTask.THREAD_POOL_EXECUTOR)
                .encoder(GzipEncoder)
                .sync()
    }

    var showCount by int(1)
    var account by string(2)
    var token by string(3)
    var secret by array(4 or DataType.ENCODE)
}
val account = AppData.account
if (TextUtils.isEmpty(account)) {
   AppData.account = "foo@gmail.com"
}

使用Kotlin委托,省了各种put和set的方法调用,看起来像是在直接访问AppData的属性。


四、属性委托的实现

4.1 声明属性

语法: val/var <属性名>: <类型> by <表达式>。

class Example {
    var p: String by Delegate()
}

by 后面的表达式是对应的委托, 属性的 get() 和 set() 会被委托给它的 getValue() 和 setValue() 方法。
当然,如果声明的是val, 则不会委托set()方法。

4.2 实现委托

属性的委托,需要提供一个 getValue() 函数和 setValue() 函数(如果声明的是var 的话),并以operator修饰。

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.")
    }
}

例子中,thisRef 是 Example 的引用, 参数 property 保存了对属性p的描述,例如可以通过property.name获取p的名字.

4.3 访问属性

访问 p 时,将调用 Delegate 中的 getValue() 函数;
给 p 赋值时,将调用 setValue() 函数。

val e = Example()
println(e.p)
e.p = "NEW"

输出结果:

Example@33a17727, thank you for delegating ‘p’ to me!
NEW has been assigned to ‘p’ in Example@33a17727.

4.4 属性委托的原理

class C {
    var prop: Type by MyDelegate()
}
// 由编译器生成的相应代码:
class C {
    private val prop$delegate = MyDelegate()
    var prop: Type
        get() = prop$delegate.getValue(this, this::prop)
        set(value: Type) = prop$delegate.setValue(this, this::prop, value)
}

前后对比,不难看出,其实属性委托的本质是“代理模式”的语法封装。

五、优化LightKV

5.1 定义抽象类

abstract class KVData{
    internal var autoCommit = true

    abstract fun createInstance() : LightKV

    val data: LightKV by lazy {
        createInstance()
    }

    protected fun boolean(key: Int) = KVProperty<Boolean>(key or DataType.BOOLEAN)
    protected fun int(key: Int) = KVProperty<Int>(key or DataType.INT)
    protected fun float(key: Int) = KVProperty<Float>(key or DataType.FLOAT)
    protected fun double(key: Int) = KVProperty<Double>(key or DataType.DOUBLE)
    protected fun long(key: Int) = KVProperty<Long>(key or DataType.LONG)
    protected fun string(key: Int) = KVProperty<String>(key or DataType.STRING)
    protected fun array(key: Int) = KVProperty<ByteArray>(key or DataType.ARRAY)

    fun disableAutoCommit(){
        autoCommit = false
    }

    fun enableAutoCommit(){
        autoCommit = true
        data.commit()
    }
}

该抽象类声明了LightKV, 添加了自动提交开关,以及定了个各种类型委托。

5.2 实现委托

为方便编写委托, Kotlin标准库定义了的ReadWriteProperty接口:

interface ReadWriteProperty<in R, T> {
    operator fun getValue(thisRef: R, property: KProperty<*>): T
    operator fun setValue(thisRef: R, property: KProperty<*>, value: T)
}

使用时实现接口的方法即可。
为了统一定义各个类型委托,我们在构造函数传入key, 由key决定对应的类型操作。
通过thisRef.data(LightKV)和 key, 分别在getValue和setValue方法中实现取值和赋值。

class KVProperty<T>(private val key: Int) : ReadWriteProperty<KVData, T> {
    @Suppress("UNCHECKED_CAST", "IMPLICIT_CAST_TO_ANY")
    override operator fun getValue(thisRef: KVData, property: KProperty<*>): T
    = with(thisRef.data) {
        return when (key and DataType.MASK) {
            DataType.BOOLEAN -> getBoolean(key)
            DataType.INT -> getInt(key)
            DataType.FLOAT -> getFloat(key)
            DataType.LONG -> getLong(key)
            DataType.DOUBLE -> getDouble(key)
            DataType.STRING -> getString(key)
            DataType.ARRAY -> getArray(key)
            else -> throw IllegalArgumentException("Invalid Key: $key")
        } as T
    }

    override operator fun setValue(thisRef: KVData, property: KProperty<*>, value: T)  
    = with(thisRef.data) {
        when (key and DataType.MASK) {
            DataType.BOOLEAN -> putBoolean(key, value as Boolean)
            DataType.INT -> putInt(key, value as Int)
            DataType.FLOAT -> putFloat(key, value as Float)
            DataType.LONG -> putLong(key, value as Long)
            DataType.DOUBLE -> putDouble(key, value as Double)
            DataType.STRING -> putString(key, value as String)
            DataType.ARRAY -> putArray(key, value as ByteArray)
            else -> throw IllegalArgumentException("Invalid Key: $key")
        }
        if(mMode == LightKV.SYNC_MODE && thisRef.autoCommit){
            commit()
        }
    }
}

在LightKV为SYNC_MODE时自动commit()。
当然,如果需要批量提交。可以调用disableAutoCommit()禁用自动提交。

最后,在使用时,继承KVData,声明属性,即可像访问变量一样读写LightKV的数据(参见第三节)。


六、下载

repositories {
    jcenter()
}

dependencies {
    implementation 'com.horizon.lightkv:lightkv:1.0.4'
}

项目地址:
https://github.com/No89757/LightKV

七、结语

以前笔者对语法糖是不感兴趣的,觉得语法糖掩盖了细节,容易使人“只知其然而不知其所以然”;
但是后来渐渐地也开始接受了,技术的发展日新月异,不可能什么都从底层开始构筑。
业界流传有“人生苦短,我用python”,说的就是高级语言所带来的便利,可以节约不少时间。
当然,C语言,汇编语言,还是需要有人去写,要看问题领域。
对APP开发而言,诚然有大量的“搬砖”工作,砖头搬累了,来一发语法糖,也是不错的。

相关文章
|
7月前
|
IDE Java 编译器
Kotlin属性访问器与方法签名冲突的问题
Kotlin属性访问器与方法签名冲突的问题
51 0
|
4月前
|
Kotlin
kotlin获取属性注解
kotlin获取属性注解
49 0
|
6月前
|
Cloud Native Go Kotlin
Kotlin 环境下解决属性初始化问题
Kotlin 环境下解决属性初始化问题
28 0
|
8月前
|
Java Kotlin
Kotlin中与Java互操作与可空性、类型映射、属性访问、@JvmOverloads、@JvmField、@JvmStatic、@Throws和函数类型操作详解
Kotlin中与Java互操作与可空性、类型映射、属性访问、@JvmOverloads、@JvmField、@JvmStatic、@Throws和函数类型操作详解
68 0
|
JSON 安全 Java
Kotlin学历之委托属性
Kotlin学历之委托属性
99 0
Kotlin学历之委托属性
|
Java Kotlin
Kotlin学历之扩展与委托
Kotlin学历之扩展与委托
91 0
Kotlin学历之扩展与委托
|
XML Java API
Jetpack 系列(6)—— ViewBinding 与 Kotlin 委托双剑合璧
Jetpack 系列(6)—— ViewBinding 与 Kotlin 委托双剑合璧
186 0
Jetpack 系列(6)—— ViewBinding 与 Kotlin 委托双剑合璧
|
开发工具 git Kotlin
使用kotlin委托实现ViewBinding懒加载
使用kotlin委托实现ViewBinding懒加载
225 0
|
存储 安全 编译器
kotlin委托言简意赅的讲解
kotlin委托言简意赅的讲解
150 0
kotlin委托言简意赅的讲解
|
Java Kotlin
【Kotlin】变量简介 ( 可空类型 | lateinit | 初始化判定 | 非空类型 | !! 与 ? 修饰符 | ?= ?. ?: 运算符 | 抽象属性变量)(二)
【Kotlin】变量简介 ( 可空类型 | lateinit | 初始化判定 | 非空类型 | !! 与 ? 修饰符 | ?= ?. ?: 运算符 | 抽象属性变量)(二)
190 0