Hành viBehavioral

Observeraka Listener, Event Listener, Publish–Subscribe (in-process)

Khi một object thay đổi, mọi object đăng ký theo dõi được báo tự động — mà nó không cần biết họ là ai.When one object changes, every subscriber is notified automatically — without it knowing who they are.

Độ khóDifficulty: VừaMedium
Mức phổ biếnUsage: Mức phổ biếnUsage 5/5
Thời gian đọcReading time: ~9 phút đọc~9 min read

Thảo luậnDiscussion

Ví dụ đời thườngReal-life analogy

Bạn bấm 'Theo dõi' một shop trên Shopee. Khi shop tung flash sale, bạn và hàng nghìn người khác nhận thông báo. Shop không gọi điện từng người, cũng không cần biết bạn là ai — chỉ cần 'phát' một lần. Ai chán thì bấm bỏ theo dõi.You tap 'Follow' on a Shopee shop. When it launches a flash sale, you and thousands of others get notified. The shop doesn't call anyone individually or even know who you are — it just broadcasts once. Bored? Unfollow.

Vấn đề và giải phápProblem and solution

Không có patternWithout the pattern

Sau khi đặt hàng, hệ thống phải gửi email xác nhận, cộng điểm thành viên, kiểm tra gian lận, đẩy dữ liệu analytics... OrderService gọi trực tiếp cả 4 service đó: nó phụ thuộc vào mọi team, email chậm làm API đặt hàng chậm theo, và thêm tính năng 'gửi Zalo' lại phải sửa OrderService.After an order is placed, the system must send a confirmation email, add loyalty points, run fraud checks, push analytics... OrderService calls all 4 services directly: it depends on every team, a slow email slows down the order API, and adding 'send Zalo' means editing OrderService again.

Với ObserverWith Observer

OrderService (Subject) chỉ phát một sự kiện OrderPlaced. Các Observer tự đăng ký lắng nghe sự kiện đó và tự xử lý. Subject không biết có bao nhiêu observer hay chúng làm gì; thêm hành vi mới = thêm một listener. Spring có sẵn ApplicationEventPublisher + @EventListener; Go dùng callback hoặc channel.OrderService (the Subject) just publishes an OrderPlaced event. Observers register themselves for that event and react on their own. The subject doesn't know how many observers exist or what they do; new behaviour = a new listener. Spring ships ApplicationEventPublisher + @EventListener; Go uses callbacks or channels.

Thành phần tham giaParticipants

Subject / Publisher: Nơi xảy ra thay đổi; phát sự kiện mà không biết ai nghe.Where the change happens; publishes events without knowing who listens.
Event: Dữ liệu bất biến mô tả điều đã xảy ra (OrderPlacedEvent).Immutable data describing what happened (OrderPlacedEvent).
Observer / Listener: Đăng ký nhận sự kiện và phản ứng (gửi email, cộng điểm).Subscribes to events and reacts (send email, add points).
Event bus / Dispatcher: Giữ danh sách observer và chuyển sự kiện tới họ (ApplicationEventPublisher, Topic).Keeps the observer list and dispatches events to them (ApplicationEventPublisher, Topic).

Sơ đồ và luồng thực thiDiagram and execution flow

Dùng Tự chạy hoặc phím mũi tên để đi qua từng bước gọi giữa các object. Console hiển thị output tương ứng của chương trình.Use Autoplay or the arrow keys to step through each call between objects. The console shows the matching program output.

1place() lưu đơn hàng trong một transaction (chưa commit) và tạo OrderPlacedEvent.place() saves the order inside a transaction (not committed yet) and creates an OrderPlacedEvent.

← →

console

1> place(cart=3 items) -> INSERT orders id=1024 (tx open)

implementsimplementsextendsextendsgọi / dùngcalls / usestạo racreatesgửi qua channelsends via channel1thứ tự chạy (bấm để nhảy bước)execution order (click to jump)

Code: Java Spring Boot ⇄ GoCode: Java Spring Boot ⇄ Go

Cùng một bài toán, hai ngôn ngữ. Rê chuột hoặc focus vào chú thích (số màu cam) để làm nổi bật dòng code tương ứng.Same problem, two languages. Hover or focus an annotation (orange number) to highlight its line.

JavaSpring Boot 3 · Java 21Spring Boot 3 · Java 21

package com.shop.order;

import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class OrderService {
    private final OrderRepository orders;
    private final ApplicationEventPublisher events;1

    public OrderService(OrderRepository orders, ApplicationEventPublisher events) {
        this.orders = orders;
        this.events = events;
    }

    @Transactional
    public Order place(PlaceOrderCommand cmd) {
        Order order = orders.save(Order.from(cmd));
        // The subject doesn't know who listens: email, loyalty, analytics...
        events.publishEvent(new OrderPlacedEvent(order.id(), order.customerId(), order.total()));2
        return order;
    }
}

// In OrderPlacedEvent.java — an immutable record is the ideal event:
// public record OrderPlacedEvent(long orderId, String customerId, BigDecimal total) {}3

GoGo 1.23 · thư viện chuẩnGo 1.23 · standard library

package events

import (
	"context"
	"slices"
	"sync"
)

// Listener is just a function: Go's lightest observer.
type Listener[T any] func(ctx context.Context, event T)1

// Topic is a tiny typed in-process event bus. The zero value is ready to use.
type Topic[T any] struct {2
	mu        sync.RWMutex
	listeners []Listener[T]
}

func (t *Topic[T]) Subscribe(l Listener[T]) {
	t.mu.Lock()
	defer t.mu.Unlock()
	t.listeners = append(t.listeners, l)
}

// Publish calls observers synchronously, in subscription order.
func (t *Topic[T]) Publish(ctx context.Context, event T) {
	t.mu.RLock()
	ls := slices.Clone(t.listeners) // don't hold the lock while calling out3
	t.mu.RUnlock()
	for _, l := range ls {
		l(ctx, event)
	}
}

Khác biệt chính giữa Java và GoKey differences between Java and Go

01Spring: listener được tìm theo kiểu tham số của method @EventListener, tự đăng ký khi khởi động. Go: bạn gọi Subscribe tường minh khi wiring trong main.Spring: listeners are found by the parameter type of @EventListener methods and registered at startup. Go: you call Subscribe explicitly while wiring in main.
02Spring gắn sự kiện với transaction (@TransactionalEventListener AFTER_COMMIT/AFTER_ROLLBACK). Go không có khái niệm đó — bạn tự Publish sau khi tx.Commit() thành công.Spring ties events to transactions (@TransactionalEventListener AFTER_COMMIT/AFTER_ROLLBACK). Go has no such notion — you Publish after tx.Commit() succeeds.
03Bất đồng bộ: Java dùng @Async + thread pool (hoặc virtual threads). Go dùng goroutine + channel có buffer, và phải tự xử lý khi hàng đợi đầy.Async: Java uses @Async + a thread pool (or virtual threads). Go uses a goroutine + buffered channel, and you decide what happens when the queue is full.
04Observer trong Go thường chỉ là func; trong Java là method có annotation trên một bean — cả hai đều tránh được interface Observer cổ điển của GoF.A Go observer is often just a func; in Java it's an annotated method on a bean — both avoid the classic GoF Observer interface.
05Cả hai đều chỉ trong một process: app crash là mất sự kiện chưa xử lý. Cần bền vững thì dùng Transactional Outbox + Kafka/RabbitMQ.Both are in-process only: a crash loses unprocessed events. For durability, use a Transactional Outbox + Kafka/RabbitMQ.

Ứng dụng thực tếReal-world usage

Spring ApplicationEventSpring ApplicationEvents
Ngoài sự kiện của bạn, Spring tự phát ContextRefreshedEvent, ApplicationReadyEvent... — dùng @EventListener(ApplicationReadyEvent.class) để chạy việc khi app khởi động xong.Besides your own events, Spring publishes ContextRefreshedEvent, ApplicationReadyEvent... — use @EventListener(ApplicationReadyEvent.class) to run work once the app is up.
Spring ModulithSpring Modulith
Các module giao tiếp qua sự kiện; @ApplicationModuleListener = transactional + async listener, kèm Event Publication Registry để không mất sự kiện.Modules talk via events; @ApplicationModuleListener = a transactional + async listener, with an Event Publication Registry so events aren't lost.
Go: signal.Notify và contextGo: signal.Notify and context
signal.Notify(ch, os.Interrupt) đăng ký một channel làm observer cho tín hiệu hệ điều hành; ctx.Done() là một kênh thông báo huỷ cho mọi goroutine đang nghe.signal.Notify(ch, os.Interrupt) registers a channel as an observer of OS signals; ctx.Done() is a cancellation broadcast to every listening goroutine.
Webhook và UIWebhooks and UIs
Cổng thanh toán (VNPay, Momo) gọi webhook khi giao dịch thành công; addEventListener trong trình duyệt, state store trong React — tất cả đều là Observer.Payment gateways (VNPay, Momo) call your webhook on success; addEventListener in the browser, state stores in React — all Observer.

Khi nào dùng và khi nào khôngWhen to use it, and when not

Nên dùng khiUse it when

Một thay đổi cần kéo theo nhiều phản ứng thuộc các module/team khác nhau.One change triggers several reactions owned by different modules/teams.
Muốn thêm/bớt phản ứng mà không sửa nơi phát sinh sự kiện.You want to add/remove reactions without touching where the event originates.
Các tác vụ phụ (email, thống kê) không nên làm chậm luồng chính.Side tasks (email, analytics) shouldn't slow down the main flow.

Không nên dùng khiAvoid it when

Bước bắt buộc phải thành công cùng luồng chính (trừ kho, trừ tiền) — gọi trực tiếp cho rõ ràng.A step that must succeed with the main flow (stock, payment) — call it directly for clarity.
Chỉ có một người nhận cố định — một lời gọi method đơn giản dễ đọc và dễ debug hơn.There's a single fixed receiver — a plain method call is easier to read and debug.
Cần đảm bảo giao nhận giữa các service khác process — dùng message broker + Outbox, không phải event trong bộ nhớ.You need guaranteed delivery across processes — use a message broker + Outbox, not in-memory events.

Ưu điểmPros

Subject và observer lỏng lẻo: chỉ dính nhau qua kiểu sự kiện.Loose coupling: subject and observers share only the event type.
Open/Closed: thêm phản ứng mới bằng một listener mới.Open/Closed: add reactions with a new listener.
Dễ chuyển tác vụ phụ sang bất đồng bộ.Easy to move side tasks to async.

Nhược điểmCons

Luồng điều khiển ẩn: khó trả lời 'đặt hàng xong thì chuyện gì xảy ra?' khi đọc code.Hidden control flow: hard to answer 'what happens after an order?' by reading code.
Thứ tự chạy listener và xử lý lỗi dễ gây bất ngờ (exception đồng bộ làm rollback, async thì nuốt lỗi).Listener order and error handling can surprise you (sync exceptions roll back, async ones get swallowed).
Sự kiện trong bộ nhớ mất khi crash; rò rỉ bộ nhớ nếu quên huỷ đăng ký observer tồn tại ngắn.In-memory events are lost on crash; memory leaks if short-lived observers never unsubscribe.

Anti-pattern: lỗi thường gặpAnti-pattern: common mistake

Gửi email bằng @EventListener thường, trong transactionSending email from a plain @EventListener inside the transaction

@EventListener chạy ngay lúc publishEvent, TRƯỚC khi commit. Nếu sau đó transaction rollback (ví dụ hết hàng), khách vẫn nhận email 'đặt hàng thành công'. Và email chậm 3 giây làm transaction giữ khoá DB 3 giây. Hãy dùng @TransactionalEventListener(AFTER_COMMIT) + @Async.@EventListener runs at publishEvent time, BEFORE commit. If the transaction later rolls back (e.g. out of stock), the customer still gets 'order confirmed'. And a 3-second email keeps DB locks for 3 seconds. Use @TransactionalEventListener(AFTER_COMMIT) + @Async.

@Component
class ConfirmationMailer {
    @EventListener                              // ❌ runs before commit
    public void on(OrderPlacedEvent e) {
        mail.send(e.customerId(), "Order confirmed!"); // ❌ slow I/O inside tx
    }
}
// later in OrderService.place(): inventory.reserve(...) throws
// -> transaction rolls back, but the email is already gone

Dễ nhầm vớiEasily confused with

Observer vs Publish-Subscribe

Observer: subject giữ danh sách observer, thường trong cùng process và đồng bộ. Pub-Sub: có broker trung gian (Kafka, Redis), publisher và subscriber hoàn toàn không biết nhau, thường khác process.Observer: the subject keeps the observer list, usually in-process and synchronous. Pub-Sub: a broker (Kafka, Redis) sits in between; publishers and subscribers never know each other, often across processes.

Observer vs Mediator

Observer: phát một chiều, ai muốn thì nghe. Mediator: một object trung tâm điều phối hai chiều giữa các thành viên và chứa logic phối hợp.Observer: one-way broadcast, whoever wants listens. Mediator: a central object coordinates two-way interaction between colleagues and holds the coordination logic.

Bài tập áp dụngExercise

Thêm observer 'cộng điểm thành viên': 1 điểm cho mỗi 100đ, chỉ khi đơn đã commit. Không được sửa OrderService/Service.Add a 'loyalty points' observer: 1 point per 100 VND, only once the order is committed. Do not edit OrderService/Service.

Kiểm tra kiến thứcKnowledge check

Câu 1 / 6Question 1 of 6

Ý tưởng cốt lõi của Observer là gì?What is the core idea of Observer?

Phím 1–4 để chọn đáp án, Enter để kiểm tra.Press 1–4 to choose an answer, Enter to check.

Thẻ ghi nhớFlashcards

Ôn tập ngắt quãng (spaced repetition): thẻ được lặp lại sau 1 → 3 → 7 → 14 → 30 ngày để củng cố trí nhớ dài hạn.Spaced repetition: cards are repeated after 1 → 3 → 7 → 14 → 30 days to build long-term memory.

Dùng trong bài toánUsed in problems

5 bài toán Backend dùng pattern này5 backend problems use this pattern

Pattern liên quanRelated patterns

Publish-Subscribe Mediator Transactional Outbox Command

Thảo luậnDiscussion

Observeraka Listener, Event Listener, Publish–Subscribe (in-process)

VừaMedium

Mức phổ biếnUsage 5/5

~9 phút đọc~9 min read

package com.shop.order; import org.springframework.context.ApplicationEventPublisher; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; @Service public class OrderService { private final OrderRepository orders; private final ApplicationEventPublisher events;1 public OrderService(OrderRepository orders, ApplicationEventPublisher events) { this.orders = orders; this.events = events; } @Transactional public Order place(PlaceOrderCommand cmd) { Order order = orders.save(Order.from(cmd)); // The subject doesn't know who listens: email, loyalty, analytics... events.publishEvent(new OrderPlacedEvent(order.id(), order.customerId(), order.total()));2 return order; } } // In OrderPlacedEvent.java — an immutable record is the ideal event: // public record OrderPlacedEvent(long orderId, String customerId, BigDecimal total) {}3

package events import ( "context" "slices" "sync" ) // Listener is just a function: Go's lightest observer. type Listener[T any] func(ctx context.Context, event T)1 // Topic is a tiny typed in-process event bus. The zero value is ready to use. type Topic[T any] struct {2 mu sync.RWMutex listeners []Listener[T] } func (t *Topic[T]) Subscribe(l Listener[T]) { t.mu.Lock() defer t.mu.Unlock() t.listeners = append(t.listeners, l) } // Publish calls observers synchronously, in subscription order. func (t *Topic[T]) Publish(ctx context.Context, event T) { t.mu.RLock() ls := slices.Clone(t.listeners) // don't hold the lock while calling out3 t.mu.RUnlock() for _, l := range ls { l(ctx, event) } }

@Component class ConfirmationMailer { @EventListener // ❌ runs before commit public void on(OrderPlacedEvent e) { mail.send(e.customerId(), "Order confirmed!"); // ❌ slow I/O inside tx } } // later in OrderService.place(): inventory.reserve(...) throws // -> transaction rolls back, but the email is already gone