Kotlin 委托模式用于 Android 开发

委托模式被证明是一种很好的替代继承的方式，Kotlin 在语言层面对委托模式提供了非常优雅的支持（语法糖）。

先给大家看看我用 Kotlin 的属性委托语法糖在 Android 工程里面做的一件有用工作——SharedPreferences 的读写委托。

文中陈列的所有代码已汇总成 Demo 传至 github，点这儿获取源码。建议配合 Demo 阅读本文。

项目主要文件结构如下：

│  App.kt
│
├─base
│      SpBase.kt
│
├─delegates
│      SPDelegates.kt
│      SPUtils.kt
│
├─demo
└─ui
        MainActivity.kt

先来看看 delegates 包下的文件。

SPUtils 是个读写 SharedPreferences(以下简称 SP) 存储项的基础工具类：

/**
 * @author xiaofei_dev
 * @desc 读写 SP 存储项的基础工具类
 */

object SPUtils {
    val SP by lazy {
        App.instance.getSharedPreferences("default", Context.MODE_PRIVATE)
    }

    //读 SP 存储项
    fun  getValue(name: String, default: T): T = with(SP) {
        val res: 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 java.lang.IllegalArgumentException()
        }
        @Suppress("UNCHECKED_CAST")
        res as T
    }

    //写 SP 存储项
    fun  putValue(name: String, value: T) = with(SP.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 can't be saved into Preferences")
        }.apply()
    }
}

主要使用泛型实现了完善的 SP 读写，整体还是非常简洁易懂的。上下文对象使用了自定义的 Application 类实例（见 Demo 中的 App 类）。

Kotlin 中的委托属性

下面重点来看一下 SPDelegates 类的定义：

/**
 * @author xiaofei_dev
 * @desc 读写 SP 存储项的轻量级委托类，如下，
 * 读 SP 的操作委托给该类对象的 getValue 方法，
 * 写 SP 操作委托给该类对象的 setValue 方法，
 * 注意这两个方法不用你显式调用，把一切交给编译器就行（还是语法糖）
 * 具体使用此类定义 SP 存储项的代码请参考 SpBase 文件
 */

class SPDelegates(private val key: String, private val default: T) : ReadWriteProperty {
    override fun getValue(thisRef: Any?, property: KProperty<*>): T {
        return SPUtils.getValue(key, default)
    }
    override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
        SPUtils.putValue(key, value)
    }
}

SPDelegates 类实现了 Kotlin 标准库中声明的用于属性委托的 ReadWriteProperty 接口（SPDelegates 类的用法后面会详细说到），从名字可以看出此接口是可读写的(适用于 var 声明的属性)，除此之外还有个 ReadOnlyProperty （只读）接口(适用于 val 声明的属性)。

对于属性的委托类（以SPDelegates为例），要求必须提供一个 getValue() 函数（和一个setValue()函数——对于 var 属性）。其getValue 方法的参数要求如下：

thisRef —— 必须与 属性所属类 的类型（对于扩展属性——指被扩展的类型）相同或是它的超类型(参见后面 SpBase 单例类中的注释)；
property —— 必须是类型 KProperty<*> （Kotlin 标准库 kotlin.reflect (反射)包下的一个类）或其超类型。

对于其 setValue 方法，前两个参数同 getValue。第三个参数value 必须与属性同类型或是它的子类型。

以上概念暂时看不懂不要紧，下面通过委托属性的具体应用来加深理解。

接着是具体使用到委托属性的 SpBase 单例类：

/**
 * @author xiaofei_dev
 * @desc 定义的 SP 存储项
 */
object SpBase{
    //SP 存储项的键
    private const val CONTENT_SOMETHING = "CONTENT_SOMETHING"


    // 这就定义了一个 SP 存储项
    // 把 SP 的读写操作委托给 SPDelegates 类的一个实例（使用 by 关键字，by 是 Kotlin 语言层面的一个原语），
    // 此时访问 SpBase 的 contentSomething (你可以简单把其看成 Java 里的一个静态变量)属性即是在读取 SP 的存储项，
    // 给 contentSomething 属性赋值即是写 SP 的操作，就这么简单
    // 这里用到的 SPDelegates 对象的 getValue 方法的 thisRef（见上文） 参数的类型正是外层的 SpBase
    var contentSomething: String by SPDelegates(CONTENT_SOMETHING, "我是一个 SP 存储项，点击编辑我")
}

上面代码中，单例 SpBase 的属性 contentSomething 就是一个定义好的 SP 存储项。得益于语言级别的强大语法糖支持，写出来的代码可以如此简洁而优雅。读写 SP 存储项的请求通过属性委托给了一个 SPDelegates 对象，委托属性的语法为

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

其最后会被编译器解释成下面这样的代码(大致上)：

object SpBase{
    private const val CONTENT_SOMETHING = "CONTENT_SOMETHING"
    
    private val propDelegate = SPDelegates(CONTENT_SOMETHING, "我是一个 SP 存储项，点击编辑我")
    var contentSomething: String
        get() = propDelegate.getValue(this, this::contentSomething)//读SP
        set(value) = propDelegate.setValue(this, this::contentSomething, value)//写SP
}

还是比较容易理解的。下面演示下这个定义好的 SP 存储项如何使用，见 Demo 的 MainActivity 类文件：

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        initView()
    }

    private fun initView(){
        //读取 SP 内容显示到界面上
        editContent.setText(SpBase.contentSomething)
        btnSave.setOnClickListener {
            //保存 SP 项
            SpBase.contentSomething = "${editContent.text}"
            Toast.makeText(this, R.string.main_save_success, Toast.LENGTH_SHORT).show()
        }
    }
}

整体比较简单，就是个读写 SP 存储项的过程。大家可以实际运行下 Demo 看下具体效果。

从零实现一个属性的委托类

上文述及的 SPDelegates 类实现了 Kotlin 标准库提供的 ReadWriteProperty 接口，我们当然也可以不借助任何接口来实现一个属性委托类，只要其提供一个getValue() 函数（和一个setValue()函数——对于 var 属性）并且符合我们上面讨论的参数要求就行。下面来定义一个平凡的属性委托类 Delegate （见 Demo 的 demo 包下 Example 文件）：

/**
 * @author xiaofei_dev
 * @desc 不用实现任何接口的平凡属性委托类
 */

class Delegate {
    private var value: T? = null

    operator fun getValue(thisRef: Any?, property: KProperty<*>): T? {
        println("$thisRef, thank you for delegating '${property.name}' to me! The value is $value")
        return value
    }

    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: T?) {
        this.value = value
        println("$value has been assigned to '${property.name}' in $thisRef.")
    }
}

使用方式依旧：

class Example {
    //委托属性
    var p: String? by Delegate()
}

fun main(args: Array) {
    val e = Example()
    e.p = "hehe"
    println(e.p)
}

控制台输出如下：

hehe has been assigned to 'p' in com.xiaofeidev.delegatedemo.demo.Example@1fb3ebeb.
com.xiaofeidev.delegatedemo.demo.Example@1fb3ebeb, thank you for delegating 'p' to me! The value is hehe
hehe

你可以自己跑下试试~

关于委托模式

有必要单独花篇幅解释下何为委托模式。

简而言之，在委托模式中，有两个对象共同处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。

委托模式最简单的例子：

//委托类，墨水能用来打印文字(￣▽￣)"
class Ink {
    fun print() {
        print("This message comes from the delegate class,Not Printer.")
    }
}

class Printer {
    //委托对象
    var ink = Ink()

    fun print() {
        //Printer 的实例会将请求委托给另一个对象（DelegateNormal 的对象）来处理
        ink.print()//调用委托对象的方法
    }
}

fun main(args: Array) {
    val printer = Printer()
    printer.print()
}

控制台输出如下：

This message comes from the delegate class,Not Printer.

委托模式使我们可以用聚合来代替继承，是许多其他设计模式（如状态模式、策略模式、访问者模式）的基础。

Kotlin 的委托模式

Kotlin 可以做到零样板代码实现委托模式（而不是像上面展示的那样还需要样板代码）！

比如我们现在有如下接口和类：

interface Base {
    fun print()
}

class BaseImpl(val x: Int) : Base {
    override fun print() { print(x) }
}

Base 接口想做的就是在控制台打印些什么东西。这没啥问题，我们已经在 BaseImpl 类上完整实现了 Base 接口。

此时我们想再给 Base 接口写一个实现时可以这么做：

class Derived(b: Base) : Base by b

这其实跟下面的写法是等价的（编译器实际生成的）：

class Derived(val delegate: Base) : Base {
    override fun print() {
        delegate.print()
    }
}

注意不是下面这种：

class Derived(val delegate: Base){
    fun print() {
        delegate.print()
    }
}

Kotlin 通过编译器的黑魔法将许多样板代码封印在了 by 这样一个语言级别的原语中（又是语法糖）。使用方式：

fun main(args: Array) {
    val b = BaseImpl(10)
    Derived(b).print()
}

控制台输出如下：

Kotlin 标准库中其他属性委托

说回属性委托，Kotlin 的标准库为一些常用的委托写好了工厂方法，下面一一列举。

延迟属性 Lazy

fun main(args: Array) {
    //延迟计算属性的值，lazy 后面 lambda 表达式中的逻辑只会执行一次(且是线程安全的)并记录结果，后续调用属性的 get() 方法只是返回记录的结果
    val lazyValue: String by lazy {
        println("computed!")
        "Hello"
    }
    println(lazyValue)
    println(lazyValue)
}

控制台输出如下：

computed!
Hello
Hello

可观察属性 Observable

Delegates.observable()接受两个参数：初始值与修改时处理程序。每次给属性赋值时就会调用该处理程序（在赋值后执行）。处理程序有三个参数：被赋值属性的 KProperty 对象、旧值与新值：

class User {
    var name: String by Delegates.observable("") {
            prop, old, new ->
        println("$old -> $new")
    }
}

fun main(args: Array) {
    val user = User()
    user.name = "first"
    user.name = "second"
}

控制台输出如下：

 -> first
first -> second

把属性储存在映射中

你甚至可以在一个映射（map）中存储属性的值。这种情况下，你可以直接将属性委托给映射实例：

class Student(val map: Map) {
    val name: String by map
    val age: Int     by map
}

fun main(args: Array) {
    val student = Student(mapOf(
        "name" to "xiaofei",
        "age"  to 25
    ))

    println(student.name)
    println(student.age)
}

当然这种应用必须确保属性的名字和 map中的键对应起来，不然你可能会收获一个 NoSuchElementException 运行时异常，大概像这样：

java.util.NoSuchElementException: Key XXXX is missing in the map.

言止于此，未完待续。

参考文献

《设计模式：可复用面向对象软件的基础》
《Kotlin for Android Developers》
《Kotlin 极简教程》
《Kotlin 核心编程》
维基百科委托模式词条
Kotlin 官方文档

Kotlin 委托模式用于 Android 开发

Kotlin 中的委托属性

从零实现一个属性的委托类

关于委托模式

Kotlin 的委托模式

Kotlin 标准库中其他属性委托

延迟属性 Lazy

可观察属性 Observable

把属性储存在映射中

参考文献

你可能感兴趣的:(Kotlin 委托模式用于 Android 开发)