Kotlin、Ktor、Exposed によるデータベースの統合
コード例: tutorial-server-db-integration
使用プラグイン: Static Contentスタイルシート、スクリプト、画像などの静的コンテンツを配信する方法を学びます。、 Content NegotiationContentNegotiation プラグインには、主に2つの目的があります。クライアントとサーバー間でのメディアタイプのネゴシエーション、および特定の形式でのコンテンツのシリアライズ/デシリアライズです。、Status PagesStatusPages により、Ktor アプリケーションはスローされた例外やステータスコードに基づいて、あらゆる障害状態に適切に応答できるようになります。、 kotlinx.serializationContentNegotiation プラグインには、主に2つの目的があります。クライアントとサーバー間でのメディアタイプのネゴシエーション、および特定の形式でのコンテンツのシリアライズ/デシリアライズです。、 Dependency Injection必要な依存関係: io.ktor:ktor-server-di、 Exposed、 PostgreSQL
この記事では、Kotlin 向けの SQL ライブラリである Exposed を使用して、Ktor サービスをリレーショナルデータベースと統合する方法を学びます。
このチュートリアルを終えるまでに、以下の方法を習得できます。
- JSON シリアライゼーションを使用する RESTful サービスを作成する。
- これらのサービスにさまざまなリポジトリを注入(Inject)する。
- インメモリリポジトリを使用してサービスの単体テストを作成する。
- Exposed と依存性注入(DI)を使用して実用的なリポジトリを構築する。
- 外部データベースにアクセスするサービスをデプロイする。
以前のチュートリアルでは、タスクマネージャーの例を使用して、リクエストの処理、RESTful API の作成、Thymeleaf テンプレートを使用した Web アプリの構築などの基本事項を扱いました。
それらのチュートリアルではシンプルなインメモリの TaskRepository を使用してフロントエンド機能に焦点を当てていましたが、本ガイドでは、Exposed SQL ライブラリを通じて Ktor サービスがリレーショナルデータベースとどのようにやり取りできるかに焦点を移します。
本ガイドは以前のものより長くて複雑ですが、すぐに動作するコードを作成し、段階的に新機能を導入していきます。
本ガイドは以下の2つのパートで構成されています。
前提条件
このチュートリアルは単独で進めることも可能ですが、コンテンツネゴシエーションと REST に慣れるために、事前に RESTful API の作成 チュートリアルを完了しておくことをお勧めします。
IntelliJ IDEA のインストールを推奨しますが、お好みの他の IDE を使用することも可能です。
RESTful サービスとインメモリリポジトリの作成
まず、タスクマネージャーの RESTful サービスを再作成します。最初はインメモリリポジトリを使用しますが、最小限の手間で置き換えられるような設計で構造化します。
これには以下の6つのステージがあります。
プラグインを含めた新規プロジェクトの作成
Ktor Project Generator で新しいプロジェクトを作成するには、以下の手順に従ってください。
Ktor Project Generator にアクセスします。
Project artifact フィールドに、プロジェクトのアーティファクト名として
com.example.ktor-exposed-task-appと入力します。
プラグインセクションで、Add ボタンをクリックして以下のプラグインを検索し、追加します。
- Content Negotiation
- kotlinx.serialization
- Static Content
- Status Pages
- Dependency Injection
- Exposed
- PostgreSQL

プラグインを追加したら、プラグインセクションの右上にある 7 plugins ボタンをクリックして、追加されたプラグインを確認します。
プロジェクトに追加されるすべてのプラグインのリストが表示されます。

Download ボタンをクリックして、Ktor プロジェクトを生成してダウンロードします。
生成されたプロジェクトを IntelliJ IDEA またはお好みの IDE で開きます。
src/main/kotlin に移動し、CitySchema.kt、UsersService.kt、GreetingService.kt、Postgres.kt ファイルを削除します。
Exposed.kt ファイルを開き、
.configureExposed()関数の内容を削除します:kotlinsuspend fun Application.configureExposed() { }この機能を削除する理由は、Ktor Project Generator がユーザーや都市に関するデータを HSQLDB や PostgreSQL に永続化する方法を示すサンプルコードを追加したためです。このチュートリアルでは、そのサンプルコードは必要ありません。
gradle/libs.versions.toml ファイルを開き、最新の Exposed バージョンが指定されていることを確認します。
kotlin[versions] #... exposed = 1.6.0
スターターコードの追加
src/main/kotlin に移動し、model というサブパッケージを作成します。
model パッケージ内に、新しい Task.kt ファイルを作成します。
Task.kt を開き、優先度を表す enum とタスクを表すクラスを追加します。
kotlinpackage com.example.model import kotlinx.serialization.Serializable enum class Priority { Low, Medium, High, Vital } @Serializable data class Task( val name: String, val description: String, val priority: Priority )Taskクラスには、kotlinx.serializationライブラリのSerializableアノテーションが付けられています。以前のチュートリアルと同様に、インメモリリポジトリを作成します。ただし今回は、後で簡単に置き換えられるように、リポジトリにインターフェースを実装させます。
model サブパッケージ内に、新しい TaskRepository.kt ファイルを作成します。
TaskRepository.kt を開き、以下のインターフェースを追加します。
kotlinpackage com.example.model interface TaskRepository { fun allTasks(): List<Task> fun tasksByPriority(priority: Priority): List<Task> fun taskByName(name: String): Task? fun addTask(task: Task) fun removeTask(name: String): Boolean }同じディレクトリ内に新しい FakeTaskRepository.kt ファイルを作成します。
FakeTaskRepository.kt を開き、以下のクラスを追加します。
kotlinpackage com.example.model class FakeTaskRepository : TaskRepository { private val tasks = mutableListOf( Task("cleaning", "Clean the house", Priority.Low), Task("gardening", "Mow the lawn", Priority.Medium), Task("shopping", "Buy the groceries", Priority.High), Task("painting", "Paint the fence", Priority.Medium) ) override fun allTasks(): List<Task> = tasks override fun tasksByPriority(priority: Priority) = tasks.filter { it.priority == priority } override fun taskByName(name: String) = tasks.find { it.name.equals(name, ignoreCase = true) } override fun addTask(task: Task) { if (taskByName(task.name) != null) { throw IllegalStateException("Cannot duplicate task names!") } tasks.add(task) } override fun removeTask(name: String): Boolean { return tasks.removeIf { it.name == name } } }
ルートの追加
src/main/kotlin にある Serialization.kt ファイルを開きます。
既存の
Application.configureSerialization()関数を以下の実装に置き換えます。kotlinpackage com.example import com.example.model.Priority import com.example.model.Task import com.example.model.TaskRepository import io.ktor.http.* import io.ktor.serialization.* import io.ktor.serialization.kotlinx.json.* import io.ktor.server.application.* import io.ktor.server.plugins.contentnegotiation.* import io.ktor.server.plugins.di.dependencies import io.ktor.server.request.* import io.ktor.server.response.* import io.ktor.server.routing.* suspend fun Application.configureSerialization() { val repository = dependencies.resolve<TaskRepository>() install(ContentNegotiation) { json() } routing { route("/tasks") { get { val tasks = repository.allTasks() call.respond(tasks) } get("/byName/{taskName}") { val name = call.parameters["taskName"] if (name == null) { call.respond(HttpStatusCode.BadRequest) return@get } val task = repository.taskByName(name) if (task == null) { call.respond(HttpStatusCode.NotFound) return@get } call.respond(task) } get("/byPriority/{priority}") { val priorityAsText = call.parameters["priority"] if (priorityAsText == null) { call.respond(HttpStatusCode.BadRequest) return@get } try { val priority = Priority.valueOf(priorityAsText) val tasks = repository.tasksByPriority(priority) if (tasks.isEmpty()) { call.respond(HttpStatusCode.NotFound) return@get } call.respond(tasks) } catch (ex: IllegalArgumentException) { call.respond(HttpStatusCode.BadRequest) } } post { try { val task = call.receive<Task>() repository.addTask(task) call.respond(HttpStatusCode.NoContent) } catch (ex: IllegalStateException) { call.respond(HttpStatusCode.BadRequest) } catch (ex: JsonConvertException) { call.respond(HttpStatusCode.BadRequest) } } delete("/{taskName}") { val name = call.parameters["taskName"] if (name == null) { call.respond(HttpStatusCode.BadRequest) return@delete } if (repository.removeTask(name)) { call.respond(HttpStatusCode.NoContent) } else { call.respond(HttpStatusCode.NotFound) } } } } }これは、Ktor の依存性注入コンテナからリポジトリを解決している点を除いて、RESTful API の作成チュートリアルで実装したものと同じルーティングです。依存関係の型が
interfaceであるため、さまざまな実装を注入できます。dependencies.resolve()は suspend 関数であるため、.configureSerialization()も suspend として宣言する必要があります。.configureSerialization()に依存関係を追加したため、既存の呼び出しはコンパイルされなくなります。幸いにも、この関数は一度しか呼び出されません。src/main/kotlin 内の DI.kt ファイルを開きます。
.configureDependencyInjection()関数の内容を以下の実装に置き換えます。kotlinimport com.example.model.FakeTaskRepository import com.example.model.TaskRepository // ... fun Application.configureDependencyInjection() { dependencies { provide<TaskRepository> { FakeTaskRepository() } } }これで、
TaskRepositoryの実装としてFakeTaskRepositoryが登録されました。長期的な目標は、これをPostgresTaskRepositoryに置き換えられるようにすることです。src/main/resources フォルダ内にある application.yaml ファイルを開き、
.configureDependencyInjection()関数が.configureSerialization()の前に記述されていることを確認します。yamlktor: deployment: port: 8080 application: modules: - com.example.DIKt.configureDependencyInjection - com.example.SerializationKt.configureSerialization - com.example.ExposedKt.configureExposed - com.example.StatusPagesKt.configureStatusPages - com.example.RoutingKt.configureRouting
クライアントページの追加
src/main/resources/static の index.html ファイルを開きます。
現在の内容を以下の実装に置き換えます。
html<html> <head> <title>A Simple SPA For Tasks</title> <script type="application/javascript"> function displayAllTasks() { clearTasksTable(); fetchAllTasks().then(displayTasks) } function displayTasksWithPriority() { clearTasksTable(); const priority = readTaskPriority(); fetchTasksWithPriority(priority).then(displayTasks) } function displayTask(name) { fetchTaskWithName(name).then(t => taskDisplay().innerHTML = `${t.priority} priority task ${t.name} with description "${t.description}"` ) } function deleteTask(name) { deleteTaskWithName(name).then(() => { clearTaskDisplay(); displayAllTasks(); }) } function deleteTaskWithName(name) { return sendDELETE(`/tasks/${name}`) } function addNewTask() { const task = buildTaskFromForm(); sendPOST("/tasks", task).then(displayAllTasks); } function buildTaskFromForm() { return { name: getTaskFormValue("newTaskName"), description: getTaskFormValue("newTaskDescription"), priority: getTaskFormValue("newTaskPriority") } } function getTaskFormValue(controlName) { return document.addTaskForm[controlName].value; } function taskDisplay() { return document.getElementById("currentTaskDisplay"); } function readTaskPriority() { return document.priorityForm.priority.value } function fetchTasksWithPriority(priority) { return sendGET(`/tasks/byPriority/${priority}`); } function fetchTaskWithName(name) { return sendGET(`/tasks/byName/${name}`); } function fetchAllTasks() { return sendGET("/tasks") } function sendGET(url) { return fetch( url, {headers: {'Accept': 'application/json'}} ).then(response => { if (response.ok) { return response.json() } return []; }); } function sendPOST(url, data) { return fetch(url, { method: 'POST', headers: {'Content-Type': 'application/json'}, body: JSON.stringify(data) }); } function sendDELETE(url) { return fetch(url, { method: "DELETE" }); } function tasksTable() { return document.getElementById("tasksTableBody"); } function clearTasksTable() { tasksTable().innerHTML = ""; } function clearTaskDisplay() { taskDisplay().innerText = "None"; } function displayTasks(tasks) { const tasksTableBody = tasksTable() tasks.forEach(task => { const newRow = taskRow(task); tasksTableBody.appendChild(newRow); }); } function taskRow(task) { return tr([ td(task.name), td(task.priority), td(viewLink(task.name)), td(deleteLink(task.name)), ]); } function tr(children) { const node = document.createElement("tr"); children.forEach(child => node.appendChild(child)); return node; } function td(content) { const node = document.createElement("td"); if (content instanceof Element) { node.appendChild(content) } else { node.appendChild(document.createTextNode(content)); } return node; } function viewLink(taskName) { const node = document.createElement("a"); node.setAttribute( "href", `javascript:displayTask("${taskName}")` ) node.appendChild(document.createTextNode("view")); return node; } function deleteLink(taskName) { const node = document.createElement("a"); node.setAttribute( "href", `javascript:deleteTask("${taskName}")` ) node.appendChild(document.createTextNode("delete")); return node; } </script> </head> <body onload="displayAllTasks()"> <h1>Task Manager Client</h1> <form action="javascript:displayAllTasks()"> <span>View all the tasks</span> <input type="submit" value="Go"> </form> <form name="priorityForm" action="javascript:displayTasksWithPriority()"> <span>View tasks with priority</span> <select name="priority"> <option name="Low">Low</option> <option name="Medium">Medium</option> <option name="High">High</option> <option name="Vital">Vital</option> </select> <input type="submit" value="Go"> </form> <form name="addTaskForm" action="javascript:addNewTask()"> <span>Create new task with</span> <label for="newTaskName">name</label> <input type="text" id="newTaskName" name="newTaskName" size="10"> <label for="newTaskDescription">description</label> <input type="text" id="newTaskDescription" name="newTaskDescription" size="20"> <label for="newTaskPriority">priority</label> <select id="newTaskPriority" name="newTaskPriority"> <option name="Low">Low</option> <option name="Medium">Medium</option> <option name="High">High</option> <option name="Vital">Vital</option> </select> <input type="submit" value="Go"> </form> <hr> <div> Current task is <em id="currentTaskDisplay">None</em> </div> <hr> <table> <thead> <tr> <th>Name</th> <th>Priority</th> <th></th> <th></th> </tr> </thead> <tbody id="tasksTableBody"> </tbody> </table> </body> </html>これは、以前のチュートリアルで使用されたものと同じ SPA です。JavaScript で書かれており、ブラウザ内で利用可能なライブラリのみを使用しているため、クライアント側の依存関係について心配する必要はありません。
アプリケーションの手動テスト
IntelliJ IDEA で実行ボタン (
) をクリックして、アプリケーションを起動します。
ブラウザで http://0.0.0.0:8080/static/index.html にアクセスします。3つのフォームとフィルタリングされた結果を表示するテーブルで構成されるクライアントページが表示されるはずです。

Go ボタンを使用してフォームに入力・送信し、アプリケーションをテストします。テーブル項目の View および Delete ボタンも使用してみてください。

自動単体テストの追加
src/test/kotlin の ServerTest.kt ファイルを開き、以下のテストを追加します。
kotlinpackage com.example import com.example.model.Priority import com.example.model.Task import com.example.model.TaskRepository import io.ktor.client.call.* import io.ktor.client.plugins.contentnegotiation.* import io.ktor.server.plugins.di.dependencies import io.ktor.client.request.* import io.ktor.http.* import io.ktor.serialization.kotlinx.json.* import io.ktor.server.application.* import io.ktor.server.testing.* import kotlin.test.* suspend fun Application.configureTestApp() { dependencies { provide<TaskRepository> { FakeTaskRepository() } } configureSerialization() configureStatusPages() configureRouting() } class ServerTest { @Test fun tasksCanBeFoundByPriority() = testApplication { application { configureTestApp() } val client = createClient { install(ContentNegotiation) { json() } } val response = client.get("/tasks/byPriority/Medium") val results = response.body<List<Task>>() assertEquals(HttpStatusCode.OK, response.status) val expectedTaskNames = listOf("gardening", "painting") val actualTaskNames = results.map(Task::name) assertContentEquals(expectedTaskNames, actualTaskNames) } @Test fun invalidPriorityProduces400() = testApplication { application { configureTestApp() } val response = client.get("/tasks/byPriority/Invalid") assertEquals(HttpStatusCode.BadRequest, response.status) } @Test fun unusedPriorityProduces404() = testApplication { application { configureTestApp() } val response = client.get("/tasks/byPriority/Vital") assertEquals(HttpStatusCode.NotFound, response.status) } @Test fun newTasksCanBeAdded() = testApplication { application { configureTestApp() } val client = createClient { install(ContentNegotiation) { json() } } val task = Task("swimming", "Go to the beach", Priority.Low) val response1 = client.post("/tasks") { header( HttpHeaders.ContentType, ContentType.Application.Json ) setBody(task) } assertEquals(HttpStatusCode.NoContent, response1.status) val response2 = client.get("/tasks") assertEquals(HttpStatusCode.OK, response2.status) val taskNames = response2 .body<List<Task>>() .map { it.name } assertContains(taskNames, "swimming") } }これらのテストをコンパイルして実行するには、Ktor Client 用の Content Negotiation プラグインへの依存関係を追加する必要があります。
build.gradle.kts ファイルを開き、以下の依存関係を追加します。
kotlindependencies { //... testImplementation(ktorLibs.client.contentNegotiation) }IntelliJ IDEA で、エディターの右側にある Gradle 通知アイコン (
) をクリックして Gradle の変更を読み込みます。
IntelliJ IDEA で、テストクラス定義の横にある実行ボタン (
) をクリックしてテストを実行します。
Run ペインにテストが正常に実行されたことが表示されます。

PostgreSQL リポジトリの追加
インメモリデータを使用する動作可能なアプリケーションができたので、次のステップとしてデータストレージを PostgreSQL データベースに外出しします。
これは以下の手順で行います。
- PostgreSQL 内にデータベーススキーマを作成する。
- 非同期アクセス用に
TaskRepositoryを適合させる。 - アプリケーション内でデータベース接続を設定する。
Task型を関連付けられたデータベーステーブルにマッピングする。- マッピングに基づいた新しいリポジトリを作成する。
- 起動コードで新しいリポジトリに切り替える。
データベーススキーマの作成
お好みのデータベース管理ツールを使用して、PostgreSQL 内に新しいデータベースを作成します。 名前は覚えていられれば何でもかまいません。この例では、
ktor_tutorial_dbを使用します。PostgreSQL の詳細については、公式ドキュメントを参照してください。
IntelliJ IDEA では、データベースツールを利用して PostgreSQL データベースへの接続と管理を行うことができます。
データベースに対して以下の SQL コマンドを実行します。これらのコマンドによって、データベーススキーマが作成され、データが投入されます。
sqlDROP TABLE IF EXISTS task; CREATE TABLE task(id SERIAL PRIMARY KEY, name VARCHAR(50), description VARCHAR(50), priority VARCHAR(50)); INSERT INTO task (name, description, priority) VALUES ('cleaning', 'Clean the house', 'Low'); INSERT INTO task (name, description, priority) VALUES ('gardening', 'Mow the lawn', 'Medium'); INSERT INTO task (name, description, priority) VALUES ('shopping', 'Buy the groceries', 'High'); INSERT INTO task (name, description, priority) VALUES ('painting', 'Paint the fence', 'Medium'); INSERT INTO task (name, description, priority) VALUES ('exercising', 'Walk the dog', 'Medium'); INSERT INTO task (name, description, priority) VALUES ('meditating', 'Contemplate the infinite', 'High');以下の点に注意してください。
name、description、priorityのカラムを持つtaskという単一のテーブルを作成しています。これらはTaskクラスのプロパティにマッピングする必要があります。- 既に存在する場合はテーブルを再作成するようにしているため、スクリプトを繰り返し実行できます。
SERIAL型のidという追加のカラムがあります。これは各行に主キーを付与するために使用される整数値です。これらの値はデータベースによって自動的に割り当てられます。
既存リポジトリの適合
データベースに対してクエリを実行する際は、HTTP リクエストを処理するスレッドのブロックを回避するために、非同期で実行することが望まれます。Kotlin では、これは コルーチン を使用して最適に管理されます。
src/main/kotlin/model の TaskRepository.kt ファイルを開きます。
すべてのインターフェースメソッドに
suspendキーワードを追加します。kotlininterface TaskRepository { suspend fun allTasks(): List<Task> suspend fun tasksByPriority(priority: Priority): List<Task> suspend fun taskByName(name: String): Task? suspend fun addTask(task: Task) suspend fun removeTask(name: String): Boolean }これにより、インターフェースメソッドの実装が別のコルーチンディスパッチャ上で処理を開始できるようになります。
ここで、
FakeTaskRepositoryのメソッドもこれに合わせて調整する必要があります(その実装内ではディスパッチャを切り替える必要はありませんが)。FakeTaskRepository.kt ファイルを開き、すべてのメソッドに
suspendキーワードを追加します。kotlinclass FakeTaskRepository : TaskRepository { //... override suspend fun allTasks(): List<Task> = tasks override suspend fun tasksByPriority(priority: Priority) = tasks.filter { //... } override suspend fun taskByName(name: String) = tasks.find { //... } override suspend fun addTask(task: Task) { //... } override suspend fun removeTask(name: String): Boolean { //... } }ここまでは、新しい機能は導入していません。代わりに、データベースに対して非同期にクエリを実行する
PostgresTaskRepositoryを作成するための土台を整えました。
データベース接続の設定
このチュートリアルの最初のパートで、Exposed.kt にあった .configureExposed() 関数のサンプルコードを削除しました。これで、独自の実装を追加する準備が整いました。
DAO 型のサポートは Ktor Project Generator によって追加されていないため、まず Gradle ビルドファイルに関連する依存関係を追加する必要があります。
gradle/libs.versions.toml ファイルに、
exposed-jdbcとexposed-daoライブラリを追加します。toml[libraries] exposed-jdbc = { module = "org.jetbrains.exposed:exposed-jdbc", version.ref = "exposed" } exposed-dao = { module = "org.jetbrains.exposed:exposed-dao", version.ref = "exposed" }これにより、Exposed Data Access Object(DAO)パターンを操作できるようになります。
build.gradle.kts ファイルに、以下の依存関係を追加します。
kotlindependencies { // ... implementation(libs.exposed.jdbc) implementation(libs.exposed.dao) }必要なトランスポートモジュールは
exposed-jdbcまたはexposed-r2dbcのいずれか1つのみです。Ktor プロジェクトジェネレーターによってexposed-r2dbcへの依存関係が追加されている場合は、次に進む前に削除してください。IntelliJ IDEA で、エディターの右側にある Gradle 通知アイコン (
) をクリックして Gradle の変更を読み込みます。
src/main/kotlin の Exposed.kt ファイルを開きます。
Database.connect()関数を使用してデータベースに接続し、環境に合わせて設定の値を調整します。kotlinsuspend fun Application.configureExposed() { Database.connect( "jdbc:postgresql://localhost:5432/ktor_tutorial_db", user = "postgres", password = "password" ) }urlには以下のコンポーネントが含まれている点に注意してください。localhost:5432は、PostgreSQL データベースが実行されているホストとポートです。ktor_tutorial_dbは、サービスの実行時に作成されるデータベースの名前です。
詳細については、Working with Databases in Exposed を参照してください。
オブジェクト/リレーショナルマッピングの作成
src/main/kotlin に移動し、db という新しいパッケージを作成します。
db パッケージ内に、新しい mapping.kt ファイルを作成します。
mapping.kt を開き、型
TaskTableとTaskDAOを追加します。kotlinpackage com.example.db import org.jetbrains.exposed.v1.core.dao.id.EntityID import org.jetbrains.exposed.v1.core.dao.id.IntIdTable import org.jetbrains.exposed.v1.dao.IntEntity import org.jetbrains.exposed.v1.dao.IntEntityClass object TaskTable : IntIdTable("task") { val name = varchar("name", 50) val description = varchar("description", 50) val priority = varchar("priority", 50) } class TaskDAO(id: EntityID<Int>) : IntEntity(id) { companion object : IntEntityClass<TaskDAO>(TaskTable) var name by TaskTable.name var description by TaskTable.description var priority by TaskTable.priority }これらの型は Exposed ライブラリを使用して、
Task型のプロパティをデータベースのtaskテーブルのカラムにマッピングします。TaskTable型は基本的なマッピングを定義し、TaskDAO型はタスクの作成、検索、更新、削除を行うヘルパーメソッドを追加します。同じ mapping.kt ファイルに、以下のヘルパー関数を追加します。
kotlinpackage com.example.db import com.example.model.Priority import com.example.model.Task import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.withContext import org.jetbrains.exposed.v1.core.dao.id.EntityID import org.jetbrains.exposed.v1.core.dao.id.IntIdTable import org.jetbrains.exposed.v1.dao.IntEntity import org.jetbrains.exposed.v1.dao.IntEntityClass import org.jetbrains.exposed.v1.jdbc.JdbcTransaction import org.jetbrains.exposed.v1.jdbc.transactions.inTopLevelSuspendTransaction object TaskTable : IntIdTable("task") { val name = varchar("name", 50) val description = varchar("description", 50) val priority = varchar("priority", 50) } class TaskDAO(id: EntityID<Int>) : IntEntity(id) { companion object : IntEntityClass<TaskDAO>(TaskTable) var name by TaskTable.name var description by TaskTable.description var priority by TaskTable.priority } suspend fun <T> withTransaction(block: suspend JdbcTransaction.() -> T): T = withContext(Dispatchers.IO) { inTopLevelSuspendTransaction { block() } } fun daoToModel(dao: TaskDAO) = Task( dao.name, dao.description, Priority.valueOf(dao.priority) )withTransaction()関数は、新しいトップレベルのデータベーストランザクション内でサスペンドブロックを実行します。コルーチンコンテキストはDispatchers.IOに切り替えられるため、ブロッキングな JDBC 操作は I/O タスク用に最適化されたスレッドプール上で実行されます。daoToModel()関数は、TaskDAO型のインスタンスをTaskオブジェクトに変換します。
不足している以下のインポートを追加します。
kotlinimport com.example.model.Priority import com.example.model.Task import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.withContext import org.jetbrains.exposed.v1.jdbc.JdbcTransaction import org.jetbrains.exposed.v1.jdbc.transactions.inTopLevelSuspendTransaction
新しいリポジトリの作成
これで、データベース固有のリポジトリを作成するために必要なリソースがすべて揃いました。
src/main/kotlin/model に移動し、新しい PostgresTaskRepository.kt ファイルを作成します。
PostgresTaskRepository.kt ファイルを開き、以下の実装で新しい型を作成します。
kotlinpackage com.example.model import com.example.db.TaskDAO import com.example.db.TaskTable import com.example.db.daoToModel import com.example.db.withTransaction import org.jetbrains.exposed.v1.core.eq import org.jetbrains.exposed.v1.jdbc.deleteWhere class PostgresTaskRepository : TaskRepository { override suspend fun allTasks(): List<Task> = withTransaction { TaskDAO.all().map(::daoToModel) } override suspend fun tasksByPriority(priority: Priority): List<Task> = withTransaction { TaskDAO .find { (TaskTable.priority eq priority.toString()) } .map(::daoToModel) } override suspend fun taskByName(name: String): Task? = withTransaction { TaskDAO .find { (TaskTable.name eq name) } .limit(1) .map(::daoToModel) .firstOrNull() } override suspend fun addTask(task: Task): Unit = withTransaction { TaskDAO.new { name = task.name description = task.description priority = task.priority.toString() } } override suspend fun removeTask(name: String): Boolean = withTransaction { val rowsDeleted = TaskTable.deleteWhere { TaskTable.name eq name } rowsDeleted == 1 } }この実装では、
TaskDAOおよびTaskTable型のヘルパーメソッドを使用してデータベースとやり取りします。この新しいリポジトリを作成した後の残りの作業は、ルート内でこれを使用するように切り替えることだけです。
新しいリポジトリへの切り替え
外部データベースに切り替えるには、リポジトリの型を変更するだけです。
src/main/kotlin の DI.kt ファイルを開きます。
Application.configureDependencyInjection()関数内で、FakeTaskRepositoryをPostgresTaskRepositoryに置き換えます。kotlin//... import com.example.model.PostgresTaskRepository //... fun Application.configureDependencyInjection() { dependencies { provide<TaskRepository> { PostgresTaskRepository() } } }インターフェースを介して依存関係を注入しているため、実装の切り替えはルート管理コードに対して透過的です。
IntelliJ IDEA で再実行ボタン (
) をクリックして、アプリケーションを再起動します。
http://0.0.0.0:8080/static/index.html にアクセスします。UI は変わりませんが、データはデータベースから取得されるようになります。
これを確認するには、フォームを使用して新しいタスクを追加し、PostgreSQL の tasks テーブルに保持されているデータをクエリします。
IntelliJ IDEA では、クエリコンソールと
SELECTSQL ステートメントを使用してテーブルデータをクエリできます。sqlSELECT * FROM task;クエリを実行すると、新しいタスクを含め、データが Service ペインに表示されるはずです。

これで、アプリケーションへのデータベースの統合が正常に完了しました。
FakeTaskRepository 型は本番コードでは不要になったため、src/test のテストソースセットに移動できます。
最終的なプロジェクト構造は以下のようになります。

次のステップ
これで、Ktor RESTful サービスと通信するアプリケーションが完成しました。このサービスはさらに Exposed で記述されたリポジトリを使用して PostgreSQL にアクセスします。また、Web サーバーやデータベースを必要とせずにコア機能を検証する 一連のテスト も用意されています。
この構造は必要に応じて任意の機能をサポートするように拡張できますが、まずは耐障害性、セキュリティ、スケーラビリティなどの設計の非機能面を考慮することをお勧めします。まずは、データベース接続設定を抽出する ことで 設定ファイル に移動することから始めるとよいでしょう。
