Работа с базами данных из Kotlin

ОБЯЗАТЕЛЬНОДЛЯ НОВИЧКОВ

Разработчику Архитектору

Работа с базами данных в Kotlin

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

как Kotlin взаимодействует с файлами как с примитивным способом хранения,
как организуется обработка данных в памяти,
как осуществляется подключение к внешним системам хранения,
какие модели и инструменты применяются при взаимодействии с реляционными и нереляционными базами данных,
как реализованы популярные ORM-библиотеки, созданные специально под Kotlin (Exposed, Ktorm), и в чём их отличия от классических решений, таких как Hibernate.

Все рассматриваемые механизмы демонстрируются в контексте реального применения — без упрощений, но с акцентом на понимание принципов работы, а не на копирование готовых решений.

Маршрут новичка по теме

Если вы впервые настраиваете слой данных, начните с Ktor Server и Тестирования, затем возвращайтесь сюда и внедряйте БД по шагам: JDBC → пул соединений → ORM/DSL → миграции.

1. Работа с файлами в Kotlin

Файловая система — это один из наиболее базовых уровней хранения данных. Kotlin не предоставляет собственных классов для файлового ввода-вывода, но полностью интегрируется со стандартными библиотеками Java (java.io, java.nio.file). Это позволяет использовать проверенные, кроссплатформенные и высокопроизводительные инструменты без избыточной абстракции.

Базовые операции

Для работы с файлами в Kotlin используются объекты типа java.io.File (устаревший, но простой в использовании) и java.nio.file.Path (современный, более гибкий). В Kotlin эти классы дополнены расширениями, упрощающими чтение и запись:

val file = File("data.txt")
file.writeText("Привет, Kotlin!")               // Запись строки
val content = file.readText()                   // Чтение всего файла как строки
val lines = file.readLines()                    // Чтение по строкам в список

Разбор:

Фрагмент показывает исполняемый сценарий: здесь важен порядок шагов и состояние между вызовами.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
Ключевые вызовы во фрагменте (File, writeText, readText, readLines) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.
Фрагмент полезно читать сверху вниз: каждая строка подготавливает контекст для следующего шага.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

Для бинарных данных применяются потоковые операции:

val bytes = byteArrayOf(0x01, 0x02, 0x03)
file.writeBytes(bytes)
val readBytes = file.readBytes()

Разбор:

Фрагмент показывает исполняемый сценарий: здесь важен порядок шагов и состояние между вызовами.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
Ключевые вызовы во фрагменте (byteArrayOf, writeBytes, readBytes) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.
Фрагмент полезно читать сверху вниз: каждая строка подготавливает контекст для следующего шага.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

Эти методы являются синхронными и блокирующими — они завершаются только после фактического завершения операции ввода-вывода. В многопоточных приложениях их следует использовать вне основного потока (например, в Dispatchers.IO при использовании Kotlin Coroutines).

Кодировки и локализация

Kotlin по умолчанию использует кодировку UTF-8 в методах writeText, readText, readLines, что соответствует современным стандартам. При необходимости кодировку можно указать явно:

file.writeText("Текст", Charsets.UTF_16)

Разбор:

Фрагмент показывает исполняемый сценарий: здесь важен порядок шагов и состояние между вызовами.
Ключевые вызовы во фрагменте (writeText) формируют основной поток выполнения и обмена данными.
Фрагмент полезно читать сверху вниз: каждая строка подготавливает контекст для следующего шага.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

Это особенно важно при работе с унаследованными системами, где может применяться Windows-1251 или ISO-8859-1.

Контекстные менеджеры и безопасность ресурсов

Хотя readText() и writeText() скрывают управление потоками внутри себя, при ручной работе с InputStream/OutputStream или Reader/Writer необходимо гарантировать корректное освобождение ресурсов. Kotlin предлагает идиоматичное решение — расширение use, реализующее паттерн try-with-resources:

FileInputStream("data.bin").use { input ->
    // Работа с input
    // input.close() будет вызван автоматически
}

Разбор:

Фрагмент показывает исполняемый сценарий: здесь важен порядок шагов и состояние между вызовами.
use {} автоматически закрывает ресурс в конце блока и защищает от утечек соединений/потоков.
Ключевые вызовы во фрагменте (FileInputStream, close) формируют основной поток выполнения и обмена данными.
Границы блоков в фигурных скобках помогают сразу увидеть области видимости и жизненный цикл локальных переменных.
Фрагмент полезно читать сверху вниз: каждая строка подготавливает контекст для следующего шага.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

Метод use принимает лямбду, внутри которой можно безопасно использовать ресурс. При выходе из блока, в том числе при возникновении исключения, вызывается close().

Файловая система как хранилище

Несмотря на простоту, файлы редко используются в продакшен-приложениях для хранения структурированных данных по следующим причинам:

отсутствие транзакционности;
сложность реализации конкурентного доступа;
отсутствие индексов и эффективных методов поиска;
высокий риск повреждения данных при сбое;
необходимость ручной сериализации/десериализации.

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

2. Работа с данными в памяти

Прежде чем данные попадут в базу или файл, они существуют в оперативной памяти. Kotlin предоставляет богатую систему типов и коллекций, позволяющую эффективно моделировать доменные сущности и их связи.

Типы данных и неизменяемость

Kotlin делает акцент на неизменяемости по умолчанию. Объявление как val x = 42, так и val list = listOf(1, 2, 3) создаёт ссылку, которую нельзя переназначить, а в случае коллекций — структуру, которую нельзя модифицировать. Для изменения требуется явно выбрать изменяемую форму:

val immutableList = listOf(1, 2, 3)         // List<Int> — только для чтения
val mutableList = mutableListOf(1, 2, 3)     // MutableList<Int> — можно менять

Разбор:

Фрагмент показывает исполняемый сценарий: здесь важен порядок шагов и состояние между вызовами.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
Ключевые вызовы во фрагменте (listOf, mutableListOf) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.
Фрагмент полезно читать сверху вниз: каждая строка подготавливает контекст для следующего шага.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

Этот подход снижает когнитивную нагрузку и уменьшает количество ошибок, связанных с неожиданными побочными эффектами — особенно при передаче данных между компонентами (например, между слоями приложения: контроллер → сервис → репозиторий).

data-классы как основа доменной модели

Одним из ключевых инструментов моделирования данных в Kotlin являются data-классы. Они автоматически генерируют:

конструктор с параметрами всех свойств;
реализации equals() и hashCode() на основе значений свойств;
метод toString() для отладки;
функцию copy() для создания изменённых копий (поддержка иммутабельного стиля).

Пример:

data class User(
    val id: Long,
    val name: String,
    val email: String,
    val createdAt: Instant
)

Разбор:

Фрагмент строит структуру типов: объявления классов/интерфейсов задают контракт и модель данных.
data class автоматически генерирует методы сравнения и копирования, поэтому модель удобна для DTO и сериализации.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
Ключевые вызовы во фрагменте (User) формируют основной поток выполнения и обмена данными.
Фрагмент полезно читать сверху вниз: каждая строка подготавливает контекст для следующего шага.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

copy() позволяет безопасно изменять отдельные поля без побочных эффектов:

val user = User(1, "Анна", "anna@example.com", Instant.now())
val updated = user.copy(email = "new@example.com")

Разбор:

Фрагмент показывает исполняемый сценарий: здесь важен порядок шагов и состояние между вызовами.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
copy(...) создаёт новую версию объекта с точечными изменениями без мутации исходного экземпляра.
Ключевые вызовы во фрагменте (User, now, copy) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

data-классы идеально подходят для передачи данных между уровнями приложения (DTO), для кэширования, для сериализации и, конечно, для отображения строк таблиц баз данных.

Сериализация

Для сохранения данных в файл или передачи по сети требуется сериализация. Kotlin поддерживает несколько подходов:

JSON через kotlinx.serialization — официальный, типобезопасный, поддерживает вложенные структуры, полиморфизм, кастомные сериализаторы;
Protobuf, CBOR, Properties — также поддерживаются через соответствующие модули kotlinx.serialization;
Java-Serializable — наследуется от Java, но не рекомендуется из-за нестабильности формата и отсутствия контроля версий.

Пример с JSON:

@Serializable
data class User(val id: Long, val name: String)

val json = Json.encodeToString(User(1, "Иван"))
val user = Json.decodeFromString<User>(json)

Разбор:

Фрагмент строит структуру типов: объявления классов/интерфейсов задают контракт и модель данных.
data class автоматически генерирует методы сравнения и копирования, поэтому модель удобна для DTO и сериализации.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
Ключевые вызовы во фрагменте (User, encodeToString) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

Сериализация — обязательный этап при работе с внешними системами. От её корректности зависит стабильность взаимодействия между компонентами системы.

3. Работа с базами данных

Под "работой с базой данных" в контексте приложения на Kotlin понимается организация постоянного, структурированного и надёжного хранения данных. На этом уровне возникают следующие задачи:

установление соединения с СУБД;
выполнение запросов (чтение, запись, модификация);
управление транзакциями;
преобразование данных между реляционной моделью (таблицы, строки, столбцы) и объектной моделью (классы, свойства, связи);
обработка ошибок и восстановление после сбоев;
обеспечение безопасности (предотвращение SQL-инъекций);
работа с пулами соединений для повышения производительности.

Play ITЗагрузка интерактивного демо…

Kotlin, как и Java, опирается на интерфейс java.sql.*, входящий в состав Java SE. Однако его низкоуровневый характер (ручное управление PreparedStatement, ResultSet, Connection) делает код многословным и подверженным ошибкам. Поэтому на практике применяются более высокоуровневые абстракции.

4. Взаимодействие с СУБД

Есть три основных уровня работы с базами данных в Kotlin-экосистеме:

Уровень	Описание	Примеры
Низкоуровневый (JDBC)	Прямое использование `java.sql.Connection`, `PreparedStatement`, `ResultSet`. Полный контроль, но высокая трудоёмкость и риск ошибок.	`java.sql.DriverManager`, `HikariCP` (пул соединений)
SQL-мапперы	Автоматическое сопоставление результатов SQL-запросов с Kotlin-классами. Запросы пишутся вручную, но обработка результата упрощена.	`JDBI`, `KotliQuery`, `MapStruct` + кастомные обёртки
ORM (Object-Relational Mapping)	Полная абстракция над SQL: объекты в коде отображаются на таблицы, свойства — на столбцы, коллекции — на связи. Запросы могут формулироваться в виде вызовов методов или DSL.	`Exposed`, `Ktorm`, `Hibernate` (через `hibernate-kotlin` или `JPA`)

Выбор уровня зависит от требований проекта:

для микросервисов с простой моделью данных предпочтителен лёгкий ORM или SQL-маппер;
для сложных доменных моделей с наследованием, полиморфизмом и кэшированием — полноценный ORM;
для высоконагруженных сценариев, где важен контроль над SQL, — ручные запросы с маппингом.

Важно понимать: Kotlin не навязывает никакой конкретный подход. Это позволяет использовать лучший инструмент под задачу — в отличие от некоторых фреймворков, где ORM "вшит" в архитектуру.

5. Низкоуровневая работа — JDBC и его ограничения в Kotlin-контексте

Java Database Connectivity (JDBC) — стандартный API для доступа к реляционным СУБД. Он предоставляет унифицированный интерфейс (DriverManager, Connection, Statement, ResultSet) и реализуется драйверами от поставщиков СУБД — pgjdbc для PostgreSQL, mysql-connector-j для MySQL, mariadb-java-client, sqlite-jdbc и др.

Как работает типичный JDBC-запрос

Код ITЗагрузка примера кода…

Разбор:

Фрагмент показывает исполняемый сценарий: здесь важен порядок шагов и состояние между вызовами.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
Циклическая конструкция в примере показывает повторяемую обработку элементов или шагов алгоритма.
println используется как быстрая проверка результата и помогает увидеть фактический ход выполнения.
Интерполяция ${...} или $name в строках делает вывод компактным и избавляет от ручной конкатенации.
Ключевые вызовы во фрагменте (getConnection, prepareStatement, setLong, executeQuery) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.

Этот код — корректный Kotlin, но он страдает от нескольких проблем:

Многословность: каждая операция требует явного управления ресурсами.
Подверженность ошибкам — забытый close(), неправильный индекс параметра (1 вместо 0), непроверенный null.
Отсутствие типобезопасности — getString("name") возвращает String?, но компилятор не проверяет, существует ли столбец name в результате.
Несовместимость с корутинами: executeQuery() блокирует поток.

Пулы соединений

Открытие нового соединения — дорогая операция. В production-средах используются пулы соединений, которые удерживают заранее инициализированные Connection и выдают их по запросу. Популярные реализации:

HikariCP — самый быстрый и лёгкий пул, де-факто стандарт в Kotlin/JVM-мире;
Tomcat JDBC Pool, C3P0, DBCP2 — альтернативы, чаще встречаются в legacy-проектах.

Пример инициализации HikariCP:

val config = HikariConfig().apply {
    jdbcUrl = "jdbc:postgresql://localhost/mydb"
    username = "user"
    password = "pass"
    maximumPoolSize = 20
    connectionTimeout = 3000
}

val dataSource = HikariDataSource(config)

Разбор:

Фрагмент показывает исполняемый сценарий: здесь важен порядок шагов и состояние между вызовами.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
Ключевые вызовы во фрагменте (HikariConfig, HikariDataSource) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.
Границы блоков в фигурных скобках помогают сразу увидеть области видимости и жизненный цикл локальных переменных.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

Теперь dataSource.connection возвращает соединение из пула, и его тоже обязательно закрывать (хотя физическое закрытие не происходит — соединение возвращается в пул).

Kotlin-расширения для облегчения JDBC

Комьюнити создало множество расширений, сокращающих шаблонный код:

Код ITЗагрузка примера кода…

Разбор:

Фрагмент показывает исполняемый сценарий: здесь важен порядок шагов и состояние между вызовами.
fun выделяет именованные блоки логики, что упрощает повторное использование и тестирование кода.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
Циклическая конструкция в примере показывает повторяемую обработку элементов или шагов алгоритма.
Транзакционный блок фиксирует границу атомарной операции: изменения либо применяются целиком, либо откатываются.
Ключевые вызовы во фрагменте (useTransaction, block, commit, catch) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.

Использование:

dataSource.connection.use { conn ->
    conn.useTransaction {
        val users = prepareStatement("SELECT id, name FROM users")
            .executeQuery()
            .use { rs -> rs.mapRow { User(getLong("id"), getString("name")!!) } }
        // ...
    }
}

Разбор:

Фрагмент показывает исполняемый сценарий: здесь важен порядок шагов и состояние между вызовами.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
use {} автоматически закрывает ресурс в конце блока и защищает от утечек соединений/потоков.
Транзакционный блок фиксирует границу атомарной операции: изменения либо применяются целиком, либо откатываются.
Ключевые вызовы во фрагменте (prepareStatement, executeQuery, User, getLong) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.
Границы блоков в фигурных скобках помогают сразу увидеть области видимости и жизненный цикл локальных переменных.

Такой подход уже ближе к идиоматичному Kotlin — безопасность ресурсов, лаконичность, читаемость. Однако он по-прежнему требует написания SQL вручную и не решает проблему маппинга "таблица ↔ объект" при сложных схемах.

6. Паттерны проектирования для работы с данными

Качественное приложение разделяет ответственности между уровнями. В работе с БД выделяют следующие паттерны:

DAO (Data Access Object)

Изолирует логику доступа к данным от бизнес-логики. Каждый DAO отвечает за одну сущность и предоставляет методы вроде findById, save, delete.

interface UserDao {
    fun findById(id: Long): User?
    fun save(user: User): User
    fun delete(id: Long)
}

Разбор:

Фрагмент строит структуру типов: объявления классов/интерфейсов задают контракт и модель данных.
fun выделяет именованные блоки логики, что упрощает повторное использование и тестирование кода.
Ключевые вызовы во фрагменте (findById, save, delete) формируют основной поток выполнения и обмена данными.
Границы блоков в фигурных скобках помогают сразу увидеть области видимости и жизненный цикл локальных переменных.
Фрагмент полезно читать сверху вниз: каждая строка подготавливает контекст для следующего шага.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

Реализация может использовать JDBC, Exposed или любой другой инструмент. Преимущество — простота тестирования (можно подменить реализацией на in-memory базе или моке).

Repository

Более высокоуровневый, чем DAO. Repository работает с агрегатами (группами связанных сущностей), поддерживает критерии поиска (спецификации), кэширование, пагинацию. Часто используется в DDD (Domain-Driven Проектирование).

interface UserRepository : CrudRepository<User, Long> {
    fun findByEmail(email: String): User?
    fun findActive(page: Int, size: Int): Page<User>
}

Разбор:

Фрагмент строит структуру типов: объявления классов/интерфейсов задают контракт и модель данных.
fun выделяет именованные блоки логики, что упрощает повторное использование и тестирование кода.
Ключевые вызовы во фрагменте (findByEmail, findActive) формируют основной поток выполнения и обмена данными.
Границы блоков в фигурных скобках помогают сразу увидеть области видимости и жизненный цикл локальных переменных.
Фрагмент полезно читать сверху вниз: каждая строка подготавливает контекст для следующего шага.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

Spring Data предоставляет такую абстракцию "из коробки", но её можно реализовать и самостоятельно.

Unit of Work

Паттерн, отслеживающий изменения в объектах в течение одного логического действия (например, одного HTTP-запроса) и применяющий их в рамках одной транзакции. Hibernate реализует его через Session, Exposed — через Transaction.

Преимущество: избегается частичное обновление состояния при ошибке в середине операции.

7. SQL-мапперы — баланс контроля и удобства

SQL-мапперы сохраняют прямой контроль над SQL, но автоматизируют сопоставление результата с Kotlin-объектами.

KotliQuery

Лёгкая библиотека, построенная поверх JDBC, с поддержкой DSL для построения запросов и типобезопасного маппинга.

Пример:

val users = sessionOf(dataSource).use { session ->
    session.list("SELECT id, name FROM users WHERE active = ?") {
        bind(true)
        map { row -> User(row.long("id"), row.string("name")) }
    }
}

Разбор:

Фрагмент показывает исполняемый сценарий: здесь важен порядок шагов и состояние между вызовами.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
use {} автоматически закрывает ресурс в конце блока и защищает от утечек соединений/потоков.
Ключевые вызовы во фрагменте (sessionOf, list, bind, User) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.
Границы блоков в фигурных скобках помогают сразу увидеть области видимости и жизненный цикл локальных переменных.

Особенности:

Поддержка NamedParameterJdbcTemplate-подобного синтаксиса (WHERE active = :active);
Интеграция с HikariCP;
Совместимость с корутинами (асинхронная версия — asyncSessionOf);
Минимальный оверхед.

JDBI

Более зрелое решение от разработчиков Dropwizard. Использует аннотации и интерфейсы:

@RegisterRowMapper(UserMapper::class)
interface UserDao {
    @SqlQuery("SELECT * FROM users WHERE id = :id")
    fun findById(@Bind("id") id: Long): User?

    @SqlUpdate("INSERT INTO users (name, email) VALUES (:name, :email)")
    @GetGeneratedKeys
    fun insert(@BindBean user: User): Long
}

Разбор:

Фрагмент строит структуру типов: объявления классов/интерфейсов задают контракт и модель данных.
fun выделяет именованные блоки логики, что упрощает повторное использование и тестирование кода.
Ключевые вызовы во фрагменте (RegisterRowMapper, SqlQuery, findById, Bind) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.
Границы блоков в фигурных скобках помогают сразу увидеть области видимости и жизненный цикл локальных переменных.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

Преимущества JDBI:

Чёткое разделение интерфейса и реализации;
Поддержка плагинов (например, для Kotlin data-классов);
Гибкость: можно комбинировать аннотации и программное построение запросов.

Оба подхода хороши, когда:

требуется полный контроль над SQL (оптимизация, оконные функции, CTE);
схема БД не меняется часто;
команда владеет SQL на продвинутом уровне.

8. ORM — зачем нужна абстракция над SQL?

ORM (Object-Relational Mapping) решает фундаментальную проблему impedance mismatch — несоответствие между реляционной моделью (таблицы, нормализация, внешние ключи) и объектной моделью (иерархии, наследование, полиморфизм, поведение).

Основные функции ORM:

декларативное описание сущностей (аннотации или DSL);
автоматическая генерация DDL (миграции, схемы);
CRUD-операции без написания SQL;
ленивая и жадная загрузка связей;
кэширование (1st/2nd level);
управление транзакциями на уровне бизнес-операций.

Важно: ORM не заменяет знание SQL. Наоборот — эффективное использование ORM требует понимания, какой SQL он генерирует. Антипаттерн "N+1 selects" (множественные запросы при итерации по коллекции связанных сущностей) — прямое следствие непонимания этого.

Hibernate/JPA в Kotlin

Hibernate остаётся самым распространённым ORM в JVM-мире. С Kotlin он совместим, но требует аккуратности:

data-классы должны быть open (Hibernate использует прокси-наследование);
свойства — var, иначе невозможно изменение через reflection;
аннотации из javax.persistence или jakarta.persistence.

Пример:

@Entity
@Table(name = "users")
open class User(
    @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
    var id: Long? = null,

    @Column(nullable = false)
    var name: String = "",

    @ManyToOne(fetch = FetchType.LAZY)
    var department: Department? = null
)

Разбор:

Фрагмент строит структуру типов: объявления классов/интерфейсов задают контракт и модель данных.
var используется там, где состояние действительно меняется во времени, например при обновлении данных.
Ключевые вызовы во фрагменте (Table, User, GeneratedValue, Column) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.
Фрагмент полезно читать сверху вниз: каждая строка подготавливает контекст для следующего шага.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

Минусы:

тяжёлый runtime (инициализация, метаданные);
сложный конфигурационный файл (persistence.xml);
ограничения Kotlin (необходимость open, var) снижают преимущества языка.

Отсюда возникает потребность в Kotlin-first ORM.

9. Exposed — лёгкий, типобезопасный, Kotlin-нативный ORM

Exposed (разрабатывается JetBrains) — это типобезопасный DSL для SQL, сочетающий два режима работы:

DAO API — классический ORM-стиль с наследованием от Entity;
SQL DSL API — программное построение запросов с компиляционной проверкой типов.

Архитектурные особенности

Полностью написан на Kotlin;
Не требует reflection — работает через встроенные DSL и extension-функции;
Поддерживает транзакции через transaction { };
Совместим с корутинами (через suspendedTransactionAsync);
Поддерживает основные СУБД — PostgreSQL, MySQL, SQLite, H2, Oracle, SQL Server.

Описание схемы — типобезопасно

Схема описывается как объект, наследующий Table:

object Users : Table() {
    val id = long("id").autoIncrement().primaryKey()
    val name = varchar("name", length = 50)
    val email = varchar("email", length = 100).uniqueIndex()
    val createdAt = datetime("created_at").defaultExpression(CurrentDateTime())
}

Разбор:

Фрагмент показывает исполняемый сценарий: здесь важен порядок шагов и состояние между вызовами.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
Ключевые вызовы во фрагменте (Table, long, autoIncrement, primaryKey) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.
Границы блоков в фигурных скобках помогают сразу увидеть области видимости и жизненный цикл локальных переменных.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

Компилятор проверяет:

наличие столбца при обращении: Users.name;
совместимость типов: Users.name eq "Иван" — валидно, Users.id eq "abc" — ошибка на этапе компиляции.

Выполнение запросов (SQL DSL)

val users = Users.selectAll().where { Users.name eq "Иван" }.toList()
val count = Users.slice(Users.id.count()).selectAll().where { Users.createdAt greaterEq oneWeekAgo }.single()[Users.id.count()]

Разбор:

Фрагмент показывает исполняемый сценарий: здесь важен порядок шагов и состояние между вызовами.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
Ключевые вызовы во фрагменте (selectAll, toList, slice, count) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.
Границы блоков в фигурных скобках помогают сразу увидеть области видимости и жизненный цикл локальных переменных.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

Преимущества DSL:

запросы строятся программно — легко параметризовать, переиспользовать части;
безопасность от SQL-инъекций (все значения передаются как параметры);
подсказки IDE и автодополнение работают на полную мощность.

DAO API (Entity-based)

Код ITЗагрузка примера кода…

Разбор:

Фрагмент строит структуру типов: объявления классов/интерфейсов задают контракт и модель данных.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
var используется там, где состояние действительно меняется во времени, например при обновлении данных.
Ключевые вызовы во фрагменте (User, LongEntity, refresh) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.
Границы блоков в фигурных скобках помогают сразу увидеть области видимости и жизненный цикл локальных переменных.

DAO API удобен для CRUD, но менее гибок при сложных выборках. Рекомендуется использовать SQL DSL как основной инструмент, а DAO — для простых операций.

Производительность и ограничения

Exposed генерирует минимальный, читаемый SQL — близкий к написанному вручную;
Нет overhead-а на reflection или proxy;
Ограничения:
- Нет встроенной поддержки миграций (используются Flyway/Liquibase отдельно);
- Нет вторичного кэша;
- Ленивая загрузка связей не поддерживается — только жадная (join вручную или через with-конструкции).

Exposed идеален для:

микросервисов;
приложений с умеренной сложностью домена;
проектов, где важна прозрачность SQL и контроль над запросами.

10. Ktorm — ORM с функциональным уклоном

Ktorm — это ORM, спроектированный с акцентом на иммутабельность, выразительность DSL и чистоту функционального подхода. В отличие от Exposed, он не предоставляет DAO-стиль с изменяемыми сущностями, а строит всю работу вокруг неизменяемых data-классов и декларативных запросов.

Философия и ключевые принципы

Иммутабельность по умолчанию
Все сущности — это data class с val, а не var. Изменения осуществляются через copy(), что исключает побочные эффекты и упрощает рассуждение о состоянии.
Типобезопасный SQL DSL без reflection
Ktorm строит запросы, используя вложенные лямбды и extension-функции. Все операции проверяются на этапе компиляции — типы столбцов, совместимость выражений, наличие полей.
Минимальная зависимость от runtime
Нет необходимости в байткоде-манипуляциях, прокси или аннотациях. Всё — через Kotlin-код.
Поддержка функциональных паттернов
Запросы можно компоновать, частично применять, кэшировать как значения, передавать как параметры.

Описание схемы — таблицы и столбцы

Схема определяется через объекты, представляющие таблицы. Каждый столбец — это экземпляр Column<T>:

object Users : Table<Nothing>("users") {
    val id = int("id").primaryKey()
    val name = varchar("name")
    val email = varchar("email")
    val createdAt = datetime("created_at")
}

Разбор:

Фрагмент показывает исполняемый сценарий: здесь важен порядок шагов и состояние между вызовами.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
Ключевые вызовы во фрагменте (int, primaryKey, varchar, datetime) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.
Границы блоков в фигурных скобках помогают сразу увидеть области видимости и жизненный цикл локальных переменных.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

Обратите внимание: Table<Nothing> — так как Ktorm не привязывает таблицу к конкретному классу сущности. Связь устанавливается отдельно.

Сущности

data class User(
    val id: Int,
    val name: String,
    val email: String,
    val createdAt: LocalDateTime
)

Разбор:

Фрагмент строит структуру типов: объявления классов/интерфейсов задают контракт и модель данных.
data class автоматически генерирует методы сравнения и копирования, поэтому модель удобна для DTO и сериализации.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
Ключевые вызовы во фрагменте (User) формируют основной поток выполнения и обмена данными.
Фрагмент полезно читать сверху вниз: каждая строка подготавливает контекст для следующего шага.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

Нет наследования, нет прокси, нет open/var. Это чистая Kotlin-модель.

Отображение — Row Mapper

Сопоставление строки результата и сущности задаётся явно через rowMapper:

val User.mapper: RowMapper<User> = { row ->
    User(
        id = row[Users.id],
        name = row[Users.name],
        email = row[Users.email],
        createdAt = row[Users.createdAt]
    )
}

Разбор:

Фрагмент показывает исполняемый сценарий: здесь важен порядок шагов и состояние между вызовами.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
Ключевые вызовы во фрагменте (User) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.
Границы блоков в фигурных скобках помогают сразу увидеть области видимости и жизненный цикл локальных переменных.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

Метод row[column] типобезопасен: компилятор знает, что row[Users.id] возвращает Int, а не Any?.

Запросы

Пример выборки:

val users = database.from(Users).select().map { it.mapper }.toList()

Разбор:

Фрагмент показывает исполняемый сценарий: здесь важен порядок шагов и состояние между вызовами.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
Ключевые вызовы во фрагменте (from, select, toList) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.
Границы блоков в фигурных скобках помогают сразу увидеть области видимости и жизненный цикл локальных переменных.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

Фильтрация и сортировка:

val activeUsers = database
    .from(Users)
    .select()
    .where { Users.createdAt greaterEq oneWeekAgo }
    .orderBy(Users.name.asc())
    .map { it.mapper }
    .toList()

Разбор:

Фрагмент показывает исполняемый сценарий: здесь важен порядок шагов и состояние между вызовами.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
Ключевые вызовы во фрагменте (from, select, orderBy, asc) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.
Границы блоков в фигурных скобках помогают сразу увидеть области видимости и жизненный цикл локальных переменных.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

Сложные запросы с JOIN:

val query = database
    .from(Users.join(Departments, JoinType.INNER, Users.departmentId eq Departments.id))
    .select(Users.name, Departments.name)
    .where { Users.active eq true }

val results = query.map { row ->
    UserWithDept(
        userName = row[Users.name],
        deptName = row[Departments.name]
    )
}.toList()

Разбор:

Фрагмент показывает исполняемый сценарий: здесь важен порядок шагов и состояние между вызовами.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
join объединяет данные из нескольких таблиц в одном запросе и уменьшает число отдельных походов в БД.
Ключевые вызовы во фрагменте (from, join, select, UserWithDept) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.
Границы блоков в фигурных скобках помогают сразу увидеть области видимости и жизненный цикл локальных переменных.

Особенность — join() возвращает новую виртуальную таблицу, составленную из нескольких, и к ней можно применять select(), where(), groupBy().

Вставка и обновление

Ktorm не предоставляет save() или update() на уровне сущности — только декларативные операторы:

Код ITЗагрузка примера кода…

Разбор:

Фрагмент показывает исполняемый сценарий: здесь важен порядок шагов и состояние между вызовами.
Ключевые вызовы во фрагменте (insert, set, now, update) формируют основной поток выполнения и обмена данными.
Границы блоков в фигурных скобках помогают сразу увидеть области видимости и жизненный цикл локальных переменных.
Фрагмент полезно читать сверху вниз: каждая строка подготавливает контекст для следующего шага.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

Это ближе к SQL, но с гарантией типобезопасности. Отсутствие "магического" save() снижает риск неявных изменений.

Продвинутые возможности

Подзапросы: Users.id inSubQuery { ... };
Агрегаты — count(), sum(), avg(), groupBy;
Оконные функции: rowNumber().over { partitionBy(Users.departmentId).orderBy(Users.salary.desc()) };
Кастомные функции: регистрация собственных SQL-функций;
Пакетные операции: insertAndGenerateKey { ... }, batchInsert, batchUpdate.

Производительность и ограничения

Плюсы:
- Отсутствие reflection → быстрая инициализация;
- Генерируемый SQL предсказуем и оптимизируем;
- Полная совместимость с корутинами (можно оборачивать withContext(Dispatchers.IO));
- Лёгкий вес: ~500 KB JAR без зависимостей.
Минусы:
- Нет встроенной поддержки миграций;
- Нет кэширования;
- Отсутствие автоматической поддержки связей "один-ко-многим" (нужно вручную писать JOIN или постобработку);
- Менее зрелая документация по сравнению с Exposed (на 2025 год — активно развивается, но сообщество меньше).

Когда выбирать Ktorm?

Когда приоритет — чистота архитектуры, иммутабельность, функциональный стиль;
В системах, где доменная модель строится на алгебраических типах данных (sealed classes, Result<T>);
При интенсивном использовании корутин и реактивных потоков (Ktorm легко интегрируется с Flow);
В проектах, где разработчики предпочитают явное управление запросами, а не "магию" ORM.

11. Сравнение

Критерий	Exposed	Ktorm	Hibernate (JPA)
Парадигма	Гибрид: DAO + SQL DSL	Функциональный DSL	Объектно-ориентированный ORM
Сущности	Изменяемые (`var`, `open`)	Неизменяемые (`val`, `data class`)	Изменяемые (`var`, `open`, прокси)
Типобезопасность	Высокая (DSL), частичная (DAO)	Очень высокая (всё в DSL)	Умеренная (аннотации → runtime-ошибки)
Reflection	Нет (DSL), есть (DAO через `by`)	Нет	Да (интенсивно)
Производительность инициализации	Низкая (мгновенная)	Низкая	Высокая (метамодель, прокси)
Сложность SQL-генерации	Простой, прозрачный	Простой, прозрачный	Сложный, часто требует оптимизации
Ленивая загрузка	Нет	Нет	Да
2nd-level cache	Нет	Нет	Да (через Ehcache, Infinispan)
Миграции	Нет (сторонние: Flyway)	Нет (Flyway/Liquibase)	Да (Hibernate SchemaUpdate, но не для production)
Поддержка корутин	`suspendedTransactionAsync`	Через `withContext(Dispatchers.IO)`	Нет (требуется `@Transactional(propagation = REQUIRES_NEW)` + адаптеры)
Обучение	Легко (если знаешь SQL)	Средне (нужен функциональный mindset)	Сложно (много концепций: Session, Persistence Context, Flush)
Сообщество	Крупное (JetBrains, Spring Boot интеграции)	Растущее (активные maintainer’ы, но меньше adoption)	Очень крупное (стандарт де-факто)

Рекомендации по выбору:

Стартап / микросервис / PoC → Exposed (быстро, просто, легко уйти вручную при росте).
Финтех / аналитика / ETL / функциональная архитектура → Ktorm (иммутабельность, композируемость, прозрачность).
Корпоративное enterprise-приложение с комплексной моделью (наследование, полиморфизм, аудит) → Hibernate (неизбежность legacy-совместимости, поддержка инструментов, зрелые паттерны).

Примечание: в одном проекте можно комбинировать подходы. Например, Exposed/Ktorm для основного домена, а JDBC напрямую — для аналитических запросов с CTE и оконными функциями.

11.1 Быстрый выбор подхода под задачу

Когда стек ещё не выбран, полезно начать с простого дерева решений.

Ситуация в проекте	Что взять первым шагом
Нужно запустить API за 1–2 дня и сохранить данные	Exposed SQL DSL + Flyway
Команда сильно опирается на SQL и оптимизацию запросов	JDBC/JDBI + HikariCP
Много сложных связей и enterprise-инфраструктуры	Hibernate/JPA
KMP-клиент и общий слой данных между платформами	SQLDelight + `kotlinx.serialization`

Через 2–3 спринта обычно уже видно, нужно ли усложнять уровень абстракции.

12. Работа с NoSQL в Kotlin

Хотя Kotlin чаще ассоциируется с реляционными БД, он отлично подходит и для NoSQL.

MongoDB

Официальный драйвер mongodb-driver-kotlin (от MongoDB Inc.) предоставляет корутин-совместимый API:

Код ITЗагрузка примера кода…

Разбор:

Фрагмент показывает исполняемый сценарий: здесь важен порядок шагов и состояние между вызовами.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
Ключевые вызовы во фрагменте (insertOne, documentOf, listOf, fromRegistries) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.
Фрагмент полезно читать сверху вниз: каждая строка подготавливает контекст для следующего шага.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

Можно использовать KMongo — обёртку с улучшенным DSL и поддержкой data-классов "из коробки".

Redis

Для кэширования и быстрых операций — Lettuce или Redisson:

val redis = RedisClient.create("redis://localhost")
val conn = redis.connect()
val sync = conn.sync()

sync.set("user:101:name", "Елена")
val name = sync.get("user:101:name")

Разбор:

Фрагмент показывает исполняемый сценарий: здесь важен порядок шагов и состояние между вызовами.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
Ключевые вызовы во фрагменте (create, connect, sync, set) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.
Фрагмент полезно читать сверху вниз: каждая строка подготавливает контекст для следующего шага.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

Асинхронная версия — conn.async(), реактивная — conn.reactive().

Для типобезопасности — сериализация через kotlinx.serialization:

val json = Json.encodeToString(user)
sync.set("user:101", json)
val restored = Json.decodeFromString<User>(sync.get("user:101")!!)

Разбор:

Фрагмент показывает исполняемый сценарий: здесь важен порядок шагов и состояние между вызовами.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
Ключевые вызовы во фрагменте (encodeToString, set, get) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.
Фрагмент полезно читать сверху вниз: каждая строка подготавливает контекст для следующего шага.
В практическом коде этот шаблон обычно оборачивают обработкой ошибок и проверкой входных данных.

Гибридные архитектуры

Часто применяется:

PostgreSQL — для транзакционных данных (заказы, пользователи);
Redis — для сессий, рейт-лимитов, кэша;
Elasticsearch/MongoDB — для поиска и аналитики.

Kotlin позволяет унифицировать обработку через абстракции:

Код ITЗагрузка примера кода…

Разбор:

Фрагмент строит структуру типов: объявления классов/интерфейсов задают контракт и модель данных.
fun выделяет именованные блоки логики, что упрощает повторное использование и тестирование кода.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
if выполняет проверку условия и направляет выполнение в соответствующую ветку.
Корутины в этом фрагменте показывают неблокирующий стиль: поток не простаивает во время ожиданий.
Интерполяция ${...} или $name в строках делает вывод компактным и избавляет от ручной конкатенации.
Ключевые вызовы во фрагменте (findById, save, PostgresUserRepository, CachedUserRepository) формируют основной поток выполнения и обмена данными.

13. Практики

Миграции — Flyway и Liquibase

Kotlin не имеет встроенного инструмента миграций, но интегрируется со всеми основными.

Flyway (SQL-ориентированный):

миграции — .sql-файлы: V1__create_users.sql, V2__add_email_index.sql;
запуск через Flyway.configure().dataSource(...).load().migrate().

Liquibase (XML/YAML/JSON):

декларативные изменения: <addColumn tableName="users">...;
поддержка генерации diff между состояниями.

Можно писать миграции на Kotlin (через kotlin-script или kotlinc), но это редкость — предпочтителен SQL для прозрачности.

Безопасность

SQL-инъекции: у Exposed и Ktorm — невозможны благодаря параметризации. В JDBC — только PreparedStatement, никогда конкатенация строк.
Утечки данных: избегайте логирования ResultSet или User(password = "..."). Используйте @JsonIgnore или кастомные toString() в data-классах.
Права доступа — учётные записи приложения должны иметь минимальные привилегии (только на нужные таблицы, без DROP, CREATE, GRANT).

SELECT/INSERT/UPDATE/DELETE

Разбор:

Фрагмент задаёт базовый набор SQL-операций, с которыми работает приложение на уровне хранилища.
Команды перечислены явно, поэтому политика прав доступа может ограничиваться только нужными действиями.
Такой набор операций обычно выполняется через параметризованные запросы в PreparedStatement или DSL ORM.
Разделение SELECT и модифицирующих команд помогает проектировать отдельные сценарии чтения и записи.
Этот блок выступает как краткая спецификация контракта между приложением и таблицами БД.

Тестирование

Unit-тесты — моки репозиториев (Mockk, Mockito-Kotlin).
Интеграционные тесты:
- Testcontainers — запуск реальной СУБД в Docker-контейнере;
- H2 in-memory — для простых случаев (но помните: синтаксис H2 ≠ PostgreSQL);
- Transactional rollback — каждый тест оборачивается в транзакцию, которая откатывается после завершения.

Пример с Testcontainers:

Код ITЗагрузка примера кода…

Разбор:

Фрагмент строит структуру типов: объявления классов/интерфейсов задают контракт и модель данных.
fun выделяет именованные блоки логики, что упрощает повторное использование и тестирование кода.
val фиксирует ссылку после инициализации и делает поведение участка более предсказуемым.
var используется там, где состояние действительно меняется во времени, например при обновлении данных.
Транзакционный блок фиксирует границу атомарной операции: изменения либо применяются целиком, либо откатываются.
Ключевые вызовы во фрагменте (start, setup, connect, transaction) формируют основной поток выполнения и обмена данными.
Операции присваивания связывают вычисленные значения с переменными и делают промежуточные шаги явно читаемыми.

Дополнительные сниппеты

suspend fun createUserIfMissing(repo: UserRepository, user: User): User {
    val existing = repo.findById(user.id)
    if (existing != null) return existing
    repo.save(user)
    return user
}

Разбор:

Функция объединяет сценарий чтения и записи в одном месте и формирует чёткий контракт поведения.
suspend показывает, что вызовы репозитория могут быть асинхронными и выполняться в корутинном контексте.
Переменная existing хранит результат первой проверки и позволяет принять решение без повторного запроса.
Ранний return упрощает поток выполнения: удачный путь и путь вставки разделены явно.
Шаблон полезен для idempotent-операций, где повторный вызов не должен создавать дубликаты.

transaction(db) {
    val insertedId = Users.insertAndGetId {
        it[name] = "Новый пользователь"
        it[email] = "new@example.com"
    }
    println("Создан пользователь с id=$insertedId")
}

Разбор:

Блок transaction(db) задаёт атомарную границу операции вставки и защищает целостность данных.
insertAndGetId добавляет запись и сразу возвращает первичный ключ созданной строки.
DSL it[name] = ... и it[email] = ... делает маппинг колонок прозрачным прямо в месте вставки.
Вывод идентификатора в лог полезен для трассировки и быстрой диагностики в интеграционных тестах.
Такой сниппет хорошо ложится в слой репозитория как базовая операция create.

Связанные материалы

Ktor Server — где слой данных подключается в API
Корутины — правильный Dispatchers.IO и отмена задач
Тестирование — unit/integration подходы
Коллекции и Sequence — модели и преобразования в памяти

Основа по протоколу

Базовый разбор HTTP и HTTPS находится в отдельной статье — HTTP как основа веб-интеграций.

Работа с базами данных в Kotlin​

1. Работа с файлами в Kotlin​

2. Работа с данными в памяти​

3. Работа с базами данных​

4. Взаимодействие с СУБД​

5. Низкоуровневая работа — JDBC и его ограничения в Kotlin-контексте​

Как работает типичный JDBC-запрос​

Пулы соединений​

Kotlin-расширения для облегчения JDBC​

6. Паттерны проектирования для работы с данными​

DAO (Data Access Object)​

Repository​

Unit of Work​

7. SQL-мапперы — баланс контроля и удобства​

KotliQuery​

JDBI​

8. ORM — зачем нужна абстракция над SQL?​

Hibernate/JPA в Kotlin​

9. Exposed — лёгкий, типобезопасный, Kotlin-нативный ORM​

Архитектурные особенности​

Описание схемы — типобезопасно​

Выполнение запросов (SQL DSL)​

DAO API (Entity-based)​

Производительность и ограничения​

10. Ktorm — ORM с функциональным уклоном​

Философия и ключевые принципы​

Описание схемы — таблицы и столбцы​

Сущности​

Отображение — Row Mapper​

Запросы​

Вставка и обновление​

Продвинутые возможности​

Производительность и ограничения​

Когда выбирать Ktorm?​

11. Сравнение​

11.1 Быстрый выбор подхода под задачу​

12. Работа с NoSQL в Kotlin​

MongoDB​

Redis​

Гибридные архитектуры​

13. Практики​

Миграции — Flyway и Liquibase​

Безопасность​

Тестирование​

Дополнительные сниппеты​

Связанные материалы​

См. также

История языка Kotlin

Экосистема Kotlin-приложений

Что требуется знать перед началом изучения языка программирования Kotlin

Рекомендации по разработке на Kotlin

Основы языка Kotlin

Типы данных и объявление переменных в Kotlin

Операторы и выражения в Kotlin

Циклы и управляющие конструкции в Kotlin

Объектно-ориентированное программирование в Kotlin

Синтаксис и пунктуация в Kotlin

Ключевые слова языка Kotlin

Встроенные функции и расширения Kotlin

Работа с базами данных в Kotlin

1. Работа с файлами в Kotlin

2. Работа с данными в памяти

3. Работа с базами данных

4. Взаимодействие с СУБД

5. Низкоуровневая работа — JDBC и его ограничения в Kotlin-контексте

Как работает типичный JDBC-запрос

Пулы соединений

Kotlin-расширения для облегчения JDBC

6. Паттерны проектирования для работы с данными

DAO (Data Access Object)

Repository

Unit of Work

7. SQL-мапперы — баланс контроля и удобства

KotliQuery

JDBI

8. ORM — зачем нужна абстракция над SQL?

Hibernate/JPA в Kotlin

9. Exposed — лёгкий, типобезопасный, Kotlin-нативный ORM

Архитектурные особенности

Описание схемы — типобезопасно

Выполнение запросов (SQL DSL)

DAO API (Entity-based)

Производительность и ограничения

10. Ktorm — ORM с функциональным уклоном

Философия и ключевые принципы

Описание схемы — таблицы и столбцы

Сущности

Отображение — Row Mapper

Запросы

Вставка и обновление

Продвинутые возможности

Производительность и ограничения

Когда выбирать Ktorm?

11. Сравнение

11.1 Быстрый выбор подхода под задачу

12. Работа с NoSQL в Kotlin

MongoDB

Redis

Гибридные архитектуры

13. Практики

Миграции — Flyway и Liquibase

Безопасность

Тестирование

Дополнительные сниппеты

Связанные материалы