Đến nội dung chính
notes.vinhnq.com

Tìm kiếm

OOP & Thiết kếMid16 phút đọc

Observer: từ danh sách listener đến Spring event và outbox

Ôn 13 thẻ
Trong bài này

Cụm bài Design pattern qua refactor: 1. Strategy · 2. Template Method và composition · 3. Observer và Spring event · 4. Adapter và Factory

Bài 1 tách việc đồng bộ dữ liệu của app mobile thành các strategy, nhưng để lại câu hỏi: ai đổi strategy khi mạng chập chờn? Observer trả lời: object nắm trạng thái tự báo cho những ai quan tâm. Đọc xong, bạn viết được một publisher không vỡ trong app thật, và biết khi nào dùng Spring event, khi nào cần message broker với outbox.

1. v0: publisher gọi thẳng subscriber

Ý chính: trong code v0, lớp quản lý mạng giữ tham chiếu tới lớp đồng bộ và tự gắn strategy, nên mọi thứ dính chặt vào nhau.

Comment trong repo ghi ba vấn đề của NetworkManagerV0:

  1. Coupling chặt: lớp quản lý mạng phụ thuộc trực tiếp vào lớp đồng bộ, và cả các class strategy.
  2. Logic thông báo viết cứng: “mạng đổi thì làm gì” nằm ở lớp quản lý mạng, không ở lớp quan tâm tới nó.
  3. Thêm subscriber phải sửa publisher: muốn banner “bạn đang offline” hay bộ upload ảnh cũng phản ứng, phải sửa NetworkManagerV0.

2. v1: danh sách subscriber, notify khi có thay đổi

Ý chính: Observer đảo chiều phụ thuộc: publisher chỉ biết interface NetworkListener, ai quan tâm thì tự đăng ký, và chỉ notify khi giá trị khác cũ.

Bản v1 của repo làm đúng vậy: NetworkManager có subscribe/unsubscribe, DataSyncManager implement interface subscriber và đổi strategy trong update. Repo ghi hai ưu điểm (thêm subscriber không sửa publisher; quan hệ thiết lập lúc chạy) và một nhược điểm (thứ tự gọi không như mong đợi).

sequenceDiagram
  participant OS as Hệ điều hành
  participant NM as NetworkMonitor
  participant DS as DataSyncManager
  participant UI as OfflineBanner
  DS->>NM: subscribe(this)
  UI->>NM: subscribe(this)
  OS->>NM: setOnline(false)
  NM->>DS: onChange(false)
  DS->>DS: chuyển sang LocalSync
  NM->>UI: onChange(false)
  UI->>UI: hiện banner
  OS->>NM: setOnline(false)
  Note over NM: không đổi, không notify

Bản đơn giản nhất mà nhiều người viết (gần với repo):

interface NetworkListener { void onChange(boolean online); }

static final class NaiveNetworkMonitor {
    private final List<NetworkListener> listeners = new ArrayList<>();
    private boolean online;
    void subscribe(NetworkListener l) { listeners.add(l); }
    void unsubscribe(NetworkListener l) { listeners.remove(l); }
    void setOnline(boolean value) {
        if (online == value) return;                 // chỉ notify khi thay đổi
        online = value;
        for (NetworkListener l : listeners) l.onChange(value);
    }
}

Nó chạy đúng trong demo, nhưng sai theo bốn cách trong app thật.

3. Bốn cách Observer vỡ, chạy thử

Ý chính: publisher ngây thơ hỏng khi listener tự huỷ đăng ký, khi một listener ném lỗi, khi không ai huỷ đăng ký, và khi có thread hoặc listener chậm.

Kịch bản Kết quả đo được Hậu quả
Listener tự huỷ đăng ký lúc được notify 2 listener: không lỗi nhưng listener sau không được gọi; 3 listener: ConcurrentModificationException bỏ sót im lặng hoặc vỡ vòng lặp
Listener đầu (banner) ném IllegalStateException sync manager không bao giờ được notify bug UI làm hỏng đồng bộ dữ liệu
1000 màn hình đăng ký, không gỡ khi đóng còn 1000 listener bị giữ memory leak
Thứ tự và thread notify đồng bộ, ArrayList và field online không thread-safe listener chậm chặn publisher
Code và output của các kịch bản chạy thử

Listener tự huỷ đăng ký (một listener “chỉ cần biết lần đầu có mạng”):

var naive = new NaiveNetworkMonitor();
boolean[] syncNotified = {false};
NetworkListener once = new NetworkListener() {
    public void onChange(boolean online) { naive.unsubscribe(this); }
};
naive.subscribe(once);
naive.subscribe(online -> syncNotified[0] = true);
naive.setOnline(true);
System.out.println("naive, 2 listeners: no exception, sync notified = " + syncNotified[0]);
// thêm một listener thứ ba vào cùng kịch bản thì ra ConcurrentModificationException
naive, 2 listeners: no exception, sync notified = false
naive, 3 listeners: ConcurrentModificationException

Một listener ném exception: exception đi ngược lên vòng for và setOnline, nên sync manager đứng sau không bao giờ biết mạng đã đổi.

naive: sync manager never notified (banner widget crashed)

Quên huỷ đăng ký (mỗi màn hình đăng ký khi mở, không gỡ khi đóng):

var naive3 = new NaiveNetworkMonitor();
for (int screen = 0; screen < 1_000; screen++) {
    byte[] screenState = new byte[10_000];       // bị lambda giữ lại
    naive3.subscribe(online -> { if (screenState.length < 0) System.out.println(); });
}
naive: listeners still referenced after closing 1000 screens = 1000

Thứ tự và thread. Với ArrayList, thứ tự notify là thứ tự đăng ký, mà thứ tự đăng ký phụ thuộc thứ tự khởi tạo, nên đừng dựa vào nó. Repo không nói hai vấn đề còn lại: listener chậm chặn luôn thread gọi setOnline, và state không an toàn khi mạng được báo từ thread khác.

4. Publisher cứng cáp hơn

Ý chính: duyệt trên snapshot, bắt lỗi từng listener, trả handle để huỷ đăng ký, và đăng ký từ bên ngoài chứ không trong constructor.

static final class NetworkMonitor {
    private final List<NetworkListener> listeners = new CopyOnWriteArrayList<>();
    private volatile boolean online;

    /** Trả về handle; close() là huỷ đăng ký. */
    AutoCloseable subscribe(NetworkListener l) {
        listeners.add(l);
        l.onChange(online);                          // người đến sau nhận luôn trạng thái hiện tại
        return () -> listeners.remove(l);
    }

    synchronized void setOnline(boolean value) {
        if (online == value) return;
        online = value;
        for (NetworkListener l : listeners) {        // duyệt trên snapshot
            try {
                l.onChange(value);
            } catch (RuntimeException e) {           // một listener lỗi không được làm đói các listener khác
                System.out.println("  listener failed: " + e.getMessage());
            }
        }
    }
}

Chạy lại ba kịch bản (1000 màn hình giờ dùng try-with-resources): sync manager vẫn được notify, chỉ còn 2 listener.

hardened: going online
  listener failed: banner widget crashed
  sync sees online=true
hardened: listeners left = 2
hardened: listeners after 1000 screens = 2

Thêm một chi tiết trong repo: DataSyncManager gọi networkManager.subscribe(this) trong constructor của nó. Object chưa khởi tạo xong; publisher notify ngay (hoặc từ thread khác) thì listener chạy trên một object dở dang.

Cảnh báo this-escape của javac 21

5. Observer trong Spring: event, transaction và message broker

Ý chính: trong Spring, ApplicationEventPublisher là publisher, @EventListener là subscriber, container lo đăng ký. Câu hỏi thật là listener chạy trong transaction hay sau commit, và khi nào phải ra khỏi JVM bằng broker + outbox.

Ví dụ phát event khi đặt phòng thành công (code Spring, không chạy trong bài):

public record BookingCreated(long bookingId, long homestayId, String requestId) {}

@Service
@RequiredArgsConstructor
public class BookingService {
    private final ApplicationEventPublisher events;
    private final BookingRepository bookings;

    @Transactional
    public Booking book(BookingRequest request) {
        Booking booking = bookings.save(/* ... */);
        events.publishEvent(new BookingCreated(booking.getId(), booking.getHomestayId(), request.requestId()));
        return booking;
    }
}

@Component
class BookingEmailListener {
    @TransactionalEventListener(phase = TransactionPhase.AFTER_COMMIT)
    void onBooked(BookingCreated event) {
        // chỉ chạy nếu transaction đặt phòng đã commit
    }
}
  • @EventListener mặc định chạy đồng bộ, cùng thread, cùng transaction. Listener ném lỗi thì transaction của book rollback: tốt cho kiểm tra bắt buộc, tệ nếu email lỗi làm mất booking.
  • @Order quyết định thứ tự giữa các listener cùng event; không khai báo thì đừng dựa vào thứ tự.
  • @TransactionalEventListener(phase = AFTER_COMMIT) chỉ chạy khi commit thành công. Thêm @Async nếu không muốn request chờ listener.

Dual write (ghi vào hai hệ thống không chung transaction) là lỗi của luồng đặt phòng v2 trong repo: nó phát Kafka trong hook postProcess, tức bên trong transaction. Commit lỗi thì event đã ra ngoài cho booking không tồn tại; phát sau commit thì crash ở giữa làm mất event. Lời giải là transactional outbox: ghi event vào bảng outbox trong cùng transaction, tiến trình khác đọc và đẩy lên broker (xem Idempotency trong hệ thống phân tán và Message broker và cách chọn).

AFTER_COMMIT: mất việc khi crash và ghi DB trong listener

Trong DDD, chúng gọi là domain event (BookingConfirmed, SeatsReleased): aggregate ghi nhận, application service publish sau khi lưu, bounded context khác lắng nghe; xem DDD và cấu trúc package.

Bài tập

Bài 1: Notify bất đồng bộ nhưng giữ thứ tự

Đề: NetworkMonitor ở mục 4 notify đồng bộ, nên một listener chậm chặn luôn thread báo trạng thái mạng. Sửa để publisher trả về ngay, nhưng mọi listener vẫn nhận các thay đổi đúng thứ tự đã xảy ra, và tắt app thì các event đang chờ được giao hết.

Lời giải Bài 1: executor một thread làm hàng đợi FIFO
static final class AsyncNetworkMonitor implements AutoCloseable {
    private final List<NetworkListener> listeners = new CopyOnWriteArrayList<>();
    // một thread duy nhất = event được giao theo đúng thứ tự publish
    private final ExecutorService delivery = Executors.newSingleThreadExecutor(
            Thread.ofPlatform().name("network-events").daemon().factory());
    private boolean online;

    AutoCloseable subscribe(NetworkListener l) {
        listeners.add(l);
        return () -> listeners.remove(l);
    }

    synchronized void setOnline(boolean value) {
        if (online == value) return;
        online = value;
        delivery.execute(() -> {
            for (NetworkListener l : listeners) {
                try { l.onChange(value); }
                catch (RuntimeException e) { System.out.println("listener failed: " + e.getMessage()); }
            }
        });
    }

    @Override public void close() throws InterruptedException {
        delivery.shutdown();                                     // cho các event đã xếp hàng chạy hết
        if (!delivery.awaitTermination(5, TimeUnit.SECONDS)) delivery.shutdownNow();
    }
}

Một listener ngủ 50 ms mỗi lần, publisher đổi trạng thái 6 lần liên tiếp:

publisher returned after 0 ms
[sync:true, banner:true, sync:false, banner:false, sync:true, banner:true, sync:false, banner:false, sync:true, banner:true, sync:false, banner:false]
  • Thread pool nhiều thread nhanh hơn nhưng mất thứ tự (“offline” có thể đến trước “online” xảy ra trước nó). Executor một thread là một hàng đợi FIFO.
  • Hàng đợi của newSingleThreadExecutor không giới hạn, nên listener quá chậm làm nó phình ra. Với trạng thái kiểu “mạng có/không” chỉ giá trị mới nhất có nghĩa, có thể gộp (coalesce) các thay đổi chưa giao thay vì giao từng cái.

Ghi nhớ

  • Giải thích được vì sao listener tự huỷ đăng ký với hai listener thì bỏ sót im lặng, còn ba listener thì ném CME.
  • Kể được bốn cách publisher ngây thơ vỡ và cách sửa từng cái.
  • Biết khi nào dùng @EventListener, khi nào @TransactionalEventListener(AFTER_COMMIT), và vì sao cái sau không bền.
  • Giải thích được dual write và vì sao outbox giải quyết nó.
  • Biết cách notify bất đồng bộ mà vẫn giữ thứ tự.

Câu hỏi phỏng vấn

Junior

Observer pattern giải quyết vấn đề gì?

Cho một object báo cho nhiều object khác khi trạng thái đổi, mà không phụ thuộc vào từng object đó.

Publisher giữ danh sách subscriber qua một interface và gọi lần lượt; ai quan tâm thì tự đăng ký. Thêm subscriber mới không phải sửa publisher.

Mid

Viết publisher cho Observer, bạn chú ý những gì?

Snapshot khi duyệt, cô lập lỗi từng listener, huỷ đăng ký gắn với vòng đời, và không đăng ký this trong constructor.

  • Duyệt trên snapshot (CopyOnWriteArrayList) để listener tự huỷ đăng ký không gây lỗi.
  • Bắt exception từng listener để một listener lỗi không chặn các listener khác.
  • Trả handle huỷ đăng ký, gắn vào vòng đời để tránh leak.
  • Chỉ notify khi giá trị đổi; không dựa vào thứ tự; cân nhắc notify bất đồng bộ nếu listener có thể chậm.
@EventListener và @TransactionalEventListener khác nhau thế nào?

@EventListener chạy ngay khi publish, cùng thread và cùng transaction; @TransactionalEventListener hoãn tới một pha của transaction, mặc định AFTER_COMMIT.

Exception của @EventListener làm method publish thất bại. @TransactionalEventListener chỉ chạy khi commit thành công, hợp với gửi email, xoá cache. Nó không bền: app chết sau commit là mất việc của listener.

Vì sao không nên gọi subscribe(this) trong constructor?

Vì object chưa khởi tạo xong (this-escape): listener có thể chạy trên object có field còn null.

Nếu publisher notify ngay, hoặc một thread khác notify, lớp con (nếu có) còn chưa chạy constructor của nó. Từ JDK 21, javac -Xlint:this-escape cảnh báo trường hợp này. Đăng ký từ bên ngoài sau khi tạo xong: factory method create(), code lắp ráp, hoặc @PostConstruct.

Senior

Khi nào dùng Spring event, khi nào dùng Kafka cho cùng một nhu cầu “khi đặt phòng xong thì làm X”?

Spring event khi X trong cùng service và mất được hoặc làm lại được; Kafka qua outbox khi X ở service khác hoặc phải bền.

Spring event hợp với xoá cache, ghi metric, mục tiêu là tách module. Kafka khi cần bền, retry, nhiều consumer độc lập hoặc chịu tải. Không publish Kafka trực tiếp trong transaction DB: dual write sẽ phát event cho booking đã rollback hoặc mất event khi crash sau commit.

Một Observer trong app gây memory leak. Bạn điều tra và sửa thế nào?

Lấy heap dump, tìm đường tham chiếu từ GC root tới object đáng lẽ đã chết (thường là list listener của một singleton), rồi gắn việc huỷ đăng ký vào vòng đời.

  • Heap dump bằng jcmd <pid> GC.heap_dump, mở bằng Eclipse MAT, xem dominator tree.
  • Sửa: subscribe trả về handle để huỷ đăng ký, đóng theo vòng đời; thêm metric số listener để phát hiện sớm.
  • WeakReference chỉ là lưới an toàn vì listener lambda có thể bị thu quá sớm.
Listener chậm làm publisher bị chặn. Bạn notify bất đồng bộ thế nào mà không mất thứ tự?

Giao event qua một executor một thread (hàng đợi FIFO); publisher chỉ đẩy việc vào hàng rồi trả về.

  • Thread pool nhiều thread nhanh hơn nhưng đảo thứ tự.
  • Hàng đợi nên có giới hạn, hoặc gộp các thay đổi chưa giao khi chỉ giá trị mới nhất có nghĩa.
  • Bắt lỗi listener trong task; khi tắt thì shutdown rồi awaitTermination để giao nốt.
  • Cần thứ tự theo từng key thay vì toàn cục thì dùng một hàng cho mỗi key (giống partition của Kafka).

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu tiếng Anh dùng trong phỏng vấn
publisher / subscriber /ˈpʌblɪʃə səbˈskraɪbə/ bên phát / bên nhận thông báo “The publisher only knows the listener interface, not the concrete subscribers.”
lapsed listener /læpst ˈlɪsənə/ listener quên huỷ đăng ký, gây leak “The heap dump showed a classic lapsed listener problem.”
snapshot iteration /ˈsnæpʃɒt ˌɪtəˈreɪʃn/ duyệt trên bản sao của danh sách “CopyOnWriteArrayList gives snapshot iteration, so unsubscribing during a callback is safe.”
this-escape /ðɪs ɪˈskeɪp/ để lộ this trước khi constructor chạy xong “Registering this in the constructor is a this-escape.”
dual write /ˈdjuːəl raɪt/ ghi vào hai hệ thống không cùng transaction “Publishing to Kafka inside the transaction is a dual write; we use an outbox.”
coalesce /ˌkəʊəˈles/ gộp nhiều thay đổi thành một “For network status, we coalesce pending events and only deliver the latest.”
transactional outbox /trænˈzækʃənl ˈaʊtbɒks/ bảng event ghi cùng transaction, đẩy đi sau “The booking and its event are written in one transaction to the outbox table.”
heap dump /hiːp dʌmp/ ảnh chụp bộ nhớ heap để phân tích “The heap dump showed thousands of screens held by the listener list.”

Ghi chép dựa trên khoá Advanced Backend (Ronin Engineer), viết lại theo cách hiểu của mình.