Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian · Pelajaran

Menyambung dengan Transactor

Sediakan akses pangkalan data.

Pelajaran 1 daripada 413 langkah

Menyambung dengan Transactor ialah pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian percuma di CoddyKit. Ini ialah pelajaran 1 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian merangkumi sejumlah 4 pelajaran.

Apakah Transactor?

Doobie ialah lapisan JDBC berfungsi tulen untuk Scala. Transactor[F] ialah jambatan antara atur cara tulen Doobie dengan sambungan pangkalan data sebenar.

Transactor mengetahui cara memperoleh sambungan JDBC Connection, menjalankan atur cara anda dalam transaksi dan melepaskan resource dengan selamat.

Ia diparameterkan oleh jenis kesan F[_] seperti cats.effect.IO.

import doobie._
import cats.effect.IO

val xa: Transactor[IO] = ???

Atur Cara ConnectionIO

Permintaan Doobie ialah nilai berjenis ConnectionIO[A]. Nilai ini menerangkan pengiraan yang memerlukan sambungan JDBC tetapi belum dijalankan.

Anda membina atur cara ini secara tulen, kemudian menyerahkannya kepada Transactor untuk dilaksanakan. Tiada apa-apa menyentuh pangkalan data sehingga anda menjalankannya.

import doobie.implicits._

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

DriverManagerTransactor

Transactor yang paling mudah ialah Transactor.fromDriverManager. Ia membuka sambungan baharu untuk setiap transaksi menggunakan DriverManager JDBC.

Ia memerlukan nama kelas pemacu, URL JDBC, nama pengguna dan kata laluan. Ia sesuai untuk ujian dan skrip tetapi tidak mempunyai pengumpulan sambungan.

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

Menjalankan Atur Cara

Untuk melaksanakan ConnectionIO, anda memanggil .transact(xa). Ini menghasilkan F[A], iaitu IO[A] dalam contoh ini.

Transactor membungkus atur cara dalam transaksi: ia melakukan commit apabila berjaya dan rollback apabila gagal, sambil melepaskan sambungan dalam kedua-dua keadaan.

import doobie.implicits._

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

Pengumpulan dengan HikariCP

Untuk pengeluaran, anda memerlukan kumpulan sambungan. Doobie menyediakan HikariTransactor yang disokong oleh HikariCP.

Ia dicipta sebagai Resource supaya kumpulan ditutup dengan bersih. Anda juga menghantar konteks pelaksanaan untuk operasi JDBC yang menyekat.

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 terkumpul memiliki keadaan berjangka panjang: sambungan terbuka dan utas latar belakang. Resource[F, A] menjamin pemerolehan dan pelepasan sentiasa berpasangan walaupun berlaku ralat atau pembatalan.

Biasanya anda membina Transactor sekali semasa permulaan dan menggunakannya semula sepanjang hayat aplikasi.

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

Kumpulan connectEC

HikariCP memerlukan ExecutionContext untuk menunggu sambungan daripada kumpulan. Doobie menyediakan ExecutionContexts.fixedThreadPool untuk tujuan ini, dan ia sendiri ialah Resource.

Memisahkannya daripada kumpulan pengiraan menghalang pemerolehan sambungan yang menyekat daripada menyebabkan kerja terikat CPU kebuluran.

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

Mengkonfigurasi DataSource Sedia Ada

Jika anda sudah mempunyai javax.sql.DataSource yang dikonfigurasi, contohnya tika Hikari yang ditala, bungkusnya terus dengan Transactor.fromDataSource.

Ini lazim apabila rangka kerja menguruskan kumpulan dan anda hanya mahu Doobie menggunakannya.

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

Menguji Sambungan Secara Ringkas

Pemeriksaan kesihatan yang mudah ialah menjalankan select 1 melalui Transactor. Jika ia memulangkan hasil, pemacu, URL dan kelayakan anda semuanya berfungsi.

Ini langkah pertama yang baik sebelum menyambungkan permintaan sebenar.

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

// check.unsafeRunSync() == 1

Dalaman Transactor: Strategi

Transactor dibina daripada pentafsir dan Strategy. Strategy mengawal perkara yang berlaku di sekitar setiap transaksi: before, after, oops (apabila berlaku ralat) dan always.

Strategi lalai mematikan auto-commit, melakukan commit selepas berjaya, rollback apabila berlaku ralat dan sentiasa menutup sambungan.

import doobie.util.transactor.Strategy

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

Pengelogan dan Kebolehlihatan

Doobie boleh merekod setiap pernyataan, argumennya dan masa pelaksanaan. Versi moden melampirkan LogHandler[F] pada setiap permintaan, bukannya pada setiap Transactor.

Ini amat berguna untuk mengesan permintaan yang perlahan dan mengesahkan pengikatan parameter dalam pengeluaran.

import doobie.util.log._

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

Semakan Pantas

Uji pemahaman anda tentang Transactor.

Jawab dalam pelajaran interaktif

Ringkasan

Transactor[F] menyambungkan atur cara ConnectionIO yang tulen kepada pangkalan data sebenar. fromDriverManager sesuai untuk ujian; HikariTransactor dan fromDataSource sesuai untuk pengeluaran melalui pengumpulan.

Bina Transactor terkumpul sebagai Resource, jalankan atur cara dengan .transact(xa), dan biarkan Strategy lalai mengendalikan commit, rollback serta pembersihan.

Percuma untuk bermula

Pelajari Scala dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 39
Pelajaran: 143

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Menyambung dengan Transactor” percuma?

Ya — teks penuh “Menyambung dengan Transactor” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian, tingkat taraf kepada CoddyKit PRO. Kursus Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Menyambung dengan Transactor”?

Sediakan akses pangkalan data. Anda berlatih Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 1 daripada 4.

Berapa lamakah pelajaran “Menyambung dengan Transactor” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian ini?

Ya. Setiap pelajaran Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Scala untuk Kejuruteraan Bahagian Belakang dan Pengaturcaraan Fungsian