Arbeit mit Datenbanken in Kotlin: PostgreSQL und MongoDB

Einleitung: Warum Kotlin und Datenbanken ein ideales Paar sind

Kotlin ist eine moderne, statisch typisierte Sprache, die auf der JVM läuft. Dank seiner prägnanten Syntax, Null-Sicherheit (null safety) und vollständigen Kompatibilität mit Java ist Kotlin zu einer der am schnellsten wachsenden Sprachen für die Backend-Entwicklung geworden. In diesem Artikel werden wir untersuchen, wie man eine Verbindung zu zwei populären DBMS herstellt und CRUD-Operationen durchführt: dem relationalen PostgreSQL und dem dokumentenorientierten MongoDB.

Wir werden zwei Hauptansätze betrachten: die Verwendung der Bibliothek Exposed für SQL und des Frameworks KMongo für die Arbeit mit MongoDB. Alle Codebeispiele sind in reinem Kotlin geschrieben und bereit zur Ausführung.

1. Arbeiten mit PostgreSQL über die Bibliothek Exposed

1.1. Abhängigkeiten konfigurieren

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

dependencies {    implementation("org.jetbrains.exposed:exposed-core:0.44.0")    implementation("org.jetbrains.exposed:exposed-dao:0.44.0")    implementation("org.jetbrains.exposed:exposed-jdbc:0.44.0")    implementation("org.postgresql:postgresql:42.6.0")    implementation("com.zaxxer:HikariCP:5.0.1")}

HikariCP ist ein leistungsstarker Connection-Pool, den wir zur Verwaltung der Datenbankverbindungen verwenden werden.

1.2. Verbindung zur Datenbank herstellen

Erstellen wir ein Objekt zur Verwaltung der Verbindung:

import com.zaxxer.hikari.HikariConfigimport com.zaxxer.hikari.HikariDataSourceimport org.jetbrains.exposed.sql.Database

object DatabaseFactory {    fun init() {        val config = HikariConfig().apply {            driverClassName = "org.postgresql.Driver"            jdbcUrl = "jdbc:postgresql://localhost:5432/my_db"            username = "user"            password = "password"            maximumPoolSize = 10            isAutoCommit = false        }

        val dataSource = HikariDataSource(config)        Database.connect(dataSource)    }}

1.3. Tabellen definieren und CRUD-Operationen

Exposed verwendet einen DSL-Stil zur Beschreibung von Tabellen. Definieren wir eine einfache Benutzertabelle:

import org.jetbrains.exposed.sql.Tableimport org.jetbrains.exposed.sql.*import org.jetbrains.exposed.sql.transactions.transaction

object Users : Table() {    val id = integer("id").autoIncrement()    val name = varchar("name", 100)    val email = varchar("email", 255).uniqueIndex()

    override val primaryKey = PrimaryKey(id)}

// Daten einfügenfun insertUser(name: String, email: String) {    transaction {        Users.insert {            it[Users.name] = name            it[Users.email] = email        }    }}

// Alle Benutzer lesenfun getAllUsers(): List<ResultRow> {    return transaction {        Users.selectAll().toList()    }}

// E-Mail aktualisierenfun updateUserEmail(id: Int, newEmail: String) {    transaction {        Users.update({ Users.id eq id }) {            it[email] = newEmail        }    }}

// Benutzer löschenfun deleteUser(id: Int) {    transaction {        Users.deleteWhere { Users.id eq id }    }}

1.4. Besonderheiten von Exposed

• Transaktionen: Alle Operationen werden innerhalb eines transaction-Blocks ausgeführt.
• Typsicherheit: Fehler in SQL-Abfragen werden zur Kompilierzeit abgefangen.
• Migrationen: Exposed unterstützt die automatische Tabellenerstellung über SchemaUtils.create(Users).

2. Arbeiten mit MongoDB über KMongo

2.1. Abhängigkeiten konfigurieren

Fügen Sie in build.gradle.kts hinzu:

dependencies {    implementation("org.litote.kmongo:kmongo-coroutine:4.9.0")    implementation("org.litote.kmongo:kmongo-id:4.9.0")}<