ทำไมเราถึงต้องการ Patterns?

หลักการ S.O.L.I.D.

SRP: ความรับผิดชอบเดียว

class Report:
  def calculate_data(self):
    ...
  def format_html(self):
    ...
  def save_to_db(self):
    ...

class ReportData:
  def calculate(self): ...

class ReportFormatter:
  def to_html(self, data): ...

class ReportRepository:
  def save(self, data): ...

OCP: เปิด/ปิด

"ซอฟต์แวร์ควร เปิดกว้างต่อการขยาย แต่ ปิดต่อการแก้ไข" [7]

def get_area(shapes):
  for s in shapes:
    if type(s) == Rectangle:
       ...
    elif type(s) == Circle:
       ...
    # ต้องแก้ตรงนี้ถ้ามี Triangle!

class Shape(ABC):
  @abstractmethod
  def area(self): pass

# เพิ่ม Triangle โดยไม่กระทบโค้ดเดิม
class Triangle(Shape):
  def area(self): ...

LSP: การแทนที่ของ Liskov

class Rectangle:
  def set_w(self, w): ...
  def set_h(self, h): ...

class Square(Rectangle):
  def set_w(self, w):
     self.width = w
     self.height = w # Side effect!

def resize(rect):
  rect.set_w(10)
  rect.set_h(20)
  # คาดหวังพื้นที่ 200
  # ถ้าส่ง Square มา พื้นที่จะเป็น 400!
  assert rect.area() == 200

ISP: การแยกอินเทอร์เฟซ

"ไม่ควรบังคับให้ Client พึ่งพาเมธอดที่พวกเขาไม่ได้ใช้งาน" (อย่าทำ Interface ที่เทอะทะ) [9]

DIP: การกลับด้านความขึ้นต่อกัน

class App:
  def __init__(self):
    # พึ่งพา MySQL โดยตรง!
    self.db = MySQLDatabase()

  def get_data(self):
    self.db.query()

class App:
  # พึ่งพา Abstraction
  def __init__(self, db: DataSource):
    self.db = db

# ส่งสิ่งที่ต้องใช้เข้าไป (Injection)
app = App(MySQLDatabase())
app = App(PostgresDatabase())

Design Patterns: The Gang of Four

โซลูชันสำหรับปัญหาที่พบบ่อยในการออกแบบซอฟต์แวร์ แบ่งออกเป็น 3 ประเภท: [3]

Creational Patterns (รูปแบบการสร้าง)

Structural Patterns: Adapter

class OldSystem:
    def legacy_method(self):
        return "DATA_XML"

class NewSystem:
    def request(self):
        return "DATA_JSON"

class Adapter(NewSystem):
    def __init__(self, old_obj):
        self.old_obj = old_obj

    def request(self):
        # แปลงข้อมูลเก่าให้เข้ากับระบบใหม่
        data = self.old_obj.legacy_method()
        return convert_xml_to_json(data)

Structural Patterns: Decorator

# Base Component
class Coffee:
    def cost(self): return 50

# Decorator
class MilkDecorator:
    def __init__(self, coffee):
        self._coffee = coffee
    
    def cost(self):
        return self._coffee.cost() + 10

my_coffee = Coffee()
my_coffee = MilkDecorator(my_coffee) 
print(my_coffee.cost()) # 60

Behavioral: Observer Pattern

Behavioral: Strategy Pattern

class PaymentContext:
    def __init__(self, strategy):
        self.strategy = strategy
    
    def pay(self, amount):
        self.strategy.execute(amount)

# Strategies
class CreditCardStrategy:
    def execute(self, amount): 
        print(f"Paid {amount} via Card")

class PayPalStrategy:
    def execute(self, amount): 
        print(f"Paid {amount} via PayPal")

# Usage
context = PaymentContext(CreditCardStrategy())
context.pay(100) # Paid 100 via Card

Composition เหนือกว่า Inheritance?

Dependency Injection (DI)

เทคนิคสำคัญในการทำตามหลักการ DIP (Dependency Inversion)

class App:
  def __init__(self):
    # ผูกติดกับ MySQL
    self.db = MySQLDatabase()

class App:
  def __init__(self, db):
    # ยืดหยุ่น รับอะไรก็ได้ที่เป็น DB
    self.db = db

app = App(PostgresDatabase())

วิถีแห่ง Python: Duck Typing & Protocols

สิ่งที่ควรระวัง (Anti-Patterns)

สรุปบทเรียน: Design Patterns

เข้าสู่ ห้องปฏิบัติการ

การสร้าง "Log Viewer Application" ด้วย PySide6

ชั่วโมงปฏิบัติการ:
SOLID Principles in Action

สถาปัตยกรรม โปรเจกต์

เราจะไม่เขียนทุกอย่างใน `main.py` แต่จะแยกส่วนประกอบตามหน้าที่ (SRP)

Step 1: สร้าง Abstraction

from abc import ABC, abstractmethod
from typing import List

# Interface (Contract)
class ILogSource(ABC):
    
    @abstractmethod
    def get_logs(self) -> List[str]:
        """ดึงข้อมูล Logs กลับมาเป็น List ของ String"""
        pass

Step 2: สร้าง Concrete Classes

สร้างคลาสที่ทำงานจริง 2 แบบ (ไฟล์ services/file_source.py และ services/mock_source.py)

class FileLogSource(ILogSource):
    def __init__(self, filepath):
        self.filepath = filepath

    def get_logs(self) -> List[str]:
        try:
            with open(self.filepath, 'r') as f:
                return f.readlines()
        except FileNotFoundError:
            return ["Error: File not found"]

class MockLogSource(ILogSource):
    def get_logs(self) -> List[str]:
        return [
            "[INFO] System started",
            "[WARN] Memory usage high",
            "[ERROR] Connection lost"
        ]

Step 3: Dependency Injection ใน UI

from PySide6.QtWidgets import *

class MainWindow(QMainWindow):
    # รับ Abstraction เข้ามา (DIP)
    def __init__(self, source: ILogSource):
        super().__init__()
        self.source = source  # Composition
        self.init_ui()

    def load_data(self):
        # UI ไม่รู้ว่าข้อมูลมาจากไหน รู้แค่ get_logs()
        logs = self.source.get_logs()
        self.list_widget.addItems(logs)

Step 4: Factory Pattern

สร้าง Simple Factory เพื่อเลือกแหล่งข้อมูลตาม Configuration

class SourceFactory:
    @staticmethod
    def create_source(source_type: str) -> ILogSource:
        if source_type == "file":
            return FileLogSource("app.log")
        elif source_type == "mock":
            return MockLogSource()
        else:
            raise ValueError("Unknown type")

Step 5: Strategy Pattern

# Strategy Interface
class IFilterStrategy(ABC):
    @abstractmethod
    def filter(self, logs: List[str]) -> List[str]:
        pass

# Concrete Strategies
class ErrorOnlyFilter(IFilterStrategy):
    def filter(self, logs):
        return [l for l in logs if "ERROR" in l]

class NoFilter(IFilterStrategy):
    def filter(self, logs):
        return logs

Step 6: รวมร่าง (Composition Root)

ใน main.py เราจะเชื่อมต่อทุกส่วนเข้าด้วยกัน

import sys
from PySide6.QtWidgets import QApplication
from ui.main_window import MainWindow
from services.factory import SourceFactory

if __name__ == "__main__":
    app = QApplication(sys.argv)

    # 1. เลือก Source (เปลี่ยนแค่ตรงนี้ก็เปลี่ยนทั้งแอปได้)
    # ลองเปลี่ยนเป็น "file" หรือ "mock"
    source = SourceFactory.create_source("mock")

    # 2. Inject เข้าไปใน UI (Dependency Injection)
    window = MainWindow(source)
    window.show()

    sys.exit(app.exec())

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

สรุปการเรียนรู้