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

Strategy Pattern: đóng gói thuật toán để hoán đổi lúc chạy

TL;DR: Strategy đóng gói mỗi cách làm (mỗi thuật toán) thành một đối tượng riêng chung một interface, để bạn hoán đổi cách làm ngay lúc chạy mà client không phải sửa gì. Nó chính là hiện thân trực tiếp của "composition over inheritance" và "program to an interface": thay vì đẻ một cây kế thừa cho từng biến thể hành vi, bạn tách hành vi ra rồi ghép vào. Khi có nhiều cách làm cho cùng một việc và cần đổi qua lại, Strategy là lựa chọn gọn nhất.

Bạn có một đơn hàng và cần tính phí ship. Hôm nay là phí tiêu chuẩn, mai chạy chương trình miễn phí, mốt lại thêm gói hoả tốc. Cùng một chỗ trong code, nhưng cách tính thay đổi liên tục. Nếu bạn nhét hết vào một chuỗi if/elif, mỗi lần thêm một kiểu là phải mở lại đúng cái hàm đó ra sửa. Strategy sinh ra để tách những "cách tính" đó thành các mảnh lắp rời, đổi qua lại thoải mái mà không đụng vào phần còn lại.

Strategy là gì

Strategy (mẫu chiến lược) là một design pattern nhóm hành vi (behavioral). Ý tưởng: đóng gói mỗi thuật toán/cách làm thành một đối tượng riêng, tất cả chia sẻ chung một interface. Phần code sử dụng (client) chỉ giữ một tham chiếu tới interface đó, nên bạn tráo cài đặt này bằng cài đặt khác lúc chạy mà client không hề biết và không cần đổi.

Hình dung bạn cần đi từ nhà tới sân bay. Đích đến cố định, nhưng phương tiện thì tuỳ chọn: đi bộ, chạy xe máy, hay bắt taxi. Mỗi phương tiện là một "chiến lược" khác nhau cho cùng một mục tiêu, có ưu nhược riêng (rẻ/nhanh/tiện). Bạn chọn phương tiện theo hoàn cảnh, còn "đi tới sân bay" thì không đổi. Strategy trong code cũng vậy: cái việc cần làm giữ nguyên, cách làm thì rút ra và cắm vào được.

Ba vai trong mẫu này:

  • Strategy (interface): hợp đồng chung, khai báo cái method mà mọi cách làm phải có.
  • Concrete Strategy: từng cài đặt cụ thể của thuật toán (phí tiêu chuẩn, phí hoả tốc...).
  • Context: đối tượng giữ một Strategy và uỷ thác công việc cho nó (ở ví dụ dưới là Order).

Vấn đề: chuỗi if/elif phình dần

Khi mới có hai kiểu, ai cũng viết thẳng bằng điều kiện. Trông rất ổn:

def shipping_fee(order, method):
    if method == "standard":
        return 10000 + order.weight_kg * 2000
    elif method == "express":
        return 25000 + order.weight_kg * 3000 + order.distance_km * 500
    elif method == "free":
        return 0
    # thêm "same_day", "locker", "cod"... -> nhánh cứ dài mãi

Vấn đề lộ ra khi số cách làm tăng. Mỗi lần thêm một kiểu ship, bạn phải mở đúng hàm này ra và thêm một nhánh, tức là sửa code đang chạy mỗi khi có yêu cầu mới. Đây là vi phạm nguyên tắc Open/Closed trong SOLID (mở để mở rộng, đóng với sửa đổi). Hàm càng lúc càng dài, các nhánh không liên quan nằm chung một chỗ, và muốn test riêng một cách tính cũng khó vì chúng dính vào nhau. Nếu logic mỗi nhánh còn phức tạp hơn (đọc cấu hình, gọi service), khối if/elif này nhanh chóng thành một cục khó bảo trì.

Cách hoạt động: tách mỗi cách làm thành một đối tượng

Ý tưởng của Strategy: mỗi nhánh if ở trên thực chất là một thuật toán độc lập. Hãy kéo mỗi cái ra thành một class riêng, cho chúng chung một interface, rồi để Order giữ một chiến lược và uỷ thác cho nó. Đây đúng là composition (Order có một strategy, ghép vào) đứng trên một interface chung:

from abc import ABC, abstractmethod

class ShippingStrategy(ABC):          # interface chung cho mọi cách tính phí
    @abstractmethod
    def fee(self, weight_kg, distance_km): ...

class StandardShipping(ShippingStrategy):
    def fee(self, weight_kg, distance_km):
        return 10000 + weight_kg * 2000

class ExpressShipping(ShippingStrategy):
    def fee(self, weight_kg, distance_km):
        return 25000 + weight_kg * 3000 + distance_km * 500

class FreeShipping(ShippingStrategy):
    def fee(self, weight_kg, distance_km):
        return 0

class Order:
    def __init__(self, weight_kg, distance_km, strategy: ShippingStrategy):
        self.weight_kg = weight_kg
        self.distance_km = distance_km
        self.strategy = strategy          # ghép chiến lược vào, không kế thừa

    def shipping_fee(self):
        return self.strategy.fee(self.weight_kg, self.distance_km)

order = Order(weight_kg=2, distance_km=15, strategy=StandardShipping())
print("Tieu chuan:", order.shipping_fee(), "d")

order.strategy = ExpressShipping()        # HOAN DOI luc chay, Order khong doi
print("Hoa toc  :", order.shipping_fee(), "d")

order.strategy = FreeShipping()
print("Mien phi :", order.shipping_fee(), "d")
Tieu chuan: 14000 d Hoa toc : 38500 d Mien phi : 0 d

Để ý dòng order.strategy = ExpressShipping(): cùng một order, chỉ tráo chiến lược là hành vi đổi hẳn, còn Order.shipping_fee không sửa một chữ. Thêm một kiểu ship mới bây giờ là viết một class mới, không cần đụng vào Order hay các chiến lược cũ. Mỗi cách tính nằm gọn một chỗ, test riêng từng cái cũng dễ. So với chuỗi if/elif lúc nãy, đây là khác biệt lớn nhất: hệ thống mở để mở rộng nhưng đóng với sửa đổi.

Biến thể trong Python: dùng luôn hàm làm chiến lược

Ở nhiều ngôn ngữ, Strategy bắt buộc phải là class vì hàm không phải "công dân hạng nhất" (first-class function). Python thì hàm là đối tượng, truyền đi được như mọi giá trị khác. Nếu một chiến lược chỉ là "nhận input, trả kết quả" và không cần giữ trạng thái, bạn bỏ hẳn class đi, dùng thẳng hàm cho gọn:

# Chien luoc chi la "mot ham nhan input, tra phi" -> dung luon ham, khoi class
def standard(weight_kg, distance_km):
    return 10000 + weight_kg * 2000

def express(weight_kg, distance_km):
    return 25000 + weight_kg * 3000 + distance_km * 500

def free(weight_kg, distance_km):
    return 0

def shipping_fee(weight_kg, distance_km, strategy):   # strategy la mot ham
    return strategy(weight_kg, distance_km)

for name, strat in [("Tieu chuan", standard), ("Hoa toc", express), ("Mien phi", free)]:
    print(f"{name:10}:", shipping_fee(2, 15, strat), "d")
Tieu chuan: 14000 d Hoa toc : 38500 d Mien phi : 0 d

Vẫn là Strategy đúng nghĩa: interface bây giờ là "một thứ gọi được, nhận (weight_kg, distance_km) và trả về số". Ít khuôn mẫu hơn hẳn. Khi nào nên quay lại dùng class? Khi chiến lược cần giữ cấu hình riêng (ví dụ mức phụ phí đọc từ config), cần nhiều method liên quan, hoặc bạn muốn interface tường minh để đọc code và bắt lỗi sớm. Còn với thuật toán một-hàm-là-đủ, first-class function là cách Python-ic nhất.

Khi nào dùng và khi nào không nên

Dùng Strategy khi:

  • Bạn có nhiều cách làm khác nhau cho cùng một việc (nhiều cách tính phí, nhiều cách nén, nhiều cách sắp xếp) và muốn đổi qua lại được.
  • Cách làm cần chọn lúc chạy theo cấu hình, theo loại người dùng, hay theo dữ liệu đầu vào.
  • Một hàm/lớp đang phình vì chứa quá nhiều nhánh if/elif cho các biến thể hành vi, và bạn muốn tách chúng ra để dễ test, dễ mở rộng.

Đừng dùng khi:

  • Chỉ có một-hai nhánh cố định, hiếm khi đổi. Lúc đó một if/else đơn giản là đủ và dễ đọc hơn. Dựng cả interface với vài class chỉ để bọc một điều kiện là trừu tượng hoá quá sớm, thêm tầng gián tiếp vô ích.
  • Các "chiến lược" thực ra chẳng khác nhau bao nhiêu, hoặc số biến thể sẽ không bao giờ tăng. Nhớ nguyên tắc: chỉ áp pattern khi cơn đau (khó thêm biến thể, hàm phình, khó test) đã thật sự xuất hiện.
Phân biệt nhẹ với State. State pattern nhìn rất giống Strategy về cấu trúc (đều ghép một đối tượng hành vi qua interface), nhưng khác ở chỗ ai điều khiển việc đổi. Với Strategy, client chọn chiến lược và thường giữ nguyên trong suốt một tác vụ. Với State, các trạng thái tự chuyển cho nhau tuỳ theo diễn biến bên trong. Nói ngắn: Strategy là "bạn chọn cách làm", State là "hệ thống tự đổi trạng thái".

Trong hệ thống thật

Trong code production, Strategy hiếm khi được gọi tên là "Strategy". Nó xuất hiện dưới những cái tên rất đời thường, và một khi bạn quen mặt thì sẽ thấy nó ở khắp nơi:

  • ShippingFeeStrategy: đúng ví dụ ở trên, nhưng ngoài đời còn tách theo vùng (nội thành, liên tỉnh, quốc tế) và theo bậc cân nặng. Mỗi hãng vận chuyển một bảng giá, mỗi bảng giá một chiến lược.
  • PricingStrategy hoặc DiscountStrategy: khuyến mãi theo chiến dịch. Giảm theo phần trăm, giảm số tiền cố định, mua 2 tặng 1, giá riêng cho khách thân thiết. Marketing đẻ chiến dịch mới hàng tháng, và bạn chỉ thêm một lớp chứ không mở lại hàm tính tiền.
  • RetryStrategy: khi gọi service ngoài bị lỗi thì chờ bao lâu rồi thử lại. Backoff cố định (cứ 2 giây một lần), backoff luỹ thừa (1, 2, 4, 8 giây), hoặc luỹ thừa có jitter (cộng thêm một khoảng ngẫu nhiên để tránh cả đàn client cùng dội lại một lúc).
  • AuthStrategy: cùng một client HTTP nhưng cách gắn danh tính vào request thì mỗi nơi một kiểu - API key trong header, OAuth với access token phải refresh, hay JWT tự ký. Phần gọi API không cần biết, nó chỉ bảo chiến lược "ký giùm cái request này".
  • Chiến lược chọn shard hoặc cân bằng tải: round-robin, least-connections, hash theo user id. Bộ định tuyến giữ nguyên, chỉ tráo cách chọn đích.
  • Chiến lược nén hoặc serialize: json cho dễ đọc khi debug, msgpack cho gọn, protobuf khi cần schema chặt và nhanh. Tầng lưu trữ hay tầng message chỉ thấy một interface dumps/loads.

Ngay trong thư viện chuẩn Python cũng có sẵn hai ví dụ bạn dùng hàng ngày mà không để ý. Tham số key= của sorted() chính là một strategy truyền vào dưới dạng hàm: thuật toán sắp xếp giữ nguyên, còn "so theo tiêu chí nào" thì bạn cắm vào. Và logging.Formatter cũng là một dạng chiến lược cắm vào handler: cùng một dòng log, đổi formatter là ra text cho người đọc hay ra JSON cho máy gom.

Hai họ hàng gần cũng hay bị nhầm khi đặt tên trong hệ thống thật. Nếu việc đổi cách làm không do người gọi quyết định mà do chính hệ thống tự chuyển theo diễn biến, cái bạn cần là State. Còn nếu khung xử lý luôn chạy đúng một trình tự và bạn chỉ muốn thay vài bước bên trong, đó là Template Method.

Trade-off

Được:

  • Thêm một cách làm mới chỉ là viết thêm một lớp (hoặc một hàm), không phải sửa code gọi - đúng tinh thần Open/Closed.
  • Hoán đổi được lúc chạy: theo cấu hình, theo môi trường, theo từng khách hàng, thậm chí theo từng request.
  • Mỗi chiến lược test riêng rất dễ, vì nó là một đơn vị độc lập với đầu vào và đầu ra rõ ràng, không cần dựng cả context lên mới chạy được.
  • Code gọi ngắn lại và hết rừng if: chỗ gọi chỉ còn một dòng uỷ thác, đọc là hiểu ngay nó đang làm gì.

Phải trả giá:

  • Sinh thêm nhiều lớp hoặc nhiều hàm nhỏ rải rác. Một khối if/elif 20 dòng có thể nở thành bốn file, và không phải lúc nào đó cũng là cải thiện.
  • Người đọc phải truy ngược mới biết chiến lược nào đang chạy. Đọc chỗ gọi chỉ thấy self.strategy.fee(...), muốn biết thật sự cái gì được gọi thì phải lần ra chỗ lắp ráp (factory, config, DI container).
  • Nếu các nhánh cần dữ liệu đầu vào khác nhau, interface chung bị kéo về mẫu số chung khó chịu: hoặc thêm tham số mà nửa số chiến lược bỏ qua, hoặc nhét tất cả vào một object "context" mơ hồ.
  • Với đúng hai nhánh cố định và gần như không bao giờ thêm, if/else vẫn gọn hơn và trung thực hơn. Đừng dựng giàn giáo cho một bức tường chưa cao.

Tóm tắt

  • Strategy đóng gói mỗi cách làm thành một đối tượng riêng chung một interface, cho phép hoán đổi lúc chạy mà client không đổi.
  • Nó là hiện thân trực tiếp của composition over inheritance (ghép hành vi thay vì kế thừa) và program to an interface (client chỉ phụ thuộc hợp đồng chung).
  • Nó thay chuỗi if/elif phình dần bằng các mảnh lắp rời: thêm cách làm mới là viết class mới, không sửa code cũ (tôn trọng Open/Closed).
  • Trong Python, khi chiến lược chỉ là một thuật toán không trạng thái, dùng thẳng hàm (first-class function) gọn hơn class.
  • Đừng lạm dụng: một-hai nhánh cố định thì if/else là đủ. Và nhớ phân biệt với State (client chọn vs tự chuyển).

Nguồn tham khảo

  • Gamma, Helm, Johnson, Vlissides (Gang of Four), Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley, 1994 - chương Strategy trong nhóm Behavioral.
Series Design Patterns - nhóm Behavioral. Strategy là cách áp dụng trực tiếp của hai nguyên tắc trong bài Program to interface & Composition over inheritance (bài đó đã gọi Strategy là hạt nhân - giờ bạn thấy vì sao). Xem toàn bộ lộ trình ở 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