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

Tìm kiếm

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

Template Method hay composition: refactor luồng đặt phòng v0 đến v2

Ôn 12 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 trước dùng Strategy để gỡ một khối if/else lặp lại. Bài này xử lý smell họ hàng: nhiều luồng có cùng thứ tự bước, chỉ khác ở vài bước, qua ba phiên bản v0, v1, v2 của luồng đặt phòng kiểu Airbnb (Spring Boot 3, PostgreSQL) trong code mẫu của khoá học, viết lại bằng Java thuần chạy với JDK 21. Đọc xong, bạn viết được Template Method an toàn, tránh được ba bẫy khi chạy trong Spring, và biết lúc nào chuyển sang composition.

Nên đọc trước: UML và quan hệ giữa các class (phần composition hơn inheritance) và Abstract class và interface.

1. v0: một method transactional làm tất cả

Ý chính: v0 là một method @Transactional chạy bảy bước từ trên xuống. Với một loại chỗ ở, như vậy là ổn: đọc một lần là hiểu.

Bảng homestay_availability có một dòng cho mỗi đêm của mỗi homestay (giá và trạng thái theo đêm). Bảy bước:

  1. Kiểm tra request: ngày nhận phòng không ở quá khứ, nhận phòng không sau trả phòng, số khách lớn hơn 0.
  2. Kiểm tra homestay: tồn tại, đang ACTIVE, số khách không vượt sức chứa.
  3. Số đêm không quá 365.
  4. Lấy và khoá các dòng availability còn trống trong khoảng ngày (@Lock(PESSIMISTIC_WRITE), tức SELECT ... FOR UPDATE); thiếu đêm nào thì báo HOMESTAY_BUSY.
  5. Tính giá (cộng giá từng đêm, trừ giảm giá dài ngày).
  6. Tạo booking, đánh dấu các đêm là BOOKED, lưu.
  7. Gửi email (trong code mẫu chỉ là một dòng log).

Tách v0 thành các bước có tên rõ ràng, mỗi hàm chỉ ở một mức trừu tượng, là kỹ thuật clean code trước cả khi nói tới pattern; xem Clean code: đặt tên, hàm và luồng điều khiển.

Ghi chú về khoá dòng ở bước 4

Phần khoá dòng đáng một bài riêng: hai booking chồng ngày sẽ chờ nhau trên FOR UPDATE. Nên thêm ORDER BY date để hai khoảng ngày giao nhau không khoá theo thứ tự khác nhau rồi deadlock; xem Transaction, isolation level và locking.

2. v1: chia thành các bước, nhưng if theo loại bắt đầu lan

Ý chính: v1 tách v0 thành các method protected, nhưng loại chỗ ở mới được xử lý bằng if theo type trong nhiều bước. Đó là smell “switch theo type”.

Yêu cầu mới: căn hộ (apartment) nằm trong toà nhà. Trước khi giữ phòng phải kiểm tra toà nhà có mở cửa không, sau khi đặt phải báo ban quản lý toà nhà. v1 tách thành validateRequest, validateHomestay, checkAvailability, buildBooking, sendNotifications, rồi thêm vào hai trong số đó:

if (ListingType.of(homestay.getType()) == ListingType.APARTMENT) {
    log.info("Checking the status of the building...");
}

Một câu hỏi về loại xuất hiện ở nhiều bước. Loại thứ ba (resort cần đặt cọc, villa cần chủ nhà xác nhận) sẽ thêm nhánh vào mọi bước đó. Mỗi lần thêm là sửa một class mà mọi loại đều dùng.

3. v2: Template Method

Ý chính: Template Method giữ thứ tự các bước ở lớp cha trong một method cố định (template), lớp con chỉ thay nội dung vài bước. An toàn nhờ ba quy tắc: template final, bước bất biến private, tách bước abstract khỏi hook.

v2 của repo:

  • BaseBookingService.execute là bộ khung; method rỗng postProcess là hook (điểm mở rộng tuỳ chọn).
  • ApartmentBookingService override bước kiểm tra phòng, bước gửi thông báo và hook (phát event lên Kafka).
  • VillaBookingService không override gì.
  • BookingFactory chọn service theo loại chỗ ở.
classDiagram
  class BookingService {
    <<interface>>
    +execute(request) BookingResponse
  }
  class BaseBookingService {
    +execute(request) BookingResponse
    #validateRequest(request)
    #validateHomestay(request) Homestay
    #checkAvailability(homestay, request)
    #sendNotifications(booking)
    #postProcess(booking)
  }
  class ApartmentBookingService {
    #checkAvailability(homestay, request)
    #sendNotifications(booking)
    #postProcess(booking)
  }
  class VillaBookingService
  class BookingFactory {
    +build(request) BookingService
  }
  BookingService <|.. BaseBookingService
  BaseBookingService <|-- ApartmentBookingService
  BaseBookingService <|-- VillaBookingService
  BookingFactory ..> BookingService : chọn theo loại

Phiên bản của mình, bỏ Spring và database để chạy được với java TemplateDemo.java:

static abstract class BookingTemplate {
    protected final List<String> log = new ArrayList<>();

    /** Bộ khung. final: lớp con được đổi nội dung bước, không được đổi thứ tự. */
    public final Booking book(BookingRequest r) {
        validate(r);
        Homestay h = load(r.homestayId());
        checkAvailability(h, r);           // bước có thể override
        Booking b = new Booking(r.requestId(), h.id(), r.nights());
        notifyParties(b);                   // bước có thể override
        afterBooked(b);                     // hook: mặc định không làm gì
        return b;
    }

    private void validate(BookingRequest r) {           // bước bất biến: private
        if (r.nights() <= 0 || r.nights() > 365) throw new BusinessException("NIGHTS_INVALID");
        if (r.guests() <= 0) throw new BusinessException("GUESTS_INVALID");
    }

    private Homestay load(long id) {
        Homestay h = HOMESTAYS.get(id);
        if (h == null) throw new BusinessException("HOMESTAY_NOT_FOUND");
        return h;
    }

    protected void checkAvailability(Homestay h, BookingRequest r) {
        if (r.guests() > h.maxGuests()) throw new BusinessException("GUESTS_INVALID");
        log.add("nights locked for homestay " + h.id());
    }

    protected void notifyParties(Booking b) { log.add("email guest"); }

    protected void afterBooked(Booking b) { }
}

static final class DefaultBooking extends BookingTemplate { }

static final class ApartmentBooking extends BookingTemplate {
    @Override protected void checkAvailability(Homestay h, BookingRequest r) {
        if (!h.buildingOpen()) throw new BusinessException("BUILDING_CLOSED");
        super.checkAvailability(h, r);   // quên dòng này là bỏ qua kiểm tra số khách mà không ai biết
    }
    @Override protected void notifyParties(Booking b) {
        super.notifyParties(b);
        log.add("email building management");
    }
    @Override protected void afterBooked(Booking b) { log.add("publish BookingCreated"); }
}
apartment, building closed: FAIL BUILDING_CLOSED
apartment, open:            OK [nights locked for homestay 3, email guest, email building management, publish BookingCreated]
villa via default:          OK [nights locked for homestay 2, email guest]
too many guests:            FAIL GUESTS_INVALID

Ba quy tắc làm Template Method an toàn:

  • Template method là final. Nếu lớp con override được book, nó có thể bỏ bước validate. (Code mẫu để execute không final.)
  • Bước bất biến là private. Chỉ mở (protected) những bước thật sự được phép khác nhau.
  • Tách bước abstract khỏi hook. Bước lớp con bắt buộc cài thì để abstract; hook là method rỗng mặc định, lớp con có thể cài (ở đây là afterBooked). Đây là nguyên tắc Hollywood ở mức class: lớp cha gọi lớp con, không phải ngược lại.
Abstract hay hook: chi phí của mỗi lựa chọn
Bẫy constructor: lớp cha gọi method mà lớp con override

4. Template Method chạy trong Spring: những chỗ dễ vỡ

Ý chính: đặt hierarchy vào Spring sinh ra ba lỗi mà UML không cho thấy: constructor injection phải lặp ở mọi lớp con, @SneakyThrows làm transaction commit khi lỗi, và @Transactional trên một bước bị bỏ qua.

Constructor injection và kế thừa không hợp nhau. BaseBookingService cần năm dependency (hai repository, HomestayService, PricingService, mapper). Với constructor injection, mỗi lớp con phải khai lại constructor nhận đủ năm thứ và gọi super(...); Lombok không sinh được lời gọi super có tham số. Code mẫu né bằng cách để field không final và giữ @RequiredArgsConstructor, nên Spring không inject gì và request đầu tiên gặp NullPointerException.

Vì sao @RequiredArgsConstructor sinh constructor rỗng: kiểm chứng với Lombok 1.18.42

Lombok chỉ đưa field final vào constructor, nên khi không field nào final, constructor sinh ra không có tham số. Mình kiểm tra lại bằng Lombok 1.18.42:

  • Class có một field final và một field thường: constructor chỉ nhận field final.
  • Class không có field final nào: constructor rỗng.

Phân tích đầy đủ (và cách review nó) nằm ở bài 4: Adapter và Factory và buổi review mẫu luồng đặt phòng.

Rollback với @SneakyThrows. execute có @SneakyThrows và @Transactional của jakarta.transaction. Mặc định cả Spring lẫn JTA chỉ rollback khi gặp RuntimeException hoặc Error. Checked exception “ném lén” qua @SneakyThrows vẫn là checked, nên transaction commit dù method thất bại. Sửa: bỏ @SneakyThrows, hoặc khai rollbackFor = Exception.class (Spring) / rollbackOn = Exception.class (JTA).

5. Template Method hay composition?

Ý chính: Template Method biến thể là lớp con; composition biến thể là danh sách rule và listener ghép theo loại. Composition thắng khi biến thể bắt đầu kết hợp với nhau.

Cùng hành vi như mục 3, viết bằng composition:

interface BookingRule { void check(Homestay h, BookingRequest r); }
interface BookingListener { void onBooked(Booking b, List<String> log); }

static final BookingRule GUEST_LIMIT = (h, r) -> {
    if (r.guests() > h.maxGuests()) throw new BusinessException("GUESTS_INVALID");
};
static final BookingRule BUILDING_OPEN = (h, r) -> {
    if (!h.buildingOpen()) throw new BusinessException("BUILDING_CLOSED");
};
static final BookingListener EMAIL_GUEST = (b, log) -> log.add("email guest");
static final BookingListener EMAIL_BUILDING = (b, log) -> log.add("email building management");
static final BookingListener PUBLISH = (b, log) -> log.add("publish BookingCreated");

record Policy(List<BookingRule> rules, List<BookingListener> listeners) {}

static final class BookingService {
    private final Map<ListingType, Policy> policies;
    BookingService(Map<ListingType, Policy> policies) {
        for (ListingType t : ListingType.values())
            if (!policies.containsKey(t)) throw new IllegalStateException("no policy for " + t);
        this.policies = new EnumMap<>(policies);
    }

    Booking book(BookingRequest r, List<String> log) {
        Homestay h = HOMESTAYS.get(r.homestayId());
        if (h == null) throw new BusinessException("HOMESTAY_NOT_FOUND");
        Policy p = policies.get(h.type());
        p.rules().forEach(rule -> rule.check(h, r));
        log.add("nights locked for homestay " + h.id());
        Booking b = new Booking(r.requestId(), h.id(), r.nights());
        p.listeners().forEach(l -> l.onBooked(b, log));
        return b;
    }
}
composition, apartment:     OK [nights locked for homestay 3, email guest, email building management, publish BookingCreated]
startup check: no policy for APARTMENT

Constructor kiểm tra mọi loại đều có policy, nên thiếu cấu hình là lỗi lúc khởi động, không phải lúc khách bấm đặt phòng.

Tiêu chí Template Method Composition (Strategy/rule)
Biến thể là lớp con object được ghép
Đổi lúc chạy không được
Kết hợp nhiều biến thể khó (một lớp cha) dễ
Thấy toàn bộ luồng ở một chỗ có phải đọc cấu hình
Constructor injection trong Spring lặp ở mọi lớp con mỗi rule tự khai dependency

6. Ai chọn lớp con nào?

Ý chính: một BookingFactory đọc homestay rồi switch theo loại để chọn lớp con. Comment ghi “Abstract Factory” nhưng thực chất là simple factory.

Factory này có hai lỗi đáng học: nhánh default che mất loại mới, và các dependency không bao giờ được inject. Phân tích nằm ở bài 4: Adapter và Factory.

Bài tập

Bài 1: Thêm rule “khách doanh nghiệp cần mã số thuế” mà không sửa rule cũ

Đề: với thiết kế composition ở mục 5, thêm yêu cầu: booking của khách doanh nghiệp phải có mã số thuế hợp lệ (10 số, có thể thêm - và 3 số chi nhánh), áp cho mọi loại chỗ ở. Không sửa rule cũ, không sửa BookingService.

Lời giải Bài 1: thêm một rule và đổi phần ghép nối
interface BookingRule {
    void check(Homestay h, BookingRequest r);
    default BookingRule andThen(BookingRule next) {
        return (h, r) -> { check(h, r); next.check(h, r); };
    }
}

static final BookingRule CORPORATE_NEEDS_TAX_CODE = (h, r) -> {
    if (r.corporate() && r.companyTaxCode().filter(code -> code.matches("\\d{10}(-\\d{3})?")).isEmpty())
        throw new BusinessException("TAX_CODE_REQUIRED");
};

// chỉ phần ghép nối thay đổi
var service = new BookingService(Map.of(
        ListingType.APARTMENT, GUEST_LIMIT.andThen(CORPORATE_NEEDS_TAX_CODE),
        ListingType.VILLA, GUEST_LIMIT.andThen(CORPORATE_NEEDS_TAX_CODE)));
BOOKED APARTMENT
FAIL TAX_CODE_REQUIRED
BOOKED APARTMENT
FAIL GUESTS_INVALID

Bốn dòng là: khách thường không cần mã; khách doanh nghiệp thiếu mã; có mã hợp lệ; có mã nhưng quá số khách (rule cũ vẫn chạy).

Với Template Method, cùng yêu cầu buộc phải sửa lớp cha hoặc tạo lớp con kết hợp cho từng loại. Đó là lý do composition thắng khi biến thể bắt đầu cộng dồn.

Bài 2: Tìm lỗi trong một lớp con

Đề: một ResortBooking extends BookingTemplate override checkAvailability để kiểm tra khách đã đặt cọc, và không gọi super.checkAvailability. Test của ResortBooking chỉ kiểm tra trường hợp chưa đặt cọc và đều xanh. Lỗi gì sẽ lên production?

Lời giải Bài 2

Kiểm tra số khách so với sức chứa (nằm trong checkAvailability của lớp cha) bị bỏ qua cho resort, nên resort nhận đặt vượt sức chứa.

  • Sửa ngay: gọi super.
  • Sửa tận gốc: đưa kiểm tra sức chứa vào một bước private mà template luôn gọi, lớp con chỉ cài hook checkExtraRules.
  • Thêm một test chạy chung cho mọi lớp con (parameterized test) để kiểm tra các quy tắc bất biến.

Ghi nhớ

  • Giải thích được Template Method khác Strategy ở đâu (kế thừa hay composition, chọn lúc biên dịch hay lúc chạy).
  • Nêu được ba quy tắc giữ Template Method an toàn, và vì sao quên super là lỗi im lặng.
  • Biết khi nào dùng bước abstract, khi nào dùng hook.
  • Giải thích được vì sao @Transactional trên một bước bị bỏ qua và vì sao @SneakyThrows làm transaction commit khi lỗi.
  • Biết dấu hiệu nào cho thấy nên chuyển từ Template Method sang composition.

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

Junior

Template Method là gì và khác Strategy ở đâu?

Template Method dùng kế thừa để cố định thứ tự bước; Strategy dùng composition để thay cả một hành vi, đổi được lúc chạy.

Template Method đặt thứ tự các bước trong một method cố định ở lớp cha, lớp con override vài bước; biến thể được chọn lúc biên dịch (chọn lớp con nào). Strategy: object nhận một implementation qua constructor hoặc setter, đổi được lúc chạy, và có thể ghép nhiều strategy.

Mid

Hook method là gì? Khác bước abstract thế nào?

Hook là method có mặc định (thường rỗng) mà lớp con có thể override; bước abstract thì lớp con bắt buộc cài.

Template gọi hook ở một điểm cố định, ví dụ afterBooked để phát event. Dùng hook cho phần mở rộng tuỳ chọn, abstract cho phần mà mọi biến thể đều phải tự quyết.

Vì sao không nên để template method có thể override?

Vì giá trị của Template Method là bảo đảm thứ tự và các bước bắt buộc; override được template là bỏ qua được chúng.

Các bước bắt buộc như validate, khoá, ghi log. Khai báo template là final, bước bất biến là private, chỉ mở những bước được phép khác.

Vì sao không nên gọi method có thể override trong constructor?

Vì constructor lớp cha chạy trước khi field lớp con được gán, nên method override thấy field của nó là null hoặc 0.

Kể cả field final không phải hằng biên dịch. Compiler không bắt, và lỗi chỉ hiện ở lớp con nào dùng field. Khởi tạo cần gọi bước của template thì dùng method init() gọi sau constructor, hoặc @PostConstruct trong Spring.

Senior

Khi nào bạn chọn composition thay cho Template Method?

Khi các biến thể bắt đầu kết hợp, khi lớp con override quá nửa số bước, khi cần đổi hành vi theo cấu hình lúc chạy, hoặc khi constructor injection lặp ở mọi lớp con.

Ví dụ kết hợp: căn hộ và khách doanh nghiệp và dài ngày. Composition tách mỗi quy tắc thành một bean nhỏ, test riêng, ghép theo loại. Giá phải trả là luồng tổng thể không còn ở một chỗ, nên mình thường giữ một service điều phối đọc như Template Method nhưng gọi các rule được inject.

Một bước của template có @Transactional(propagation = REQUIRES_NEW) nhưng không thấy transaction mới. Vì sao?

Self-invocation: template gọi bước bằng this.step(), không qua proxy của Spring, nên annotation bị bỏ qua.

Sửa bằng cách chuyển bước đó sang một bean khác được inject vào, hoặc dùng TransactionTemplate trong bước đó. Kèm theo kiểm tra: method private hay final cũng không được proxy CGLIB chặn.

Một service có @SneakyThrows và @Transactional. Có rủi ro gì?

Checked exception ném lén qua @SneakyThrows không kích hoạt rollback, nên transaction commit dù method thất bại giữa chừng.

Mặc định Spring và JTA chỉ rollback khi gặp unchecked exception. Hậu quả ví dụ: đã đánh dấu đêm là đã đặt nhưng chưa lưu booking hoàn chỉnh. Sửa: bỏ @SneakyThrows, bọc thành exception nghiệp vụ unchecked, hoặc khai báo rollbackFor = Exception.class.

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
template method /ˈtempleɪt ˈmeθəd/ method cố định thứ tự các bước “The template method is final, so subclasses can’t skip validation.”
hook /hʊk/ điểm mở rộng tuỳ chọn, mặc định rỗng “We added an afterBooked hook for apartments to publish an event.”
composition over inheritance /ˌkɒmpəˈzɪʃn ˈəʊvə ɪnˈherɪtəns/ ưu tiên ghép object hơn kế thừa “Once variants started combining, composition over inheritance paid off.”
fragile base class /ˈfrædʒaɪl beɪs klɑːs/ lớp cha đổi làm vỡ lớp con “Template Method can suffer from the fragile base class problem.”
self-invocation /self ˌɪnvəˈkeɪʃn/ object gọi method của chính nó, không qua proxy “The annotation was ignored because of self-invocation.”
invariant step /ɪnˈveəriənt step/ bước bắt buộc, không được thay “Invariant steps are private so no subclass can skip them.”
subclass explosion /ˈsʌbklɑːs ɪkˈspləʊʒn/ số lớp con bùng nổ vì tổ hợp biến thể “Combining listing types with guest types caused a subclass explosion.”
rollback rule /ˈrəʊlbæk ruːl/ quy tắc exception nào làm transaction rollback “Checked exceptions don’t trigger a rollback unless you change the rollback rule.”

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.