Dependency injection (Depends) ทำงานอย่างไร?

Question

Accepted Answer

ระบบ **dependency injection** ของ FastAPI ช่วยให้คุณประกาศ dependencies ที่นำกลับมาใช้ซ้ำได้ (functions/classes) ซึ่ง FastAPI จะเรียกและ **ฉีด (inject)** เข้าไปใน path operations ของคุณผ่าน `Depends()` มันถูกใช้สำหรับ logic ที่ใช้ร่วมกัน เช่น database sessions, การยืนยันตัวตน และพารามิเตอร์ที่ใช้ร่วมกัน — ทำให้โค้ดเป็น DRY และทดสอบได้

## dependency พื้นฐาน

```python
from fastapi import Depends

# a dependency is just a callable that returns something
def pagination(skip: int = 0, limit: int = 10):
    return {"skip": skip, "limit": limit}

@app.get("/items")
def list_items(params: dict = Depends(pagination)):   # FastAPI calls pagination() and injects the result
    return params
# the skip/limit query params are now handled by the reusable dependency
```

การประกาศ `params = Depends(pagination)` บอก FastAPI ให้เรียก `pagination` (โดยแก้ค่าพารามิเตอร์ *ของมันเอง* จาก request ด้วย) และส่งผลลัพธ์เข้าไปใน function ของคุณ dependency นั้นนำกลับมาใช้ซ้ำได้ในหลาย ๆ endpoint

## dependencies ที่มีการ cleanup (yield) — เช่น database sessions

```python
def get_db():
    db = SessionLocal()
    try:
        yield db                  # provide the session to the endpoint
    finally:
        db.close()                # cleanup runs AFTER the response — guaranteed

@app.get("/users")
def list_users(db = Depends(get_db)):
    return db.query(User).all()    # uses the injected, auto-closed session
```

dependency แบบ `yield` จะจัดหา resource และทำงาน teardown หลังจาก request — เป็น pattern มาตรฐานสำหรับ database sessions (เปิดก่อน ปิดหลัง โดยอัตโนมัติ)

## dependencies สามารถพึ่งพา dependencies อื่นได้

```python
def get_current_user(token: str = Depends(get_token)):   # depends on another dependency
    return decode(token)

@app.get("/me")
def me(user: User = Depends(get_current_user)):           # auth via injection
    return user
```

dependencies ก่อตัวเป็น tree — FastAPI จะแก้ทั้ง chain นี่คือวิธีที่การยืนยันตัวตนมักทำกัน (dependency `get_current_user`)

## class dependencies และการนำกลับมาใช้ซ้ำ

```python
@app.get("/items", dependencies=[Depends(verify_api_key)])   # run a dependency without using its return
def items(): ...                                              # e.g. enforce auth as a side effect
```

## ทำไมจึงสำคัญ

Dependency injection เป็นหนึ่งในฟีเจอร์ที่ทรงพลังและสำคัญที่สุดของ FastAPI — เป็นวิธีที่คุณแบ่งปันและนำ logic กลับมาใช้ซ้ำได้อย่างสะอาดในหลาย endpoint (database sessions, การยืนยันตัวตน, พารามิเตอร์ query ที่ใช้ร่วมกัน, การตรวจสอบสิทธิ์) โดยไม่ต้องเขียนซ้ำ

การเข้าใจมันเป็นสิ่งจำเป็นเพราะมันรองรับ pattern หลัก ๆ: **`yield` dependency** เป็นวิธีมาตรฐานในการจัดการ database sessions (พร้อม cleanup ที่รับประกันหลังแต่ละ request) และ **`get_current_user` dependency** เป็นวิธีที่เป็นสำนวน (idiomatic) ในการ implement การยืนยันตัวตน

DI ยังทำให้โค้ด **ทดสอบได้** สูง — คุณสามารถ override dependencies ด้วย mocks ในการทดสอบได้

ความสง่างามของระบบ (dependencies แก้ค่าพารามิเตอร์ของตัวเองจาก request ได้, พึ่งพา dependencies อื่นเป็น tree ได้, และทำงานร่วมกับเอกสารได้) ทำให้มันเป็นเครื่องมืออเนกประสงค์สำหรับการจัดโครงสร้างแอปจริง ดังนั้นการเชี่ยวชาญ `Depends` จึงเป็นกุญแจสำคัญในการสร้างแอป FastAPI ที่จัดระเบียบดี ดูแลง่าย และทดสอบได้