ทำไมต้องใช้ OOP ใน FastAPI?

รากฐานของ FastAPI: Type System & OOP

FastAPI ถูกสร้างมาบนพื้นฐานของ Python Type Hints ซึ่งสอดคล้องกับแนวคิด Class และ Object อย่างยิ่ง

from pydantic import BaseModel

class UserBase(BaseModel):
    username: str
    email: str

# Inheritance in Action
class UserCreate(UserBase):
    password: str

S - Single Responsibility Principle

O - Open/Closed Principle

"เปิดรับการขยาย (Extension) แต่ปิดกั้นการแก้ไข (Modification)"

# ขยายความสามารถด้วย Dependency
def get_current_user(token: str = Depends(oauth2_scheme)):
    # Logic ตรวจสอบ user
    ...

# ไม่ต้องแก้โค้ด read_items แค่เพิ่ม Depends
@app.get("/items")
def read_items(user = Depends(get_current_user)):
    ...

L - Liskov Substitution Principle

"Subtypes ต้องสามารถแทนที่ Base types ได้โดยไม่ทำให้โปรแกรมพัง"

I - Interface Segregation Principle

class UserBase(BaseModel):
    username: str

class UserCreate(UserBase):
    password: str  # Input มี password

class UserResponse(UserBase):
    id: int        # Output มี ID แต่ไม่มี Password
    
    class Config:
        orm_mode = True

D - Dependency Inversion Principle

โครงสร้างสถาปัตยกรรม (Layered Architecture)

การแบ่งเลเยอร์ช่วยให้โค้ดสะอาดและทำตามหลัก SRP

Design Pattern: Repository Pattern

class UserRepository:
    def __init__(self, db: Session):
        self.db = db

    def get_by_id(self, user_id: int):
        return self.db.query(User).filter(...).first()

    def create(self, user: UserCreate):
        # จัดการ logic การบันทึกลง DB
        ...

Design Pattern: Service Layer

Service Layer คือที่อยู่ของ "Business Logic" ที่แท้จริง

Design Pattern: Dependency Injection (DI)

# 1. นิยาม Dependency (เช่น การต่อ Database)
def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

# 2. Inject เข้าไปใน Route
@app.get("/users/")
def read_users(db: Session = Depends(get_db)):
    # FastAPI จะรัน get_db() และส่งผลลัพธ์มาให้ตัวแปร db
    return repository.get_users(db)

Design Pattern: Singleton

ใช้สำหรับสิ่งที่ควรมีแค่อันเดียวในระบบ เช่น Configuration หรือ Database Connection Pool

from functools import lru_cache

class Settings(BaseSettings):
    app_name: str = "My API"
    db_url: str

@lru_cache()
def get_settings():
    # โหลดไฟล์ config แค่ครั้งเดียว
    # ครั้งต่อไปจะดึงจาก Cache
    return Settings()

โครงสร้างโปรเจกต์แบบ Production Grade

การใช้ Abstract Base Class (ABC)

เพื่อให้ Service ไม่ยึดติดกับ Database ตัวใดตัวหนึ่ง เราควรกำหนด Interface ไว้ก่อน (DIP)

from abc import ABC, abstractmethod

# Interface (Contract)
class ITaskRepository(ABC):
    @abstractmethod
    def get_all(self):
        pass

    @abstractmethod
    def add(self, task):
        pass

# Service จะคุยกับ ITaskRepository แทนที่จะคุยกับ SQLRepository โดยตรง

การทดสอบ (Testing)

class MockTaskRepository(ITaskRepository):
    def __init__(self):
        self.tasks = []

    def add(self, task):
        self.tasks.append(task)
        return task

# Test Service โดยใช้ Mock
def test_create_task():
    repo = MockTaskRepository()
    service = TaskService(repo)
    service.create_task(...)

Design Pattern: Factory Pattern

ใช้สร้าง Object ที่ซับซ้อน หรือเลือก Implementation ตามสถานการณ์

สรุปประโยชน์ของการใช้ OOP ใน FastAPI

เตรียมตัวเข้าสู่ Lab Session

จบการบรรยาย

คำถามก่อนเริ่มลงมือปฏิบัติ?

Lab: Task Management API

Step 1: การตั้งค่าโปรเจกต์

Step 2: สร้าง Models (DTOs)

แก้ไขไฟล์ app/models.py เพื่อกำหนดโครงสร้างข้อมูลด้วย Pydantic

from pydantic import BaseModel
from typing import Optional

# Base Model (Shared properties)
class TaskBase(BaseModel):
    title: str
    description: Optional[str] = None
    completed: bool = False

# Model for Creation (Input)
class TaskCreate(TaskBase):
    pass

# Model for Reading (Output - includes ID)
class Task(TaskBase):
    id: int

    class Config:
        orm_mode = True

Step 3: สร้าง Repository Interface

แก้ไขไฟล์ app/repositories.py สร้าง Abstract Base Class (DIP Principle)

from abc import ABC, abstractmethod
from typing import List
from .models import Task, TaskCreate

class ITaskRepository(ABC):
    
    @abstractmethod
    def get_all(self) -> List[Task]:
        pass

    @abstractmethod
    def create(self, task: TaskCreate) -> Task:
        pass
        
    @abstractmethod
    def get_by_id(self, task_id: int) -> Optional[Task]:
        pass

Step 4: สร้าง InMemoryRepository

เพิ่มโค้ดใน app/repositories.py เพื่อจำลอง Database ด้วย List

class InMemoryTaskRepository(ITaskRepository):
    def __init__(self):
        self.tasks = []
        self.current_id = 1

    def get_all(self) -> List[Task]:
        return self.tasks

    def create(self, task_in: TaskCreate) -> Task:
        task = Task(
            id=self.current_id,
            **task_in.dict()
        )
        self.tasks.append(task)
        self.current_id += 1
        return task

    def get_by_id(self, task_id: int) -> Optional[Task]:
        for task in self.tasks:
            if task.id == task_id:
                return task
        return None

Step 5: สร้าง Service Layer

แก้ไข app/services.py (Business Logic)

from .repositories import ITaskRepository
from .models import TaskCreate

class TaskService:
    def __init__(self, repo: ITaskRepository):
        self.repo = repo

    def get_tasks(self):
        return self.repo.get_all()

    def create_task(self, task_in: TaskCreate):
        # Business logic could go here
        return self.repo.create(task_in)

Step 6: เชื่อมต่อใน Main App

แก้ไข app/main.py

from fastapi import FastAPI, Depends
from typing import List
from .models import Task, TaskCreate
from .repositories import InMemoryTaskRepository, ITaskRepository
from .services import TaskService

app = FastAPI()

# Singleton Repository Instance
task_repo = InMemoryTaskRepository()

# Dependency Provider
def get_task_service():
    return TaskService(task_repo)

@app.get("/tasks", response_model=List[Task])
def read_tasks(service: TaskService = Depends(get_task_service)):
    return service.get_tasks()

@app.post("/tasks", response_model=Task)
def create_task(
    task: TaskCreate, 
    service: TaskService = Depends(get_task_service)
):
    return service.create_task(task)

Step 7: รันและทดสอบ

Step 8: ก้าวสู่ Database จริง (Advanced)

ตอนนี้เราใช้ In-Memory ถ้าปิดแอปข้อมูลจะหาย เราจะเปลี่ยนไปใช้ SQLite โดยไม่แก้ Service Code

SQL Repository Implementation

# app/repositories.py (เพิ่มต่อท้าย)
from sqlalchemy.orm import Session
from . import models_orm  # ต้องสร้าง SQLAlchemy Model แยก

class SqlTaskRepository(ITaskRepository):
    def __init__(self, db: Session):
        self.db = db

    def get_all(self) -> List[Task]:
        return self.db.query(models_orm.Task).all()

    def create(self, task_in: TaskCreate) -> Task:
        db_task = models_orm.Task(**task_in.dict())
        self.db.add(db_task)
        self.db.commit()
        self.db.refresh(db_task)
        return db_task
    
    def get_by_id(self, id: int):
        # ... implementation ...
        pass

Step 9: สลับ Repository (Magic of DIP)

กลับไปที่ main.py และเปลี่ยนแค่ Dependency Provider

# main.py

# เดิม:
# def get_task_service():
#     return TaskService(InMemoryTaskRepository())

# ใหม่ (ใช้ SQL):
def get_task_service(db: Session = Depends(get_db)):
    repo = SqlTaskRepository(db)
    return TaskService(repo)

Step 10: การเขียน Test

สร้างไฟล์ tests/test_service.py

from app.services import TaskService
from app.repositories import InMemoryTaskRepository
from app.models import TaskCreate

def test_create_task():
    # Arrange
    repo = InMemoryTaskRepository()
    service = TaskService(repo)
    task_data = TaskCreate(title="Test Task")

    # Act
    created_task = service.create_task(task_data)

    # Assert
    assert created_task.title == "Test Task"
    assert created_task.id == 1
    assert len(repo.get_all()) == 1

ภารกิจท้าทาย (Challenge 1)

ภารกิจท้าทาย (Challenge 2)

Lab Complete!

คุณได้สร้าง API ที่มีโครงสร้างระดับ Production Grade แล้ว