373 lines
17 KiB
Markdown
373 lines
17 KiB
Markdown
---
|
||
title: Делегирование
|
||
description: Делегирование интерфейсов через by, делегаты свойств и границы автоматического перенаправления
|
||
tags:
|
||
- kotlin
|
||
- oop
|
||
---
|
||
|
||
Делегирование - передача работы другому объекту. Kotlin поддерживает его на уровне языка словом `by`, поэтому композиция требует не больше кода, чем наследование.
|
||
|
||
## Делегирование интерфейса
|
||
```kotlin
|
||
interface Logger5 {
|
||
fun log(msg: String): String
|
||
fun warn(msg: String): String
|
||
}
|
||
|
||
class ConsoleLogger3 : Logger5 {
|
||
override fun log(msg: String) = "[LOG] $msg"
|
||
override fun warn(msg: String) = "[WARN] $msg"
|
||
}
|
||
|
||
class Service15(logger: Logger5) : Logger5 by logger {
|
||
fun work() = log("начинаю работу")
|
||
}
|
||
|
||
fun main() {
|
||
val s = Service15(ConsoleLogger3())
|
||
println(s.work()) // [LOG] начинаю работу
|
||
println(s.warn("внимание")) // [WARN] внимание — метод перенаправлен
|
||
}
|
||
```
|
||
`Service15` реализует `Logger5`, но код методов не пишет: компилятор генерирует перенаправление на `logger`. Унаследованной реализации при этом нет - есть ссылка на другой объект.
|
||
|
||
## Переопределение части методов
|
||
Делегировать можно всё, кроме того, что нужно изменить:
|
||
```kotlin
|
||
interface Repository3 {
|
||
fun find(id: Int): String?
|
||
fun save(id: Int, value: String): String
|
||
}
|
||
|
||
class DbRepository : Repository3 {
|
||
private val data = mutableMapOf<Int, String>()
|
||
override fun find(id: Int) = data[id]
|
||
override fun save(id: Int, value: String): String {
|
||
data[id] = value
|
||
return "сохранено"
|
||
}
|
||
}
|
||
|
||
class CachingRepository(private val origin: Repository3) : Repository3 by origin {
|
||
private val cache = mutableMapOf<Int, String>()
|
||
|
||
override fun find(id: Int): String? = // только этот метод свой
|
||
cache.getOrPut(id) { origin.find(id) ?: return null }
|
||
}
|
||
|
||
fun main() {
|
||
val repo = CachingRepository(DbRepository())
|
||
println(repo.save(1, "Иван")) // сохранено — делегировано
|
||
println(repo.find(1)) // Иван — через кеш
|
||
println(repo.find(1)) // Иван — уже из кеша
|
||
println(repo.find(99)) // null
|
||
}
|
||
```
|
||
Это декоратор в три строки. На наследовании он потребовал бы `open`-класса и был бы связан с его внутренностями.
|
||
|
||
## Делегирование нескольких интерфейсов
|
||
```kotlin
|
||
interface Reader { fun read(): String }
|
||
interface Writer2 { fun write(data: String): String }
|
||
|
||
class FileReader2 : Reader { override fun read() = "данные из файла" }
|
||
class FileWriter2 : Writer2 { override fun write(data: String) = "записано: $data" }
|
||
|
||
class ReadWriteFile(
|
||
reader: Reader,
|
||
writer: Writer2,
|
||
) : Reader by reader, Writer2 by writer
|
||
|
||
fun main() {
|
||
val f = ReadWriteFile(FileReader2(), FileWriter2())
|
||
println(f.read()) // данные из файла
|
||
println(f.write("текст")) // записано: текст
|
||
}
|
||
```
|
||
Это даёт эффект множественного наследования реализации - но без его проблем, потому что каждый интерфейс обслуживает отдельный объект.
|
||
|
||
## Расширение коллекции
|
||
Классическая задача, которую нельзя безопасно решить наследованием:
|
||
```kotlin
|
||
class CountingList3<T>(private val inner: MutableList<T> = mutableListOf())
|
||
: MutableList<T> by inner {
|
||
|
||
var addedCount = 0
|
||
private set
|
||
|
||
override fun add(element: T): Boolean {
|
||
addedCount++
|
||
return inner.add(element)
|
||
}
|
||
|
||
override fun addAll(elements: Collection<T>): Boolean {
|
||
addedCount += elements.size
|
||
return inner.addAll(elements)
|
||
}
|
||
}
|
||
|
||
fun main() {
|
||
val list = CountingList3<Int>()
|
||
list.add(1)
|
||
list.addAll(listOf(2, 3))
|
||
println("${list.size} элементов, добавлений: ${list.addedCount}") // 3 элементов, добавлений: 3
|
||
println(list.toList()) // [1, 2, 3]
|
||
}
|
||
```
|
||
При наследовании от `ArrayList` счётчик мог бы удвоиться, если `addAll` внутри вызывает `add`. С делегированием внутренние вызовы `inner` остаются внутри `inner` и наших переопределений не касаются.
|
||
|
||
Обратите внимание на `list.toList()`: сам `println(list)` вывел бы `CountingList3@5fa7e7ff`, потому что `toString` - член `Any`, а члены `Any` делегирование не перенаправляет.
|
||
|
||
Эта же особенность - источник главной ловушки делегирования, см. подводные камни.
|
||
|
||
## Делегаты свойств
|
||
Тот же `by` для свойства передаёт работу объекту с методами `getValue` и `setValue`.
|
||
|
||
### Готовые делегаты
|
||
```kotlin
|
||
import kotlin.properties.Delegates
|
||
|
||
class Form3 {
|
||
val config: String by lazy { "вычислено один раз" }
|
||
|
||
var name: String by Delegates.observable("") { _, old, new ->
|
||
println("name: '$old' -> '$new'")
|
||
}
|
||
|
||
var age: Int by Delegates.vetoable(0) { _, _, new -> new in 0..150 }
|
||
|
||
var port: Int by Delegates.notNull()
|
||
}
|
||
|
||
fun main() {
|
||
val f = Form3()
|
||
println(f.config) // вычислено один раз
|
||
f.name = "Иван" // name: '' -> 'Иван'
|
||
f.age = 200 // отклонено
|
||
println(f.age) // 0
|
||
f.port = 8080
|
||
println(f.port) // 8080
|
||
}
|
||
```
|
||
Подробнее: [Свойства](Свойства.md)
|
||
|
||
### Делегирование свойства в Map
|
||
```kotlin
|
||
class Settings(private val map: Map<String, Any?>) {
|
||
val host: String by map
|
||
val port: Int by map
|
||
}
|
||
|
||
fun main() {
|
||
val s = Settings(mapOf("host" to "localhost", "port" to 8080))
|
||
println("${s.host}:${s.port}") // localhost:8080
|
||
}
|
||
```
|
||
Имя свойства становится ключом. Для `var` нужен `MutableMap`.
|
||
|
||
### Свой делегат
|
||
Нужны операторы `getValue` и (для `var`) `setValue`:
|
||
```kotlin
|
||
import kotlin.reflect.KProperty
|
||
|
||
class NonBlank(private var value: String = "") {
|
||
operator fun getValue(thisRef: Any?, property: KProperty<*>) = value
|
||
|
||
operator fun setValue(thisRef: Any?, property: KProperty<*>, newValue: String) {
|
||
require(newValue.isNotBlank()) { "${property.name} не может быть пустым" }
|
||
value = newValue.trim()
|
||
}
|
||
}
|
||
|
||
class User6 {
|
||
var name: String by NonBlank()
|
||
}
|
||
|
||
fun main() {
|
||
val u = User6()
|
||
u.name = " Иван "
|
||
println("'${u.name}'") // 'Иван'
|
||
try {
|
||
u.name = " "
|
||
} catch (e: IllegalArgumentException) {
|
||
println(e.message) // name не может быть пустым
|
||
}
|
||
}
|
||
```
|
||
`property` даёт имя и метаданные свойства - удобно для сообщений об ошибках и для чтения из конфигурации по имени.
|
||
|
||
Для делегата только на чтение достаточно реализовать `ReadOnlyProperty`:
|
||
```kotlin
|
||
import kotlin.properties.ReadOnlyProperty
|
||
|
||
fun envVar(name: String) = ReadOnlyProperty<Any?, String> { _, _ ->
|
||
System.getenv(name) ?: "<не задано>"
|
||
}
|
||
|
||
class Config7 {
|
||
val home: String by envVar("HOME")
|
||
val missing: String by envVar("НЕТ_ТАКОЙ_ПЕРЕМЕННОЙ")
|
||
}
|
||
|
||
fun main() {
|
||
println(Config7().home.isNotEmpty()) // true
|
||
println(Config7().missing) // <не задано>
|
||
}
|
||
```
|
||
|
||
### provideDelegate
|
||
Позволяет проверить свойство при создании делегата - например, что имя есть в конфигурации:
|
||
```kotlin
|
||
import kotlin.reflect.KProperty
|
||
|
||
class Required(private val source: Map<String, String>) {
|
||
operator fun provideDelegate(thisRef: Any?, property: KProperty<*>): Required {
|
||
require(property.name in source) { "нет ключа '${property.name}'" }
|
||
return this
|
||
}
|
||
|
||
operator fun getValue(thisRef: Any?, property: KProperty<*>) = source[property.name]!!
|
||
}
|
||
|
||
fun main() {
|
||
val source = mapOf("host" to "localhost")
|
||
|
||
class Ok3 { val host: String by Required(source) }
|
||
println(Ok3().host) // localhost
|
||
|
||
try {
|
||
class Bad4 { val port: String by Required(source) }
|
||
Bad4()
|
||
} catch (e: IllegalArgumentException) {
|
||
println(e.message) // нет ключа 'port'
|
||
}
|
||
}
|
||
```
|
||
Проверка происходит при создании объекта, а не при первом чтении - ошибка обнаруживается раньше.
|
||
|
||
> [!info] Отличия от Java
|
||
> | Java | Kotlin |
|
||
> |---|---|
|
||
> | все методы перенаправлять вручную | `by` генерирует их |
|
||
> | декоратор = класс с полем и 10 методами | `class D(x: I) : I by x` |
|
||
> | `Supplier` + `volatile` для ленивости | `by lazy` |
|
||
> | `PropertyChangeSupport` | `Delegates.observable` |
|
||
> | нет аналога делегатов свойств | `by` с `getValue`/`setValue` |
|
||
>
|
||
> **Делегирование интерфейса - главная экономия.** В Java декоратор над интерфейсом из десяти методов требует десять методов-перенаправлений, даже если менять нужно один. Любой новый метод в интерфейсе нужно добавить во все декораторы. Kotlin генерирует перенаправление сам:
|
||
> ```java
|
||
> class CachingRepository implements Repository {
|
||
> private final Repository origin;
|
||
> CachingRepository(Repository origin) { this.origin = origin; }
|
||
> public String save(int id, String v) { return origin.save(id, v); } // шум
|
||
> public String find(int id) { /* своя логика */ }
|
||
> }
|
||
> ```
|
||
>
|
||
> **Делегатов свойств в Java нет совсем.** Ленивое поле требует ручной двойной проверки блокировки, наблюдаемое - `PropertyChangeSupport` и явных вызовов. В Kotlin это `by lazy` и `by Delegates.observable`.
|
||
>
|
||
> **Паттерн Декоратор перестаёт быть паттерном** - он становится однострочной конструкцией языка, поэтому его применяют там, где в Java предпочли бы наследование «чтобы не писать много кода».
|
||
>
|
||
> Сравнить: [Полиморфизм подтипов в Java](../../Программирование%20на%20Java/ООП/Полиморфизм/Полиморфизм%20подтипов.md), [Абстрактные классы](../../Программирование%20на%20Java/ООП/Абстрактные%20классы.md)
|
||
|
||
> [!warning] Подводные камни
|
||
> **Делегат не знает о переопределениях - это главная ловушка.** Если один метод делегата вызывает другой, он вызовет **свою** версию, а не вашу:
|
||
> ```kotlin
|
||
> interface Sender {
|
||
> fun send(msg: String): String
|
||
> fun sendAll(msgs: List<String>): String
|
||
> }
|
||
>
|
||
> class BasicSender : Sender {
|
||
> override fun send(msg: String) = "отправлено: $msg"
|
||
> override fun sendAll(msgs: List<String>) = msgs.joinToString { send(it) }
|
||
> }
|
||
>
|
||
> class LoggingSender(private val inner: Sender) : Sender by inner {
|
||
> var logged = 0
|
||
> private set
|
||
>
|
||
> override fun send(msg: String): String {
|
||
> logged++
|
||
> return inner.send(msg)
|
||
> }
|
||
> }
|
||
>
|
||
> fun main() {
|
||
> val s = LoggingSender(BasicSender())
|
||
> s.sendAll(listOf("a", "b"))
|
||
> println("залогировано: ${s.logged}") // 0 — наш send не вызвался!
|
||
> }
|
||
> ```
|
||
> `sendAll` делегирован и внутри вызывает `send` объекта `inner`. Чтобы счётчик работал, нужно переопределить и `sendAll`. Это обратная сторона изоляции: наследование здесь сработало бы «как ожидается», но стало бы хрупким.
|
||
>
|
||
> **Члены `Any` не делегируются.** `toString`, `equals` и `hashCode` остаются реализациями по умолчанию, то есть по ссылке:
|
||
> ```kotlin
|
||
> class Wrapped<T>(private val inner: MutableList<T> = mutableListOf()) : MutableList<T> by inner
|
||
>
|
||
> fun main() {
|
||
> val a = Wrapped<Int>().apply { add(1) }
|
||
> val b = Wrapped<Int>().apply { add(1) }
|
||
> println(a.toString()) // Wrapped@4554617c, а не [1]
|
||
> println(a == b) // false, хотя содержимое одинаково
|
||
> println(a == listOf(1)) // false
|
||
> }
|
||
> ```
|
||
> Обёртка над коллекцией, попавшая в `Set` или в сравнение, поведёт себя не как коллекция. Эти три метода нужно переопределять вручную. Подробнее: [equals, hashCode и toString](../Синтаксис%20и%20типы/Базовые%20типы%20ООП/equals,%20hashCode%20и%20toString.md)
|
||
>
|
||
> **Делегат фиксируется при создании** и не может быть заменён:
|
||
> ```kotlin
|
||
> fun interface Source { fun get(): String }
|
||
>
|
||
> class Service16(private var source: Source) : Source by source {
|
||
> fun replace(newSource: Source) { source = newSource } // не влияет на by!
|
||
> }
|
||
>
|
||
> fun main() {
|
||
> val s = Service16 { "первый" }
|
||
> s.replace { "второй" }
|
||
> println(s.get()) // первый — by хранит исходную ссылку
|
||
> }
|
||
> ```
|
||
> `by` копирует ссылку в скрытое поле при создании объекта. Для подменяемого делегата нужно перенаправлять вручную.
|
||
>
|
||
> **Делегирование нельзя сделать `by this`** или сослаться на собственное свойство в заголовке - объект ещё не создан.
|
||
>
|
||
> **Из делегированных методов нет доступа к `this` обёртки.** Делегат не знает, что его кто-то оборачивает, - он не может вызвать методы обёртки.
|
||
>
|
||
> **`by lazy` на `var` невозможен** - только `val`.
|
||
>
|
||
> **Делегат свойства - объект на каждый экземпляр:**
|
||
> ```kotlin
|
||
> class Heavy {
|
||
> val a: String by lazy { "a" }
|
||
> val b: String by lazy { "b" } // ещё один объект Lazy
|
||
> }
|
||
>
|
||
> fun main() { println(Heavy().a + Heavy().b) } // ab
|
||
> ```
|
||
> Для класса с десятками ленивых свойств, создаваемого миллионами экземпляров, это заметный расход памяти.
|
||
>
|
||
> **Делегирование в `Map` падает в рантайме при отсутствии ключа:**
|
||
> ```kotlin
|
||
> class Settings2(map: Map<String, Any?>) {
|
||
> val host: String by map
|
||
> }
|
||
>
|
||
> fun main() {
|
||
> val s = Settings2(emptyMap())
|
||
> try {
|
||
> println(s.host)
|
||
> } catch (e: NoSuchElementException) {
|
||
> println("ключ отсутствует") // ключ отсутствует
|
||
> }
|
||
> }
|
||
> ```
|
||
> Проверить это заранее помогает `provideDelegate`.
|
||
>
|
||
> **Делегирование `MutableList` раскрывает полный изменяемый API.** Обёртка, делегирующая `MutableList`, позволяет внешнему коду добавлять элементы в обход вашей логики - через `iterator().remove()`, `subList()` и другие пути.
|
||
|
||
Дополнительно: [Свойства](Свойства.md)
|
||
Далее: [Вложенные и внутренние классы](Вложенные%20и%20внутренние%20классы.md)
|