委托模式 被证明是一种很好的替代 继承 的方式，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 <T> 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 <T> 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 <p>读写 SP 存储项的轻量级委托类，如下，
 * 读 SP 的操作委托给该类对象的 getValue 方法，
 * 写 SP 操作委托给该类对象的 setValue 方法，
 * 注意这两个方法不用你显式调用，把一切交给编译器就行（还是语法糖）
 * 具体使用此类定义 SP 存储项的代码请参考 SpBase 文件</p>
 */

class SPDelegates<T>(private val key: String, private val default: T) : ReadWriteProperty<Any?, T> {
    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<T> {
    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<String>) {
    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<String>) {
    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