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

Tìm kiếm

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

Design pattern qua refactor: Strategy

Ô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

Pattern không phải thứ mình chủ động “áp vào” code: nó xuất hiện sau một smell cụ thể, và là tên gọi chung của một cách sửa để team nói ngắn (“chỗ này tách thành strategy đi”). Bài này refactor một bộ đồng bộ dữ liệu đầy if/else sang Strategy, rồi dùng Strategy với lambda và trong Spring. Nên đọc trước: Abstract class và interface và IoC và Dependency Injection, vì phần Spring dựa vào constructor injection.

Sơ đồ tóm tắt:

flowchart TD
  SM["Smell: cùng câu hỏi lặp lại"] --> Q{Tập lựa chọn?}
  Q -->|"2–3 nhánh không đổi"| IF["if/else"]
  Q -->|tập đóng| EN[Enum có method]
  Q -->|"tập mở / có dependency"| ST[Strategy]
  ST --> CTX[Context giữ một tham chiếu]
  ST --> LB["Lambda, ghép composite"]
  ST --> SP["Spring: List → Map, kiểm lúc khởi động"]
  SP -.->|bẫy| SF[Strategy có state dùng chung]

1. Cách đọc một pattern trong cụm bài này

Ý chính: mỗi pattern đi qua bốn câu hỏi: smell là gì, refactor thế nào, được gì, mất gì. Pattern nào cũng có giá.

Thường được: thêm biến thể mới không sửa code cũ (Open/Closed Principle — mở để mở rộng, đóng để sửa đổi) và test từng phần riêng. Thường mất: thêm class, thêm tầng gián tiếp (indirection — phải nhảy qua một interface mới tới code thật), logic rải ra nhiều file. Ví dụ lấy từ code mẫu của khoá học, mình viết lại bằng code riêng chạy với JDK 21.

Smell Pattern hay dùng để sửa Bài
if/else hay switch theo “chế độ” lặp lại ở nhiều method Strategy bài này
Nhiều luồng giống nhau về thứ tự bước, khác nhau ở vài bước Template Method, hoặc composition bài 2
Một class phải gọi trực tiếp tất cả những class quan tâm đến thay đổi của nó Observer bài 3
Interface của thư viện ngoài không khớp với interface mình cần Adapter bài 4
Code tạo object rải rác, new cụ thể ở khắp nơi Factory bài 4

2. Strategy: bộ đồng bộ dữ liệu online/offline

Ý chính: app mobile có mạng thì đẩy dữ liệu lên cloud, mất mạng thì lưu tạm trên máy. Ta biến mỗi chế độ thành một strategy để class đồng bộ hết rẽ nhánh.

2.1. v0: một cờ boolean, nhánh ở khắp nơi

Ý chính: smell không phải là “có if”, mà là cùng một câu hỏi (online?) bị hỏi ở nhiều nơi, và mỗi chế độ là một khối hành vi đủ lớn để sống riêng.

Code v0 giữ cờ online và mọi method rẽ nhánh theo nó. Thêm chế độ “chỉ qua Wi-Fi” là phải sửa class đang chạy, vi phạm Open/Closed.

Bốn nhược điểm của v0 do chính tác giả repo mẫu ghi
  • Mỗi lần gọi đều kiểm tra lại trạng thái mạng.
  • Logic nghiệp vụ dính chặt vào chế độ mạng.
  • if/else phình dần (đồng bộ, retry, xử lý xung đột, báo tiến độ đều rẽ nhánh).
  • Thêm chế độ “chỉ qua Wi-Fi” phải sửa class đang chạy, vi phạm Open/Closed.
static class DataSyncManagerV0 {
    private boolean online;
    DataSyncManagerV0(boolean online) { this.online = online; }
    void setOnline(boolean online) { this.online = online; }

    void sync(String data) {
        if (online) {
            System.out.println("v0 upload to cloud: " + data);
        } else {
            System.out.println("v0 save locally: " + data);
        }
        // ...và cùng cái if (online) đó lặp lại trong retry(), conflict(), progress()...
    }
}

Strategy không phải lối thoát duy nhất. Với tập biến thể đóng, sealed interface + switch theo pattern, hoặc guard clause (xử lý trường hợp biên rồi return sớm) đôi khi đủ và đơn giản hơn; xem Clean code: đặt tên, hàm và luồng điều khiển (cùng SRP/OCP ở mức class).

2.2. Refactor: phần thay đổi thành một interface

Ý chính: “cách làm” thành interface, mỗi cách một class, còn object dùng nó (context) chỉ giữ một tham chiếu và gọi thẳng.

interface SyncStrategy {
    void sync(String data);
}

static final class CloudSync implements SyncStrategy {
    public void sync(String data) { System.out.println("upload to cloud: " + data); }
}

static final class LocalSync implements SyncStrategy {
    private final List<String> pending = new java.util.ArrayList<>();
    public void sync(String data) {
        pending.add(data);
        System.out.println("queued locally (" + pending.size() + " pending): " + data);
    }
}

static final class DataSyncManager {
    private volatile SyncStrategy strategy;            // có thể bị thread khác đổi lúc chạy
    DataSyncManager(SyncStrategy initial) { this.strategy = initial; }
    void use(SyncStrategy next) { this.strategy = next; }
    void sync(String data) { strategy.sync(data); }   // không còn if/else
}
var manager = new DataSyncManager(new CloudSync());
manager.sync("prefs");
manager.use(new LocalSync());
manager.sync("images");
manager.use(data -> System.out.println("dry-run, would sync: " + data)); // lambda cũng là strategy
manager.sync("logs");
upload to cloud: prefs
queued locally (1 pending): images
dry-run, would sync: logs
  • Được: DataSyncManager không biết có bao nhiêu chế độ; “Wi-Fi only” chỉ là thêm một class; mỗi strategy test riêng được.
  • Mất: thêm ba type, người đọc phải nhảy file mới biết “sync” thật sự làm gì.

2.3. Strategy chỉ dời chỗ rẽ nhánh, không xoá nó

Ý chính: quyết định “dùng strategy nào” vẫn phải xảy ra ở đâu đó; đặt nó ở một chỗ duy nhất, đừng để lặp lại ở mọi nơi gọi.

Trong repo mẫu, sau refactor main vẫn tự kiểm tra mạng rồi gọi setSyncStrategy, lặp lại mỗi lần trạng thái đổi. Có ba chỗ hợp lý để đặt quyết định:

2.4. Strategy trong Java hiện đại: functional interface và lambda

Ý chính: strategy chỉ có một method là một functional interface, nên một lambda là một strategy, và ghép strategy chỉ cần code bình thường.

Ví dụ giảm giá booking (repo mẫu có DiscountService giảm 5% cho kỳ nghỉ từ 3 đêm):

@FunctionalInterface
interface DiscountPolicy {
    /** Trả về số tiền giảm, luôn không âm. */
    BigDecimal discount(BigDecimal subtotal, int nights);

    DiscountPolicy NONE = (subtotal, nights) -> BigDecimal.ZERO;

    static DiscountPolicy longStay(int minNights, String rate) {
        BigDecimal r = new BigDecimal(rate);
        return (subtotal, nights) -> nights >= minNights ? subtotal.multiply(r) : BigDecimal.ZERO;
    }

    /** Các ưu đãi không cộng dồn: khách được mức tốt nhất. */
    static DiscountPolicy bestOf(List<DiscountPolicy> policies) {
        return (subtotal, nights) -> policies.stream()
                .map(p -> p.discount(subtotal, nights))
                .max(BigDecimal::compareTo)
                .orElse(BigDecimal.ZERO);
    }
}

record Price(BigDecimal subtotal, BigDecimal discount, BigDecimal total) {}

static Price price(List<BigDecimal> nightly, DiscountPolicy policy) {
    BigDecimal subtotal = nightly.stream().reduce(BigDecimal.ZERO, BigDecimal::add);
    BigDecimal discount = policy.discount(subtotal, nightly.size()).setScale(2, RoundingMode.HALF_EVEN);
    return new Price(subtotal, discount, subtotal.subtract(discount));
}

bestOf là một composite strategy: strategy ghép từ các strategy khác, không cần thêm class hierarchy.

Chạy thử DiscountPolicy và output
var nightly = List.of(new BigDecimal("33.33"), new BigDecimal("33.33"), new BigDecimal("33.34"));
System.out.println(price(nightly, DiscountPolicy.NONE));
System.out.println(price(nightly, DiscountPolicy.longStay(3, "0.05")));
var best = DiscountPolicy.bestOf(List.of(DiscountPolicy.longStay(3, "0.05"), DiscountPolicy.longStay(7, "0.12")));
System.out.println(price(nightly, best));

BigDecimal raw = new BigDecimal("100.00").multiply(BigDecimal.valueOf(-0.05));
System.out.println("raw negative discount = " + raw + " (scale " + raw.scale() + ")");
Price[subtotal=100.00, discount=0.00, total=100.00]
Price[subtotal=100.00, discount=5.00, total=95.00]
Price[subtotal=100.00, discount=5.00, total=95.00]
raw negative discount = -5.0000 (scale 4)

2.5. Strategy trong Spring

Ý chính: Spring inject mọi bean cùng implement một interface thành List (hoặc Map<String, T> theo tên bean); service dựng registry theo key và lỗi cấu hình lộ ra lúc khởi động.

Dạng code thường gặp (cần Spring nên mình không chạy trong bài):

public interface DiscountPolicy {
    String code();                                   // "LONG_STAY", "EARLY_BIRD"...
    BigDecimal discount(BigDecimal subtotal, int nights);
}

@Service
public class PricingService {
    private final Map<String, DiscountPolicy> policies;

    public PricingService(List<DiscountPolicy> all) {             // Spring inject mọi bean DiscountPolicy
        this.policies = all.stream().collect(Collectors.toUnmodifiableMap(DiscountPolicy::code, p -> p));
        // toUnmodifiableMap ném IllegalStateException nếu hai bean trùng code: lỗi lúc khởi động, không phải lúc chạy
    }

    public BigDecimal discountFor(String code, BigDecimal subtotal, int nights) {
        var policy = policies.get(code);
        if (policy == null) throw new IllegalArgumentException("unknown discount " + code);
        return policy.discount(subtotal, nights);
    }
}

Hai lựa chọn khác: @Qualifier("longStay") khi chỗ dùng cố định một strategy, @ConditionalOnProperty khi cấu hình chọn strategy cho cả ứng dụng (ví dụ storage.mode=s3|local).

Chi tiết registry: toMap ném lỗi khi trùng key

Bài tập

Bài 1: Refactor phí vận chuyển sang Strategy

Đề (diễn đạt lại): một method tính phí ship bằng if/else cho ba hãng: hãng nhanh 30.000đ + 8.000đ/kg; hãng tiết kiệm 15.000đ + 500đ/km, miễn phí cho đơn từ 500.000đ; tự đến lấy thì miễn phí. Tách thành Strategy chọn theo hãng, sao cho thêm hãng mới không sửa code cũ và thiếu cấu hình bị phát hiện lúc khởi động. Kết quả phải giống hệt code cũ.

Lời giải Bài 1: registry EnumMap kiểm tra trùng và thiếu
interface FeeStrategy {
    Carrier carrier();
    BigDecimal fee(Parcel p);
}

static final class ExpressFee implements FeeStrategy {
    public Carrier carrier() { return Carrier.EXPRESS; }
    public BigDecimal fee(Parcel p) { return new BigDecimal("30000").add(p.weightKg().multiply(new BigDecimal("8000"))); }
}

static final class EconomyFee implements FeeStrategy {
    private static final BigDecimal FREE_FROM = new BigDecimal("500000");
    public Carrier carrier() { return Carrier.ECONOMY; }
    public BigDecimal fee(Parcel p) {
        if (p.orderValue().compareTo(FREE_FROM) >= 0) return BigDecimal.ZERO;
        return new BigDecimal("15000").add(BigDecimal.valueOf(p.distanceKm()).multiply(new BigDecimal("500")));
    }
}

static final class PickupFee implements FeeStrategy {
    public Carrier carrier() { return Carrier.PICKUP; }
    public BigDecimal fee(Parcel p) { return BigDecimal.ZERO; }
}

static final class ShippingCalculator {
    private final Map<Carrier, FeeStrategy> strategies = new EnumMap<>(Carrier.class);

    ShippingCalculator(List<FeeStrategy> all) {                 // trong Spring: inject List<FeeStrategy>
        all.forEach(s -> {
            if (strategies.put(s.carrier(), s) != null) throw new IllegalStateException("duplicate " + s.carrier());
        });
        for (Carrier c : Carrier.values())
            if (!strategies.containsKey(c)) throw new IllegalStateException("missing " + c);
    }

    BigDecimal fee(Carrier c, Parcel p) {
        return strategies.get(c).fee(p).setScale(0, RoundingMode.HALF_UP);   // VND: đồng chẵn
    }
}

So với hàm cũ trên hai kiện hàng (1,25 kg/12 km/đơn 200.000đ và 3 kg/40 km/đơn 650.000đ), không có dòng MISMATCH nào:

EXPRESS  1.25kg/12km -> 40000
ECONOMY  1.25kg/12km -> 21000
PICKUP   1.25kg/12km -> 0
EXPRESS  3kg/40km -> 54000
ECONOMY  3kg/40km -> 0
PICKUP   3kg/40km -> 0
  • Mỗi strategy tự khai báo hãng nó phục vụ (carrier()), nên registry không cần biết danh sách hãng.
  • Kiểm tra trùng và thiếu trong constructor biến lỗi cấu hình thành lỗi khởi động.
  • Senior làm thêm: characterization test so code cũ và mới trên nhiều input ngẫu nhiên trước khi xoá code cũ; đưa các con số (30.000, 8.000…) vào cấu hình có version nếu nghiệp vụ hay đổi giá.

Ghi nhớ

  • Chỉ ra được smell nào đáng tách Strategy, và vì sao “có if” chưa phải smell.
  • Biết đặt quyết định “dùng strategy nào” ở đâu: cấu hình, registry hay Observer.
  • Chọn được giữa if/else, enum có method và Strategy cho một tình huống cụ thể.
  • Giải thích được vì sao strategy dùng chung phải stateless trong Spring.
  • Dựng được registry strategy trong Spring mà lỗi trùng/thiếu lộ ra lúc khởi động.

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

Junior

Strategy pattern là gì? Cho một ví dụ trong backend.

Strategy tách một hành vi có nhiều cách làm thành một interface, mỗi cách một implementation; object dùng nó chỉ giữ tham chiếu tới interface.

Ví dụ: tính giảm giá (dài ngày, đặt sớm, mã voucher), tính phí ship theo hãng, chọn cách lưu file (S3 hay ổ đĩa local). Thêm cách mới là thêm một class, không sửa code đang dùng.

Open/Closed Principle nghĩa là gì?

Code “mở để mở rộng, đóng để sửa đổi”: thêm hành vi bằng cách thêm code (class mới, bean mới), không sửa code đang chạy ổn.

Strategy và Template Method là hai cách hay dùng để đạt điều này. Không cần áp tuyệt đối: chỉ ở những chỗ thật sự hay thay đổi.

Mid

Trong Spring, bạn chọn strategy theo dữ liệu của request thế nào?

Mỗi strategy là một bean tự khai báo key; service nhận List<Strategy> qua constructor, dựng Map/EnumMap từ key tới bean, lúc chạy chỉ map.get(key).

Kiểm tra trùng và thiếu ngay trong constructor, nên lỗi cấu hình hiện ra lúc khởi động. Cách này tránh switch phải sửa mỗi lần thêm loại.

Strategy có state thì có vấn đề gì khi là Spring bean?

Bean mặc định là singleton dùng chung cho mọi request và thread, nên state trong strategy trộn dữ liệu giữa các request và gặp race condition.

Strategy nên stateless. Cần state theo từng lần dùng thì tạo instance mới (factory hoặc scope prototype) hoặc truyền state qua tham số.

Khi nào dùng enum có method thay cho Strategy?

Khi tập biến thể đóng, nằm cùng module và không có dependency riêng, ví dụ trạng thái đơn hàng hay loại phí cố định.

Mỗi hằng enum cài method của nó và compiler bắt cài đủ. Khi biến thể cần inject bean (repository, client), cần thêm từ module khác hoặc đổi lúc chạy, chuyển sang interface và các bean Strategy.

Senior

Refactor một method 300 dòng đầy if/else theo loại sang pattern, bạn làm từng bước thế nào để không làm vỡ production?

Khoá hành vi hiện tại bằng characterization test trước, rồi tách từng nhánh qua nhiều PR nhỏ, test luôn xanh, và không trộn refactor với thay đổi nghiệp vụ.

  • Characterization test ghi lại hành vi trên nhiều input, kể cả các case “sai” mà hệ thống đang dựa vào.
  • Tách method thành các bước nhỏ không đổi hành vi, rồi chuyển từng nhánh theo loại sang một implementation.
  • Có thể chạy song song code cũ và mới, so kết quả (shadow), trước khi xoá code cũ.
Strategy dời quyết định “dùng cách nào” đi đâu? Bạn đặt quyết định đó ở chỗ nào?

Strategy xoá if/else khỏi context, nhưng quyết định vẫn phải nằm ở một chỗ duy nhất.

  • Cả ứng dụng dùng một cách: cấu hình lúc khởi động (@ConditionalOnProperty, profile).
  • Mỗi request mỗi khác: registry tra theo dữ liệu request.
  • Cách làm đổi theo trạng thái hệ thống (mạng, feature flag): Observer.

Cần tránh để quyết định lặp lại ở nhiều nơi gọi, vì khi đó smell cũ chỉ đổi chỗ.

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
code smell /kəʊd smel/ dấu hiệu code có vấn đề thiết kế “The smell was the same if (online) check repeated in every method.”
strategy /ˈstrætədʒi/ một cách làm có thể thay thế “Each carrier’s fee rule is a strategy registered by its type.”
open/closed principle /ˈəʊpən kləʊzd ˈprɪnsəpl/ mở để mở rộng, đóng để sửa đổi “Adding a carrier is a new class, which keeps the calculator closed for modification.”
registry /ˈredʒɪstri/ bảng tra từ key tới implementation “The registry fails at startup if a type has no handler.”
characterization test /ˌkærəktəraɪˈzeɪʃn test/ test ghi lại hành vi hiện có trước khi refactor “I wrote characterization tests before touching the legacy method.”
over-engineering /ˌəʊvər ˌendʒɪˈnɪərɪŋ/ thiết kế phức tạp hơn mức cần “A strategy interface with one implementation is over-engineering.”
indirection /ˌɪndɪˈrekʃn/ tầng gián tiếp “Every pattern adds a level of indirection, so it has to earn its keep.”
stateless /ˈsteɪtləs/ không giữ trạng thái giữa các lần gọi “Shared strategies must be stateless because beans are singletons.”
composite strategy /ˈkɒmpəzɪt ˈstrætədʒi/ strategy ghép từ nhiều strategy khác “bestOf is a composite strategy that returns the biggest discount.”

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.