Kotlin + Spring Boot + Clean Architecture — กฎทิศทางที่ compiler บังคับให้

ทุกทีมเขียนกฎทิศทางไว้ในเอกสาร แล้วก็เผลอละเมิดมันภายในไม่กี่เดือน เพราะไม่มีอะไรบังคับ คอร์สนี้ไม่เล่าซ้ำว่ากฎนั้นคืออะไร มันถามว่าอะไรบังคับมัน — เราแยกโมดูลจนการ import Spring ในโดเมนกลายเป็นข้อผิดพลาดตอนแปล แล้วเดินไปหาข้อที่ compiler ช่วยไม่ได้ คือกติกาที่กว้างกว่า aggregate ซึ่งต้องมีคนบังคับที่ฐานข้อมูล ทุกข้ออ้างในคอร์สนี้มาจาก probe ที่คุณรันเองได้

เริ่มบทที่ 1

ความคืบหน้า0 / 8 บทเรียน

เส้นทางการเรียน

แปดบท เรียงตามลำดับที่กฎทิศทางถูกทดสอบทีละข้อ จนถึงข้อที่มันบังคับไม่ได้

คอร์สนี้เขียนให้ใคร

คุณเขียน Kotlin ได้แล้ว และอ่านเรื่อง Clean Architecture มาแล้วอย่างน้อยรอบหนึ่ง

คอร์สนี้ไม่ได้เริ่มที่ว่า data class คืออะไร · ถ้ายังไม่เคยเขียน Kotlin ให้ไปที่ คอร์ส Kotlin จากศูนย์ ก่อน แล้วค่อยกลับมา

และมันไม่ได้เริ่มที่ว่า aggregate คืออะไรด้วย · เว็บนี้มีสี่คอร์สที่ถือเรื่องนั้นอยู่แล้ว คอร์สนี้ลิงก์ไป ไม่เล่าซ้ำ

คำถามที่คอร์สนี้ตอบ

ไม่ใช่ “โครงสร้างที่ดีหน้าตาอย่างไร” แต่เป็น “อะไรบังคับมันหลังจากคุณเขียนมันลงไปแล้ว”

เอกสารออกแบบไม่บังคับอะไร · การรีวิวบังคับได้เท่าที่คนอ่านทัน · สิ่งที่บังคับได้จริงมีสองอย่างเท่านั้น คือ compiler กับฐานข้อมูล

คอร์สนี้จึงเรียงตามลำดับที่ กฎแต่ละข้อย้ายจากเอกสารไปอยู่ในเครื่องมือ และหยุดตรงที่มัน ย้ายไม่ได้ แล้วบอกว่าตรงนั้นต้องทำอย่างไรแทน

สิ่งที่คุณจะได้สร้าง

ระบบจองคิวคลินิก — ไม่ใช่ orderctl และไม่ใช่ ledger

เลือกโดเมนนี้เพราะกติกาหลักของมันบังคับใน aggregate เดียวไม่ได้

หมอคนหนึ่งมีนัดซ้อนเวลากันไม่ได้

การตรวจข้อนี้ต้องดูนัดของหมอคนนั้นทั้งหมด ซึ่งอยู่นอกนัดใบที่กำลังจะบันทึก · โดเมนตรวจได้เฉพาะที่มันมองเห็น · สอง request ที่ผ่านด่านโดเมนพร้อมกัน จึงยังสร้างแถวที่ซ้อนกันได้จริง และเราจะทำให้มันเกิดขึ้นให้ดูในบทที่ 6

คอร์สนี้พิสูจน์อะไรบ้าง

หกข้อ · ทุกข้อมีคำสั่งที่คุณรันเองแล้วเห็นตัวเลขเดียวกัน

กฎทิศทางบังคับด้วย build ได้ — import Spring ใน domain แล้วแปลไม่ผ่าน · เอาบรรทัดนั้นออกแล้วเขียวทันที
JPA ดึงตัวเองเข้าไปหา entity — build เขียว · context สตาร์ตขึ้น · คำเตือนเดียวที่มีอยู่ที่ระดับ INFO · แล้วมันตายที่ save() ครั้งแรก
การแยก persistence model มีราคา — นับเป็นจำนวนบรรทัดของทั้งสองทาง
โดเมนกันจองซ้อนเองไม่ได้ — สอง session ผ่านด่านโดเมนทั้งคู่ แล้วแถวซ้อนกันเกิดจริง
optimistic locking ทำงานจริง — อ่านจากชนิดของ exception ที่ Spring โยนออกมา
ทดสอบโดเมนได้โดยไม่มี Spring — วัดด้วยจำนวน bean ที่โหลด

คอร์สนี้จงใจไม่ทำอะไร

สี่ข้อที่ตัดออก พร้อมเหตุผลของแต่ละข้อ

ไม่สอน DDD ตั้งแต่ต้น เว็บนี้มีสี่คอร์สที่ถือเรื่องนั้นอยู่แล้ว · คอร์สนี้ลิงก์ไปที่ คอร์ส DDD ไม่เล่าซ้ำ
ไม่เทียบ framework ไม่มี Ktor ไม่มี Micronaut · คำถามของคอร์สนี้เป็นคำถามเรื่องโครงสร้าง ไม่ใช่เรื่องการเลือกของ
ไม่วัดความเร็ว ทั้งคอร์สไม่มีหน่วยเวลาสักตัว · หน่วยที่ใช้คือรหัสออก · SQLSTATE · ชนิดและข้อความของ exception · จำนวนบรรทัด · จำนวน bean · จำนวนแถว
ไม่สอน Kotlin พื้นฐาน ผู้อ่านที่ยังไม่เคยเขียนให้ไปที่คอร์สก่อนหน้า

คอร์สนี้ต่างจากคอร์ส Clean Architecture ที่มีอยู่แล้วตรงไหน

ข้อที่ต้องพูดออกมาก่อน เพราะเว็บนี้มีคอร์สชื่อคล้ายกันอยู่แล้ว

คอร์ส Clean Architecture บน .NET สอนว่าชั้นแต่ละชั้น รับผิดชอบอะไร และวางของอย่างไรให้ dependency ชี้เข้าใน · มันตอบคำถามว่าโครงสร้างควรเป็นอย่างไร

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

ของที่ต้องมีบนเครื่อง

สี่อย่าง · และมีข้อหนึ่งที่ทำให้ Gradle หา JDK ไม่เจอถ้าตั้งผิดชั้น

JDK 25 และตรึงด้วย jvmToolchain(25) ไม่ใช่ปล่อยตามใจ JDK ที่ Gradle รันอยู่
Gradle 9.7.1 กับ Kotlin DSL · โปรเจกต์เป็น multi-module ตั้งแต่บทที่ 1
Docker สำหรับ PostgreSQL 18 · เริ่มใช้จริงตั้งแต่บทที่ 3
org.gradle.java.installations.paths ใน gradle.properties ถ้า JDK ของคุณมาจาก Homebrew · บทที่ 1 อธิบายว่าทำไม และทำไมต้องชี้ลึกกว่าที่คิดหนึ่งชั้น

Kotlin + Spring Boot + Clean Architecture — กฎ​ทิศทาง​ที่ compiler บังคับ​ให้

เส้น​ทางการ​เรียน

คอร์ส​นี้​เขียน​ให้​ใคร

คำถาม​ที่​คอร์ส​นี้​ตอบ

สิ่ง​ที่​คุณ​จะ​ได้​สร้าง

คอร์ส​นี้​พิสูจน์​อะไร​บ้าง

คอร์ส​นี้​จงใจ​ไม่​ทำ​อะไร

คอร์ส​นี้​ต่าง​จาก​คอร์ส Clean Architecture ที่​มี​อยู่​แล้ว​ตรง​ไหน

ของ​ที่​ต้อง​มี​บน​เครื่อง