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

Tìm kiếm

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

Adapter và Factory: tích hợp cổng thanh toán và chọn đúng implementation

Ôn 16 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

Khi tích hợp với bên ngoài, Adapter giữ chi tiết của SDK bên thứ ba khỏi code nghiệp vụ, còn Factory tạo hoặc chọn đúng implementation. Bài này review hai đoạn code mẫu của khoá học (một adapter đổi USD sang VND có bốn lỗi trong một dòng, một “factory” bị gọi nhầm tên và không được inject) rồi viết lại cho đúng (JDK 21, Lombok 1.18.42). Phần Spring dựa vào IoC và Dependency Injection; luồng đặt phòng ở mục 2 được giải thích ở bài 2: Template Method.

Sơ đồ tóm tắt:

flowchart LR
  A[Code của mình] --> AD[Adapter]
  AD -->|"dịch kiểu, đơn vị, lỗi"| PG[Cổng thanh toán]
  AD -.-> M["Tiền: BigDecimal/long"]
  AD -.-> T["Timeout = chưa biết"]
  F{Cần factory nào?} -->|chọn theo key| S[Simple factory]
  F -->|lớp con chọn| FM[Factory Method]
  F -->|họ object khớp nhau| AF[Abstract Factory]
  F -->|Spring| R[Registry chọn bean]

1. Adapter: tích hợp cổng thanh toán nhận VND

Ý chính: Adapter chuyển interface của một class thành interface mà client cần, để cả hai bên không phải sửa. Adapter tốt còn đổi đơn vị, kiểu tiền và mã lỗi, nên chi tiết của SDK không lọt ra ngoài.

1.1. v1 và v2 của repo

OrderService tính tiền bằng USD, còn SDK thanh toán (không sửa được) nhận VND. Bản v1 gọi thẳng SDK với số USD: khách mua 12 USD bị trừ 12 đồng (“failed integration”).

Bản v2 thêm interface PaymentGateway (nhận USD) cho OrderService dùng, và PaymentAdapter implement nó: đổi USD sang VND rồi gọi SDK. OrderService không biết SDK tồn tại. Phần đổi tiền của repo:

private int convertToVND(double amount) {
    return (int) amount * 26000; // USD = 26000 VND
}

1.2. Review adapter: bốn lỗi trong một dòng

Chạy thử chính công thức đó:

static int buggyConvert(double usd) { return (int) usd * 26000; }

System.out.println("buggy 12.99 USD -> " + buggyConvert(12.99) + " VND");
System.out.println("buggy  0.99 USD -> " + buggyConvert(0.99) + " VND");
System.out.println("buggy 99999 USD -> " + buggyConvert(99_999) + " VND (int overflow)");
System.out.println("double 19.99*26000 = " + (19.99 * 26000) + ", cast to long = " + (long) (19.99 * 26000));
buggy 12.99 USD -> 312000 VND
buggy  0.99 USD -> 0 VND
buggy 99999 USD -> -1694993296 VND (int overflow)
double 19.99*26000 = 519739.99999999994, cast to long = 519739

Ngoài phép tính còn ba lỗi thiết kế:

  • Tỷ giá 26.000 viết cứng trong code.
  • Adapter tự new SDK, OrderServiceV2 tự new adapter, nên không thay được khi test.
  • Adapter trả nguyên chuỗi kết quả của SDK, nên chi tiết bên thứ ba vẫn rò sang code của mình.

1.3. Adapter làm đúng

Adapter tốt dịch toàn bộ ngôn ngữ của bên thứ ba: tiền là Money (số + mã tiền tệ), kết quả là Paid/Declined thay vì mã "00"/"51", tỷ giá đến từ FxRates được inject.

// adaptee: SDK của bên thứ ba
static final class LocalPayClient {
    /** Số tiền VND (đồng chẵn). Trả "00" nếu thành công, mã khác nếu lỗi. */
    String charge(long amountVnd, String orderRef) {
        if (amountVnd > 50_000_000) return "51";             // không đủ tiền
        return "00";
    }
}

// port: thứ ứng dụng muốn nói chuyện cùng
record Money(BigDecimal amount, Currency currency) {
    Money {
        if (amount.scale() > currency.getDefaultFractionDigits())
            throw new IllegalArgumentException("too many decimals for " + currency + ": " + amount);
    }
    static Money of(String amount, String code) { return new Money(new BigDecimal(amount), Currency.getInstance(code)); }
}

sealed interface PaymentResult permits Paid, Declined {}
record Paid(String orderRef, Money charged) implements PaymentResult {}
record Declined(String orderRef, String reason) implements PaymentResult {}

interface PaymentGateway { PaymentResult pay(String orderRef, Money amount); }
interface FxRates { BigDecimal rate(Currency from, Currency to); }

// adapter
static final class LocalPayAdapter implements PaymentGateway {
    private static final Currency VND = Currency.getInstance("VND");
    private static final Map<String, String> REASONS = Map.of("51", "INSUFFICIENT_FUNDS", "24", "CANCELLED_BY_USER");
    private final LocalPayClient client;
    private final FxRates fx;

    LocalPayAdapter(LocalPayClient client, FxRates fx) { this.client = client; this.fx = fx; }

    @Override
    public PaymentResult pay(String orderRef, Money amount) {
        Money vnd = toVnd(amount);
        String code = client.charge(vnd.amount().longValueExact(), orderRef);
        return "00".equals(code)
                ? new Paid(orderRef, vnd)
                : new Declined(orderRef, REASONS.getOrDefault(code, "UNKNOWN_" + code));
    }

    private Money toVnd(Money m) {
        if (m.currency().equals(VND)) return m;
        BigDecimal converted = m.amount()
                .multiply(fx.rate(m.currency(), VND))
                .setScale(VND.getDefaultFractionDigits(), RoundingMode.HALF_UP);
        return new Money(converted, VND);
    }
}
Output với tỷ giá giả và switch trên sealed result

Với tỷ giá giả 26.000,50 cho demo:

Paid[orderRef=ORD-1, charged=Money[amount=337746, currency=VND]]
Paid[orderRef=ORD-2, charged=Money[amount=519750, currency=VND]]
Declined[orderRef=ORD-3, reason=INSUFFICIENT_FUNDS]
Paid[orderRef=ORD-4, charged=Money[amount=150000, currency=VND]]
rejected: too many decimals for VND: 1.5
declined: INSUFFICIENT_FUNDS

Dòng cuối đến từ một switch trên PaymentResult. Vì interface là sealed (chỉ các class trong permits được implement), switch không cần default và compiler bắt xử lý đủ mọi kết quả. Thêm Pending vào permits mà quên chỗ xử lý là lỗi biên dịch.

1.4. Adapter khác Facade, Decorator và anti-corruption layer thế nào

Pattern Interface đầu ra so với thứ được bọc Mục đích
Adapter khác: đúng interface client cần cho hai interface không khớp làm việc với nhau
Facade đơn giản hơn: gộp nhiều lời gọi thành vài method giấu sự phức tạp của một subsystem
Decorator giống hệt thêm hành vi (log, retry, cache) mà không đổi interface
Proxy giống hệt kiểm soát truy cập (lazy, bảo mật, remote, transaction của Spring)
Anti-corruption layer một tập adapter + translator ở biên giữ model của bounded context mình khỏi bị model bên ngoài “nhiễm”
Object adapter hay class adapter

Object adapter giữ adaptee làm field (như ở trên). Class adapter kế thừa adaptee và implement target. Java chỉ cho kế thừa một class, và kế thừa SDK là phụ thuộc cả những gì mình không dùng, nên gần như luôn chọn object adapter.

Bọc SDK bên thứ ba sau interface của mình là một trường hợp của quy tắc boundary trong clean code; bài Clean code: xử lý lỗi, boundary và refactor bàn thêm cách test boundary đó mà không mock quá tay và cách dịch exception của SDK ngay tại đó.

2. Factory: ba thứ khác nhau cùng mang tên factory

Ý chính: “factory” là tên của ba thứ: simple factory chọn implementation bằng switch hoặc bảng tra, Factory Method để lớp con chọn class, Abstract Factory tạo một họ object phải khớp nhau. Trong Spring, container đã tạo bean, nên code thường chỉ cần chọn.

Bài 2 đã cho thấy chuyện gọi nhầm tên: BookingFactory của luồng đặt phòng v2 có comment “Abstract Factory”, nhưng chỉ chọn một trong ba service có sẵn theo loại chỗ ở.

Simple factory Factory Method Abstract Factory
Hình dạng một hàm/class có switch hoặc bảng tra một method trừu tượng, lớp con cài một interface có nhiều method tạo
Tạo ra một object trong nhiều loại một object, loại do lớp con chọn một họ object phải khớp nhau
Cơ chế điều kiện hoặc tra bảng kế thừa composition (truyền factory vào)
Ví dụ chọn booking service theo loại chỗ ở ReceiptSender email/SMS cổng thanh toán: URL builder + verifier

2.1. Simple factory: một hàm chọn implementation

Không phải pattern trong sách của GoF, nhưng hay gặp nhất. Đủ tốt khi ít loại và cùng module.

static BookingHandler simpleFactory(ListingType type, BookingHandler apartment, BookingHandler villa, BookingHandler base) {
    return switch (type) {             // không có default: thêm hằng mới thì vỡ build ở đây
        case APARTMENT -> apartment;
        case VILLA -> villa;
        case HOMESTAY -> base;
    };
}

2.2. Registry: simple factory mà Spring lắp giúp

Khi mỗi implementation là một bean: mỗi bean tự nói nó phục vụ loại nào (type()), inject cả danh sách, dựng bảng tra. Thiếu hoặc trùng là lỗi khi khởi động (fail fast).

static final class BookingHandlerRegistry {
    private final Map<ListingType, BookingHandler> byType = new EnumMap<>(ListingType.class);

    BookingHandlerRegistry(List<BookingHandler> handlers) {     // Spring inject mọi bean BookingHandler
        for (BookingHandler h : handlers) {
            BookingHandler previous = byType.putIfAbsent(h.type(), h);
            if (previous != null) throw new IllegalStateException("two handlers for " + h.type());
        }
        EnumSet<ListingType> missing = EnumSet.complementOf(EnumSet.copyOf(byType.keySet()));
        if (!missing.isEmpty()) throw new IllegalStateException("no handler for " + missing);
    }

    BookingHandler forType(ListingType t) { return byType.get(t); }
}
APARTMENT booking for homestay 8
startup: no handler for [HOMESTAY]
startup: two handlers for VILLA

2.3. Factory Method: lớp con quyết định tạo object nào

Một method trừu tượng trả về object; lớp con chọn class cụ thể, lớp cha dùng object mà không biết nó là gì. Thực chất là Template Method có một bước là “tạo object”, nên hai pattern hay đi cùng nhau.

interface Receipt { String render(String bookingId); }

static abstract class ReceiptSender {
    protected abstract Receipt createReceipt();               // factory method
    final String send(String bookingId) { return "sent: " + createReceipt().render(bookingId); }
}
static final class EmailReceiptSender extends ReceiptSender {
    protected Receipt createReceipt() { return id -> "<html>booking " + id + "</html>"; }
}
static final class SmsReceiptSender extends ReceiptSender {
    protected Receipt createReceipt() { return id -> "Booking " + id + " confirmed"; }
}
sent: <html>booking B-42</html>
sent: Booking B-42 confirmed

2.4. Abstract Factory: một họ object phải khớp nhau

Abstract Factory tạo nhiều loại object liên quan luôn cùng một họ. Ví dụ: mỗi cổng thanh toán cần một bộ dựng URL (ký bằng secret) và một bộ xác minh callback (kiểm chữ ký bằng cùng thuật toán và secret). Trộn URL builder của cổng A với verifier của cổng B là bug; một PaymentProvider trả cả hai thì không trộn được.

Code PaymentProvider với HMAC và so sánh thời gian hằng
interface PaymentUrlBuilder { String build(String orderRef, long amount); }
interface CallbackVerifier { boolean verify(String query, String signature); }
interface PaymentProvider {                                   // abstract factory
    PaymentUrlBuilder urlBuilder();
    CallbackVerifier callbackVerifier();
}

record HmacProvider(String name, String algorithm, String secret) implements PaymentProvider {
    public PaymentUrlBuilder urlBuilder() {
        return (ref, amount) -> {
            String query = "amount=" + amount + "&ref=" + ref;
            return "https://pay." + name + ".example/?" + query + "&sig=" + hmacHex(algorithm, secret, query);
        };
    }
    public CallbackVerifier callbackVerifier() {
        return (query, sig) -> MessageDigest.isEqual(          // so sánh thời gian hằng
                hmacHex(algorithm, secret, query).getBytes(StandardCharsets.US_ASCII),
                sig.getBytes(StandardCharsets.US_ASCII));
    }
}
url length 186, verify own callback = true
verify with another provider's verifier = false
verify tampered amount = false

MessageDigest.isEqual so sánh hết các byte bất kể khác ở đâu. String.equals dừng ở byte khác đầu tiên, nên kẻ tấn công có thể đo thời gian phản hồi để đoán dần chữ ký (timing attack).

2.5. Spring đã là factory, và bẫy @RequiredArgsConstructor

IoC container là một factory lớn: tạo bean, quyết định tạo bao nhiêu (scope), lắp dependency. Code của mình cần chọn bean (registry), hoặc tạo object theo dữ liệu runtime (ObjectProvider<T> hay một factory bean nhận tham số).

Vì container lo lắp ráp, lỗi lắp ráp khó thấy khi đọc code. Luồng đặt phòng v2 có lỗi này ở ba class: BookingV2Controller, BookingFactory, BaseBookingService đều có @RequiredArgsConstructor nhưng các field dependency (hoặc phần lớn) không final:

@Service
@RequiredArgsConstructor
public class BookingFactory {   // Abstract Factory
    private final VillaBookingService villaBookingService;
    private HomestayService homestayService;
    private BaseBookingService baseBookingService;
    private ApartmentBookingService apartmentBookingService;
Thí nghiệm Lombok 1.18.42: constructor được sinh ra và NPE

Mình viết hai class rút gọn cùng kiểu khai báo (một class có một field final và một field thường, một class không có field final nào), biên dịch với Lombok 1.18.42 rồi in constructor bằng reflection:

BookingFactory constructor params: [class Probe$PricingService]
BaseBookingService constructor params: []

Lombok chỉ đưa field final (và field @NonNull chưa khởi tạo) vào constructor. Field thường không được inject, giữ null, và lỗi chỉ lộ ra khi gọi method:

NPE: Cannot invoke "FactoryDemo$PricingService.price(long)" because "this.pricingService" is null

Sửa final xong sẽ lộ bẫy thứ hai: factory inject BaseBookingService theo kiểu, mà ApartmentBookingService và VillaBookingService là lớp con của nó và cũng là bean. Ba bean khớp kiểu.

2.6. Ba khái niệm hay bị lẫn: Dependency Inversion, IoC, DI

  • Dependency Inversion (chữ D trong SOLID): code phụ thuộc vào interface, không vào class cụ thể. Service phụ thuộc PaymentGateway, không phụ thuộc LocalPayClient; adapter ở mục 1 tồn tại để giữ hướng phụ thuộc này.
  • Inversion of Control: framework gọi code của mình, thay vì mình gọi thư viện (“đừng gọi chúng tôi, chúng tôi sẽ gọi bạn”). Template Method ở bài 2 là IoC ở mức một class; Spring là IoC ở mức cả ứng dụng.
  • Dependency Injection: một cách cụ thể để làm IoC cho việc tạo và lắp dependency: container ráp sẵn object (bean) rồi đưa cho bạn.
Hai hình ảnh của khoá học: pizza và xe đạp
  • Dependency Inversion: ông chủ muốn ăn pizza. Không đảo ngược, ông chủ phụ thuộc trực tiếp vào từng loại pizza (thịt, chay, phô mai). Có đảo ngược, ông chủ chỉ phụ thuộc vào “nhân viên làm pizza” (một interface), và các loại pizza cụ thể implement interface đó.
  • Dependency Injection: tự lắp xe đạp là đi mua từng linh kiện ở từng cửa hàng rồi tự ráp, rất cực. Với DI, bạn đăng ký với một nhà máy (IoC container) loại xe mình muốn, nhà máy ráp xong (bean) và giao tận tay.

Áp Dependency Inversion cho cả codebase thì thành kiến trúc hexagonal hay clean: interface PaymentGateway nằm ở lõi nghiệp vụ, adapter VNPay nằm ở rìa và phụ thuộc hướng vào trong; xem Kiến trúc codebase: layered, hexagonal, clean.

Chi tiết về container, scope và các kiểu injection nằm ở bài IoC và Dependency Injection.

Bài tập

Bài 1: Adapter cho SDK ném exception, và timeout không phải là thất bại

Đề: SDK ví điện tử có debit(account, amount, idempotencyKey) trả về mã giao dịch, ném WalletDeclinedException khi bị từ chối và IOException (kể cả SocketTimeoutException) khi lỗi mạng. Viết adapter về một port của mình với kết quả tường minh, và xử lý đúng trường hợp timeout.

Lời giải Bài 1: kết quả Unknown cho timeout
sealed interface ChargeResult permits Charged, Rejected, Unknown {}
record Charged(String providerTxId) implements ChargeResult {}
record Rejected(String reason) implements ChargeResult {}
/** Không phải thành công cũng không phải thất bại: đối soát sau với cùng key, không retry với key mới. */
record Unknown(String idempotencyKey, String cause) implements ChargeResult {}

static final class WalletAdapter implements ChargePort {
    private final WalletSdk sdk;
    WalletAdapter(WalletSdk sdk) { this.sdk = sdk; }

    @Override
    public ChargeResult charge(String account, long amountVnd, String key) {
        try {
            return new Charged(sdk.debit(account, amountVnd, key));
        } catch (WalletDeclinedException e) {
            return new Rejected(e.getMessage());
        } catch (SocketTimeoutException e) {
            return new Unknown(key, "timeout");
        } catch (IOException e) {
            return new Unknown(key, e.getClass().getSimpleName());
        }
        // IllegalArgumentException là bug của mình: để nó đi lên
    }
}
ACC-1: mark order PAID (TX-1)
LOCKED-2: mark order PAYMENT_FAILED (ACCOUNT_LOCKED)
ACC-3: mark order PAYMENT_PENDING, schedule status query for order-ACC-3
ACC-4: bug, propagated: amount must be positive

Khi đọc response bị timeout, ví có thể đã trừ tiền. Coi là thất bại rồi cho khách thử lại với key mới là trừ hai lần; coi là thành công là giao hàng chưa thu tiền. Trạng thái đúng là “chưa biết”: đơn ở PAYMENT_PENDING, truy vấn trạng thái với cùng idempotency key (khoá chống trùng: gửi lại cùng key thì cổng không trừ lần hai), hoặc chờ callback. Lỗi lập trình (IllegalArgumentException) không bị dịch thành kết quả nghiệp vụ, vì giấu nó là giấu bug.

Bài 2: Thêm một cổng thanh toán vào Abstract Factory

Đề: thêm cổng thứ ba ký bằng HMAC-SHA256 và dùng tên tham số chữ ký khác. Cần sửa gì?

Lời giải Bài 2

Thêm một implementation PaymentProvider mới (ở demo chỉ là new HmacProvider("otherpay", "HmacSHA256", secret); cổng có định dạng khác thì là một class riêng cài cả hai method). Code thanh toán không đổi vì chỉ nhận PaymentProvider. Kết hợp với registry ở mục 2.2 (key là mã cổng) để chọn provider theo đơn hàng. Secret lấy từ secret manager, không nằm trong code hay application.yml trong git.

Ghi nhớ

  • Giải thích được vì sao (int) amount * 26000 làm mất tiền, và ba lỗi còn lại trong dòng đó.
  • Biết một adapter tốt phải dịch những gì (kiểu, đơn vị, mã lỗi, exception) và vì sao timeout là “chưa biết”.
  • Phân biệt được simple factory, Factory Method và Abstract Factory, mỗi cái kèm một ví dụ.
  • Biết khi nào dùng switch, khi nào dùng registry bean để chọn implementation.
  • Giải thích được hai bẫy wiring: @RequiredArgsConstructor với field không final, và inject theo class cha.

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

Junior

Adapter pattern là gì? Cho ví dụ.

Adapter bọc một class có interface không khớp (thường là SDK bên thứ ba) để nó trông như interface mà code của mình cần.

Ví dụ: service dùng PaymentGateway nhận Money, còn SDK nhận số nguyên VND và trả mã chuỗi; adapter đổi đơn vị, gọi SDK và dịch mã lỗi thành kết quả của mình.

Factory Method khác Abstract Factory thế nào?

Factory Method tạo một object và để lớp con chọn loại; Abstract Factory tạo một họ object liên quan phải khớp nhau.

Factory Method là một method (thường trừu tượng). Abstract Factory là một interface có nhiều method tạo, mỗi implementation ra một họ. Còn simple factory chỉ là hàm switch chọn implementation, không phải pattern của GoF.

Mid

Vì sao không dùng double cho tiền? Dùng gì thay?

Vì double là số nhị phân, 19,99 không biểu diễn chính xác; dùng BigDecimal từ chuỗi hoặc long theo đơn vị nhỏ nhất.

Nhân rồi cắt ra 519.739 thay vì 519.740. Làm tròn tường minh với RoundingMode đã thống nhất và đúng số chữ số của tiền tệ.

@RequiredArgsConstructor có field không final thì chuyện gì xảy ra?

Field đó không có trong constructor Lombok sinh ra, nên Spring không inject và nó giữ null.

App vẫn khởi động, NPE chỉ xuất hiện khi code dùng field đó chạy. Phòng bằng private final cho mọi dependency, rule tĩnh (IDE, ArchUnit) và test khởi động context gọi qua các luồng chính.

Factory chọn implementation bằng switch có nhánh default. Bạn review thế nào?

Đề nghị bỏ default, vì nó làm loại mới thêm vào enum lặng lẽ đi luồng mặc định.

Không có default, switch expression bắt phủ hết hằng: thêm loại mà quên factory là lỗi biên dịch. Hoặc chuyển sang registry dựng từ List<Handler> có kiểm tra thiếu và trùng lúc khởi động. Chỉ giữ default nếu “mọi loại khác đi luồng chung” là quyết định nghiệp vụ có ghi rõ.

Senior

Gọi cổng thanh toán bị timeout. Adapter nên trả về gì?

Một trạng thái “chưa biết” tường minh, không phải thất bại, vì tiền có thể đã bị trừ.

Coi là thất bại rồi cho thử lại với key mới là trừ hai lần. Đơn ở trạng thái chờ; hệ thống truy vấn trạng thái bằng cùng idempotency key, nhận callback (IPN), và có job đối soát cho các đơn chờ quá lâu.

Adapter, Facade, Decorator và anti-corruption layer khác nhau thế nào?

Adapter đổi interface, Facade đơn giản hoá interface, Decorator giữ interface và thêm hành vi, anti-corruption layer là cả một lớp biên chặn model bên ngoài.

Facade đặt trước một subsystem phức tạp. Decorator thêm retry, log, cache. Anti-corruption layer ở biên bounded context, gồm adapter và translator, để mã lỗi, khái niệm, đơn vị của bên ngoài không lọt vào domain của mình.

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
adapter / adaptee /əˈdæptə ˌædæpˈtiː/ lớp bọc / lớp được bọc “The adapter translates the adaptee’s error codes into our own result type.”
anti-corruption layer /ˌænti kəˈrʌpʃn ˈleɪə/ lớp biên chặn model bên ngoài “Each payment provider sits behind an anti-corruption layer.”
rounding mode /ˈraʊndɪŋ məʊd/ cách làm tròn “We agreed on HALF_UP for charging and store the rate with the transaction.”
minor unit /ˈmaɪnə ˈjuːnɪt/ đơn vị tiền nhỏ nhất (cent, đồng) “Amounts are stored as longs in minor units.”
simple factory /ˈsɪmpl ˈfæktəri/ hàm chọn implementation “That class isn’t an abstract factory, it’s a simple factory that picks a bean.”
product family /ˈprɒdʌkt ˈfæməli/ họ object phải đi cùng nhau “An abstract factory guarantees the URL builder and the verifier come from the same family.”
constant-time comparison /ˈkɒnstənt taɪm kəmˈpærɪsn/ so sánh không lộ thông tin qua thời gian “Signatures are checked with a constant-time comparison.”
fail fast /feɪl fɑːst/ lỗi sớm, ngay khi khởi động “The registry fails fast at startup if a listing type has no handler.”
exhaustive switch /ɪɡˈzɔːstɪv swɪtʃ/ switch phủ hết mọi giá trị “An exhaustive switch turns a missing case into a compile error.”

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.