Arbeit mit Datenbanken in Kotlin: PostgreSQL und MongoDB in der Praxis

Einleitung: Warum Kotlin eine hervorragende Wahl für die Arbeit mit Datenbanken ist

Kotlin, als moderne und prägnante Programmiersprache, bietet Entwicklern leistungsstarke Werkzeuge für die Interaktion mit verschiedenen Datenbanken. Dank der vollständigen Kompatibilität mit Java und einer eigenen Bibliotheksökosystem ermöglicht Kotlin das Schreiben von sicherem, ausdrucksstarkem und performantem Code für die Arbeit mit sowohl relationalen (SQL) als auch dokumentenorientierten (NoSQL) Speichern.

In diesem Artikel werden wir anhand praktischer Beispiele die Einbindung und Durchführung von CRUD-Operationen (Create, Read, Update, Delete) für zwei beliebte Datenbankmanagementsysteme behandeln: PostgreSQL (relational) und MongoDB (dokumentenbasiert). Sie erfahren, wie Sie ein Projekt einrichten, moderne Bibliotheken (Exposed für SQL und KMongo für MongoDB) verwenden und sauberen Code unter Berücksichtigung der Besonderheiten von Kotlin schreiben.

1. Arbeiten mit PostgreSQL in Kotlin: Verwendung der Bibliothek Exposed

Für die Arbeit mit relationalen Datenbanken in Kotlin gibt es mehrere Ansätze. Wir betrachten die Bibliothek Exposed – einen leichtgewichtigen ORM-Wrapper, der in Kotlin geschrieben ist und eine typsichere DSL (Domain-Specific Language) zur Erstellung von SQL-Abfragen bereitstellt.

1.1. Einbinden der Abhängigkeiten

Fügen Sie in die Datei build.gradle.kts die folgenden Abhängigkeiten hinzu:

dependencies {    implementation("org.jetbrains.exposed:exposed-core:0.41.1")    implementation("org.jetbrains.exposed:exposed-dao:0.41.1")    implementation("org.jetbrains.exposed:exposed-jdbc:0.41.1")    implementation("org.postgresql:postgresql:42.6.0")    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3")}

1.2. Erstellen einer Tabelle und Verbindung zur Datenbank

Definieren wir die Entität "Benutzer" und die entsprechende Tabelle im Code:

import org.jetbrains.exposed.sql.*import org.jetbrains.exposed.sql.transactions.transactionimport org.jetbrains.exposed.sql.SqlExpressionBuilder.eq

// Tabelle definierenobject Users : Table() {    val id = integer("id").autoIncrement()    val name = varchar("name", 255)    val email = varchar("email", 255).uniqueIndex()

    override val primaryKey = PrimaryKey(id)}

// Data class für Benutzerdata class User(val id: Int, val name: String, val email: String)

fun main() {    // Verbindung zur Datenbank    Database.connect(        url = "jdbc:postgresql://localhost:5432/mydb",        driver = "org.postgresql.Driver",        user = "postgres",        password = "password"    )

    // Tabelle erstellen (falls nicht vorhanden)    transaction {        SchemaUtils.create(Users)    }}

1.3. CRUD-Operationen

Nun implementieren wir die grundlegenden Operationen zum Erstellen, Lesen, Aktualisieren und Löschen von Datensätzen:

fun createUser(name: String, email: String): User {    return transaction {        val insertId = Users.insert {            it[Users.name] = name            it[Users.email] = email        } get Users.id

        User(            id = insertId,            name = name,            email = email        )    }}

fun readUserById(id: Int): User? {    return transaction {        Users.selectAll().where { Users.id eq id }            .singleOrNull()            ?.let { row ->                User(                    id = row[Users.id],                    name = row[Users.name],                    email = row[Users.email]                )            }    }}

fun updateUserEmail(id: Int, newEmail: String) {    transaction {        Users.update({ Users.id eq id }) {            it[email] = newEmail        }    }}

fun deleteUser(id: Int) {    transaction {        Users.deleteWhere { Users.id eq id }    }}

Dank Exposed wird der Kotlin-Code prägnant und typsicher. Fehler in Spalten- oder Tabellennamen werden