Kotlin Academy · Lezione

Configurazione di Exposed: connessione al database e DSL delle transazioni

Si connetta a un database, configuri Exposed ed esegua il codice all'interno delle transazioni.

Configurazione di Exposed: connessione al database e DSL delle transazioni è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Che cos'è Exposed

Exposed è un framework SQL leggero di JetBrains per Kotlin. Offre due livelli: una Query DSL (espressioni SQL type-safe) e un DAO layer (entità in stile Active Record). Entrambi vengono eseguiti all'interno di transazioni esplicite.

Aggiunta delle dipendenze di Exposed

Aggiunga il core, il bridge per il driver JDBC e il driver del database:

dependencies {
    implementation("org.jetbrains.exposed:exposed-core:0.52.0")
    implementation("org.jetbrains.exposed:exposed-jdbc:0.52.0")
    implementation("org.jetbrains.exposed:exposed-dao:0.52.0")
    implementation("com.h2database:h2:2.2.224") // or postgresql driver
    implementation("com.zaxxer:HikariCP:5.1.0")  // connection pooling
}

Connessione al database

Chiami Database.connect() una volta all'avvio. In produzione, passi un HikariDataSource; per i test è sufficiente un semplice URL JDBC:

import org.jetbrains.exposed.sql.Database

// Simple (dev/test)
Database.connect(
    url = "jdbc:h2:mem:test;DB_CLOSE_DELAY=-1",
    driver = "org.h2.Driver"
)

// Production with HikariCP
Database.connect(HikariDataSource(HikariConfig().apply {
    jdbcUrl = "jdbc:postgresql://localhost/mydb"
    username = "user"
    password = "pass"
    maximumPoolSize = 10
}))

Il blocco transaction { }

Tutte le operazioni di Exposed devono essere eseguite all'interno di un blocco transaction { }. Exposed esegue il commit in caso di successo e il rollback in presenza di qualsiasi eccezione non gestita:

transaction {
    // all DB operations here
    SchemaUtils.create(Users)
}

Transazioni compatibili con le coroutine

Utilizzi newSuspendedTransaction { } da exposed-r2dbc oppure exposed-spring-boot-starter per transazioni compatibili con le coroutine. In Ktor, racchiuda le chiamate bloccanti a Exposed in withContext(Dispatchers.IO) { transaction { ... } }:

suspend fun findUser(id: Long): User? = withContext(Dispatchers.IO) {
    transaction {
        UserEntity.findById(id)?.toUser()
    }
}

SchemaUtils: creazione ed eliminazione delle tabelle

Utilizzi SchemaUtils.create(Table1, Table2) per creare le tabelle se non esistono e SchemaUtils.drop() per eliminarle. Chiami queste funzioni all'interno di un blocco transaction { } all'avvio dell'applicazione:

transaction {
    SchemaUtils.create(Users, Posts, Comments)
}

Configurazione di una connessione in Ktor

Inizializzi il database in un modulo Application, in modo che venga eseguito una sola volta all'avvio del server:

fun Application.configureDatabase() {
    val dbUrl = environment.config.property("ktor.database.url").getString()
    Database.connect(dbUrl, driver = "org.postgresql.Driver",
        user = "...", password = "...")
    transaction { SchemaUtils.create(Users) }
}

Livelli di isolamento delle transazioni

Passi un livello di isolamento a transaction() quando sono necessarie garanzie di coerenza più o meno forti:

transaction(Connection.TRANSACTION_SERIALIZABLE) {
    // serializable isolation
}

Transazioni annidate

Per impostazione predefinita, le chiamate annidate a transaction { } si uniscono alla transazione esterna. Per ottenere una transazione indipendente, utilizzi transaction(db, outerTransactionIsEmpty = false) { } oppure un savepoint.

Logging SQL

Abiliti il logging SQL per visualizzare le query generate durante lo sviluppo. Imposti un StdOutSqlLogger o un logger personalizzato all'interno del blocco della transazione:

transaction {
    addLogger(StdOutSqlLogger)
    // ...
}

Buone pratiche per il pooling delle connessioni

In produzione utilizzi sempre HikariCP o una soluzione analoga. Imposti maximumPoolSize in base al numero di thread del server e connectionTimeout per interrompere rapidamente l'attesa quando il pool è esaurito. Monitori l'utilizzo del pool in produzione.

Verifica rapida

Che cosa accade se all'interno di un blocco transaction { } di Exposed viene generata un'eccezione non gestita?

Riepilogo: configurazione di Exposed e DSL delle transazioni

Punti chiave:

Si connetta con Database.connect() una volta all'avvio (in produzione utilizzi HikariCP)
Esegua tutte le operazioni sul DB all'interno di transaction { }: commit in caso di successo e rollback in caso di eccezione
Crei o elimini le tabelle con SchemaUtils.create() all'interno di una transazione
Nei contesti coroutine, racchiuda le chiamate bloccanti a Exposed in withContext(Dispatchers.IO)
Durante lo sviluppo abiliti StdOutSqlLogger per esaminare l'SQL generato

Domande Frequenti

La lezione «Configurazione di Exposed: connessione al database e DSL delle transazioni» è gratuita?

Sì — il testo completo di «Configurazione di Exposed: connessione al database e DSL delle transazioni» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «Configurazione di Exposed: connessione al database e DSL delle transazioni»?

Si connetta a un database, configuri Exposed ed esegua il codice all'interno delle transazioni. Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Configurazione di Exposed: connessione al database e DSL delle transazioni»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?

Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Configurazione di Exposed: connessione al database e DSL delle transazioni
Definire le tabelle con la DSL Table
CRUD con la DSL Query: insert, select, update, delete
DAO di Exposed: classi Entity e relazioni

← Torna a Kotlin Academy