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

Observer Pattern: khi trạng thái đổi, cả "hội theo dõi" tự biết

TL;DR: Observer định nghĩa quan hệ một-nhiều: một đối tượng (subject/publisher) khi đổi trạng thái sẽ tự động thông báo cho mọi đối tượng phụ thuộc (observer/subscriber). Nhờ đó bên phát và bên nhận không cần biết cụ thể về nhau, chỉ nói chuyện qua một hợp đồng chung. Đây là hình thức đơn giản nhất của tư duy "đăng ký - thông báo", họ hàng gần của kiến trúc hướng sự kiện (event-driven), nhưng không đồng nhất với Pub/Sub.

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)
[Bang dien tu] gia moi: 80 [Bang dien tu] gia moi: 120 [CanhBao] gia 120 vuot nguong 100! --- da go CanhBao --- [Bang dien tu] gia moi: 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.

Python có duck typing nên thực ra không bắt buộc kế thừa 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

Quên unsubscribe gây rò rỉ bộ nhớ (lapsed listener). Subject giữ tham chiếu tới observer trong danh sách của nó. Nếu một observer đã hết vòng đời mà bạn quên gỡ ra, subject vẫn nắm nó, nên bộ thu gom rác không dọn được; observer đó thành "listener treo". Tệ hơn, nó vẫn nhận thông báo và phản ứng dù lẽ ra đã chết. Luôn có đường gỡ đăng ký và gọi nó khi observer không còn cần.
  • 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 update của một observer ở giữa danh sách ném exception, vòng for dừ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 trong try/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íObserverPub/SubEvent Bus
Ai biết aiSubject giữ tham chiếu trực tiếp tới observerPublisher chỉ biết topic, không biết subscriberHai 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ọiThường bất đồng bộTùy cài đặt, mặc định hay là đồng bộ
Phạm viTrong một tiến trìnhLiên tiến trình, liên dịch vụ, qua mạngTrong một ứng dụng
Độ bềnKhông, mất là mấtCó thể bền: hàng đợi, replay, offsetThường không bền
Xử lý lỗiLỗi của observer ném ngược về subject, có thể chặn cả vòng notifyBroker lo retry, dead-letter queue, ackBus tự quyết: nuốt lỗi, log, hoặc ném lại
Đừng gọi Redis Pub/Sub hay Kafka là "Observer pattern" trong phỏng vấn. Observer là một mẫu thiết kế ở mức object, trong bộ nhớ, đồng bộ; Pub/Sub là một mẫu kiến trúc messaging có broker ở giữa. Nói đúng tên cho thấy bạn hiểu ranh giới, nói sai thì người phỏng vấn sẽ đào tiếp đúng chỗ đó.

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.
KHÔNG nên lôi Observer vào khi chỉ có một bên nhận cố định và không đổi. Lúc đó dựng danh sách, interface, cơ chế subscribe/notify chỉ là tầng gián tiếp thừa; gọi thẳng method của bên nhận vừa ngắn vừa dễ đọc hơn nhiều. Chỉ trả cái giá phức tạp này khi bạn thật sự cần quan hệ một-nhiều động.

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 cho before_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".
Series Design Patterns - nhóm Hành vi (Behavioral). Observer là một trong các mẫu hành vi, tập trung vào cách các đối tượng giao tiếp và phân chia trách nhiệm. Cùng nhóm còn có Strategy, Command và Chain of Responsibility. Nếu chưa đọc, xem trước hai bài nền tảng: Program to interface & Composition over inheritance và SOLID. 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