Arbeit mit Datenbanken in Kotlin: PostgreSQL und MongoDB

Online Python-Trainer für Anfänger

Lernen Sie Python einfach ohne theoretische Überlastung. Lösen Sie praktische Aufgaben mit automatischer Überprüfung und schreiben Sie Code direkt im Browser.

Kurs starten

Einführung: Warum Kotlin für die Arbeit mit Datenbanken?

Kotlin ist eine moderne, statisch typisierte Sprache, die vollständig mit Java kompatibel ist und aktiv für die Entwicklung von Backend-Anwendungen eingesetzt wird. Dank der prägnanten Syntax, Null-Sicherheit und leistungsstarken Tools ist Kotlin ideal für die Arbeit mit relationalen (PostgreSQL) und dokumentenorientierten (MongoDB) Datenbanken. In diesem Artikel analysieren wir praktische Beispiele für die Verbindung, die Durchführung von CRUD-Operationen und die Abfrageoptimierung.

Wir betrachten zwei beliebte Bibliotheken: Exposed (für PostgreSQL) und KMongo (für MongoDB). Sie lernen, wie Sie die Umgebung einrichten, effiziente Abfragen schreiben und häufige Fehler vermeiden.

1. Arbeiten mit PostgreSQL über Exposed

Exposed ist eine ORM-Bibliothek für Kotlin, die zwei APIs bereitstellt: DSL (Domain-Specific Language) zum Schreiben von Abfragen im SQL-Stil und DAO (Data Access Object) für einen objektorientierten Ansatz. Schauen wir uns beide Optionen an.

1.1. Verbindung und Einrichtung

Fügen Sie Abhängigkeiten zu build.gradle.kts 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.5.0")}

Verbindung zur Datenbank herstellen:

import org.jetbrains.exposed.sql.Databaseimport org.jetbrains.exposed.sql.transactions.transaction

fun main() {    Database.connect(        url = "jdbc:postgresql://localhost:5432/mydb",        driver = "org.postgresql.Driver",        user = "user",        password = "password"    )    println("Verbindung zu PostgreSQL hergestellt")}

1.2. Erstellen einer Tabelle und CRUD-Operationen (DSL)

Definieren wir die Tabelle Users:

import org.jetbrains.exposed.sql.Tableimport org.jetbrains.exposed.sql.insertimport org.jetbrains.exposed.sql.selectAllimport org.jetbrains.exposed.sql.update

object Users : Table() {    val id = integer("id").autoIncrement()    val name = varchar("name", 50)    val email = varchar("email", 100).uniqueIndex()    override val primaryKey = PrimaryKey(id)}

Führen wir CRUD-Operationen durch:

transaction {    // Tabelle erstellen    SchemaUtils.create(Users)

    // INSERT    Users.insert {        it[name] = "Alexey"        it[email] = "alex@example.com"    }

    // SELECT    val users = Users.selectAll().map {        "${it[Users.id]}: ${it[Users.name]} (${it[Users.email]})"    }    println(users)

    // UPDATE    Users.update({ Users.id eq 1 }) {        it[name] = "Alexey Ivanov"    }

    // DELETE (mit deleteWhere)    Users.deleteWhere { Users.id eq 2 }}

1.3. DAO-Ansatz

Erstellen wir eine Entität und eine DAO-Klasse:

import org.jetbrains.exposed.dao.IntEntityimport org.jetbrains.exposed.dao.IntEntityClassimport org.jetbrains.exposed.dao.id.EntityIDimport org.jetbrains.exposed.dao.id.IntIdTable

object UsersDAO : IntIdTable() {    val name = varchar("name", 50)    val email = varchar("email", 100)}

class User(id: EntityID<Int>) : IntEntity(id) {    companion object : IntEntityClass<User>(UsersDAO)    var name by UsersDAO.name    var email by UsersDAO.email}

// Verwendungtransaction {    val newUser = User.new {        name = "Maria"        email = "maria@example.com"    }    println("Benutzer erstellt mit ID: ${newUser.id.value}")}

2. Arbeiten mit MongoDB über KMongo

KMongo ist ein coroutine-orientierter Treiber für MongoDB, der auf dem offiziellen Java-Treiber aufbaut. Er unterstützt die Serialisierung über kotlinx.serialization und Jackson.