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

การจัดการสถานะ

หากคุณเคยสร้างเว็บเซอร์วิส แม้จะเป็นเพียงโปรเจกต์ขนาดเล็ก คุณคงคุ้นเคยกับโจทย์นี้ดี: ฟังก์ชันแฮนด์เลอร์ของคุณจำเป็นต้องเข้าถึงทรัพยากรที่ใช้ร่วมกัน เช่น พูลฐานข้อมูล, ค่าคอนฟิกูเรชัน, อินสแตนซ์ของเซอร์วิส หรือแคชในหน่วยความจำ ทุกคำขอที่ส่งเข้ามาต่างต้องการสิ่งเหล่านี้ไม่มากก็น้อย และคุณต้องมีวิธีส่งข้อมูลเหล่านี้เข้าไปยังแฮนด์เลอร์โดยไม่ต้องส่งผ่านพารามิเตอร์ของฟังก์ชันทีละสิบกว่าตัว Axum มีวิธีจัดการเรื่องนี้ที่ปลอดภัยด้านชนิดข้อมูล (type-safe) ผ่านตัวแยกข้อมูล (extractor) State และเมื่อคุณเริ่มคุ้นเคยกับมันแล้ว คุณจะพบว่ามันใช้งานได้อย่างเป็นธรรมชาติและสะดวกอย่างยิ่ง

struct AppState

แพตเทิร์นที่ผมเลือกใช้เป็นประจำคือการสร้าง struct เดี่ยวๆ ขึ้นมาเพื่อเก็บทุกสิ่งที่แฮนด์เลอร์จำเป็นต้องใช้ จากนั้นส่ง struct นี้ให้กับเราเตอร์ผ่าน .with_state() แล้วปล่อยให้ Axum จัดการส่วนที่เหลือให้ทั้งหมด สิ่งสำคัญจุดหนึ่งที่ต้องจำไว้คือ struct นี้ต้อง implement Clone เสมอ เนื่องจาก Axum จะทำการ clone ค่านี้ทุกครั้งที่มีการเรียกใช้แฮนด์เลอร์

#![allow(unused)]
fn main() {
use sqlx::PgPool;
use std::sync::Arc;

#[derive(Clone)]
pub struct AppState {
    pub config: Arc<Config>,
    pub db: PgPool,
    pub user_service: UserService<PostgresUserRepo>,
    pub post_service: PostService<PostgresPostRepo>,
}

impl AppState {
    pub fn new(config: Config, pool: PgPool) -> Self {
        let user_repo = PostgresUserRepo::new(pool.clone());
        let post_repo = PostgresPostRepo::new(pool.clone());

        Self {
            config: Arc::new(config),
            db: pool,
            user_service: UserService::new(user_repo),
            post_service: PostService::new(post_repo),
        }
    }
}
}

มีข้อพิจารณาในการออกแบบที่น่าสนใจหลายจุดในโค้ดตัวอย่างนี้:

เราครอบ Config ไว้ด้วย Arc เนื่องจากคอนฟิกเป็นข้อมูลแบบอ่านอย่างเดียว (read-only) ภายหลังจากที่เริ่มต้นระบบเสร็จสิ้น และอาจมีขนาดข้อมูลค่อนข้างใหญ่ การใช้ Arc จะทำให้การ clone มีต้นทุนต่ำมาก (เพียงแค่เพิ่มตัวนับ reference count) แทนที่จะต้องทำ deep copy ข้อมูลคอนฟิกทั้งก้อนทุกครั้งที่ AppState ถูก clone ซึ่งความแตกต่างของต้นทุนนี้จะส่งผลอย่างมีนัยสำคัญเมื่อระบบต้องรองรับคำขอนับพันต่อวินาที

สำหรับ PgPool นั้นมีกลไก reference counting ภายในตัวอยู่แล้ว การ clone จึงมีต้นทุนต่ำมากเช่นกัน โดยคุณจะพบว่าชนิดข้อมูลพูลการเชื่อมต่อส่วนใหญ่ในระบบนิเวศของ Rust ล้วนออกแบบมาในลักษณะนี้

ส่วนเลเยอร์เซอร์วิสและรีพอสิทอรีจะถูกสร้างขึ้นเพียงครั้งเดียวในตอนเริ่มต้นระบบ จากนั้นจึงนำไปแชร์ใช้งานร่วมกันในทุกคำขอ ผมมองว่าจุดนี้ทำหน้าที่เป็น Composition Root ของแอปพลิเคชัน เป็นศูนย์กลางจุดเดียวที่เราประกอบเชื่อมต่อ (wiring) ดีเพนเดนซีทั้งหมดเข้าด้วยกัน และหากคุณต้องการสลับไปใช้ Test Double หรือ Mock สำหรับรีพอสิทอรีในการทดสอบ จุดนี้ก็คือจุดที่คุณจะเข้ามาปรับแต่ง

การดึงสถานะในแฮนด์เลอร์

แล้วแฮนด์เลอร์ของเราจะเข้าถึงสถานะได้อย่างไร? ผ่านตัวแยกข้อมูล State:

#![allow(unused)]
fn main() {
async fn list_users(
    State(state): State<AppState>,
) -> AppResult<Json<Vec<UserResponse>>> {
    let users = state.user_service.list_all().await?;
    Ok(Json(users.into_iter().map(Into::into).collect()))
}
}

ดูตรงไปตรงมามากใช่ไหมครับ? แต่คุณอาจสังเกตเห็นว่าแฮนด์เลอร์ทุกตัวจะได้รับ AppState ไปทั้งก้อน แม้ว่าจะต้องการเข้าถึงเพียงฟิลด์เดียวก็ตาม สำหรับแอปพลิเคชันขนาดเล็ก แนวทางนี้ก็ถือว่าใช้ได้ดีและไม่มีปัญหาอะไร แต่เมื่อโปรเจกต์เติบโตขึ้นเรื่อยๆ คุณอาจต้องการความสามารถในการควบคุมที่ละเอียด (granular) ยิ่งกว่านี้

สถานะย่อยด้วย FromRef

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

Axum มี derive macro ที่ช่วยสร้างโค้ดการอิมพลีเมนต์ FromRef สำหรับแต่ละฟิลด์ให้โดยอัตโนมัติ:

#![allow(unused)]
fn main() {
use axum::extract::FromRef;

#[derive(Clone, FromRef)]
pub struct AppState {
    config: Arc<Config>,
    db: PgPool,
    user_service: UserService<PostgresUserRepo>,
    post_service: PostService<PostgresPostRepo>,
}
}

การ derive เพียงครั้งเดียวจะช่วยลดภาระในการเขียนบล็อก impl FromRef<AppState> for ... ด้วยตัวเองในทุกๆ ฟิลด์ โดยระบบจะสร้างโค้ดอิมพลีเมนต์สำหรับชนิดข้อมูลของแต่ละฟิลด์ และหยิบฟิลด์จาก struct มาเชื่อมโยงให้อย่างถูกต้อง

คราวนี้ แฮนด์เลอร์ที่ต้องการใช้งานเพียงแค่เซอร์วิสผู้ใช้ ก็สามารถระบุความต้องการเฉพาะสิ่งนั้นได้ทันที:

#![allow(unused)]
fn main() {
async fn get_user(
    State(user_service): State<UserService<PostgresUserRepo>>,
    Path(id): Path<Uuid>,
) -> AppResult<Json<UserResponse>> {
    let user = user_service.get_by_id(UserId::from_uuid(id))
        .await?
        .ok_or(AppError::NotFound)?;
    Ok(Json(user.into()))
}
}

นอกจากนี้ แพตเทิร์นดังกล่าวยังทำงานร่วมกับตัวแยกข้อมูลแบบกำหนดเอง (Custom Extractor) ได้อย่างลงตัว ตัวอย่างเช่น ตัวแยกข้อมูล AuthUser ของเรา (ซึ่งเราจะไปสร้างกันในบท การยืนยันตัวตนและการอนุญาตสิทธิ์) สามารถดึง JWT secret ออกมาจาก State ผ่าน FromRef ได้โดยตรง โดยไม่จำเป็นต้องรับรู้ถึงฟิลด์อื่นๆ เลย ทำให้แต่ละส่วนแยกขาดจากกันอย่างเป็นระเบียบ (clean decoupling)

State เทียบกับ Extension

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

State ได้รับการตรวจสอบความถูกต้องของชนิดข้อมูลตั้งแต่ตอนคอมไพล์ หากคุณลืมเรียก .with_state() หรือระบุชนิดข้อมูลไม่ตรงกัน คอมไพเลอร์จะแจ้งเตือนข้อผิดพลาดทันที ซึ่งข้อดีเพียงข้อนี้ก็เพียงพอแล้วที่จะทำให้ State เป็นตัวเลือกเริ่มต้นของผมเสมอ

Extension จะจัดเก็บข้อมูลไว้ใน Type-map ภายในคำขอ (Request) เอง ซึ่งจะถูกตรวจสอบเฉพาะ ณ เวลารันไทม์เท่านั้น นั่นหมายความว่าหากเกิดข้อผิดพลาดหรือหาข้อมูลไม่พบ ระบบจะแสดงผลเป็น HTTP 500 Internal Server Error เมื่อคำขอจริงวิ่งมาถึงแฮนด์เลอร์ ซึ่งไม่ใช่เรื่องที่ดีนัก อย่างไรก็ตาม Extension ก็มีประโยชน์และเหมาะสมอย่างยิ่งสำหรับข้อมูลที่มิดเดิลแวร์นำมาผูกไว้ในระดับรายคำขอ (request-scoped data) เช่น ข้อมูลผู้ใช้ที่ผ่านการยืนยันตัวตนแล้วซึ่งถูกแกะออกมาจาก JWT

หลักคิดง่ายๆ ที่ผมใช้คือ: เลือกใช้ State สำหรับดีเพนเดนซีระดับแอปพลิเคชันที่เตรียมไว้ตั้งแต่ตอนเริ่มต้นระบบ (คอนฟิก, พูลฐานข้อมูล, เซอร์วิส) และเลือกใช้ Extension สำหรับข้อมูลเฉพาะของแต่ละคำขอที่มิดเดิลแวร์สร้างหรือแนบขึ้นมาระหว่างการทำงาน (on the fly)

การหลีกเลี่ยงข้อผิดพลาดที่พบบ่อย

ก่อนที่เราจะไปยังบทถัดไป ผมขอแชร์บทเรียนสำคัญสองสามข้อที่ผม (หรือทีมงาน) เคยเจ็บปวดมาแล้วบน Production:

อย่าใส่ Mutex<T> ลงใน State เว้นแต่คุณจะไตร่ตรองมาอย่างรอบคอบจริงๆ ผมเคยเห็นบั๊กจากจุดนี้มานับไม่ถ้วน การถือ lock ของ Mutex ข้ามจุด .await อาจนำไปสู่ปัญหา Deadlock หรือเกิด Lock Contention อย่างรุนแรงในโค้ดที่เป็น Asynchronous หากคุณจำเป็นต้องมี Shared Mutable State (เช่น แคชในหน่วยความจำ) ให้เลือกใช้ tokio::sync::RwLock ที่เข้าใจกลไกของ Asynchronous หรือทางที่ดีกว่านั้นคือเลือกใช้เครตอย่าง moka หรือ dashmap ที่ออกแบบมาสำหรับรองรับการเข้าถึงพร้อมกัน (concurrent access) โดยเฉพาะ

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

สร้าง State เพียงครั้งเดียวในตอนเริ่มต้นระบบ อย่าสร้างอินสแตนซ์ใหม่ของเซอร์วิสหรือรีพอสิทอรีภายในฟังก์ชันแฮนด์เลอร์ หัวใจสำคัญของแพตเทิร์น AppState คือการประกอบเชื่อมต่อ (wiring) ดีเพนเดนซีทั้งหมดไว้เพียงจุดเดียวตั้งแต่ต้น (ในฟังก์ชัน main หรือฟังก์ชัน setup) จากนั้นแชร์อินสแตนซ์เหล่านั้นแบบอ่านอย่างเดียว (immutable) ไปยังทุกๆ คำขอ เมื่อคุณเข้าใจและยึดหลักการนี้ โครงสร้างแอปพลิเคชันของคุณจะอ่านและดูแลรักษาได้ง่ายขึ้นอย่างมหาศาล