if/elif kiểm tra trạng thái khắp nơi, mỗi trạng thái thành một class riêng tự biết cách xử lý và tự quyết chuyển sang trạng thái nào. Kết quả: thêm trạng thái mới không phải sửa lại mớ điều kiện cũ.Bạn có một đối tượng mà cùng một hành động lại cho kết quả khác nhau tuỳ lúc. Đơn hàng lúc chờ thanh toán thì không cho giao; thanh toán xong mới giao được; giao rồi thì thôi. Cửa quay (turnstile) đang khoá thì đẩy không qua; bỏ xu vào mới mở. Cách phản xạ đầu tiên là nhét một biến trạng thái rồi if tứ tung. Bài này nói về State pattern: cách gói mỗi trạng thái thành một đối tượng để logic gọn lại và dễ mở rộng.
State pattern là gì
State là một mẫu thuộc nhóm Behavioral (hành vi). Ý tưởng: bạn có một đối tượng ngữ cảnh (context) mang trong mình một trạng thái. Thay vì để context tự xử lý mọi tình huống bằng điều kiện, bạn tách mỗi trạng thái ra một class riêng. Context chỉ ủy thác (delegate) lời gọi cho đối tượng trạng thái hiện tại; chính đối tượng trạng thái mới biết phải làm gì và khi nào chuyển sang trạng thái khác.
Hình dung cái máy bán nước tự động. Nó có vài trạng thái rõ ràng: chờ tiền, đã có tiền, đang nhả hàng, hết hàng. Cùng một thao tác "nhấn nút chọn nước", máy phản ứng khác nhau: ở trạng thái chờ tiền thì báo "bỏ tiền vào đi"; ở trạng thái đã có tiền thì nhả hàng rồi quay về chờ tiền. Máy không đổi, nhưng hành vi đổi theo trạng thái. Đèn giao thông cũng vậy: xanh, vàng, đỏ, mỗi màu tự biết màu kế tiếp là gì.
Điểm cốt lõi: trạng thái tự quyết bước chuyển tiếp. Không có một chỗ trung tâm nào ngồi phán "nếu đang X và gặp Y thì sang Z". Mỗi trạng thái tự ôm phần luật của riêng nó.
Vấn đề: khối if/elif theo trạng thái phình to
Giả sử làm một đơn hàng với ba trạng thái: pending (chờ thanh toán), paid (đã thanh toán), shipped (đã giao). Cách quen thuộc là giữ một chuỗi trạng thái rồi phân nhánh trong từng hành động:
class Order:
def __init__(self):
self.status = "pending"
def pay(self):
if self.status == "pending":
self.status = "paid"
return "Da thanh toan"
elif self.status == "paid":
return "Don nay da thanh toan roi"
elif self.status == "shipped":
return "Don da giao, khong can thanh toan"
def ship(self):
if self.status == "pending":
return "Khong the giao: don chua thanh toan"
elif self.status == "paid":
self.status = "shipped"
return "Da giao hang"
elif self.status == "shipped":
return "Don da duoc giao truoc do"
Với ba trạng thái thì còn đọc được. Nhưng để ý mấy vấn đề đang lớn dần:
- Luật của một trạng thái bị xé lẻ. Muốn biết trạng thái
paidhành xử ra sao, bạn phải đọc nhánhpaidtrong mọi method. Logic của một trạng thái không nằm gọn một chỗ. - Thêm trạng thái là sửa khắp nơi. Có thêm
cancelled(đã huỷ) hayrefunded(đã hoàn tiền)? Bạn phải mở lại từng method và chèn thêm nhánh. Càng nhiều method lẫn nhiều trạng thái, số nhánh nhân theo tổ hợp. - Dễ sót nhánh. Thêm hành động
refundmà quên xử lý một trạng thái nào đó, hàm trả vềNonelặng lẽ, không ai báo.
Đây chính là kiểu code vi phạm nguyên tắc Open/Closed trong SOLID: mỗi lần mở rộng là phải sửa code cũ đang chạy tốt.
Cách hoạt động: mỗi trạng thái một class
State pattern lật ngược cách tổ chức: thay vì gom theo hành động rồi rẽ nhánh theo trạng thái, ta gom theo trạng thái. Mỗi trạng thái là một class cài đặt cùng một giao diện (interface), tự lo mọi hành động và tự quyết chuyển tiếp. Context (đơn hàng) chỉ giữ trạng thái hiện tại và ủy thác lời gọi.
from abc import ABC, abstractmethod
class State(ABC): # interface chung cho moi trang thai
name = "?"
@abstractmethod
def pay(self, order): ...
@abstractmethod
def ship(self, order): ...
class Pending(State):
name = "Cho thanh toan"
def pay(self, order):
order.state = Paid() # tu chuyen sang trang thai ke tiep
return "Da thanh toan, chuyen sang: " + order.state.name
def ship(self, order):
return "Khong the giao: don chua thanh toan"
class Paid(State):
name = "Da thanh toan"
def pay(self, order):
return "Don nay da thanh toan roi"
def ship(self, order):
order.state = Shipped()
return "Da giao hang, chuyen sang: " + order.state.name
class Shipped(State):
name = "Da giao"
def pay(self, order):
return "Don da giao, khong can thanh toan"
def ship(self, order):
return "Don da duoc giao truoc do"
class Order:
def __init__(self):
self.state = Pending() # trang thai khoi dau
def pay(self): return self.state.pay(self) # uy thac cho state
def ship(self): return self.state.ship(self)
order = Order()
print(order.ship()) # thu giao khi chua tra tien
print(order.pay()) # tra tien: Pending -> Paid
print(order.pay()) # tra tien mot lan nua
print(order.ship()) # giao hang: Paid -> Shipped
print(order.ship()) # thu giao lai
Nhìn kỹ hai điểm mấu chốt trong output:
- Cùng một hành động, kết quả khác nhau tuỳ trạng thái.
order.ship()lúc đầu bị từ chối vì đơn cònPending; sau khi trả tiền thì lại giao được; giao rồi thì báo đã giao. Method không đổi, chỉ đối tượng trạng thái phía sau đổi. - Trạng thái tự chuyển. Chính
Pending.paygánorder.state = Paid(). ContextOrderkhông hề biết luật chuyển tiếp; nó chỉ chuyển lời gọi. Toàn bộ luật của một trạng thái nằm gọn trong đúng một class.
Giờ thêm trạng thái Cancelled chỉ là viết thêm một class mới cài State, và cho Pending một hành động cancel chuyển sang nó. Bạn không phải đụng vào Paid hay Shipped. Đây đúng là tinh thần "đóng để sửa, mở để mở rộng".
Paid()). Vì các trạng thái này không giữ dữ liệu riêng, bạn hoàn toàn có thể dùng một instance dùng chung (singleton) cho mỗi trạng thái để đỡ tạo đối tượng liên tục. Với máy trạng thái nhỏ thì khác biệt không đáng kể, cứ chọn cách nào dễ đọc.1. State tự quyết chuyển tiếp. Mỗi state ôm luôn luật "sau tôi là ai". Gọn khi luật chuyển tiếp gắn chặt với từng trạng thái, nhưng đổi lại các state phải biết về nhau (coupling), và muốn nhìn toàn cảnh thì phải đọc hết các class.
2. Context hoặc một bảng chuyển tiếp quyết định. State chỉ lo hành vi, còn sơ đồ chuyển tiếp nằm tập trung ở một chỗ (context, hoặc một bảng dạng
(trạng thái, sự kiện) -> trạng thái mới). Dễ nhìn toàn cảnh máy trạng thái, dễ kiểm tra một chuyển tiếp có hợp lệ hay không, và dễ sinh sơ đồ tài liệu từ chính bảng đó.Chọn kiểu nào tuỳ việc bạn muốn luật chuyển tiếp nằm phân tán theo từng trạng thái hay tập trung một chỗ.
State và Strategy: giống vỏ, khác ruột
Nếu bạn đã đọc Program to interface & Composition over inheritance, bạn sẽ thấy State trông y hệt Strategy: cùng một interface, nhiều class cài đặt, context ghép một cái vào rồi ủy thác. Về cấu trúc, hai mẫu này gần như trùng nhau (đều là composition + program to interface). Khác nhau nằm ở ý định.
Với State, các trạng thái tự chuyển lẫn nhau theo luật nội bộ. Client không ngồi chọn "giờ chuyển sang Paid"; chính hành động
pay() trên trạng thái Pending kích hoạt bước chuyển. Nói ngắn: Strategy do client quyết, State do chính các state quyết.Một dấu hiệu nhận biết nhanh: nếu các đối tượng cài đặt tham chiếu đến nhau để chuyển tiếp (như Pending biết đến Paid), gần như chắc chắn bạn đang làm State. Strategy thì các thuật toán độc lập, không cần biết nhau.
Khi nào dùng và khi nào không
Dùng State khi:
- Đối tượng có một số trạng thái rõ ràng và hành vi thay đổi hẳn theo trạng thái (không chỉ đổi vài giá trị).
- Bạn đã thấy các khối
if/elifkiểm tra cùng một biến trạng thái lặp lại ở nhiều method, và mỗi lần thêm trạng thái là một lần đau. - Luật chuyển trạng thái đủ phức tạp để đáng gói lại từng chỗ cho gọn.
if/elif hay một enum là quá đủ. Dựng cả một cây class State cho tình huống nhỏ chỉ làm code dài ra và khó theo dõi luồng chuyển. State đáng giá khi số trạng thái và số hành động đủ lớn để khối điều kiện thật sự trở thành gánh nặng, không phải mặc định cho mọi biến trạng thái.Trong hệ thống thật
State không phải mẫu hình học thuật. Đi làm backend bạn gặp nó suốt, chỉ là không ai gọi tên:
- Vòng đời đơn hàng. Chờ thanh toán, đã thanh toán, đang giao, hoàn tất, đã huỷ, hoàn tiền. Luật chuyển tiếp rất chặt: đơn đã giao thì không được quay về chờ thanh toán, đơn đã huỷ thì không được giao, và chỉ đơn đã thanh toán mới hoàn tiền được.
- Vòng đời bài viết. Nháp, chờ duyệt, đã đăng, gỡ. Mỗi trạng thái có quyền khác nhau: bài nháp ai sửa cũng được, bài đã đăng thì sửa phải sinh phiên bản.
- Circuit breaker. Ba trạng thái kinh điển: đóng (cho request đi qua), mở (chặn hết vì service đầu kia đang hỏng), nửa mở (thả vài request thăm dò xem đã hồi chưa). Mỗi trạng thái xử lý một lời gọi theo một kiểu hoàn toàn khác.
- Máy trạng thái của job hay pipeline. Chờ, đang chạy, thất bại, thử lại, xong. Đây là chỗ mà luật chuyển tiếp hay đi kèm điều kiện số lần thử.
- Luồng xác thực nhiều bước. Nhập mật khẩu, chờ mã OTP, chờ đổi mật khẩu bắt buộc, đã đăng nhập. Ở mỗi bước, cùng một request lại được hiểu khác nhau.
Có một điều rất thực tế mà sách vở hay bỏ qua: trong backend, trạng thái thường phải lưu xuống cơ sở dữ liệu, không chỉ sống trong bộ nhớ. Kéo theo hai việc. Một là bạn cần ánh xạ giữa giá trị lưu trữ (chuỗi "paid", một enum, một số) và đối tượng state tương ứng, thường là một dict tra cứu lúc đọc bản ghi lên. Hai là đừng tin rằng tầng code là cổng duy nhất: phải chặn chuyển tiếp không hợp lệ ngay ở tầng dữ liệu, bằng ràng buộc (constraint, check trên cột trạng thái) hoặc bằng kiểm tra trong transaction theo kiểu "chỉ cập nhật sang shipped nếu trạng thái hiện tại đúng là paid". Hai tiến trình cùng bấm nút một lúc là chuyện bình thường, và máy trạng thái đẹp đến mấy trong code cũng không cứu được bản ghi bị ghi đè.
Trade-off
Được:
- Hết rừng
if/eliftheo trạng thái rải khắp các method. - Mỗi trạng thái nằm gọn một chỗ, nên thêm trạng thái mới không đụng vào các trạng thái cũ.
- Luật chuyển tiếp trở nên tường minh và test được: viết test cho từng cặp trạng thái và hành động.
- Code phản ánh đúng sơ đồ nghiệp vụ, đọc class là thấy được dân nghiệp vụ đang nói gì.
Phải trả giá:
- Sinh ra nhiều lớp nhỏ, thừa thãi nếu máy trạng thái vốn đơn giản.
- Nhìn toàn cảnh sơ đồ khó hơn nếu luật chuyển tiếp nằm phân tán trong từng state.
- Phải tự xử lý việc lưu trạng thái xuống cơ sở dữ liệu và khôi phục đúng đối tượng state khi đọc lên.
- Với hai trạng thái kiểu bật tắt thì một biến boolean là đủ, dựng class chỉ làm code dài ra.
Tóm tắt
- State pattern gói mỗi trạng thái thành một class riêng cài chung một interface; đối tượng context ủy thác hành động cho trạng thái hiện tại.
- Nó thay cho các khối
if/eliftheo trạng thái bị xé lẻ khắp các method: luật của một trạng thái được gom gọn một chỗ, thêm trạng thái mới không phải sửa cái cũ. - Đặc trưng: cùng một hành động cho kết quả khác nhau tuỳ trạng thái, và các trạng thái tự chuyển lẫn nhau theo luật nội bộ.
- Giống Strategy về cấu trúc nhưng khác ý định: Strategy do client chọn thuật toán, State do chính các state tự chuyển.
- Trạng thái ít và đơn giản thì
if/elifhoặcenumlà đủ, đừng dựng class cho có.
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 State, nhóm Behavioral.
- Kai