![Tooling]()
委托模式已经被证明是实现继承的一个很好的替代方式，在扩展一个基类并且重写方法时，基类就必须依赖子类的实现，当不断地修改的时候，基类就会失去当初的性质，Kotlin中就将类默认为final，确保不会被修改。
有一种模式是装饰器模式，本质就是创建一个新类，实现与基类一样的接口，并且将类的实现作为一个字段保存，这样就能在基类不被修改就能直接修改基类的实例。但是这样的缺点是会造成很多的样板代码。
class DelegatingCollection<T> : Collection<T> {
private val innerList = mutableListOf<T>()
override val size: Int
get() = innerList.size
override fun contains(element: T): Boolean = innerList.contains(element)
override fun containsAll(elements: Collection<T>): Boolean = innerList.addAll(elements)
override fun isEmpty(): Boolean = innerList.isEmpty()
override fun iterator(): Iterator<T> = innerList.iterator()
}
当你实现Collection接口的时候，需要重写这几个方法，这里面的代码量是很多的，但是如果用了委托，那么代码就是这样的
class DelegatingCollection2<T>(innerList: Collection<T> = mutableListOf<T>()) : Collection<T> by innerList
这么简单？就能实现那几个方法？我们来看一下生成的代码
![]()
是不是省去了很多手写的代码量，下面我们来介绍这种属性。
委托模式(Delegate)
Kotlin支持委托模式，是允许对象组合实现与继承相同的代码复用的，简单来说就是操作的对象不用自己去执行，而是将任务交给另一个对象操作，这样的模式就叫委托模式，被操作的对象叫委托。
委托模式是有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。
类委托
同样我们用上面集合的栗子，现在我们已经是委托到一个对象了，如果我们要修改集合里面的方法的时候，可以直接重写，而不用重复的去写新的方法，下面我们来在一个集合里面插入数据，并且获取插入的次数。
下面代码是默认实现MutableCollection接口，获取插入的次数
class DefaultCollection<T> : MutableCollection<T> {
private val innerList = mutableListOf<T>()
private var addedSum = 0
override fun add(element: T): Boolean {
addedSum++
return innerList.add(element)
}
override fun addAll(elements: Collection<T>): Boolean {
addedSum += elements.size
return innerList.addAll(elements)
}
override val size: Int
get() = innerList.size
override fun contains(element: T): Boolean = innerList.contains(element)
override fun containsAll(elements: Collection<T>): Boolean = innerList.addAll(elements)
override fun isEmpty(): Boolean = innerList.isEmpty()
override fun iterator(): MutableIterator<T> = innerList.iterator()
override fun clear() = innerList.clear()
override fun remove(element: T): Boolean = innerList.remove(element)
override fun removeAll(elements: Collection<T>): Boolean = innerList.removeAll(elements)
override fun retainAll(elements: Collection<T>): Boolean {
TODO("not implemented")
}
}
实现类委托
class DelegatingCollection3<T>(private val innerList: MutableCollection<T> = HashSet<T>()) : MutableCollection<T> by innerList {
private var addedSum = 0
override fun add(element: T): Boolean {
addedSum++
return innerList.add(element)
}
override fun addAll(elements: Collection<T>): Boolean {
addedSum += elements.size
return innerList.addAll(elements)
}
}
是不是省去很多无用的代码，只需要重写我们需要的方法add和addAll，其他没有写出来的方法全部都交给委托来实现。
而且没有对底层集合的实现方法引入任何的依赖，所以对被调用的操作具有完全的控制，如不用担心集合是不是通过循环中调用add来实现addAll。
委托属性(Delegate Properties)
有一种属性，在使用的时候每次都要手动实现它，但是可以做到只实现一次，并且放到库中，一直使用，这种属性称为委托属性。
委托属性包括：
- 延迟属性(lazy properties)：数据只在第一次被访问的时候计算。
- 可观察属性(observable properties)：监听得到属性变化通知。
- Map委托属性(Storing Properties in a Map)：将所有属性存在Map中。
class Foo {
var p: String by Delegate()
}
委托模式的语法是val/var <property name>: <Type> by <expression>在by后面的expression就是委托的部分，会将属性的get()和set()委托给getValue()和setValue()方法。
class Foo {
private val delegate = Delegate()
var p: String
set(value: String) = delegate.setValue(..., value)
get() = delegate.getValue(...)
}
委托属性不需要实现任何的接口，但是要提供getValue()方法(如果是var的话要提供setValue()方法)，方法前加operator关键字。
下面是一个自定义的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.'")
}
}
当从委托属性p获取到Deletage的的实例时，Deletage的getValue就会被调用，getValue函数中的第一个参数就是p获取到的实例，第二个参数就是属性p。
val e = Example()
println(e.p)
打印出来的内容是：
Example@33a17727, thank you for delegating ‘p’ to me!
由于p是var类型的，所有可以调用setValue函数，前两个参数与getValue参数一样，第三个就是要赋予的值：
e.p = "NEW"
这下打印出来的内容就是：
NEW has been assigned to ‘p’ in Example@33a17727.
注意：自 Kotlin1.1起可以在函数或代码块中声明一个委托属性，因此委托属性不一定是类的成员
委托标准
Kotlin的标准库中对于一些有用的委托提供了工厂(Factory)方法，这些接口在Kotlin标准库中声明。
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)
}
延迟属性 Lazy
![]()
函数lazy()接收一个Lambdas表达式，然后并返回一个Lazy <T>的实例，它可以作为实现lazy属性的委托：第一次调用get()函数的时候会向执行Lambdas传递到lazy()函数，并且保存结果，后面调用的get()函数会直接返回报错的结果。
首先我们来看一个栗子，里面先不用到lazy，我们来看如何
fun loadName(person: Person): String {
println("Load Name for ${person.name}")
return person.name
}
fun loadAge(person: Person): Int {
println("Load Age for ${person.age}")
return person.age
}
class Person(val name: String, val age: Int) {
private var _names: String? = null
val newName: String
get() {
if (_names == null) {
_names = loadName(this)
}
return _names!!
}
private var _ages: Int? = null
val newAge: Int
get() {
if (_ages == null) {
_ages = loadAge(this)
}
return _ages!!
}
}
fun main(args: Array<String>) {
val p = Person("Alice", 23)
p.newName.println()
p.newName.println()
}
首先先判断_names是否为空，然后通过一个方法，里面进行了一些操作，来赋予_names值，最后newName的值即为_names。
打印的内容：
![]()
那么如果我们用lazy来代替这种写法会是什么样的呢？
fun loadName(person: Person): String {
}
fun loadAge(person: Person): Int {
}
class Person(val name: String) {
val newName by lazy { loadName(this) }
val newAge by lazy { loadAge(this) }
}
fun main(args: Array<String>) {
}
打印出来的内容，和上面是一模一样的。
对比一下，当我们的属性越来越多，那么重复的代码也就越来越多，使用lazy省去了很多多余的代码。
![]()
默认地，对于lazy属性的计算是加了同步锁（synchronized） 的： 这个值只在一个线程被计算，并且所有的线程会看到相同的值。
如果要将同步锁关闭，可以多个线程同步执行，就加LazyThreadSafetyMode.PUBLICATION参数即可：
val lazyValue: String by lazy(LazyThreadSafetyMode.PUBLICATION) {
println("computed!")
"Hello"
}
如果要关掉线程安全配置，就加LazyThreadSafetyMode.NONE参数即可：
val lazyValue: String by lazy(LazyThreadSafetyMode.NONE) {
println("computed!")
"Hello"
}
可观察属性 Observable
Delegates.observable()有两个参数：初始化值和handler，每次对属性赋值操作，都会回调该handler方法（在属性赋值后执行），该方法里面有三个参数，分别是：被赋值的属性，旧值和新值。
举个例子：
import kotlin.properties.Delegates
class User {
var name: String by Delegates.observable("<no name>") {
prop, old, new ->
println("$old -> $new")
}
}
fun main(args: Array<String>) {
val user = User()
user.name = "first"
user.name = "second"
}
在User类中，<no name>就是初始化值，{}包住的代码块就是handler方法，pro, old, new就是该方法的三个参数，打印出来的内容为：
<no name> -> first
first -> second
如果需要拦截修改属性值动作并禁止修改，可以使用vetoable()取代observable()，handler需要返回一个Boolean，true表示同意修改，false表示禁止修改，该回调会在属性值修改前调用。
将上面的例子里面的observable()修改为vetoable()后：
import kotlin.properties.Delegates
class User {
var name: String by Delegates.vetoable("<no name>") {
prop, old, new ->
println("$old -> $new")
false
}
}
fun main(args: Array<String>) {
val user = User()
user.name = "first"
user.name = "second"
}
打印的结果是：
![false]()
如果改为true，那就更observable()打印的一样了：
![true]()
Map委托属性(Storing Properties in a Map)
可以用Map作为委托用于委托属性，多用于JSON解析上。
下面举个栗子，一个类里面有一个Map存放一些属性，通过setAttribute来设置这些属性：
class Person {
private val _attributes = hashMapOf<String, String>()
fun setAttribute(attrName: String, value: String) {
_attributes[attrName] = value
}
val name: String
get() = _attributes["name"]!!
val company: String
get() = _attributes["company"]!!
val address: String
get() = _attributes["address"]!!
val email: String
get() = _attributes["email"]!!
}
fun main(args: Array<String>) {
val p = Person()
val data = mapOf("name" to "Dmitry", "company" to "JetBrains")
for ((attrName, value) in data)
p.setAttribute(attrName, value)
println(p.name)
}
然后我们将这些属性委托给Map，再将代码简写一下
class Person2(private val attributes: Map<String, String>) {
val name: String by attributes
val company: String by attributes
val address: String by attributes
val email: String by attributes
}
fun main(args: Array<String>) {
val data = mapOf("name" to "Dmitry", "company" to "JetBrains")
val p = Person2(data)
println(p.name)
}
同样对比，省去重复代码，我们来看一下生成的代码是什么样子的：
public final class Person2 {
static final KProperty[] $$delegatedProperties = new KProperty[]{(KProperty)Reflection.property1(new PropertyReference1Impl(Reflection.getOrCreateKotlinClass(Person2.class), "name", "getName()Ljava/lang/String;")), (KProperty)Reflection.property1(new PropertyReference1Impl(Reflection.getOrCreateKotlinClass(Person2.class), "company", "getCompany()Ljava/lang/String;")), (KProperty)Reflection.property1(new PropertyReference1Impl(Reflection.getOrCreateKotlinClass(Person2.class), "address", "getAddress()Ljava/lang/String;")), (KProperty)Reflection.property1(new PropertyReference1Impl(Reflection.getOrCreateKotlinClass(Person2.class), "email", "getEmail()Ljava/lang/String;"))};
@NotNull
private final Map name$delegate;
@NotNull
private final Map company$delegate;
@NotNull
private final Map address$delegate;
@NotNull
private final Map email$delegate;
private final Map attributes;
@NotNull
public final String getName() {
Map var1 = this.name$delegate;
KProperty var3 = $$delegatedProperties[0];
return (String)MapsKt.getOrImplicitDefaultNullable(var1, var3.getName());
}
@NotNull
public final String getCompany() {
Map var1 = this.company$delegate;
KProperty var3 = $$delegatedProperties[1];
return (String)MapsKt.getOrImplicitDefaultNullable(var1, var3.getName());
}
@NotNull
public final String getAddress() {
Map var1 = this.address$delegate;
KProperty var3 = $$delegatedProperties[2];
return (String)MapsKt.getOrImplicitDefaultNullable(var1, var3.getName());
}
@NotNull
public final String getEmail() {
Map var1 = this.email$delegate;
KProperty var3 = $$delegatedProperties[3];
return (String)MapsKt.getOrImplicitDefaultNullable(var1, var3.getName());
}
public Person2(@NotNull Map attributes) {
Intrinsics.checkParameterIsNotNull(attributes, "attributes");
super();
this.attributes = attributes;
this.name$delegate = this.attributes;
this.company$delegate = this.attributes;
this.address$delegate = this.attributes;
this.email$delegate = this.attributes;
}
}
局部委托属性（1.1 起）
fun main(args: Array<String>) {
example("localDelegate")
}
fun example(value: String) {
val localDelegate by lazy {
print("first ")
value
}
localDelegate.println()
localDelegate.println()
}
现在，Kotlin支持局部委托属性。
委托属性要求
下面的代码是个委托类Delegate，里面有两个函数，一个是getValue函数，一个是setValue函数。
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.'")
}
}
只读属性（read-only，使用val定义）
委托类需提供getValue函数，参数要求：
- thisRef：第一个参数，必须是属性对应的类或父类型。(上面的thisRef: Any?)
- property：第二个参数，必须是“KProperty<*>”或它的父类型(上面的property: KProperty<*>)。
- 函数返回类型必须跟属性同类型（或者子类型）。
可变属性（mutable，使用var定义）
委托类需提供getValue函数和setValue函数，参数要求：
- thisRef：第一个参数，同getValue对应的参数
- property：第二个参数，同getValue对应的参数
- 新增(new value)：第三个参数，类型必须跟属性一样或其父类型。
getValue() 和setValue()函数可以作为委托类的成员函数或者扩展函数来使用。 当需要委托一个属性给一个不是原来就提供这些函数的对象的时候，后者更为方便。
两种函数都需要用operator关键字修饰。
接口
委托类可以实现ReadOnlyPropery和ReadWriteProperty接口中的带operator的方法，这些接口在Kotlin标准库中声明：
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)
}
提供委托（自 1.1 起）
provideDelegate为提供委托，它可以为属性提供对象委托逻辑，可能的使用场景是在创建属性时（而不仅在其 getter 或 setter 中）检查属性一致性。
provideDelegate 的参数与 getValue 相同：
- thisRef —— 必须与属性所有者类型（对于扩展属性——指被扩展的类型）相同或者是它的超类型。
- property —— 必须是类型 KProperty<*> 或其超类。
例如，在绑定之前检查属性名称：
class ResourceLoader(resId: ResourceID) {
operator fun provideDelegate(thisRef: MyUI, prop: KProperty<*>): ReadOnlyProperty<MyUI, String> {
checkProperty(thisRef, prop.name)
// 创建委托
}
private fun checkProperty(thisRef: MyUI, name: String) {
}
}
fun MyUI.bindResource(id: ResourceID): ResourceLoader {
return ResourceLoader(id)
}
class MyUI {
val image by bindResource(ResourceID.image_id) //bindResource()产生委托对象
val text by bindResource(ResourceID.text_id)
}
在创建 MyUI 实例期间，为每个属性调用provideDelegate方法，并立即执行必要的验证。
如果没有这种拦截属性与其委托之间的绑定的能力，为了实现相同的功能， 你必须显式传递属性名：
class MyUI {
val image by bindResource(ResourceID.image_id, "image")
val text by bindResource(ResourceID.text_id, "text")
}
fun <T> MyUI.bindResource(
id: ResourceID<T>,
propertyName: String
): ReadOnlyProperty<MyUI, T> {
checkProperty(this, propertyName)
}
由于暂时没用的这个提供委托，所以在这里也不过多的介绍，上面是官网的一个栗子。
一个委托实例
下面来看一个自定义的Delegate，用来访问SharedPreference，这段代码是Kotlin for Android Developer的示例：
class Preference<T>(val context: Context, val name: String, val default: T) : ReadWriteProperty<Any?, T> {
val prefs by lazy { context.getSharedPreferences("default", Context.MODE_PRIVATE) }
override fun getValue(thisRef: Any?, property: KProperty<*>): T {
return findPreference(name, default)
}
override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
putPreference(name, value)
}
private fun <U> findPreference(name: String, default: U): U = with(prefs) {
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 IllegalArgumentException("This type can be saved into Preferences")
}
res as U
}
private fun <U> putPreference(name: String, value: U) = 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 can be saved into Preferences")
}.apply()
}
}
使用的时候：
class ExampleActivity : AppCompatActivity(){
var a: Int by Preference(this, "a", 0)
fun whatever(){
println(a)
aInt = 9
}
}
这样就很方便了，再也不用去重复写getSharedPreference()、commit()、edit()、apply()之类的东西了。
作者：u011976726 发表于2017/11/26 20:50:10
原文链接
