Kotlin-代理属性(by)

本文详细介绍了Kotlin中的属性委托,通过`by`关键字实现。讲解了延迟加载、可观察属性、可撤销属性、非空属性以及如何自定义委托。还探讨了标准库中的Lazy、Observable和Vetoable委托,以及使用场景和实现原理。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

概述

所谓委托模式 ,就是为其他对象提供一种代理以控制对这个对象的访问,在Java开发过程中,是继承模式之外的很好的解决问题的方案,不熟悉委托模式的,可以参考博委托模式

对于Kotlin而言,其直接支持委托模式,从而避免为了实现模式而不得不写那些常规的代码。又不得不赞叹,Kotlin的优雅,简洁。

by

Kotlin中,委托的实现依靠于关键字 by ,by表示将抽象主题的实例(by后边的实例)保存在代理类实例的内部,比如SportsManager类继承于ISports接口,并可以ISports接口的所有的 public 方法委托给一个指定的对象。

interface ISports {
    fun doSports()
}

class SwimForSports: ISports{
    override fun doSports() {
        println("do swim")
    }
}

class SportsManager(sport: ISports): ISports by sport

fun main(args: Array<String>) {
    val swimSports: SwimForSports = SwimForSports()
    SportsManager(swimSports).doSports()// Log:do swim
}

在SportsManager声明中,by子句表示,将sport保存在SportsManager的对象实例内部,而且编译器将会生成继承自 ISports 接口的所有方法, 并将调用转发给sport。

委托属性

概述

所谓的委托属性,就是对其属性值的操作不再依赖于其自身的getter()/setter()方法,是将其托付给一个代理类,从而每个使用类中的该属性可以通过代理类统一管理,再也不用在每个类中,对其声明重复的操作方法。

当我们使用属性的get或者set的时候,属性委托的getValue和setValue就会被调用。

定义语法

定义语法:

val/var <property name>: <Type> by <expression>
  • var/val:属性类型(可变/只读)
  • name:属性名称
  • Type:属性的数据类型
  • expression:代理类

by关键字之后的表达式就是委托,属性的get()方法(以及set() 方法)将被委托给这个对象的 getValue()和setValue()方法.属性委托不必实现任何接口, 但必须提供 getValue() 函数(对于 var属性,还需要 setValue() 函数)。

使用场景

  1. 延迟加载属性(lazy property): 属性值只在初次访问时才会计算,
  2. 可观察属性(observable property): 属性发生变化时, 可以向监听器发送通知,
  3. 将多个属性保存在一个 map 内, 而不是保存在多个独立的域内.

标准类库

Kotlin标准库中,已经自定义了一系列标准委托,包括了大部分有用的委托。

延迟加载(Lazy)

lazy()是一个函数, 接受一个Lambda表达式作为参数, 返回一个Lazy类型的实例,这个实例可以作为一个委托, 实现延迟加载属性(lazy property): 第一次调用 get() 时, 将会执行 lazy() 函数受到的Lambda 表达式,然后会记住这次执行的结果, 以后所有对 get() 的调用都只会简单地返回以前记住的结果.

// File: test.kt

val no: Int by lazy {
    200
}

val c = 200

fun main(args: Array<String>) {

    val b = 200

    println(no) // Log : 200
    println(no) // Log : 200
}

现声明了两个Top-level属性no 和 c,其中no为延迟加载属性(委托属性)。现在b打了断点,从下图可以清晰的看出,此时c已被初始化,而no并未被初始化,直到println(no)调用时,no才被初始化。从那以后每次调用no,都会取得其值。

这里写图片描述


注:

  1. var类型属性不能设置为延迟加载属性,因为在lazy中并没有setValue(…)方法
  2. lazy操作符是线程安全的。如果在不考虑多线程问题或者想提高更多的性能,也可以使
    用 lazy(LazyThreadSafeMode.NONE){ … } 。

在LazyThreadSafetyMode中声明了几种,[Lazy]实例在多个线程之间同步访问的形式:

  • SYNCHRONIZED:锁定,用于确保只有一个线程可以初始化[Lazy]实例。
  • PUBLICATION:初始化函数可以在并发访问未初始化的[Lazy]实例值时调用几次,,但只有第一个返回的值将被用作[Lazy]实例的值。
  • NONE:没有锁用于同步对[Lazy]实例值的访问; 如果从多个线程访问实例,是线程不安全的。此模式应仅在高性能至关重要,并且[Lazy]实例被保证永远不会从多个线程初始化时使用。

可观察属性(Observable)

Delegates.observable() 函数接受两个参数: 第一个是初始化值, 第二个是属性值变化事件的响应器(handler).这种形式的委托,采用了观察者模式,其会检测可观察属性的变化,当被观察属性的setter()方法被调用的时候,响应器(handler)都会被调用(在属性赋值处理完成之后)并自动执行执行的lambda表达式,同时响应器会收到三个参数:被赋值的属性, 赋值前的旧属性值, 以及赋值后的新属性值。

var name: String by Delegates.observable("wang", {
    kProperty, oldName, newName ->
    println("kProperty:${kProperty.name} | oldName:$oldName | newName:$newName")
})


fun main(args: Array<String>) {

    println("name: $name") // Log:nam:wang

    name = "zhang" // Log:kProperty:name | oldName:wang | newName:zhang

    name = "li" // Log:kProperty:name | oldName:zhang | newName:li
}

在这个例子中,Delegates.observable(wang, hanler),完成了两项工作,一是,将name初始化(name=wang);二是检测name属性值的变化,每次变化时,都会打印其赋值前的旧属性值, 以及赋值后的新属性值。

Vetoable

Delegates.vetoable()函数接受两个参数: 第一个是初始化值, 第二个是属性值变化事件的响应器(handler),是可观察属性(Observable)的一个特例,不同的是在响应器指定的自动执行执行的lambda表达式中在保存新值之前做一些条件判断,来决定是否将新值保存。

var name: String by Delegates.vetoable("wang", {
    kProperty, oldValue, newValue ->
    println("oldValue:$oldValue | newValue:$newValue")
    newValue.contains("wang")
})


fun main(args: Array<String>) {

    println("name: $name")
    println("------------------")
    name = "zhangLing" 
    println("name: $name") 
    println("------------------")
    name = "wangBing" 
    println("name: $name") 
}

//Log 
name: wang
------------------
oldValue:wang | newValue:zhangLing
name: wang
------------------
oldValue:wang | newValue:wangBing
name: wangBing

代码示例中的委托,在给name赋值是,只有字符串中含有”wang”时,将新值赋值给name.第一次给name赋值“zhangLing”时,lambda表达式的返回值为false,此时并没有对name成功赋值。而第二次,赋值”wangBing” 时,lambda表达式的返回值为true,成功赋值。

Not Null

在实际开发时,我们可能会设置可为null的var类型属性,在我们使用它时,肯定是对其赋值,假如不赋值,必然要报NullPointException.一种解决方案是,我们可以在使用它时,在每个地方不管是不是null,都做null检查,这样我们就保证了在使用它时,保证它不是null。这样无形当中添加了很多重复的代码。

在Kotlin中,委托又帮我们做了一个善事,不用去写这些重复的代码,Not Null委托会含有一个可null的变量并会在我们设置这个属性的时候分配一个真实的值。如果这个值在被获取之前没有被分配,它就会抛出一个异常。

这个在单例App这个例子中很有用:

class App : Application() {
    companion object {
        var instance: App by Delegates.notNull()
    } 

    override fun onCreate() {
        super.onCreate()
        instance = this
    }
}

将多个属性保存在一个map内

使用Gson解析Json时,可以获取到相应的实体类的实例,当然该实体类的属性名称与Json中的key是一一对应的。在Kotlin中,存在这么一种委托方式,类的构造器接受一个map实例作为参数,将map实例本身作为属性的委托,属性的名称与map中的key是一致的,也就是意味着我们可以很简单的从一个动态地map中创建一个对象实例。

class User(val map: Map<String, Any?>) {
    val name: String by map
    val age: Int by map
}

上例中, 类的构造器接受一个 map 实例作为参数:

fun main(args: Array<String>) {

    val user = User(mapOf(
            "name" to "John Doe",
            "age" to 25
    ))

    println(user.name) // 打印结果为: "John Doe"
    println(user.age) // 打印结果为: 25
}

委托属性将从这个 map中读取属性值(使用属性名称字符串作为 key 值)。

如果不用只读的 Map , 而改用值可变的 MutableMap , 那么也可以用作 var 属性的委托。

class User(val map: MutableMap<String, Any?>) {
    val name: String by map
    val age: Int by map
}

fun main(args: Array<String>) {

    var map:MutableMap<String, Any?> = mutableMapOf(
            "name" to "John Doe",
            "age" to 25)

    val user = User(map)

    println(user.name) // 打印结果为: "John Doe"
    println(user.age) // 打印结果为: 25

    println("--------------")
    map.put("name", "Green Dao")
    map.put("age", 30)

    println(user.name) // 打印结果为: Green Dao
    println(user.age) // 打印结果为: 30

}

属性委托的前提条件

getValue()

对于只读属性(也就是说val属性), 它的委托必须提供一个名为getValue()的函数, 这个函数必须有以下参数及返回值

  • receiver:这个参数的类型必须与 属性所属的类 相同, 或者是它的基类(对于扩展属性 — 这个参数的
    类型必须与被扩展的类型相同, 或者是它的基类),
  • metadata:这个参数的类型必须是 KProperty<*> , 或者是它的基类,
  • 返回值:返回值类型必须与属性类型相同(或者是它的子类型).

setValue()

对于一个值可变(mutable)属性(也就是说,var 属性),除 getValue()函数之外,它的委托还必须 另外再提供一个名为setValue()的函数, 这个函数接受以下参数:

  • receiver:与 getValue() 函数的参数相同,
  • metadata:与 getValue() 函数的参数相同,
  • new value:这个参数的类型必须与属性类型相同, 或者是它的基类.

operator

getValue() 和 setValue() 函数可以是委托类的成员函数, 也可以是它的扩展函数. 如果你需要将属性委托给一个对象, 而这个对象本来没有提供这些函数, 这时使用扩展函数会更便利一些. 这两个函数都需要标记为operator.

自定义委托

在自定义委托时,必须实现ReadOnlyProperty或者ReadWriteProperty接口,具体选择实现哪一个接口取决与委托对象是val属性还是var属性。

ReadOnlyProperty

ReadOnlyProperty接口主要用于实现只读属性的属性委托。

public interface ReadOnlyProperty<in R, out T> {

    /**
     * 返回给定对象的属性的值
     * @param thisRef:拥有委托属性的对象
     * @param property:属性的元数据
     * @return:属性的值
     */
    public operator fun getValue(thisRef: R, property: KProperty<*>): T
}
  • R:拥有委托属性的对象的类型
  • T:属性值的类型

ReadWriteProperty

ReadWriteProperty接口主要用于实现可变属性的属性委托。

public interface ReadWriteProperty<in R, T> {
    /**
     * 返回给定对象的属性的值
     * @param thisRef:拥有委托属性的对象
     * @param property:属性的元数据
     * @return:属性的值
     */
    public operator fun getValue(thisRef: R, property: KProperty<*>): T

    /**
     * 设置给定对象的属性的值
     * @param thisRef:拥有委托属性的对象
     * @param property:属性的元数据
     * @param value:设置的属性的值
     */
    public operator fun setValue(thisRef: R, property: KProperty<*>, value: T)
}
  • R:拥有委托属性的对象的类型
  • T:属性值的类型

自定义委托

创建一个委托类SingleValueVar,继承自ReadWriteProperty

class SingleValueVar<T> : ReadWriteProperty<Any?, T> {

    private var value: T? = null

    override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
        if (null != value && null == this.value) {
            this.value = value
        }
    }

    override fun getValue(thisRef: Any?, property: KProperty<*>): T {
        return value!!
    }

}

这个委托可以作用在任何非null的类型,只对该该属性赋值一次,它接收任何类型的引用,然后像getter和setter那样使用T。对于getter和setter:

  • Getter函数:如果该属性已经被初始化, 则会返回一个值, 否则会抛异常。
  • Setter函数:如果初始值为null,则赋值;如果已被赋值,则不再赋值

创建一个委托的对象

创建一个委托类实例,用于保存委托的属性。

object DelegatesExt {

    fun <T> singleValueVar(): ReadWriteProperty<Any?, T> = SingleValueVar<T>()
}

为属性设置委托

在Student类中,对no属性设置刚才创建的委托SingleValueVar,意味着该属性只能够被赋值一次,而 name属性就是一个普通的成员属性

class Student {
    var no: Int by DelegatesExt.singleValueVar<Int>()
    var name: String = "wang"
    override fun toString(): String {
        return "no: $no | name: $name"
    }
}

测试实例

fun main(args: Array<String>) {
    var stu: Student = Student()

    stu.no = 20
    stu.name = "wang"

    println(stu.toString()) // 打印:no: 20 | name: wang

    stu.no = 30
    stu.name = "li"
    println(stu.toString()) // 打印:no: 20 | name: li
}

在上述测试示例中,我们先对Studeng的实例,暂定为A,第一次给A赋值no=20,name=”wang”,此时打印这个实例的结果为 “no: 20 | name: wang”,然后我们对A进行了第二次赋值no=30,name=”li”,但是实际上打印结果为“no: 20 | name: li”。相比较两次结果,no的值都是20,这恰恰是我们想要的结果。因为我们对no属性设置了SingleValueVar委托,该委托的效果是只有第一次对该属性赋值时有效,再次赋值时无效。

<think>好的,我现在需要解答用户关于Kotlin代理委托的关系的问题。首先,我得回忆一下Kotlin的相关知识,特别是委托代理的概念。用户提到参考了三个站内引用,我需要仔细看看这些引用的内容,确保回答准确。 根据引用[1],Kotlin通过关键字`by`支持委托模式,类委托的例子显示委托是将任务交给另一个对象处理。引用[2]展示了属性委托的具体代码,`Principal`类委托`intValue`给`Delegate`类,这里提到了代理者和委托者的角色。引用[3]用父子关系比喻,父亲是委托人,儿子是代理人,使用`by`关键字将任务委托出去,并建议代理人用单例。 接下来,我需要理清代理委托Kotlin中的区别和联系。通常,在软件设计模式中,委托是指一个对象将某些职责交给另一个对象处理,而代理模式则是控制对对象的访问。但在Kotlin中,这两个术语可能被互换使用,或者有特定的语境含义。 根据引用内容,Kotlin委托模式通过`by`关键字实现,这里的代理者(Delegate)负责实际的操作,而委托者(如Principal类)则将属性或方法的实现委托代理者。看起来,在Kotlin中,“委托”更多指整个模式,而“代理”指具体执行的对象。因此,代理委托关系中的实施方,委托则是建立这种关系的机制。 需要确认用户的问题是否存在术语上的混淆,例如是否将“代理”等同于“委托模式中的被委托对象”。根据引用,用户提供的例子中,代理者是实际处理逻辑的类,而委托者是使用`by`关键字将任务交给代理者的类。因此,代理委托Kotlin中是同一概念的不同方面,委托是模式,代理是实现该模式的具体对象。 然后,我需要组织回答的结构,先解释各自的定义,再说明区别和联系。需要确保用中文清晰表达,符合用户的要求,同时引用提供的资料。比如,引用[1]说明Kotlin支持委托模式,引用[2]展示代码实例,引用[3]用比喻解释关系。 可能还需要检查是否有其他资料或常见问题中的观点,但根据用户提供的引用,应该足够回答问题。需要注意的是,用户可能认为代理委托是两个不同的概念,但根据Kotlin的文档,它们其实是同一模式中的不同角色,委托是动作,代理是执行者。 总结:在Kotlin中,委托是一种设计模式,使用`by`关键字将职责交给另一个对象(代理者)。代理者是具体执行任务的对象,而委托者是发起委托的一方。两者共同构成委托模式,没有本质区别,只是角色不同。</think>### Kotlin代理委托的区别及联系 #### **1. 定义解析** - **委托(Delegation)** 委托是一种设计模式,指一个对象将某些职责**交给另一个对象处理**。在Kotlin中,通过关键字`by`实现委托,例如类委托属性委托[^1][^3]。 例如: ```kotlin // 类委托:将接口实现委托给另一个对象 interface Worker { fun work() } class Engineer : Worker { override fun work() { println("Engineer working") } } class Manager(worker: Worker) : Worker by worker // 委托给Engineer实例 ``` - **代理(Delegate)** 代理是**具体执行任务的对象**,即被委托方。它负责实现委托者需要的方法或属性。例如属性委托中的`Delegate`类[^2]: ```kotlin class Principal { var intValue: Int by Delegate() // Delegate是代理者 } class Delegate { // 代理者实现getValue和setValue operator fun getValue(...) { ... } operator fun setValue(...) { ... } } ``` --- #### **2. 区别与联系** | **维度** | **委托** | **代理** | |----------------|----------------------------------|----------------------------------| | **角色** | 委托者(如`Principal`或`Manager`) | 代理者(如`Delegate`或`Engineer`) | | **功能** | 声明需要委托的任务 | 具体实现委托的逻辑 | | **语法关键字** | `by` | 无(通过类或对象实现) | | **设计模式** | 委托模式的整体结构 | 委托模式中的具体执行者 | **联系**: - 代理委托模式的**实现载体**,委托代理的**使用场景**。例如,`Principal`(委托者)通过`by`将属性管理委托给`Delegate`(代理者)[^2]。 - 两者共同实现“**分离职责**”的目标,例如将界面逻辑与数据存储解耦[^3]。 --- #### **3. 核心代码示例** ```kotlin // 委托者 class Parent { var task: String by Son // 委托给Son代理 } // 代理者(单例建议) object Son { private var _task = "" operator fun getValue(thisRef: Parent, property: KProperty<*>): String { println("Son代理返回任务给Parent") return _task } operator fun setValue(thisRef: Parent, property: KProperty<*>, value: String) { _task = value println("Son代理设置任务:$value") } } ``` - 当`Parent`访问`task`时,实际调用`Son`的`getValue`和`setValue`[^2]。 --- #### **4. 典型应用场景** 1. **属性延迟初始化** 使用`lazy`代理实现延迟加载: ```kotlin val heavyResource by lazy { loadHeavyData() } ``` 2. **观察属性变化** 通过`Delegates.observable`代理监听值变更: ```kotlin var name: String by Delegates.observable("") { _, old, new -> println("$old → $new") } ``` 3. **接口实现委托** 将接口方法委托给其他类(如`Engineer`代理`Manager`的工作)[^1]。 ---
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值