Scala for Backend Engineering & Functional Programming · Pelajaran

Menghubungkan dengan Transactor

Siapkan akses basis data.

Menghubungkan dengan Transactor adalah pelajaran Scala for Backend Engineering & Functional Programming gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Scala for Backend Engineering & Functional Programming, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Scala for Backend Engineering & Functional Programming mencakup 4 pelajaran total.

Apa Itu Transactor?

Doobie adalah lapisan JDBC fungsional murni untuk Scala. Transactor[F] adalah jembatan antara program murni Doobie dan koneksi basis data nyata.

Transactor mengetahui cara memperoleh Connection JDBC, menjalankan program Anda dalam transaksi, dan melepaskan resource dengan aman.

Transactor diparameterkan oleh tipe efek F[_] seperti cats.effect.IO.

import doobie._
import cats.effect.IO

val xa: Transactor[IO] = ???

Program ConnectionIO

Kueri Doobie adalah nilai bertipe ConnectionIO[A]. Kueri tersebut mendeskripsikan komputasi yang memerlukan koneksi JDBC, tetapi belum dijalankan.

Anda membangun program ini secara murni, lalu menyerahkannya kepada Transactor untuk dieksekusi. Tidak ada yang menyentuh basis data sampai Anda menjalankannya.

import doobie.implicits._

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

DriverManagerTransactor

Transactor paling sederhana adalah Transactor.fromDriverManager. Transactor ini membuka koneksi baru untuk setiap transaksi menggunakan DriverManager JDBC.

Transactor ini memerlukan nama kelas driver, URL JDBC, nama pengguna, dan kata sandi. Transactor ini cocok untuk pengujian dan skrip, tetapi tidak memiliki pengumpulan koneksi.

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

Menjalankan Program

Untuk mengeksekusi ConnectionIO, Anda memanggil .transact(xa). Hasilnya adalah F[A], dalam contoh ini IO[A].

Transactor membungkus program dalam transaksi: melakukan commit saat berhasil dan rollback saat gagal, serta melepaskan koneksi dalam kedua keadaan.

import doobie.implicits._

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

Pengumpulan dengan HikariCP

Untuk produksi, Anda memerlukan pengumpulan koneksi. Doobie menyediakan HikariTransactor yang didukung oleh HikariCP.

Transactor ini dibuat sebagai Resource agar kumpulan koneksi dapat dihentikan dengan benar. Anda juga meneruskan konteks eksekusi untuk operasi JDBC yang memblokir.

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
  )

Mengapa Resource?

Transactor yang menggunakan pengumpulan memiliki keadaan berumur panjang: koneksi terbuka dan thread latar belakang. Resource[F, A] menjamin perolehan dan pelepasan selalu berpasangan, bahkan saat terjadi kesalahan atau pembatalan.

Biasanya Anda membangun Transactor sekali saat startup dan menggunakannya kembali selama masa hidup seluruh aplikasi.

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

Kumpulan connectEC

HikariCP memerlukan ExecutionContext untuk menunggu koneksi dari kumpulan. Doobie menyediakan ExecutionContexts.fixedThreadPool untuk keperluan ini, yang juga berupa Resource.

Memisahkannya dari kumpulan komputasi mencegah pengambilan koneksi yang memblokir membuat pekerjaan yang terikat CPU kehabisan thread.

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

Mengonfigurasi DataSource yang Sudah Ada

Jika Anda sudah memiliki javax.sql.DataSource yang dikonfigurasi (misalnya instans Hikari yang telah disesuaikan), bungkus langsung dengan Transactor.fromDataSource.

Ini umum dilakukan ketika framework mengelola kumpulan koneksi dan Anda hanya ingin Doobie menggunakannya.

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

Menguji Koneksi Secara Singkat

Pemeriksaan kesehatan sederhana adalah menjalankan select 1 melalui Transactor. Jika berhasil mengembalikan hasil, driver, URL, dan kredensial Anda semuanya berfungsi.

Ini merupakan langkah awal yang baik sebelum menghubungkan kueri nyata.

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

// check.unsafeRunSync() == 1

Internal Transactor: Strategi

Transactor dibangun dari interpreter dan sebuah Strategy. Strategy mengendalikan apa yang terjadi di sekitar setiap transaksi: before, after, oops (saat terjadi kesalahan), dan always.

Strategi bawaan menonaktifkan auto-commit, melakukan commit setelah berhasil, melakukan rollback saat terjadi kesalahan, dan selalu menutup koneksi.

import doobie.util.transactor.Strategy

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

Pencatatan dan Observabilitas

Doobie dapat mencatat setiap pernyataan, argumennya, dan waktunya. Versi modern memasang LogHandler[F] per kueri, bukan per Transactor.

Hal ini sangat berguna untuk menemukan kueri yang lambat dan memverifikasi pengikatan parameter dalam produksi.

import doobie.util.log._

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

Pemeriksaan Singkat

Uji pemahaman Anda tentang Transactor.

Rangkuman

Transactor[F] menghubungkan program ConnectionIO murni ke basis data nyata. fromDriverManager cocok untuk pengujian; HikariTransactor dan fromDataSource cocok untuk produksi melalui pengumpulan koneksi.

Bangun Transactor yang menggunakan pengumpulan sebagai Resource, jalankan program dengan .transact(xa), dan biarkan Strategy bawaan menangani commit, rollback, serta pembersihan.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Menghubungkan dengan Transactor” gratis?

Ya — teks lengkap “Menghubungkan dengan Transactor” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Scala for Backend Engineering & Functional Programming, upgrade ke CoddyKit PRO. Kursus Scala for Backend Engineering & Functional Programming mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Menghubungkan dengan Transactor”?

Siapkan akses basis data. Kamu berlatih Scala for Backend Engineering & Functional Programming dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Scala for Backend Engineering & Functional Programming?

Tidak diperlukan pengalaman sebelumnya. Scala for Backend Engineering & Functional Programming di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Menghubungkan dengan Transactor” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Scala for Backend Engineering & Functional Programming ini?

Ya. Setiap pelajaran Scala for Backend Engineering & Functional Programming menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Scala for Backend Engineering & Functional Programming