👋 Chào mừng đến với Nocoem — kiến thức Backend, System Design và lập trình. Khám phá ngay

Design Pattern là gì? Bản chất và khi nào nên (không nên) dùng

Design Pattern là gì - Nocoem
TL;DR: Design pattern (mẫu thiết kế) là một giải pháp đã được đặt tên cho một vấn đề thiết kế lặp đi lặp lại. Nó là từ vựng để bàn về thiết kế, không phải đoạn code để copy-paste. Điều quan trọng nhất: pattern là kết quả bạn nhận ra khi giải đúng vấn đề, không phải mục tiêu áp từ đầu. Và rất nhiều pattern quan trọng có thể nhìn dưới cùng một lăng kính: đóng gói cái hay thay đổi.

Có một cái bẫy mà gần như ai mới học design pattern cũng dính: mở một bài toán ra là hỏi ngay "nên dùng pattern nào ở đây?". Khi trong tay chỉ có một cây búa, nhìn đâu cũng thấy đinh. Kết quả là code phức tạp hơn hẳn mà chẳng giải quyết vấn đề thật nào.

Bài này là bài mở đầu của series Design Patterns. Tôi sẽ không liệt kê 23 mẫu ngay, mà nói về bản chất trước, vì đó mới là phần quyết định bạn dùng pattern đúng hay lạm dụng. Từng mẫu cụ thể sẽ được mổ xẻ ở các bài sau.

1. Design pattern không phải là code

Đây là hiểu lầm phổ biến nhất. Một pattern không phải là một class hay một đoạn code cụ thể. Nó là ý tưởng về cấu trúc quan hệ giữa các đối tượng để giải một vấn đề hay gặp.

Ví dụ, "Observer" không phải là một class Observer nào đó. Nó là ý tưởng: "khi một đối tượng đổi trạng thái, nó cần báo cho nhiều đối tượng khác mà không cần biết cụ thể chúng là ai". Bạn cài đặt ý tưởng đó trong Java, Python hay JavaScript sẽ ra code khác nhau hoàn toàn, nhưng bản chất (cấu trúc quan hệ) thì như nhau.

Nói cách khác, pattern là từ vựng (vocabulary), không phải cú pháp (syntax). Khi bạn nói "chỗ này dùng Strategy đi", đồng đội hiểu ngay ý đồ thiết kế mà không cần bạn giải thích dài dòng. Đó là giá trị lớn nhất của pattern: một ngôn ngữ chung giữa các lập trình viên.

2. Pattern sinh ra từ quan sát, không phải phát minh

Nhóm Gang of Four (GoF) - bốn tác giả của cuốn sách kinh điển năm 1994 - không "nghĩ ra" 23 mẫu. Họ quan sát hàng trăm hệ thống tốt và nhận ra: cùng một vấn đề cứ lặp lại, và những người giỏi luôn giải nó theo cùng một cấu trúc. Rồi họ đặt tên và hệ thống hoá lại.

Điều này dẫn tới một hệ quả quan trọng: pattern là kết quả, không phải mục tiêu. Bạn không nên bắt đầu bằng "tôi nên dùng pattern nào?", mà bằng "vấn đề của tôi là gì?". Giải nó cho tử tế, rồi tới một lúc bạn nhận ra "à, đây đúng là tình huống mà Factory giải quyết". Pattern xuất hiện như một lối thoát tự nhiên, chứ không phải khuôn ép từ đầu.

3. Một lăng kính hữu ích: đóng gói cái hay thay đổi

Rất nhiều pattern quan trọng có thể nhìn dưới một lăng kính chung: cô lập phần code hay thay đổi khỏi phần code ổn định. Câu thần chú của GoF là "encapsulate what varies" (đóng gói cái gì hay thay đổi), và một loạt mẫu quen thuộc chỉ là biến thể của ý tưởng đó:

PatternCái "hay thay đổi" được tách ra
StrategyThuật toán: tách thành các class hoán đổi được
FactoryCách tạo đối tượng: tách logic tạo khỏi logic dùng
DecoratorHành vi bổ sung: bọc thêm thay vì sửa class gốc
ObserverDanh sách "người quan tâm": tách người phát tin khỏi người nhận

Cần nói rõ: đây là ống kính hữu ích để bắt đầu, không phải công thức duy nhất giải thích được toàn bộ 23 mẫu GoF. Một số pattern có động cơ khác hẳn: Iterator sinh ra để duyệt qua một tập hợp mà không lộ cấu trúc bên trong, Memento để lưu và khôi phục trạng thái của một đối tượng, Visitor để tách thuật toán ra khỏi cấu trúc dữ liệu mà nó chạy trên đó. Dùng "đóng gói cái hay thay đổi" như cửa vào thì tốt, nhưng đừng ép mọi mẫu phải chui vừa một câu.

4. Xem pattern hình thành: một hệ thống tính phí thanh toán

Lý thuyết dễ gật gù đồng ý, nhưng chỉ thật sự thấm khi thấy code xấu dần đi ngay trước mắt. Hãy đi qua từng bước một hệ thống tính phí thanh toán, y như nó sẽ xảy ra trong một sprint thực tế.

Bước 0. Yêu cầu ban đầu chỉ là "tính phí khi thanh toán bằng thẻ tín dụng". Code viết thẳng, không có gì để bàn:

def process_payment(amount):
    fee = amount * 0.029 + 0.30  # phí kiểu Stripe cho thẻ credit
    return amount + fee

Bước 1. Thêm PayPal. if/elif là công cụ tự nhiên nhất cho 2 nhánh, vẫn chưa có gì sai:

def process_payment(amount, method):
    if method == "credit_card":
        fee = amount * 0.029 + 0.30
    elif method == "paypal":
        fee = amount * 0.034 + 0.49
    return amount + fee

Bước 2. Rồi business yêu cầu dồn dập: bank transfer (phí cố định), crypto (phải gọi API lấy phí network), Apple Pay (phí khác nhau theo quốc gia người dùng). Code "tự nhiên" sẽ trông thế này:

def process_payment(amount, method, **kwargs):
    if method == "credit_card":
        fee = amount * 0.029 + 0.30
    elif method == "paypal":
        fee = amount * 0.034 + 0.49
    elif method == "bank_transfer":
        fee = 5.00
    elif method == "crypto":
        network_fee = get_current_network_fee(kwargs.get("currency"))
        fee = amount * 0.01 + network_fee
    elif method == "apple_pay":
        country = kwargs.get("country")
        fee = amount * (0.025 if country == "US" else 0.032)
    return amount + fee

Đây là lúc cơn đau thật sự xuất hiện, không còn là lý thuyết:

  • Hàm này giờ phải biết chi tiết về mọi phương thức thanh toán - một class/hàm gánh quá nhiều trách nhiệm.
  • Muốn thêm phương thức mới nghĩa là phải sửa vào hàm cũ - mỗi lần thêm là một lần rủi ro làm vỡ logic đang chạy tốt cho apple_pay hay crypto.
  • **kwargs xuất hiện vì tham số không còn đồng nhất giữa các nhánh - đây là code smell kinh điển báo hiệu hàm đang cố làm quá nhiều việc khác nhau.
  • Viết unit test cho riêng crypto giờ bắt buộc phải mock luôn cả import và setup của những nhánh chẳng liên quan.

Bước 3. Câu hỏi chìa khoá lúc này: cái gì đang thay đổi ở đây? Câu trả lời là cách tính phí. Vậy đóng gói đúng cái đang thay đổi, mỗi phương thức là một class riêng cùng chung một giao diện:

from abc import ABC, abstractmethod

class PaymentStrategy(ABC):
    @abstractmethod
    def calculate_fee(self, amount): ...

class CreditCard(PaymentStrategy):
    def calculate_fee(self, amount):
        return amount * 0.029 + 0.30

class PayPal(PaymentStrategy):
    def calculate_fee(self, amount):
        return amount * 0.034 + 0.49

def total_charge(amount, strategy):
    return amount + strategy.calculate_fee(amount)

for s in (CreditCard(), PayPal()):
    print(f"{type(s).__name__:11} tong thu tren 100 = {total_charge(100, s):.2f}")
CreditCard tong thu tren 100 = 103.20 PayPal tong thu tren 100 = 103.89

Giờ thêm Crypto hay ApplePay là thêm một class mới, không đụng vào CreditCard hay PayPal đang chạy ổn định; test từng class độc lập, mock riêng từng dependency của nó.

Đây chính là Strategy pattern, và nó "trả giá xứng đáng" đúng lúc bài toán đã đủ phức tạp - tức là ở Bước 2, không phải Bước 0. Nếu bạn viết nguyên bộ class này ngay từ khi mới có một phương thức thanh toán, đó lại là lạm dụng: bạn đang giải một vấn đề chưa tồn tại, đổi lấy sự linh hoạt mà chưa ai cần tới.

Cách Observer, Adapter và các pattern khác hình thành qua đúng nhịp điệu "đơn giản -> phình to -> đau -> tách ra" này sẽ được đi sâu ở các bài riêng của series.

5. Ba nhóm lớn và câu hỏi mỗi nhóm trả lời

Strategy ở trên là một pattern thuộc nhóm Behavioral, vì nó giải quyết chuyện các đối tượng giao tiếp và chia việc với nhau ra sao. Đó cũng là lúc đáng để nhìn toàn cảnh: 23 mẫu GoF chia thành ba nhóm, mỗi nhóm trả lời một câu hỏi thiết kế khác nhau:

NhómCâu hỏi cốt lõiVí dụ
Creational (khởi tạo)Đối tượng nên được tạo ra thế nào để hệ thống không phụ thuộc cứng vào class cụ thể?Factory, Builder, Singleton
Structural (cấu trúc)Các đối tượng/class nên được ghép lại với nhau thế nào?Adapter, Decorator, Facade
Behavioral (hành vi)Các đối tượng nên giao tiếp và chia trách nhiệm ra sao?Observer, Strategy, Command

6. Thứ quan trọng hơn cả pattern: nguyên tắc nền tảng

Pattern chỉ là hệ quả của vài nguyên tắc thiết kế sâu hơn. Nắm chắc mấy nguyên tắc này thì bạn tự nghĩ ra được pattern khi cần, thay vì phải thuộc lòng 23 cái tên:

  • Program to an interface, not an implementation: phụ thuộc vào cái trừu tượng, đừng phụ thuộc vào cái cụ thể.
  • Favor composition over inheritance: ghép nối linh hoạt tốt hơn kế thừa cứng nhắc.
  • Single Responsibility: mỗi class chỉ nên có một lý do để thay đổi - đây là chữ S trong SOLID.

Nếu bạn còn mới với hai ý đầu, hãy đọc lại nền tảng Lập trình hướng đối tượng (OOP) trước; pattern sẽ dễ vào hơn nhiều.

7. Cạm bẫy cần tránh

Over-engineering là lỗi số một. Áp pattern khi chưa có vấn đề thật khiến code phức tạp hơn để đổi lấy sự linh hoạt mà không ai cần. Viết PaymentStrategy ngay khi mới có một phương thức thanh toán (Bước 0 ở trên) chính là giải quyết vấn đề chưa tồn tại.
  • Đừng áp pattern quá sớm. Code đơn giản chạy tốt ở quy mô nhỏ thì cứ để nó đơn giản. Đau thật sự (khó test, khó mở rộng, một hàm biết quá nhiều thứ) xuất hiện rồi hãy refactor.
  • Pattern là công cụ giao tiếp, không phải checklist. Nó giúp các dev có kinh nghiệm nói cùng một ngôn ngữ, chứ không phải danh sách bắt buộc phải "dùng cho đủ".
  • Đừng ép bài toán vào pattern. Nhớ đúng thứ tự: vấn đề trước, pattern sau.

Cái giá của một pattern

Mọi pattern đều là một cuộc trao đổi, không phải món quà miễn phí. Nhìn thẳng vào cả hai vế trước khi quyết định.

Được:

  • Có một cái tên chung để trao đổi trong nhóm: nói "chỗ này là Strategy" nhanh hơn mô tả mười dòng.
  • Chỗ thay đổi được khoanh lại một nơi, thay vì rải rác khắp các nhánh if/elif.
  • Dễ mở rộng: thêm một biến thể là thêm một file mới, không đụng vào code đang chạy tốt.
  • Dễ test: phần biến thiên đã tách riêng nên test được độc lập, mock gọn từng thứ.

Phải trả giá:

  • Thêm một tầng gián tiếp: muốn đọc trọn một luồng, bạn phải mở nhiều file thay vì cuộn một hàm.
  • Người mới vào dự án tốn thời gian hơn để dựng lại bức tranh trong đầu.
  • Chọn sai pattern thì khoá cứng thiết kế theo hướng sai, gỡ ra tốn hơn nhiều so với lúc đặt vào.
  • Mọi trừu tượng đều phải được bảo trì: interface cũng là code, cũng phải sửa khi yêu cầu đổi.

Nguyên tắc của cả series này gói trong một câu: chỉ trả cái giá đó khi cơn đau đã xuất hiện, đừng trả trước cho một nỗi đau bạn mới chỉ tưởng tượng ra (đọc thêm Over-engineering: khi design pattern hại nhiều hơn lợi).

Trong hệ thống thật

Nghe "23 mẫu GoF" thì có vẻ hàn lâm, nhưng nếu bạn viết backend thì ngày nào cũng chạm vào chúng:

  • Middleware trong Django hay FastAPI: mỗi lớp xử lý request rồi quyết định có chuyển tiếp xuống lớp sau hay không - đó là Chain of Responsibility.
  • Signal của Django, event listener trong hệ thống pub/sub nội bộ: một chỗ phát tin, nhiều chỗ đăng ký nghe mà bên phát không cần biết là ai - Observer.
  • ast.NodeVisitor trong thư viện chuẩn Python: bạn viết các hàm visit_* để xử lý từng loại node, cấu trúc cây giữ nguyên - Visitor.
  • Lớp bọc quanh SDK bên thứ ba (cổng thanh toán, storage, gửi mail) để phần còn lại của hệ thống chỉ thấy interface của bạn chứ không thấy API của họ - Adapter.
  • Repository hoặc storage abstraction: business logic gọi một giao diện lưu trữ, bên dưới là Postgres hôm nay và cái khác ngày mai, hai bên tiến hoá độc lập - Bridge.
  • Một task trong Celery: lời gọi hàm kèm tham số được đóng gói thành đối tượng để đẩy vào hàng đợi, chạy sau, retry hay huỷ - Command.

Điểm đáng chú ý ở đây: bạn đã dùng pattern hằng ngày mà không gọi tên chúng. Học pattern phần lớn không phải học thêm kỹ thuật mới, mà là học cách gọi tên thứ mình đã gặp - để lần sau nhận ra sớm hơn, và bàn với đồng đội bằng một từ thay vì một đoạn giải thích.

Tóm tắt

  • Pattern là từ vựng mô tả một giải pháp cấu trúc, không phải code copy-paste.
  • Nó là kết quả của việc giải đúng vấn đề, không phải mục tiêu áp từ đầu.
  • Lăng kính chung của rất nhiều pattern: đóng gói cái hay thay đổi để cô lập nó khỏi phần ổn định - hữu ích để bắt đầu, nhưng không giải thích được mọi mẫu.
  • Nhịp điệu hình thành pattern: đơn giản -> phình to (if/elif, **kwargs) -> đau (khó test, khó mở rộng) -> tách ra thành pattern.
  • Ba nhóm: Creational (tạo), Structural (ghép), Behavioral (giao tiếp).
  • Hiểu nguyên tắc nền tảng (interface, composition, SRP) quan trọng hơn thuộc tên pattern.
  • Cạm bẫy lớn nhất là over-engineering: dùng pattern khi chưa cần.

Nguồn tham khảo

  • Gamma, Helm, Johnson, Vlissides (Gang of Four), Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley, 1994 - nguồn gốc của "encapsulate what varies" và 23 mẫu kinh điển.
  • Refactoring Guru, Design Patterns - tổng hợp trực quan cả 23 mẫu GoF kèm ví dụ minh hoạ, tham khảo tốt để đối chiếu cách trình bày.
Series Design Patterns. Đây là bài mở đầu. Bài tiếp theo trong nhóm Nền tảng: Lập trình hướng đối tượng (OOP) là gì? Xem toàn bộ lộ trình và các mẫu sẽ đi sâu ở mục lục Design Patterns.

- Kai

Thấy bài viết hữu ích?

0 lượt thích

Đăng nhận xét