Bạn đăng ký (subscribe) một kênh YouTube. Từ lúc đó, mỗi khi kênh đăng video mới, YouTube tự bắn thông báo cho bạn. Bạn không phải mỗi 5 phút vào lại kênh để kiểm tra xem có gì mới không. Kênh cũng không cần biết bạn là ai, có bao nhiêu người đăng ký; nó chỉ việc "có video mới thì báo cho cả danh sách". Đó chính xác là Observer pattern, một mẫu thuộc nhóm hành vi (behavioral) trong bộ Gang of Four.
Observer là gì
Observer thiết lập quan hệ một-nhiều giữa các đối tượng: khi một đối tượng đổi trạng thái, tất cả đối tượng phụ thuộc vào nó được thông báo và cập nhật tự động. Có hai vai:
- Subject (còn gọi là publisher): đối tượng giữ trạng thái đáng quan tâm. Nó cho phép đăng ký (subscribe), gỡ đăng ký (unsubscribe) và có nhiệm vụ thông báo (notify) khi trạng thái đổi.
- Observer (còn gọi là subscriber): đối tượng muốn biết khi trạng thái của subject thay đổi. Nó cung cấp một method để subject gọi lại khi có tin.
Quay lại analogy kênh YouTube: kênh là subject, người đăng ký là các observer. Kênh giữ một danh sách người đăng ký. Có video mới, kênh duyệt qua danh sách và báo cho từng người. Người xem có thể đăng ký thêm hoặc bỏ theo dõi bất cứ lúc nào, kênh không phải sửa gì cả.
Vấn đề Observer giải quyết
Không có Observer, bạn thường rơi vào một trong hai cái bẫy.
Cách 1: hỏi liên tục (polling)
Bên cần dữ liệu cứ lặp đi lặp lại việc hỏi "có gì mới chưa?". Kiểu như cứ vài giây lại vào lại kênh xem có video mới không:
# Anti-pattern: chu dong hoi lien tuc
while True:
gia = kho.doc_gia() # lien tuc hoi, phan lon lan la vo ich
if gia != gia_cu:
cap_nhat_man_hinh(gia)
gia_cu = gia
time.sleep(1) # doi roi hoi lai...
Polling phí tài nguyên (phần lớn lần hỏi không có gì thay đổi), lại trễ (tin mới phải chờ tới nhịp hỏi kế tiếp mới biết). Càng nhiều bên cần theo dõi, càng nhiều vòng lặp hỏi vô ích.
Cách 2: subject tự gọi thẳng từng bên (coupling chặt)
Đảo lại: cho subject chủ động báo tin. Nhưng nếu subject gọi thẳng tên từng đối tượng nhận, nó phải biết rõ tất cả bọn họ:
# Anti-pattern: subject biet ro tung ben nhan
class KhoHang:
def set_gia(self, gia):
self._gia = gia
self.bang_dien_tu.ve_lai(gia) # dinh cung ten tung ben
self.he_thong_canh_bao.kiem_tra(gia)
self.bao_cao.ghi_log(gia) # them ben moi = phai sua class nay
Bây giờ KhoHang phụ thuộc trực tiếp vào bảng điện tử, hệ thống cảnh báo, báo cáo... Thêm một bên nhận mới là phải mở KhoHang ra sửa, vi phạm luôn nguyên tắc Open/Closed trong SOLID. Đây là coupling chặt: hai phía dính chặt vào nhau, khó thay, khó mở rộng.
Observer gỡ đúng nút thắt này. Subject không biết observer là ai; nó chỉ biết "có một danh sách thứ cần được báo, mỗi thứ đều có method update". Bên nhận chủ động đăng ký vào. Tin được đẩy (push) ngay khi trạng thái đổi, không phải hỏi vòng vòng.
Cách hoạt động
Xương sống của Observer gồm ba việc phía subject: subscribe (thêm observer vào danh sách), unsubscribe (gỡ ra), và notify (duyệt danh sách, gọi update trên từng observer). Observer chỉ cần cài đặt update để phản ứng.
Để subject không phụ thuộc vào class cụ thể của observer, ta cho mọi observer chung một hợp đồng (interface) là update. Đây chính là program to an interface: subject nói chuyện với abstraction Observer, không nói chuyện với ManHinh hay CanhBao cụ thể.
Ví dụ: một cái kho hàng làm subject. Khi giá mặt hàng đổi, mọi bên theo dõi được báo. Một observer là màn hình hiển thị giá, một observer khác là bộ cảnh báo khi giá vượt ngưỡng:
from abc import ABC, abstractmethod
class Observer(ABC): # hop dong cho ben theo doi
@abstractmethod
def update(self, gia): ...
class KhoHang: # subject / publisher
def __init__(self):
self._observers = [] # danh sach ben dang theo doi
self._gia = None
def subscribe(self, obs):
self._observers.append(obs)
def unsubscribe(self, obs):
self._observers.remove(obs)
def set_gia(self, gia): # trang thai doi -> bao cho tat ca
self._gia = gia
self._notify()
def _notify(self):
for obs in self._observers:
obs.update(self._gia)
class ManHinh(Observer):
def __init__(self, ten):
self._ten = ten
def update(self, gia):
print(f"[{self._ten}] gia moi: {gia}")
class CanhBao(Observer):
def update(self, gia):
if gia > 100:
print(f"[CanhBao] gia {gia} vuot nguong 100!")
kho = KhoHang()
mh = ManHinh("Bang dien tu")
cb = CanhBao()
kho.subscribe(mh)
kho.subscribe(cb)
kho.set_gia(80)
kho.set_gia(120)
kho.unsubscribe(cb) # go dang ky mot observer
print("--- da go CanhBao ---")
kho.set_gia(150)
Để ý mấy điểm quan trọng. KhoHang không hề nhắc tên ManHinh hay CanhBao; nó chỉ gọi obs.update(...). Muốn thêm một bên nhận mới (ví dụ ghi log, gửi email), bạn viết một class có update rồi subscribe vào, không phải đụng tới KhoHang. Khi gỡ CanhBao, những lần set_gia sau không còn báo cho nó nữa. Trạng thái được đẩy tới observer ngay lúc đổi, không ai phải polling.
Observer; chỉ cần đối tượng có method update là chạy. Nhưng khai báo interface rõ ràng giúp người đọc biết đâu là điểm cắm observer và bắt lỗi sớm hơn, nên tôi vẫn giữ.Cạm bẫy
- Thứ tự thông báo không đảm bảo. Đừng viết observer với giả định "tôi luôn được gọi trước/sau observer kia". Danh sách có thể đổi thứ tự, và một observer không nên phụ thuộc vào tác dụng phụ của observer khác trong cùng vòng notify.
- Một observer ném lỗi có thể làm hỏng cả vòng notify. Trong ví dụ trên, nếu
updatecủa một observer ở giữa danh sách ném exception, vòngfordừng và các observer phía sau không được báo. Khi cần chắc chắn, hãy bọc mỗi lần gọi trongtry/exceptđể một observer hỏng không kéo theo phần còn lại. - Bão thông báo (notification storm). Nếu observer khi nhận tin lại đi sửa subject, có thể sinh ra chuỗi notify lồng nhau hoặc lặp vô tận. Cẩn thận với vòng phản hồi này.
Observer vs Pub/Sub vs Event Bus
Ba cái tên này hay bị dùng thay nhau, và đó là chỗ lẫn lộn tôi gặp nhiều nhất khi nói chuyện về Observer. Chúng cùng chung một tư duy "đăng ký - thông báo", nhưng khác nhau ở mức độ tách rời giữa bên phát và bên nhận.
- Observer: subject giữ trực tiếp danh sách tham chiếu tới các observer. Nó gọi
updateđồng bộ, ngay trong cùng tiến trình, và nó biết chính xác đang có bao nhiêu observer. Đúng như code ở trên. - Pub/Sub: có một tầng trung gian (broker, topic, channel) đứng giữa. Publisher không biết subscriber là ai, thậm chí không biết có ai đang nghe hay không; nó chỉ ném message vào topic. Thường bất đồng bộ, có thể đi qua mạng, có thể lưu bền (persistent) để subscriber offline đọc lại sau, và chạy được liên tiến trình, liên dịch vụ. Redis Pub/Sub, Kafka, RabbitMQ nằm ở đây.
- Event Bus: thường là một bus trong tiến trình đóng vai broker nhẹ, nằm giữa hai cái trên. Người gửi và người nhận đã tách khỏi nhau (không ai giữ tham chiếu tới ai, chỉ biết tên event), nhưng vẫn ở chung một ứng dụng, chung bộ nhớ.
| Tiêu chí | Observer | Pub/Sub | Event Bus |
|---|---|---|---|
| Ai biết ai | Subject giữ tham chiếu trực tiếp tới observer | Publisher chỉ biết topic, không biết subscriber | Hai bên chỉ biết tên event, bus giữ mapping |
| Đồng bộ hay bất đồng bộ | Đồng bộ, chặn luồng gọi | Thường bất đồng bộ | Tùy cài đặt, mặc định hay là đồng bộ |
| Phạm vi | Trong một tiến trình | Liên tiến trình, liên dịch vụ, qua mạng | Trong một ứng dụng |
| Độ bền | Không, mất là mất | Có thể bền: hàng đợi, replay, offset | Thường không bền |
| Xử lý lỗi | Lỗi của observer ném ngược về subject, có thể chặn cả vòng notify | Broker lo retry, dead-letter queue, ack | Bus tự quyết: nuốt lỗi, log, hoặc ném lại |
Khi nào dùng, khi nào không
Dùng Observer khi một thay đổi ở một chỗ cần kéo theo cập nhật ở nhiều chỗ khác, mà bạn không muốn nơi phát tin biết cụ thể có những ai đang nghe. Vài tình huống điển hình:
- Số lượng bên quan tâm thay đổi theo thời gian (đăng ký, gỡ đăng ký lúc chạy).
- Bạn muốn bên phát và bên nhận rời rạc (loose coupling), để thêm/bớt bên nhận mà không sửa bên phát.
- Cách nghĩ nền cho kiến trúc hướng sự kiện trong một tiến trình: sự kiện UI (nút bấm), hook vòng đời, cập nhật dữ liệu thời gian thực.
Trong hệ thống thật
Observer không phải chuyện sách vở, bạn đang dùng nó mỗi ngày mà có khi không gọi tên:
- Domain event. Một
OrderCreatedđược phát ra khi đơn hàng tạo xong, kéo theo gửi email xác nhận, trừ kho, ghi analytics, đẩy notification cho app. Code tạo đơn không cần biết có bao nhiêu việc ăn theo; thêm một việc mới chỉ là thêm một handler. - Signal trong framework. Django signals (
post_save,pre_delete) chính là Observer: model là subject, các receiver là observer. SQLAlchemy cũng có event listener chobefore_insert,after_flush. - Hook vòng đời. Gần như framework nào cũng cho bạn cắm hàm vào các mốc startup, shutdown, before request, after response. Đó là danh sách observer mà framework duyệt qua ở đúng thời điểm.
- WebSocket broadcast. Server giữ danh sách các client đang theo dõi một phòng chat hay một mã chứng khoán; dữ liệu đổi thì đẩy cho cả danh sách. Danh sách connection chính là danh sách observer, và đóng connection chính là unsubscribe.
- Cache invalidation. Khi một bản ghi đổi, phát tin cho các bên đang cache nó để xóa key tương ứng, thay vì để mỗi bên tự đoán khi nào dữ liệu cũ.
Một điểm quan trọng: khi các observer này cần chạy bất đồng bộ, chạy độc lập tiến trình, hoặc phải sống sót qua một lần restart, người ta không dùng Observer thuần nữa mà chuyển sang message queue. Lúc đó cái bạn cần là broker với retry và độ bền, không phải một vòng for gọi update.
Trade-off
Được:
- Giảm coupling: subject không biết gì về class cụ thể của bên nhận, chỉ biết một interface.
- Thêm subscriber mới không phải sửa subject, đúng tinh thần Open/Closed.
- Các tính năng phụ (log, analytics, notification) gắn vào và gỡ ra dễ, không làm bẩn luồng nghiệp vụ chính.
- Quan hệ một-nhiều thay đổi được lúc chạy, không cần biết trước số lượng bên nghe.
Phải trả giá:
- Luồng điều khiển bị ẩn (hidden control flow). Đọc code thấy
set_gia(120)mà không thấy nó kéo theo năm việc khác. Muốn lần vết phải đi tìm xem ai đã subscribe, ở đâu, lúc nào. Đây là cái giá nặng nhất và nó tăng theo số observer. - Vòng đời và unsubscribe. Quên gỡ đăng ký là rò rỉ bộ nhớ (lapsed listener), observer chết rồi vẫn nằm trong danh sách và vẫn nhận tin.
- Lan truyền lỗi. Một observer ném exception có thể chặn cả chuỗi, các observer phía sau không bao giờ được gọi. Phải chủ động quyết định cô lập lỗi hay để nó nổi lên.
- Thứ tự thông báo không đảm bảo. Không được viết observer dựa trên giả định mình chạy trước hay sau ai.
- Khó debug và khó test. Số observer càng tăng, một hành động càng sinh ra nhiều tác dụng phụ; test một luồng phải dựng cả dàn observer hoặc phải giả lập chúng.
Tóm tắt
- Observer tạo quan hệ một-nhiều: subject đổi trạng thái thì tự động thông báo cho mọi observer đã đăng ký.
- Xương sống là ba việc phía subject: subscribe, unsubscribe, notify; observer chỉ cài đặt
update. - Subject nói chuyện với observer qua một interface chung nên hai phía rời rạc: thêm/bớt bên nhận không phải sửa bên phát. Đây là dạng đơn giản nhất của tư duy "đăng ký - thông báo", không phải là Pub/Sub.
- Coi chừng: quên unsubscribe gây rò rỉ bộ nhớ (lapsed listener), thứ tự notify không đảm bảo, một observer ném lỗi có thể làm hỏng cả vòng.
- Chỉ một observer cố định thì gọi thẳng cho gọn, đừng bắc giàn Observer.
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 Observer, mục đích "define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically".
- Kai