Scala for Backend Engineering & Functional Programming · บทเรียน

เชื่อมต่อด้วยทรานแซกเตอร์

ตั้งค่าการเข้าถึงฐานข้อมูล

บทเรียน 1 จาก 413 ขั้นตอน

เชื่อมต่อด้วยทรานแซกเตอร์ เป็นบทเรียน Scala for Backend Engineering & Functional Programming ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Scala for Backend Engineering & Functional Programming และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 4 บทเรียน

Transactor คืออะไร

Doobie เป็นชั้น JDBC เชิงฟังก์ชันล้วนสำหรับ Scala โดย Transactor[F] เป็นสะพานเชื่อมระหว่างโปรแกรมบริสุทธิ์ของ Doobie กับการเชื่อมต่อฐานข้อมูลจริง

Transactor รู้วิธีจัดหาการเชื่อมต่อ JDBC Connection เรียกใช้โปรแกรมภายในธุรกรรม และปล่อยทรัพยากรอย่างปลอดภัย

ชนิดนี้รับพารามิเตอร์เป็นชนิดเอฟเฟกต์ F[_] เช่น cats.effect.IO

import doobie._
import cats.effect.IO

val xa: Transactor[IO] = ???

โปรแกรม ConnectionIO

คำสั่งสอบถามของ Doobie เป็นค่าชนิด ConnectionIO[A] ซึ่งอธิบายการคำนวณที่ต้องใช้การเชื่อมต่อ JDBC แต่ยังไม่ทำงานในทันที

คุณสร้างโปรแกรมเหล่านี้แบบบริสุทธิ์ แล้วส่งให้ Transactor เป็นผู้เรียกใช้ ฐานข้อมูลจะยังไม่ถูกแตะต้องจนกว่าคุณจะสั่งให้ทำงาน

import doobie.implicits._

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

DriverManagerTransactor

Transactor ที่เรียบง่ายที่สุดคือ Transactor.fromDriverManager ซึ่งเปิดการเชื่อมต่อใหม่เอี่ยมสำหรับทุกธุรกรรมโดยใช้ DriverManager ของ JDBC

ต้องระบุชื่อคลาสไดรเวอร์ URL ของ JDBC ชื่อผู้ใช้ และรหัสผ่าน เหมาะสำหรับการทดสอบและสคริปต์ แต่ไม่มีการรวมการเชื่อมต่อ

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

การเรียกใช้โปรแกรม

หากต้องการเรียกใช้ ConnectionIO ให้เรียก .transact(xa) ซึ่งจะให้ผลลัพธ์เป็น F[A] หรือในกรณีนี้คือ IO[A]

Transactor จะครอบโปรแกรมไว้ในธุรกรรม โดยยืนยันธุรกรรมเมื่อสำเร็จและย้อนกลับเมื่อเกิดข้อผิดพลาด พร้อมปล่อยการเชื่อมต่อไม่ว่าผลลัพธ์จะเป็นอย่างไร

import doobie.implicits._

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

การรวมการเชื่อมต่อด้วย HikariCP

สำหรับการใช้งานจริง คุณควรใช้กลุ่มการเชื่อมต่อ Doobie มี HikariTransactor ซึ่งทำงานบน HikariCP

สิ่งนี้ถูกสร้างเป็น Resource เพื่อให้กลุ่มการเชื่อมต่อปิดลงอย่างเรียบร้อย นอกจากนี้คุณต้องส่งบริบทการทำงานสำหรับการดำเนินการ JDBC ที่หยุดรอ

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
  )

เหตุใดจึงต้องใช้ Resource

Transactor ที่ใช้กลุ่มการเชื่อมต่อเป็นเจ้าของสถานะที่มีอายุยาวนาน ได้แก่ การเชื่อมต่อที่เปิดอยู่และเธรดเบื้องหลัง Resource[F, A] รับประกันว่าการจัดหาและการปล่อยจะเกิดเป็นคู่ แม้เกิดข้อผิดพลาดหรือการยกเลิก

โดยทั่วไปคุณจะสร้าง Transactor หนึ่งครั้งเมื่อเริ่มต้นระบบ แล้วใช้ซ้ำตลอดอายุการทำงานของแอปพลิเคชัน

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

กลุ่ม connectEC

HikariCP ต้องใช้ ExecutionContext เพื่อรอการเชื่อมต่อจากกลุ่ม Doobie จัดเตรียม ExecutionContexts.fixedThreadPool สำหรับงานนี้ ซึ่งตัวมันเองเป็น Resource

การแยกส่วนนี้ออกจากกลุ่มคำนวณจะป้องกันไม่ให้การจัดหาการเชื่อมต่อที่หยุดรอแย่งทรัพยากรจากงานที่ใช้ CPU

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

การกำหนดค่า DataSource ที่มีอยู่แล้ว

หากคุณมี javax.sql.DataSource ที่กำหนดค่าไว้แล้ว เช่น อินสแตนซ์ Hikari ที่ปรับแต่งมาอย่างเหมาะสม ให้ครอบโดยตรงด้วย Transactor.fromDataSource

วิธีนี้ใช้กันทั่วไปเมื่อเฟรมเวิร์กเป็นผู้จัดการกลุ่มการเชื่อมต่อ และคุณต้องการให้ Doobie นำกลุ่มนั้นไปใช้เท่านั้น

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

การทดสอบการเชื่อมต่อเบื้องต้น

การตรวจสอบสุขภาพอย่างง่ายคือเรียกใช้ select 1 ผ่าน Transactor หากมีผลลัพธ์กลับมา แสดงว่าไดรเวอร์ URL และข้อมูลรับรองของคุณทำงานถูกต้องทั้งหมด

นี่เป็นขั้นตอนแรกที่ดี ก่อนเชื่อมต่อคำสั่งสอบถามจริง

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

// check.unsafeRunSync() == 1

ภายใน Transactor: กลยุทธ์

Transactor สร้างจากตัวแปลความหมายและ Strategy โดย Strategy จะควบคุมสิ่งที่เกิดขึ้นรอบธุรกรรมแต่ละรายการ ได้แก่ before, after, oops (เมื่อเกิดข้อผิดพลาด) และ always

กลยุทธ์เริ่มต้นจะปิดการยืนยันอัตโนมัติ ยืนยันหลังทำงานสำเร็จ ย้อนกลับเมื่อเกิดข้อผิดพลาด และปิดการเชื่อมต่อทุกครั้ง

import doobie.util.transactor.Strategy

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

การบันทึกและการสังเกตระบบ

Doobie สามารถบันทึกคำสั่งทุกคำสั่ง อาร์กิวเมนต์ และระยะเวลาได้ ในรุ่นสมัยใหม่จะผูก LogHandler[F] ต่อคำสั่งสอบถาม แทนที่จะผูกต่อตัว Transactor

ความสามารถนี้มีประโยชน์อย่างยิ่งสำหรับค้นหาคำสั่งสอบถามที่ทำงานช้าและตรวจสอบการผูกพารามิเตอร์ในระบบจริง

import doobie.util.log._

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

ตรวจสอบอย่างรวดเร็ว

ทดสอบความเข้าใจของคุณเกี่ยวกับ Transactor

ตอบคำถามในบทเรียนแบบโต้ตอบ

สรุป

Transactor[F] เชื่อมโปรแกรม ConnectionIO แบบบริสุทธิ์เข้ากับฐานข้อมูลจริง fromDriverManager เหมาะกับการทดสอบ ส่วน HikariTransactor และ fromDataSource เหมาะกับการใช้งานจริงผ่านการรวมการเชื่อมต่อ

สร้าง Transactor ที่ใช้กลุ่มการเชื่อมต่อเป็น Resource เรียกใช้โปรแกรมด้วย .transact(xa) และให้ Strategy เริ่มต้นจัดการการยืนยัน การย้อนกลับ และการล้างทรัพยากร

เริ่มต้นได้ฟรี

เรียนรู้ Scala ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 39
บทเรียน: 143

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

คำถามที่พบบ่อย

บทเรียน “เชื่อมต่อด้วยทรานแซกเตอร์” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “เชื่อมต่อด้วยทรานแซกเตอร์” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Scala for Backend Engineering & Functional Programming ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Scala for Backend Engineering & Functional Programming มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “เชื่อมต่อด้วยทรานแซกเตอร์”

ตั้งค่าการเข้าถึงฐานข้อมูล คุณปฏิบัติ Scala for Backend Engineering & Functional Programming ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Scala for Backend Engineering & Functional Programming หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Scala for Backend Engineering & Functional Programming บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “เชื่อมต่อด้วยทรานแซกเตอร์” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Scala for Backend Engineering & Functional Programming นี้ได้ไหม

ได้ บทเรียน Scala for Backend Engineering & Functional Programming ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Scala for Backend Engineering & Functional Programming