Scala för backendutveckling och funktionell programmering · Lektion

Anslut med en transactor

Konfigurera åtkomst till databasen.

Lektion 1 av 413 steg

Anslut med en transactor är en gratis lektion i Scala för backendutveckling och funktionell programmering på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Scala för backendutveckling och funktionell programmering, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 4 lektioner.

Vad är en Transactor?

Doobie är ett funktionellt JDBC-lager för Scala. En Transactor[F] är bryggan mellan Doobies rena program och en verklig databasanslutning.

En Transactor vet hur den ska anskaffa en JDBC-Connection, köra ert program i en transaktion och frigöra resurser på ett säkert sätt.

Den parametriseras med en effekttyp F[_], till exempel cats.effect.IO.

import doobie._
import cats.effect.IO

val xa: Transactor[IO] = ???

ConnectionIO-programmet

Doobie-frågor är värden av typen ConnectionIO[A]. De beskriver en beräkning som behöver en JDBC-anslutning men ännu inte körs.

Ni bygger dessa program rent och lämnar sedan över dem till en Transactor för körning. Ingenting berör databasen förrän ni kör programmet.

import doobie.implicits._

val program: ConnectionIO[Int] =
  sql"select 42".query[Int].unique

DriverManagerTransactor

Den enklaste Transactor är Transactor.fromDriverManager. Den öppnar en helt ny anslutning för varje transaktion med JDBC:s DriverManager.

Den behöver drivrutinsklassens namn, JDBC-URL, användarnamn och lösenord. Den passar bra för tester och skript men har ingen anslutningspool.

val xa = Transactor.fromDriverManager[IO](
  driver = "org.postgresql.Driver",
  url = "jdbc:postgresql://localhost:5432/app",
  user = "postgres",
  password = "secret",
  logHandler = None
)

Köra ett program

För att köra en ConnectionIO anropar ni .transact(xa). Det ger en F[A], här en IO[A].

Transactor omsluter programmet i en transaktion: den genomför en commit vid framgång och gör rollback vid fel, och frigör anslutningen i båda fallen.

import doobie.implicits._

val result: IO[Int] =
  sql"select 42".query[Int].unique.transact(xa)

Poolning med HikariCP

I produktion behöver ni en anslutningspool. Doobie levereras med HikariTransactor, som bygger på HikariCP.

Den skapas som en Resource så att poolen stängs korrekt. Ni skickar också med en execution context för blockerande JDBC-operationer.

import doobie.hikari.HikariTransactor
import cats.effect.IO

val xaRes: Resource[IO, HikariTransactor[IO]] =
  HikariTransactor.newHikariTransactor[IO](
    "org.postgresql.Driver",
    "jdbc:postgresql://localhost/app",
    "postgres", "secret",
    connectEC
  )

Varför en Resource?

En poolad Transactor äger långlivat tillstånd: öppna anslutningar och bakgrundstrådar. Resource[F, A] garanterar att anskaffning och frigöring hör ihop även vid fel eller avbrytning.

Vanligtvis bygger ni Transactor en gång vid uppstart och återanvänder den under hela applikationens livstid.

xaRes.use { xa =>
  program.transact(xa)
}

connectEC-poolen

HikariCP behöver en ExecutionContext för att vänta på anslutningar från poolen. Doobie tillhandahåller ExecutionContexts.fixedThreadPool för detta, och även den är en Resource.

Genom att hålla den åtskild från beräkningspoolen förhindrar ni att blockerande anskaffning av anslutningar svälter CPU-bundet arbete.

import doobie.util.ExecutionContexts

val poolRes =
  for {
    ec <- ExecutionContexts.fixedThreadPool[IO](8)
    xa <- HikariTransactor.newHikariTransactor[IO](
            "org.postgresql.Driver", url, user, pass, ec)
  } yield xa

Konfigurera en befintlig DataSource

Om ni redan har en konfigurerad javax.sql.DataSource (till exempel en finjusterad Hikari-instans) kan ni omsluta den direkt med Transactor.fromDataSource.

Detta är vanligt när ett ramverk hanterar poolen och ni bara vill att Doobie ska använda den.

val xa = Transactor.fromDataSource[IO](
  dataSource = myDataSource,
  connectEC = connectEC
)

Röktesta anslutningen

En enkel hälsokontroll är att köra select 1 genom Transactor. Om den returnerar fungerar drivrutin, URL och autentiseringsuppgifter.

Detta är ett bra första steg innan ni kopplar in riktiga frågor.

val check: IO[Int] =
  sql"select 1".query[Int].unique.transact(xa)

// check.unsafeRunSync() == 1

Transactors interna delar: Strategy

En Transactor byggs av interpreters och en Strategy. Strategin styr vad som händer runt varje transaktion: before, after, oops (vid fel) och always.

Standardstrategin stänger av auto-commit, genomför commit efter framgång, gör rollback vid fel och stänger alltid anslutningen.

import doobie.util.transactor.Strategy

val noCommit = xa.copy(
  strategy0 = Strategy.default.copy(after = doobie.free.connection.unit)
)

Loggning och observerbarhet

Doobie kan logga varje sats, dess argument och tidsåtgång. Moderna versioner kopplar en LogHandler[F] till varje fråga i stället för till varje Transactor.

Detta är ovärderligt för att upptäcka långsamma frågor och verifiera parameterbindning i produktion.

import doobie.util.log._

val handler: LogHandler[IO] = (ev: LogEvent) =>
  IO.println(ev.sql)

Snabbkontroll

Testa er förståelse av Transactors.

Besvara frågan i den interaktiva lektionen

Sammanfattning

En Transactor[F] kopplar rena ConnectionIO-program till en verklig databas. fromDriverManager passar för tester, medan HikariTransactor och fromDataSource passar i produktion med poolning.

Bygg poolade Transactors som en Resource, kör program med .transact(xa) och låt standardstrategin hantera commit, rollback och städning.

Gratis att börja

Lär dig Scala med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 39
Lektioner: 143

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Anslut med en transactor” gratis?

Ja – hela texten till ”Anslut med en transactor” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Scala för backendutveckling och funktionell programmering, kan Ni uppgradera till CoddyKit PRO. Kursen i Scala för backendutveckling och funktionell programmering innehåller totalt 4 lektioner.

Vad lär jag mig i ”Anslut med en transactor”?

Konfigurera åtkomst till databasen. Ni övar på Scala för backendutveckling och funktionell programmering med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Scala för backendutveckling och funktionell programmering?

Du behöver inga förkunskaper. Utbildningen i Scala för backendutveckling och funktionell programmering på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Anslut med en transactor”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Scala för backendutveckling och funktionell programmering-lektionen?

Ja. Varje Scala för backendutveckling och funktionell programmering-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Scala för backendutveckling och funktionell programmering