Cấu trúcStructural

Decoratoraka Wrapper, Middleware

Bọc object trong các lớp vỏ cùng interface để thêm hành vi (cache, log, transaction...) mà không sửa object gốc.Wrap an object in layers sharing its interface to add behaviour (cache, logging, transactions...) without changing it.

Độ 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

Một ly cà phê đen là 'object gốc'. Thêm sữa đặc, thêm kem muối, thêm topping — mỗi lớp thêm một chút hương vị nhưng nó vẫn là 'một ly cà phê' cầm trên tay. Bạn có thể xếp lớp theo bất kỳ thứ tự nào, và quán không phải sáng chế ra món 'cà phê-sữa-kem-muối-topping' riêng biệt.A black coffee is the 'core object'. Add condensed milk, add salted cream, add a topping — each layer adds a little flavour, but it's still 'a coffee' in your hand. You can stack layers in any order, and the shop never has to invent a dedicated 'coffee-milk-salted-cream-topping' product.

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

Không có patternWithout the pattern

Service đọc sản phẩm từ DB giờ cần thêm cache, đo thời gian, ghi log, kiểm tra quyền... Nhét hết vào một class thì nó phình to và lẫn lộn trách nhiệm. Dùng kế thừa (CachedJdbcCatalog, LoggedCachedJdbcCatalog...) thì số lớp con bùng nổ theo cấp số nhân, và không thể bật/tắt từng tính năng lúc cấu hình.A service reading products from the DB now needs caching, timing, logging, permission checks... Cramming it all into one class bloats it and mixes responsibilities. Using inheritance (CachedJdbcCatalog, LoggedCachedJdbcCatalog...) makes subclasses explode combinatorially, and you can't toggle features at config time.

Với DecoratorWith Decorator

Mỗi tính năng phụ là một Decorator implement CÙNG interface và giữ tham chiếu tới object bên trong. Nó làm việc của mình rồi uỷ quyền cho lớp trong. Ghép các lớp như búp bê Nga: Timing → Cache → JDBC. Spring làm việc này tự động bằng proxy (@Transactional, @Cacheable); Go làm bằng middleware func(http.Handler) http.Handler.Each extra feature is a Decorator implementing the SAME interface and holding a reference to the inner object. It does its job, then delegates inward. Stack layers like Russian dolls: Timing → Cache → JDBC. Spring does this automatically with proxies (@Transactional, @Cacheable); Go does it with func(http.Handler) http.Handler middleware.

Thành phần tham giaParticipants

Component: Interface chung cho cả object gốc và decorator (ProductCatalog, http.Handler).The common interface for both the core object and decorators (ProductCatalog, http.Handler).
ConcreteComponent: Object gốc làm việc chính (JdbcProductCatalog).The core object doing the real work (JdbcProductCatalog).
Decorator: Implement Component, bọc một Component khác, thêm hành vi trước/sau khi uỷ quyền.Implements Component, wraps another Component, adds behaviour before/after delegating.
Client: Chỉ thấy Component — không biết có bao nhiêu lớp vỏ.Only sees Component — unaware of how many layers there are.

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.

1Controller gọi findById("SP1001") trên một ProductCatalog — nó không biết bên trong có mấy lớp.The controller calls findById("SP1001") on a ProductCatalog — it has no idea how many layers there are.

← →

console

1> findById("SP1001")

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.catalog;

import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;

// Decorator: same interface as the object it wraps, adds caching around it
public class CachingProductCatalog implements ProductCatalog {1
    private final ProductCatalog delegate;2
    private final Map<String, Product> cache = new ConcurrentHashMap<>();

    public CachingProductCatalog(ProductCatalog delegate) {
        this.delegate = delegate;
    }

    @Override
    public Optional<Product> findById(String id) {
        Product hit = cache.get(id);
        if (hit != null) {
            return Optional.of(hit);
        }
        Optional<Product> loaded = delegate.findById(id);3
        loaded.ifPresent(p -> cache.put(id, p));
        return loaded;
    }
}

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

package httpx

import (
	"log/slog"
	"net/http"
	"time"
)

// Middleware decorates an http.Handler: same interface in, same interface out.
type Middleware func(http.Handler) http.Handler1

func Logging(log *slog.Logger) Middleware {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {2
			start := time.Now()
			next.ServeHTTP(w, r)3
			log.Info("request", "method", r.Method, "path", r.URL.Path, "took", time.Since(start))
		})
	}
}

func RequireAPIKey(key string) Middleware {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			if r.Header.Get("X-API-Key") != key {
				http.Error(w, "unauthorized", http.StatusUnauthorized)
				return // short-circuit: the inner handler never runs4
			}
			next.ServeHTTP(w, r)
		})
	}
}

// Chain applies middlewares so the first one listed is the outermost.
func Chain(h http.Handler, mws ...Middleware) http.Handler {
	for i := len(mws) - 1; i >= 0; i-- {
		h = mws[i](h)
	}
	return h
}

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

01Spring thường tạo decorator TỰ ĐỘNG bằng proxy (AOP) từ annotation như @Transactional, @Cacheable, @Async. Go không có AOP — bạn bọc tường minh bằng hàm.Spring often builds decorators AUTOMATICALLY via proxies (AOP) from annotations like @Transactional, @Cacheable, @Async. Go has no AOP — you wrap explicitly with functions.
02Decorator kiểu Go phổ biến nhất là middleware func(http.Handler) http.Handler; bên Java tương đương là Servlet Filter hoặc HandlerInterceptor.Go's most common decorator is func(http.Handler) http.Handler middleware; the Java equivalents are Servlet Filters or HandlerInterceptors.
03Proxy của Spring có bẫy self-invocation: gọi method @Transactional qua this sẽ không đi qua proxy. Decorator viết tay (Java hay Go) không có bẫy này.Spring proxies have the self-invocation trap: calling a @Transactional method via this skips the proxy. Hand-written decorators (Java or Go) don't have this trap.
04Cả hai ngôn ngữ đều cho phép decorator là một hàm/lambda khi interface chỉ có một method (functional interface / http.HandlerFunc).Both languages let a decorator be a function/lambda when the interface has a single method (functional interface / http.HandlerFunc).

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

Spring AOP: @Transactional, @Cacheable, @RetryableSpring AOP: @Transactional, @Cacheable, @Retryable
Spring bọc bean trong proxy (JDK dynamic proxy hoặc CGLIB) thêm transaction, cache, retry quanh method gốc — Decorator được sinh lúc runtime.Spring wraps beans in proxies (JDK dynamic proxy or CGLIB) adding transactions, caching, retries around the method — Decorators generated at runtime.
Java I/O streamsJava I/O streams
new BufferedInputStream(new GZIPInputStream(in)) — mỗi lớp thêm một khả năng (đệm, giải nén) nhưng vẫn là InputStream. Ngoài ra Collections.unmodifiableList(list) cũng là decorator.new BufferedInputStream(new GZIPInputStream(in)) — each layer adds a capability (buffering, decompression) but stays an InputStream. Collections.unmodifiableList(list) is a decorator too.
Go: middleware http.Handler, io.TeeReaderGo: http.Handler middleware, io.TeeReader
chi, gorilla/handlers, otelhttp đều là middleware bọc http.Handler. io.LimitReader, bufio.NewReader bọc io.Reader theo cùng cách.chi, gorilla/handlers, otelhttp are all middleware wrapping http.Handler. io.LimitReader and bufio.NewReader wrap io.Reader the same way.
Client gọi API đối tácPartner API clients
Client gọi cổng thanh toán/hãng ship được bọc thêm retry, circuit breaker, metrics, log — mỗi thứ một lớp, bật/tắt theo môi trường.A payment/carrier API client wrapped with retry, circuit breaker, metrics, logging — one layer each, toggled per environment.

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

Nên dùng khiUse it when

Cần thêm tính năng 'xuyên suốt' (log, cache, metrics, auth, transaction) mà không sửa class gốc.You need cross-cutting features (logging, caching, metrics, auth, transactions) without editing the core class.
Muốn bật/tắt hoặc đổi thứ tự các tính năng lúc cấu hình/lúc chạy.You want to toggle or reorder features at config time or runtime.
Kế thừa sẽ sinh ra quá nhiều lớp con cho mọi tổ hợp tính năng.Inheritance would create too many subclasses for every feature combination.

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

Interface có hàng chục method — decorator phải uỷ quyền lại tất cả, rất mệt (cân nhắc AOP hoặc tách interface nhỏ hơn).Interfaces with dozens of methods — a decorator must forward them all, which is painful (consider AOP or smaller interfaces).
Hành vi thêm vào phụ thuộc chi tiết nội bộ của object gốc — decorator chỉ thấy interface công khai.The added behaviour depends on the core object's internals — a decorator only sees the public interface.

Ưu điểmPros

Thêm hành vi mà không sửa code gốc (Open/Closed).Adds behaviour without modifying the original code (Open/Closed).
Mỗi lớp một trách nhiệm, dễ test riêng.One responsibility per layer, easy to test in isolation.
Ghép, bỏ, đổi thứ tự linh hoạt thay vì bùng nổ lớp con.Compose, drop and reorder flexibly instead of a subclass explosion.

Nhược điểmCons

Thứ tự các lớp ảnh hưởng kết quả (log trước hay sau auth?) — dễ sai mà khó thấy.Layer order changes the outcome (log before or after auth?) — easy to get wrong, hard to spot.
Stack trace và debug dài hơn vì nhiều lớp bọc nhau, nhất là với proxy sinh tự động.Longer stack traces and harder debugging through many wrappers, especially auto-generated proxies.
Code dựa trên kiểu cụ thể (instanceof JdbcProductCatalog) sẽ hỏng vì object thật đã bị bọc.Code relying on concrete types (instanceof JdbcProductCatalog) breaks because the real object is wrapped.

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

Gọi method @Transactional qua `this`Calling a @Transactional method via `this`

Transaction của Spring nằm ở lớp proxy BÊN NGOÀI bean. Gọi method trong cùng class là gọi thẳng object gốc, bỏ qua decorator — không có transaction, không rollback. Hãy tách method sang bean khác hoặc đặt @Transactional ở method được gọi từ bên ngoài.Spring's transaction lives in the proxy OUTSIDE the bean. Calling a method within the same class hits the raw object, skipping the decorator — no transaction, no rollback. Move the method to another bean or put @Transactional on the externally called method.

@Service
public class OrderService {
    public void checkout(Cart cart) {
        validate(cart);
        this.placeOrder(cart);   // ❌ bypasses the proxy: NO transaction
    }

    @Transactional
    public void placeOrder(Cart cart) {
        orders.save(Order.from(cart));
        stock.decrease(cart.items()); // fails -> order is NOT rolled back
    }
}

Dễ nhầm vớiEasily confused with

Decorator vs Proxy

Cấu trúc gần như giống hệt. Decorator THÊM hành vi và thường được client tự ghép nhiều lớp; Proxy KIỂM SOÁT truy cập (lazy load, bảo mật, remote) và thường tự quản lý object thật.Nearly identical structure. Decorator ADDS behaviour and is usually stacked by the client; Proxy CONTROLS access (lazy loading, security, remote) and usually manages the real object itself.

Decorator vs Chain of Responsibility

Middleware nhìn giống Chain of Responsibility. Khác biệt: decorator thường luôn gọi lớp trong và thêm việc; mắt xích trong Chain thường chọn TỰ XỬ LÝ hoặc chuyển tiếp.Middleware looks like Chain of Responsibility. Difference: a decorator normally always calls inward and adds work; a Chain link usually chooses to HANDLE it or pass it on.

Bài tập áp dụngExercise

Viết decorator giới hạn thời gian: nếu lớp bên trong mất quá 300ms thì trả lỗi timeout. Java: bọc ProductCatalog. Go: viết middleware Timeout(d time.Duration) Middleware.Write a time-limit decorator: if the inner layer takes over 300ms, fail with a timeout. Java: wrap ProductCatalog. Go: write a Timeout(d time.Duration) Middleware.

Kiểm tra kiến thứcKnowledge check

Câu 1 / 6Question 1 of 6

Điều kiện bắt buộc để một class là Decorator là gì?What is required for a class to be a Decorator?

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

9 bài toán Backend dùng pattern này9 backend problems use this pattern

Pattern liên quanRelated patterns

Proxy Adapter Chain of Responsibility Composite

Thảo luậnDiscussion

Decoratoraka Wrapper, Middleware

VừaMedium

Mức phổ biếnUsage 5/5

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

package com.shop.catalog; import java.util.Map; import java.util.Optional; import java.util.concurrent.ConcurrentHashMap; // Decorator: same interface as the object it wraps, adds caching around it public class CachingProductCatalog implements ProductCatalog {1 private final ProductCatalog delegate;2 private final Map<String, Product> cache = new ConcurrentHashMap<>(); public CachingProductCatalog(ProductCatalog delegate) { this.delegate = delegate; } @Override public Optional<Product> findById(String id) { Product hit = cache.get(id); if (hit != null) { return Optional.of(hit); } Optional<Product> loaded = delegate.findById(id);3 loaded.ifPresent(p -> cache.put(id, p)); return loaded; } }

package httpx import ( "log/slog" "net/http" "time" ) // Middleware decorates an http.Handler: same interface in, same interface out. type Middleware func(http.Handler) http.Handler1 func Logging(log *slog.Logger) Middleware { return func(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {2 start := time.Now() next.ServeHTTP(w, r)3 log.Info("request", "method", r.Method, "path", r.URL.Path, "took", time.Since(start)) }) } } func RequireAPIKey(key string) Middleware { return func(next http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { if r.Header.Get("X-API-Key") != key { http.Error(w, "unauthorized", http.StatusUnauthorized) return // short-circuit: the inner handler never runs4 } next.ServeHTTP(w, r) }) } } // Chain applies middlewares so the first one listed is the outermost. func Chain(h http.Handler, mws ...Middleware) http.Handler { for i := len(mws) - 1; i >= 0; i-- { h = mws[i](h) } return h }

@Service public class OrderService { public void checkout(Cart cart) { validate(cart); this.placeOrder(cart); // ❌ bypasses the proxy: NO transaction } @Transactional public void placeOrder(Cart cart) { orders.save(Order.from(cart)); stock.decrease(cart.items()); // fails -> order is NOT rolled back } }