Kotlin: operator fun invoke

Если вы встречали в Kotlin-коде выражения вроде Json { prettyPrint = true } или logger("Ошибка загрузки"), где на первый взгляд вызывается… класс или объект, — перед вами магия operator fun invoke. Разберём, как она устроена и когда её стоит применять.

Что происходит при вызове


В Kotlin любой объект можно «вызвать» как функцию — если у его класса объявлен оператор invoke:
class Greeter {
    operator fun invoke(name: String): String {
        return "Привет, $name!"
    }
}

fun main() {
    val greeter = Greeter()
    println(greeter("Аня"))  // Привет, Аня!
}

Строка greeter("Аня") компилируется в greeter.invoke("Аня"). На первый взгляд это выглядит странно: зачем вызывать объект, когда есть методы? Но именно это позволяет строить очень выразительный код — и не зря так работают kotlinx.serialization, Koin, Gradle DSL и DSL-библиотеки для HTML.

Важно: invoke — обычная функция, поэтому её можно перегружать по числу и типам аргументов, задавать значения по умолчанию, делать расширяемой и даже suspend.

Зачем это нужно на практике



1. «Умный конструктор» с логикой
Часто объекту нужен не «вызов», а действие: получить значение, выполнить запрос, найти запись. invoke позволяет совместить создание и выполнение:
class Http {
    suspend operator fun invoke(url: String): Response =
        client.get(url)
}

// Код читается почти как естественный язык:
val response = Http("https://api.example.com/users")

Так устроены библиотеки вроде Ktor: HttpClient(...) — и создание, и готовый к использованию клиент.

2. Конфигурируемые фабрики
Классический пример — Json из kotlinx.serialization. Объект Json — это фабрика конфигураций, а invoke позволяет сразу применить настройки:
val json = Json { 
    ignoreUnknownKeys = true 
    prettyPrint = true 
}

Здесь Json — не конструктор, а объект-компаньон, у которого объявлен operator fun invoke(builderAction: JsonBuilder.() -> Unit): Json. Внутри лямбды вы находитесь в контексте билдера (this — это JsonBuilder), поэтому присваиваете свойства напрямую, без with(...). Тот же приём лежит в основе DSL Gradle: dependencies { implementation(...) }.

3. Сокрытие бойлерплейта
Если метод объекта всегда вызывается с одними и теми же настройками, invoke позволяет убрать повторяющийся код:
class Logger(private val tag: String) {
    operator fun invoke(message: String) {
        println("[$tag] $message")
    }
}

val networkLog = Logger("NETWORK")
val dbLog = Logger("DB")

networkLog("Соединение установлено")  // [NETWORK] Соединение установлено
dbLog("Кэш очищен")                   // [DB] Кэш очищен

Без invoke пришлось бы писать networkLog.log(...). Разница небольшая, но в DSL-коде и на интенсивно используемых объектах она ощутима.

4. Проверки при создании без ограничений конструктора
Через invoke на companion-объекте удобно валидировать входные данные — это гибче, чем init, потому что можно возвращать null, бросать осмысленные исключения или кэшировать результаты:
class Email private constructor(val value: String) {

    companion object {
        operator fun invoke(raw: String): Email {
            require(raw.contains('@')) { "Некорректный email: $raw" }
            return Email(raw.trim().lowercase())
        }
    }
}

val email = Email("  User@Mail.ru  ")  // user@mail.ru
// Email("нет-собаки") // IllegalArgumentException

Конструктор закрыт — создать «плохой» объект невозможно; единственный путь — через invoke, который гарантирует валидность.

5. Кэширование и вычисления по требованию
invoke позволяет объекту вести себя как функция с состоянием:
class Fibonacci {
    private val cache = mutableMapOf(0L to 0L, 1L to 1L)

    operator fun invoke(n: Long): Long {
        return cache.getOrPut(n) { invoke(n - 1) + invoke(n - 2) }
    }
}

val fib = Fibonacci()
println(fib(50))  // 12586269025 — мгновенно, thanks to cache


Разные сигнатуры: Перегрузка и suspend


invoke — полноправная функция, поэтому её можно перегружать:
class Parser {
    operator fun invoke(text: String): List<String> =
        text.split(",").map { it.trim() }

    operator fun invoke(text: String, delimiter: Char): List<String> =
        text.split(delimiter).map { it.trim() }
}

val parser = Parser()
parser("a, b, c")       // [a, b, c]
parser("a;b;c", ';')    // [a, b, c]

А в корутинах — объявить suspend, если вызов асинхронный:
class ApiClient {
    suspend operator fun invoke(path: String): JsonObject =
        http.get("$baseUrl/$path").body()
}

// Использование:
val user = apiClient("/users/42")


Нюансы и подводные камни


  • invoke не заменяет конструктор везде. В сериализации, рефлексии и некоторых фреймворках ожидается именно конструктор. Если вы прячете создание за invoke, убедитесь, что это не ломает библиотеки, работающие с классом напрямую.
  • Не злоупотребляйте. Если у объекта есть осмысленный глагол (load, parse, execute), обычный метод часто читается понятнее. invoke хорош там, где объект концептуально и есть функция: парсер, валидатор, форматтер, конфигуратор.
  • Компаньон + приватный конструктор. Паттерн с валидацией работает, только если основной конструктор действительно закрыт (private constructor). Иначе кто-то обойдёт проверки напрямую.
  • IDE-подсказки. Инструменты рефакторинга и поиск по коду находят вызовы invoke хуже, чем явные вызовы методов: поиском по load( вы не найдёте store(...). В командной разработке это иногда становится аргументом против DSL-магии.


Когда использовать


Подводя итог, invoke оправдан, когда:
  • объект по смыслу является функцией или операцией (парсер, валидатор, запрос);
  • вы строите DSL с конфигурацией в лямбде (как Json { ... });
  • нужен контролируемый фабричный метод с валидацией и закрытым конструктором;
  • хочется убрать повторяющийся метод-обёртку при интенсивном использовании.

Во всех остальных случаях обычный метод с говорящим именем — честнее и понятнее.

Автор:  Вчера, 5:54 pm