Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

แพตเทิร์นสถาปัตยกรรม

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

บทนี้จะกล่าวถึงแพตเทิร์นที่จะช่วยป้องกันไม่ให้เกิดความสับสนวุ่นวายเหล่านั้น เราจะมาดูวิธีจัดระเบียบเว็บแอปพลิเคชัน Rust ให้แต่ละชิ้นส่วนมีความสะอาดและเป็นอิสระต่อกัน ผมจะไม่ฟันธงว่ามีแนวทางใดเพียงแนวทางเดียวที่ถูกต้อง เพราะระดับความซับซ้อนของโครงสร้างที่เหมาะสมย่อมขึ้นอยู่กับบริบทของโปรเจกต์คุณ แต่เป้าหมายของผมคือต้องการให้คุณเข้าใจตัวเลือกต่างๆ อย่างลึกซึ้งพอที่จะตัดสินใจได้อย่างมั่นใจด้วยตัวเอง

หัวใจสำคัญที่เป็นแกนหลักร่วมกันของทุกแพตเทิร์นคือ กฎของดีเพนเดนซี (Dependency Rule): ดีเพนเดนซีต้องชี้เข้าหาแกนกลางเสมอ นั่นคือจากอินฟราสตรักเจอร์มุ่งหน้าเข้าสู่โดเมน ตรรกะทางธุรกิจของคุณไม่ควรจำเป็นต้องรู้จักรหัสสถานะ HTTP, คิวรี SQL หรือแม้กระทั่งว่ากำลังใช้งานเว็บเฟรมเวิร์กตัวใดอยู่ เมื่อคุณวางรากฐานข้อนี้ได้อย่างถูกต้อง โดเมนของคุณจะสามารถนำไปใช้งานที่อื่นได้ง่าย (portable), ทดสอบได้อย่างมั่นใจ และพร้อมที่จะพัฒนาต่อยอดได้อย่างราบรื่นเมื่อบริบทแวดล้อมเปลี่ยนแปลงไป

โมเดลแบบเลเยอร์

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

┌──────────────────────────────────────────────┐
│   API Layer                                  │
│   Handlers, routes, middleware, DTOs         │
│   Knows about: Axum, HTTP, JSON              │
├──────────────────────────────────────────────┤
│   Domain Layer                               │
│   Models, services, business rules, ports    │
│   Knows about: nothing external              │
├──────────────────────────────────────────────┤
│   Infrastructure Layer                       │
│   Repositories, database, external APIs      │
│   Knows about: SQLx, Diesel, reqwest, etc.   │
└──────────────────────────────────────────────┘

เลเยอร์ API ทำหน้าที่เป็นล่ามแปลภาษาระหว่างโลกของ HTTP กับโลกของโดเมนของคุณ มีหน้าที่แปลงข้อมูลจากบอดี้คำขอ (deserialize) ให้อยู่ในรูปของชนิดข้อมูลโดเมน เรียกใช้เมธอดของเซอร์วิส แล้วแปลงผลลัพธ์ที่ได้กลับไปเป็นการตอบกลับแบบ HTTP (serialize) จงรักษาเลเยอร์นี้ให้บางและกระชับที่สุด หากคุณพบว่าตัวเองกำลังเขียนตรรกะทางธุรกิจลงในแฮนด์เลอร์ ขอให้หยุดทันที เพราะตรรกะนั้นควรไปอยู่ที่เลเยอร์โดเมน ผมเคยเห็นแฮนด์เลอร์บวมจนกลายเป็นโค้ดยาว 200 บรรทัดมามากพอ จนตระหนักดีว่าเราควรรักษามาตรฐานเรื่องนี้อย่างเคร่งครัดตั้งแต่เริ่มต้น

เลเยอร์โดเมนคือแกนกลางและหัวใจของระบบทั้งหมด เป็นที่อยู่ของเอนทิตีทางธุรกิจ, value object, ฟังก์ชันเซอร์วิส ตลอดจนนิยาม trait (พอร์ต) ที่ระบุว่าโดเมนต้องการความสามารถใดจากโลกภายนอกบ้าง เช่น “บันทึกข้อมูลผู้ใช้” หรือ “ส่งอีเมลแจ้งเตือน” จุดสำคัญอย่างยิ่งคือ เลเยอร์นี้ไม่มีความจำเป็นต้องรับรู้เลยว่าความสามารถเหล่านั้นถูกนำไปทำงานจริงอย่างไร ไม่มีการ import sqlx, axum หรือเฟรมเวิร์กใดๆ ทั้งสิ้น เลเยอร์นี้จะบรรจุเพียงตรรกะทางธุรกิจที่บริสุทธิ์เท่านั้น

เลเยอร์อินฟราสตรักเจอร์ทำหน้าที่เตรียมการทำงานจริง (concrete implementation) ให้แก่ trait ต่างๆ ของโดเมน เป็นเลเยอร์ที่รู้จักฐานข้อมูลเฉพาะเจาะจง, API ภายนอก, บริการส่งอีเมล หรือระบบคิวข้อความ เลเยอร์นี้จะขึ้นตรงต่อเลเยอร์โดเมน (เนื่องจากต้องอิมพลีเมนต์ trait ที่โดเมนกำหนดไว้) แต่เลเยอร์โดเมนจะไม่พึ่งพาเลเยอร์นี้เลยแม้แต่น้อย ทิศทางของ dependency ที่ไหลไปในทิศทางเดียวเช่นนี้คือเคล็ดลับที่ทำให้สถาปัตยกรรมทำงานได้อย่างมีประสิทธิภาพ

ทำไมลำดับนี้จึงสำคัญ

คุณอาจมองดูแผนภาพนี้แล้วนึกในใจว่า “ไดอะแกรมก็ดูสวยดี แต่ในทางปฏิบัติมันให้ประโยชน์จริงหรือ?” คำตอบคือสำคัญมากครับ และนี่คือประโยชน์ที่เป็นรูปธรรมอย่างยิ่ง:

เมื่อโดเมนของคุณไม่ต้องพึ่งพาฐานข้อมูล คุณจะสามารถทดสอบตรรกะทางธุรกิจทั้งหมดได้ง่ายๆ เพียงแค่เสียบอิมพลีเมนเทชันแบบ in-memory เข้าไปแทนที่ repository trait โดยไม่จำเป็นต้องเปิดเซิร์ฟเวอร์ PostgreSQL ขึ้นมาเพื่อพิสูจน์ว่าฟังก์ชันคำนวณราคาของคุณทำงานถูกต้อง ชุดทดสอบของคุณจะรันเสร็จในระดับมิลลิวินาที และสามารถรันแบบออฟไลน์ได้ทุกที่ทุกเวลา ซึ่งผมชอบข้อดีนี้มาก

เมื่อโดเมนของคุณเป็นอิสระจาก Axum คุณสามารถนำโค้ดโดเมนชุดเดียวกันนี้ไปใช้งานร่วมกับเครื่องมือ CLI, งานเบื้องหลัง (worker) หรือแม้กระทั่งบริการ gRPC ได้ทันที โดยไม่ต้องพ่วงพาเอาเลเยอร์ HTTP ทั้งกระบิเข้ามาเป็นภาระส่วนเกิน

และเมื่อรายละเอียดการทำงานฝั่งฐานข้อมูลมีการเปลี่ยนแปลง (เช่น การย้ายระบบจาก PostgreSQL ไปยัง CockroachDB หรือเปลี่ยนไลบรารีจาก SQLx เป็น Diesel) เลเยอร์โดเมนของคุณจะไม่ได้รับผลกระทบใดๆ เลย คุณเพียงแค่เขียนโค้ดในเลเยอร์อินฟราสตรักเจอร์ขึ้นมาใหม่ โดยที่ส่วนอื่นๆ ของแอปพลิเคชันไม่จำเป็นต้องรับรู้ถึงความเปลี่ยนแปลงนั้น ผมเคยทำไมเกรชันลักษณะนี้บนโปรเจกต์จริงมาแล้ว และกระบวนการดำเนินไปได้อย่างราบรื่นมากเพราะเรามีการแยกเลเยอร์ที่ชัดเจนตั้งแต่แรก

การแยกชั้นเชิงนามธรรมด้วยเทรต (พอร์ตและอะแดปเตอร์)

แล้วเราจะบังคับใช้การแยกเลเยอร์นี้ในภาษา Rust ได้อย่างไร? คำตอบคือการใช้ trait เลเยอร์โดเมนจะกำหนดนิยาม trait เพื่ออธิบายการดำเนินการที่ต้องการ ส่วนเลเยอร์อินฟราสตรักเจอร์จะสร้าง struct ที่อิมพลีเมนต์ trait เหล่านั้นขึ้นมา จากนั้นเลเยอร์แอปพลิเคชันจะทำหน้าที่เชื่อมต่อ (wiring) ทุกอย่างเข้าด้วยกันในตอนเริ่มต้นระบบ หากคุณคุ้นเคยกับ interface ในภาษาอื่น คุณจะเข้าใจแนวคิดนี้ได้ทันที แต่ระบบ trait ของ Rust ยังมอบการรับประกันความถูกต้องในระดับเวลาคอมไพล์ที่ยอดเยี่ยมเพิ่มขึ้นมาอีกชั้นหนึ่ง

ตัวอย่างหน้าตาของ repository port ในเลเยอร์โดเมน:

#![allow(unused)]
fn main() {
// domain/ports/user_repository.rs

use std::future::Future;
use crate::domain::models::{User, UserId, Email};
use crate::domain::errors::CreateUserError;

pub trait UserRepository: Send + Sync + 'static {
    fn create(
        &self,
        req: &CreateUserRequest,
    ) -> impl Future<Output = Result<User, CreateUserError>> + Send;

    fn find_by_id(
        &self,
        id: &UserId,
    ) -> impl Future<Output = Result<Option<User>, anyhow::Error>> + Send;

    fn find_by_email(
        &self,
        email: &Email,
    ) -> impl Future<Output = Result<Option<User>, anyhow::Error>> + Send;
}
}

มีประเด็นเกี่ยวกับ trait bound ที่น่าสนใจ ขอบเขต Send + Sync + 'static ถูกกำหนดไว้เพราะ Axum จำเป็นต้องแชร์สถานะข้าม async task ต่างๆ ที่อาจทำงานบนเธรดที่ต่างกัน หากคุณเคยเจอกับข้อผิดพลาดตอนคอมไพล์ประเภท “future is not Send” ขอบเขตเหล่านี้คือคำตอบที่ช่วยแก้ปัญหาดังกล่าว ตั้งแต่ Rust 1.75 เป็นต้นมา ฟีเจอร์ async fn ใน trait และ impl Trait ในตำแหน่ง return type ได้รับการพัฒนาจนเข้าสู่สถานะ stable แล้ว ทำให้เราสามารถเขียน signature เหล่านี้ได้โดยตรงโดยไม่ต้องพึ่งพาแมโคร #[async_trait] อีกต่อไป ซึ่งถือเป็นการพัฒนาที่น่ายินดีอย่างยิ่ง

อย่างไรก็ตาม ยังมีข้อจำกัด 2 ประการที่ควรทราบ ประการแรกคือ trait ที่ใช้ -> impl Future หรือ async fn จะไม่เป็น object-safe นั่นหมายความว่าคุณจะไม่สามารถนำมันไปใช้ในรูปของ trait object (dyn Trait) ได้โดยตรง หรือพูดให้เห็นภาพคือ Arc<dyn UserRepository> จะคอมไพล์ไม่ผ่าน หากคุณต้องการใช้งานแบบ dynamic dispatch (ซึ่งเราจะอธิบายในหัวข้อถัดไป) คุณยังคงต้องใช้เครต async_trait หรือทำการห่อ future ด้วย Box ด้วยตัวเอง สำหรับแพตเทิร์นที่แสดงในตัวอย่างนี้จะทำงานร่วมกับ static dispatch (generics) ซึ่งเป็นแนวทางที่ผมแนะนำให้ใช้เป็นค่าเริ่มต้น

ประการที่สอง สำหรับ trait ที่เป็นไลบรารีสาธารณะ (ไม่ใช่พอร์ตที่ใช้ภายในแอปพลิเคชันเอง) การใช้ async fn แบบตรงๆ อาจสร้างปัญหาได้ เนื่องจากผู้เรียกใช้งานภายนอกจะไม่สามารถเพิ่มขอบเขตอย่าง Send ให้แก่ future ที่คืนกลับมาได้โดยไม่ส่งผลกระทบต่อ API (breaking change) หากคุณกำลังพัฒนา trait สำหรับเผยแพร่ให้โค้ดภายนอกเครตนำไปใช้งาน ควรพิจารณาใช้เครต trait_variant (พัฒนาโดย Rust async working group) เพื่อช่วยสร้างวาเรียนต์ที่รองรับ Send ให้อัตโนมัติ:

#![allow(unused)]
fn main() {
#[trait_variant::make(UserRepositorySend: Send)]
pub trait UserRepository { ... }
}

แต่สำหรับพอร์ตที่ใช้งานภายในแอปพลิเคชันทั่วไป (ซึ่งครอบคลุมเซอร์วิสส่วนใหญ่ของ Axum) การใช้ async trait แบบเนทีฟถือว่าตอบโจทย์ได้อย่างยอดเยี่ยมแล้วครับ

อีกข้อสังเกตเล็กๆ คือ Clone ไม่ได้ถูกรวมอยู่ในนิยามของ trait เนื่องจากความสามารถในการโคลนเป็นคุณสมบัติของผู้ถือครอง (เช่น ตัวห่อหุ้ม Arc หรือ struct AppState) ไม่ใช่ข้อกำหนดของสัญญาในระดับโดเมน ตัว struct ในเลเยอร์อินฟราสตรักเจอร์ของคุณยังสามารถ derive Clone ได้ตามต้องการ การแยก Clone ออกจากนิยาม trait จะช่วยรักษาให้สัญญาของโดเมนมุ่งเน้นเฉพาะภารกิจที่แท้จริงเท่านั้น

ต่อไป เรามาดูการอิมพลีเมนต์ใช้งานจริงในเลเยอร์อินฟราสตรักเจอร์กันครับ:

#![allow(unused)]
fn main() {
// infra/repositories/postgres_user_repo.rs

use domain::ports::UserRepository;

#[derive(Clone)]
pub struct PostgresUserRepo {
    pool: PgPool,
}

impl PostgresUserRepo {
    pub fn new(pool: PgPool) -> Self {
        Self { pool }
    }
}

impl UserRepository for PostgresUserRepo {
    async fn create(&self, req: &CreateUserRequest) -> Result<User, CreateUserError> {
        let row = sqlx::query_as!(
            UserRow,
            r#"INSERT INTO users (id, email, name, password_hash)
               VALUES ($1, $2, $3, $4)
               RETURNING *"#,
            Uuid::new_v4(),
            req.email.as_str(),
            req.name.as_str(),
            req.password_hash,
        )
        .fetch_one(&self.pool)
        .await
        .map_err(|e| match e {
            sqlx::Error::Database(ref db_err) if db_err.is_unique_violation() => {
                CreateUserError::Duplicate { email: req.email.clone() }
            }
            other => CreateUserError::Unknown(other.into()),
        })?;

        Ok(row.into())
    }

    // ... other methods
}
}

สังเกตว่าเลเยอร์อินฟราสตรักเจอร์จะทำหน้าที่แปลงข้อผิดพลาดเฉพาะทางของฐานข้อมูล (เช่น การละเมิดเงื่อนไขความซ้ำซ้อน หรือ unique violation) ให้กลายเป็นข้อผิดพลาดเฉพาะของโดเมน ชนิดข้อมูลข้อผิดพลาดของโดเมนจึงรู้จักเพียงแนวคิดอย่าง “อีเมลซ้ำในระบบ” แทนที่จะเป็นรหัสข้อผิดพลาดของ SQL นี่คือรายละเอียดเล็กๆ ที่สร้างความแตกต่างอย่างมหาศาลเวลาที่คุณต้องตื่นมาดีบั๊กตอนตีสอง เพราะข้อความแจ้งเตือนจะสื่อสารอย่างตรงไปตรงมาว่าเกิดปัญหาอะไรขึ้นในมุมของธุรกิจ

เลเยอร์เซอร์วิส

เซอร์วิสจะอาศัยอยู่ภายในเลเยอร์โดเมนและรับผิดชอบการประสานงาน (orchestrate) ตรรกะทางธุรกิจ เซอร์วิสจะรับเอาพอร์ตของโดเมนเข้ามาผ่านทางพารามิเตอร์เจเนอริก (หรือในรูป trait object หากคุณเลือกใช้ dynamic dispatch) เรียกใช้งานตามลำดับขั้นตอนที่ถูกต้อง และบังคับใช้กฎเกณฑ์ทางธุรกิจ นี่คือพื้นที่ที่ตรรกะสำคัญที่สุดของระบบอาศัยอยู่ หากคุณต้องการทำความเข้าใจว่าแอปพลิเคชันนี้ทำงานอย่างไร การอ่านโค้ดในเลเยอร์เซอร์วิสควรช่วยให้คุณเห็นภาพรวมทั้งหมดได้อย่างชัดเจน โดยไม่ต้องพะวงกับรายละเอียดของ HTTP หรือคำสั่ง SQL

#![allow(unused)]
fn main() {
// domain/services/user_service.rs

#[derive(Clone)]
pub struct UserService<R: UserRepository> {
    repo: R,
}

impl<R: UserRepository> UserService<R> {
    pub fn new(repo: R) -> Self {
        Self { repo }
    }

    pub async fn register(
        &self,
        name: UserName,
        email: Email,
        password: &str,
    ) -> Result<User, CreateUserError> {
        let password_hash = hash_password(password)?;

        let req = CreateUserRequest {
            name,
            email,
            password_hash,
        };

        self.repo.create(&req).await
    }

    pub async fn get_by_id(&self, id: &UserId) -> Result<Option<User>, anyhow::Error> {
        self.repo.find_by_id(id).await
    }
}
}

ตัวเซอร์วิสเองไม่มีความจำเป็นต้องรับรู้เลยว่า R คือรีพอสิทอรี PostgreSQL หรือไม่ มันอาจเป็นเพียง mock repository ในหน่วยความจำที่สร้างขึ้นเพื่อใช้ในการทดสอบ หรือเป็นแคชเลเยอร์ที่คอยตรวจสอบ Redis ก่อนจะส่งต่อไปยังฐานข้อมูล เซอร์วิสรับรู้เพียงว่าไม่ว่า R จะเป็นสิ่งใด มันย่อมปฏิบัติตามสัญญาที่ระบุไว้ใน UserRepository อย่างแน่นอน นั่นคือความงดงามของแพตเทิร์นนี้ และเป็นสิ่งที่ทำให้การเขียนชุดทดสอบสำหรับตรรกะทางธุรกิจกลายเป็นเรื่องง่ายและน่ารื่นรมย์อย่างแท้จริง

สแตติกดิสแพตช์กับไดนามิกดิสแพตช์

เมื่อคุณตัดสินใจนำนามธรรมแบบ trait มาใช้ คุณจะพบกับคำถามสำคัญข้อนี้: ควรเลือกใช้เจเนอริก (static dispatch) หรือใช้ trait object (dynamic dispatch) ดี? การทำความเข้าใจข้อแลกเปลี่ยนของทั้งสองแนวทางจะช่วยให้คุณเลือกได้อย่างเหมาะสม:

สแตติกดิสแพตช์ (Static dispatch) ใช้เจเนอริก โดยคอมไพเลอร์จะทำการ monomorphize (สร้างโค้ดเฉพาะสำหรับแต่ละชนิดข้อมูลขึ้นมา) ซึ่งทำให้ไม่มี overhead ในตอนรันไทม์จากการเรียกผ่าน virtual table (vtable) เลย นี่คือแนวทางเดียวกับที่เราใช้กับ UserService<R: UserRepository> ด้านบน

#![allow(unused)]
fn main() {
// Static dispatch: zero runtime cost, resolved at compile time
pub struct UserService<R: UserRepository> {
    repo: R,
}
}

ไดนามิกดิสแพตช์ (Dynamic dispatch) อาศัย trait object ที่ถูกห่อหุ้มไว้ใต้ Arc โดยการเรียกใช้เมธอดจะวิ่งผ่าน vtable ในระหว่างรันไทม์ ซึ่งจะเพิ่ม overhead เล็กน้อย แต่ในทางปฏิบัติสำหรับเว็บแอปพลิเคชันแล้ว ผลกระทบนี้แทบจะไม่มีนัยสำคัญเลยเมื่อเทียบกับเวลาที่ต้องใช้ในการรอข้อมูลไปกลับจากฐานข้อมูล ข้อดีคือทำให้ type signature มีความกระชับและสามารถสลับเปลี่ยนการทำงานในตอนรันไทม์ได้สะดวกกว่า

ทว่ามีประเด็นสำคัญที่ต้องคำนึงถึง: trait ที่ใช้ -> impl Future หรือ async fn ใน Rust จะไม่รองรับ object-safe ทำให้ไม่สามารถนำไปใช้กับ dyn Trait ได้โดยตรง หากคุณต้องการใช้ dynamic dispatch คุณมี 2 ทางเลือกหลัก โดยวิธีที่นิยมคือการใช้เครต async_trait เพื่อแปลง async method ให้กลายเป็น boxed future ซึ่งจะทำให้ trait กลายเป็น object-safe:

#![allow(unused)]
fn main() {
use async_trait::async_trait;

#[async_trait]
pub trait UserRepository: Send + Sync + 'static {
    async fn create(&self, req: &CreateUserRequest) -> Result<User, CreateUserError>;
    async fn find_by_id(&self, id: UserId) -> anyhow::Result<Option<User>>;
}

// Now this works:
pub struct UserService {
    repo: Arc<dyn UserRepository>,
}
}

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

คำแนะนำของผม: เริ่มต้นด้วย static dispatch ก่อนเสมอ เพราะให้การรับประกันในตอนคอมไพล์ที่แข็งแกร่งกว่า ข้อความแจ้งเตือนข้อผิดพลาดชัดเจน และไม่ต้องกังวลเรื่อง object-safety ให้ยุ่งยาก แล้วค่อยพิจารณาเปลี่ยนไปใช้ dynamic dispatch เมื่อคุณต้องการความยืดหยุ่นในการสลับการทำงานในตอนรันไทม์จริงๆ เช่น การสลับการทำงานตามคอนฟิก หรือเมื่อพารามิเตอร์เจเนอริกเริ่มทำให้ signature รุงรังจนอ่านเข้าใจยากข้ามหลายเลเยอร์ คุณจะรู้ตัวทันทีเมื่อถึงจุดนั้น เพราะคุณจะพบว่าตัวเองกำลังจ้องมอง type signature ที่เต็มไปด้วยพารามิเตอร์รุงรังจนอ่านแทบไม่รู้เรื่อง

สถาปัตยกรรมเฮกซะโกนัลและสถาปัตยกรรมแบบหัวหอม

หากคุณเคยศึกษาเรื่องสถาปัตยกรรมซอฟต์แวร์มาก่อน คุณคงเคยได้ยินชื่อเรียกทั้งสองนี้มาบ้าง แม้ชื่อจะฟังดูซับซ้อน แต่โดยแก่นแท้แล้ว ทั้งหมดเป็นเพียงรูปแบบหนึ่งของแนวคิดหลักเดียวกันกับที่เราได้พูดถึงไปแล้ว นั่นคือการนำโดเมนมาไว้ตรงกลาง แล้วผลักโค้ดเฉพาะทางของเฟรมเวิร์กออกไปไว้ที่ขอบรอบนอก

สถาปัตยกรรมเฮกซะโกนัล (Hexagonal Architecture) (หรือที่รู้จักกันในชื่อพอร์ตและอะแดปเตอร์) มุ่งเน้นความสมมาตรระหว่างอะแดปเตอร์ขาเข้า (inbound adapter) ซึ่งเป็นส่วนที่เรียกเข้ามาหาโดเมน เช่น HTTP แฮนด์เลอร์หรือ gRPC เซิร์ฟเวอร์ กับอะแดปเตอร์ขาออก (outbound adapter) ซึ่งเป็นส่วนที่โดเมนเรียกออกไปหา เช่น ฐานข้อมูลหรือบริการส่งอีเมล โดย “พอร์ต” คือนิยามของ trait และ “อะแดปเตอร์” คือการอิมพลีเมนต์ใช้งานจริง ซึ่งเป็นแนวทางเดียวกับที่เราทำกันมาตลอด

สถาปัตยกรรมแบบหัวหอม (Onion Architecture) นำเสนอภาพของแนวคิดเดียวกันในรูปแบบของวงแหวนที่ซ้อนกันเป็นชั้นๆ รอบศูนย์กลาง โดยวงแหวนชั้นในสุดคือแบบจำลองโดเมน (domain model) ถัดออกมาคือเลเยอร์แอปพลิเคชันหรือเซอร์วิส จากนั้นคือเลเยอร์อินฟราสตรักเจอร์ และวงแหวนชั้นนอกสุดคือเลเยอร์การนำเสนอ (presentation) โดยมีกฎเหล็กว่า dependency ต้องชี้เข้าหาจุดศูนย์กลางเสมอ

ในความเป็นจริง สิ่งเหล่านี้เป็นเพียงชื่อเรียกที่แตกต่างกันของแพตเทิร์นพื้นฐานเดียวกัน โมเดล 3 เลเยอร์ที่เราศึกษามาตั้งแต่ต้นบทคือการนำแนวคิดเหล่านี้มาปรับใช้ในเชิงปฏิบัติ คุณไม่จำเป็นต้องยึดติดกับธรรมเนียมการตั้งชื่อหรือโครงสร้างที่เป็นทางการจนเกินไป สิ่งที่ผมและคุณควรให้ความสำคัญที่สุดคือกฎของ dependency จะต้องเป็นที่เข้าใจและถูกบังคับใช้อย่างเคร่งครัด เพราะชื่อเรียกเป็นเพียงแค่ป้ายกำกับเท่านั้น

การเลือกระดับของสถาปัตยกรรมที่เหมาะสม

โดยเนื้อแท้แล้วผมเป็นคนเน้นการใช้งานจริง (pragmatist) และอยากพูดกับคุณอย่างตรงไปตรงมาว่า: ไม่ใช่ทุกโปรเจกต์ที่ต้องการสถาปัตยกรรมเฮกซะโกนัลแบบเต็มสูบ พร้อม trait port, generic service และ 5 เครตในเวิร์กสเปซ การทำ Over-engineering มีต้นทุนที่ต้องจ่ายจริง ทั้งปริมาณโค้ดที่ต้องเขียนเพิ่ม, ภาระทางความคิด (cognitive load) และความเร็วในการพัฒนาที่ต้องแลกไปเพื่อผลประโยชน์ที่อาจไม่เคยได้ใช้จริง ผมเองก็เคย over-engineer ระบบมาหลายครั้ง และจบลงด้วยความเสียดายเวลาทุกครั้ง

นี่คือแนวทางคร่าวๆ ที่อิงจากประสบการณ์ที่ผมพบว่าใช้งานได้ผลดีที่สุด:

โมดูลแบบเรียบง่าย (Flat modules) เหมาะสำหรับงานโปรโตไทป์, API ขนาดเล็ก และโปรเจกต์ที่มีเอนด์พอยต์เพียงไม่กี่ตัว จัดวางแฮนด์เลอร์, โมเดล และคิวรีไว้ในโมดูลแยกจากกันโดยไม่ต้องสร้าง trait หรือเลเยอร์เซอร์วิสให้ยุ่งยาก คุณสามารถรีแฟกเตอร์ในภายหลังได้เสมอ และสำหรับเซอร์วิสขนาดเล็ก แนวทางที่เรียบง่ายกว่ามักเป็นแนวทางที่ดีกว่าจริงๆ

สถาปัตยกรรมแบบเลเยอร์ในเครตเดียว (Single-crate layered architecture) คือจุดลงตัวที่เหมาะสมที่สุด (sweet spot) สำหรับแอปพลิเคชันบน production ส่วนใหญ่ แยกโดเมนออกจากอินฟราสตรักเจอร์ ใช้เซอร์วิสเพื่อห่อหุ้มตรรกะทางธุรกิจ และรักษาให้แฮนด์เลอร์บางที่สุด แนวทางนี้มอบทั้งความสามารถในการทดสอบและการดูแลรักษาที่ง่ายดายโดยไม่มีขั้นตอนที่ซับซ้อนเกินจำเป็น หากคุณกำลังพัฒนาระบบที่จะนำขึ้น production และมีทีมงานร่วมดูแล นี่คือจุดเริ่มต้นที่เหมาะสมที่สุด

สถาปัตยกรรมเฮกซะโกนัลหรือแบบหัวหอมในเวิร์กสเปซ (Workspace hexagonal/onion architecture) เหมาะสำหรับระบบที่มีโดเมนซับซ้อนและมีตรรกะทางธุรกิจปริมาณมาก, มีหลายทีมทำงานควบคู่กัน หรือมีความจำเป็นต้องรองรับช่องทางขาเข้าหลากหลายรูปแบบ (เช่น HTTP, gRPC, CLI, message consumer) ภายใต้โดเมนเดียวกัน แม้จะต้องลงทุนลงแรงในช่วงแรกค่อนข้างมาก แต่จะคุ้มค่าอย่างยิ่งตลอดอายุการใช้งานของโค้ดเบสระยะยาว ผมเคยร่วมงานในโปรเจกต์ลักษณะนี้ที่การแยกเลเยอร์อย่างสะอาดช่วยประหยัดเวลาในการรีแฟกเตอร์ไปได้หลายสัปดาห์

สิ่งสำคัญที่สุดคือการเริ่มต้นด้วยการแบ่งแยกเลเยอร์ให้ชัดเจนตั้งแต่แรก แม้จะเป็นในโครงสร้างที่เรียบง่ายที่สุดก็ตาม เพราะแพตเทิร์นที่คุณใช้ในการบังคับใช้ขอบเขตจะค่อยๆ วิวัฒนาการไปพร้อมกับการเติบโตของโปรเจกต์ การขยับจากการเรียกใช้ฟังก์ชันโดยตรงไปสู่การสร้างนามธรรมด้วย trait นั้นทำได้ไม่ยากตราบใดที่ขอบเขตระหว่างโมดูลมีความสะอาดตั้งแต่แรก ดังนั้น อย่ากดดันตัวเองให้ต้องสร้างสถาปัตยกรรมที่ “สมบูรณ์แบบไร้ที่ติ” ตั้งแต่วันแรก ขอเพียงแค่วางโครงสร้างเลเยอร์ให้ถูกต้อง แล้วสิ่งดีๆ อื่นๆ จะตามมาเองครับ