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

Tìm kiếm

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

Kiến trúc codebase: layered, hexagonal, onion, clean và functional core

Ôn 17 thẻ
Trong bài này

Cụm bài Kiến trúc codebase: 1. Layered, hexagonal, onion, clean · 2. DDD và cấu trúc package

Một dự án Spring Boot chạy ba năm thường có package service 80 class gọi chéo nhau, entity JPA đi thẳng ra JSON, và muốn unit test một luật giảm giá phải dựng cả database. Nguyên nhân là codebase lớn lên mà không có quy tắc cái gì được phụ thuộc vào cái gì. Đọc xong, bạn giải thích được vì sao project chia thư mục như vậy, biết đặt một đoạn logic mới vào đâu, và biết giữ quy tắc đó khi team lớn lên.

Đọc trước nếu cần: IoC và Dependency Injection (Spring lắp ráp object thế nào) và Adapter và Factory pattern. Phần 2 đi vào DDD và cách chia package theo domain, kèm bài tập dựng khung codebase đặt vé máy bay.

1. Luồng điều khiển và hướng phụ thuộc

Ý chính: code chạy từ nghiệp vụ tới database, nhưng mã nguồn không buộc phải phụ thuộc theo chiều đó. Đặt interface ở phía nghiệp vụ thì database quay lại phụ thuộc vào nghiệp vụ.

  • Luồng điều khiển (flow of control): thứ tự code chạy khi có request. HTTP vào controller, controller gọi logic nghiệp vụ, logic gọi database, kết quả đi ngược ra.
  • Hướng phụ thuộc (dependency direction): class A import class B, biết tên B, phải biên dịch lại khi B đổi.

Trong layered truyền thống, hai hướng trùng nhau: logic nghiệp vụ gọi repository nên phụ thuộc repository. Các kiến trúc sau tách chúng ra bằng Dependency Inversion Principle (chữ D trong SOLID).

flowchart LR
  subgraph Truyền thống
    S1[OrderService] -->|gọi và import| R1[JpaOrderRepository]
  end
  subgraph Đảo ngược
    S2[OrderService] -->|gọi| P[OrderRepository interface]
    A2[JpaOrderRepositoryAdapter] -->|implements| P
  end

Bên phải, OrderService vẫn gọi tới lưu trữ lúc chạy, nhưng mã nguồn chỉ biết OrderRepository, một interface nằm cùng phía với nó. Adapter JPA mới là bên phải biết interface đó.

2. Layered architecture

Ý chính: chia code thành các tầng ngang, request đi từ trên xuống và không nhảy cóc. Đơn giản, nhưng nghiệp vụ phụ thuộc vào persistence nên database thành trung tâm thiết kế.

2.1. Ý tưởng

Kiểu kinh điển có bốn tầng: presentation (controller), business (service), persistence (repository), database. Số tầng không cố định: app nhỏ gộp bớt, app lớn thêm vào.

Quy tắc chính là tầng đóng (closed layer): controller không gọi thẳng repository, phải qua service. Lợi ích là cô lập tầng (layers of isolation): đổi cách lưu trữ chỉ chạm tầng persistence.

flowchart TB
  P[Presentation: controller, DTO] --> B[Business: service]
  B --> PE[Persistence: repository]
  PE --> D[(Database)]

2.2. Tầng mở

Tầng mở (open layer) là tầng mà request được phép bỏ qua: một ngoại lệ có chủ ý, phải ghi rõ trong tài liệu kiến trúc.

Tầng mở: cho phép request bỏ qua một tầng dùng chung

Vấn đề slide nêu: tầng business có nhiều thành phần dùng chung (gửi email, định dạng tiền, kiểm tra quyền). Để chung tầng thì service gọi chéo nhau lộn xộn.

Giải pháp là thêm một tầng services dùng chung và đánh dấu nó mở (open layer): tầng business được gọi nó, nhưng request cũng được bỏ qua nó để đi thẳng xuống persistence. Tầng mở là ngoại lệ có chủ ý, phải ghi rõ trong tài liệu kiến trúc. Nếu không, sau vài tháng mọi tầng đều “mở” và quy tắc mất nghĩa.

2.3. Ưu và nhược

Ưu: đơn giản, ai cũng hiểu, Spring Boot gần như mặc định theo kiểu này; test từng tầng bằng cách mock tầng dưới.

Nhược slide nêu là “khó mở rộng” và “các tầng phụ thuộc lẫn nhau”. Cụ thể hơn:

  • Nghiệp vụ phụ thuộc persistence: service import entity JPA và repository Spring Data. Muốn test luật giảm giá phải có JPA.
  • Chia theo kỹ thuật, không theo nghiệp vụ: một thay đổi tính năng chạm cả controller, service, repository. “Khó mở rộng” là khó cho người (nhiều team sửa cùng package), không phải khó cho runtime.
  • Sinkhole: request đi xuyên các tầng mà không tầng nào làm gì (service chỉ gọi lại repository). Không sai, nhưng là dấu hiệu tầng đó thừa cho use case đó.

3. Hexagonal architecture (ports and adapters)

Ý chính: ứng dụng ở giữa, mọi thứ vào/ra ở rìa. Ứng dụng tự định nghĩa interface (port), công nghệ cụ thể cắm vào qua implementation (adapter), nên đổi công nghệ không đụng core.

3.1. Ý tưởng

Alistair Cockburn đề xuất năm 2005. Giống ổ cắm và phích cắm: thiết bị quy định hình ổ cắm, ai muốn cắm vào thì làm phích cho vừa.

  • Driving side (phía chủ động, bên trái): những thứ gọi vào ứng dụng: HTTP controller, consumer Kafka, CLI, job, và cả test. Port là interface use case (PlaceOrderUseCase); adapter là controller gọi interface đó.
  • Driven side (phía bị động, bên phải): những thứ ứng dụng gọi ra: database, message broker, API thanh toán, email. Port là interface ứng dụng cần (OrderRepository, PaymentGateway); adapter là class cài đặt bằng JPA, Kafka, HTTP client.
flowchart LR
  WEB[REST controller] --> IN[Port vào: PlaceOrderUseCase]
  KAFKA[Kafka consumer] --> IN
  TEST[Test] --> IN
  IN --> APP[Ứng dụng]
  APP --> OUT1[Port ra: OrderRepository]
  APP --> OUT2[Port ra: PaymentGateway]
  JPA[JPA adapter] -.implements.-> OUT1
  VNPAY[VNPay adapter] -.implements.-> OUT2

Số sáu của lục giác không có ý nghĩa gì: hình này chỉ để vẽ được nhiều cạnh cho nhiều port và thoát khỏi hình ảnh “trên/dưới” của layered.

3.2. Ví dụ ngắn

// ứng dụng: chỉ biết port
public interface PaymentGateway {                   // port ra, nằm trong core
    PaymentLink createLink(OrderId id, Money amount);
}

public class PlaceOrderService implements PlaceOrderUseCase {
    private final OrderRepository orders;
    private final PaymentGateway payments;

    public PlaceOrderService(OrderRepository orders, PaymentGateway payments) {
        this.orders = orders;
        this.payments = payments;
    }

    @Override
    public PlaceOrderResult place(PlaceOrderCommand cmd) {
        Order order = Order.place(cmd.customerId(), cmd.lines());   // luật nghiệp vụ trong domain
        orders.save(order);
        return new PlaceOrderResult(order.id(), payments.createLink(order.id(), order.total()));
    }
}

// adapter: biết port và biết công nghệ
@Component
class VnpayPaymentGateway implements PaymentGateway {
    private final RestClient http;
    VnpayPaymentGateway(RestClient http) { this.http = http; }
    public PaymentLink createLink(OrderId id, Money amount) { /* ký tham số, gọi VNPay */ return null; }
}

Test PlaceOrderService chỉ cần một PaymentGateway giả (lambda hoặc class 3 dòng) và một repository trong bộ nhớ. Không Spring, không database, chạy trong vài mili giây.

3.3. Ưu và nhược

  • Ưu: lỏng lẻo (loose coupling); core test được độc lập với dịch vụ ngoài; đổi adapter dễ (đổi cổng thanh toán, thêm kênh vào GraphQL hay Kafka mà không đụng core). Netflix từng kể họ chuyển nguồn dữ liệu từ một monolith sang microservice mà chỉ phải viết adapter mới.
  • Nhược: phải học; nhiều interface và class mapping hơn; với CRUD (thêm, đọc, sửa, xoá) thì gần như toàn code chuyển tiếp.

4. Onion architecture

Ý chính: các vòng tròn đồng tâm, domain model ở tâm, mũi tên phụ thuộc chỉ hướng vào tâm. Onion bổ sung cho hexagonal phần cấu trúc bên trong.

Jeffrey Palermo đề xuất năm 2008 như một bước tiến của layered, giải hai vấn đề: các tầng phụ thuộc chuỗi vào nhau, và nghiệp vụ dính chặt vào hạ tầng.

flowchart TB
  UI[Vòng ngoài: UI, Infrastructure, Tests] --> AS[Application Services]
  AS --> DS[Domain Services]
  DS --> DM[Domain Model]
  • Domain Model ở tâm: entity, value object, luật nghiệp vụ. Không phụ thuộc gì.
  • Domain Services: luật nghiệp vụ liên quan nhiều entity, và interface của repository.
  • Application Services: điều phối use case.
  • Vòng ngoài: UI, hạ tầng (database, file, API ngoài), test. Đây là chỗ cài đặt các interface ở trong.

Không gì ở vòng trong biết bất cứ thứ gì ở vòng ngoài. Database không còn là đáy của chồng tầng mà là một chi tiết ở vòng ngoài.

So với hexagonal: hexagonal chỉ nói về ranh giới trong/ngoài và port/adapter, không nói gì về bên trong lục giác. Onion bổ sung đúng phần đó.

Ưu: nghiệp vụ là trung tâm, lỏng lẻo, dễ test. Nhược: phức tạp hơn, phải học, và dễ “làm đủ vòng” cho cả tính năng không có nghiệp vụ gì.

5. Clean architecture

Ý chính: clean architecture gom hexagonal và onion vào một hình vẽ với một quy tắc: phụ thuộc chỉ hướng vào trong. Dữ liệu qua ranh giới bằng DTO, interface repository khai báo ở trong và cài đặt ở ngoài.

5.1. Đóng gói lại, không phát minh mới

Robert C. Martin (2012) tổng hợp hexagonal, onion và vài kiến trúc khác thành bốn vòng:

  • Entities: luật nghiệp vụ cốt lõi của doanh nghiệp, ít thay đổi nhất.
  • Use cases: luật của ứng dụng, điều phối entity cho từng tình huống.
  • Interface adapters: controller, presenter, gateway; chuyển dữ liệu giữa dạng tiện cho use case và dạng tiện cho bên ngoài.
  • Frameworks and drivers: web, database, UI, thiết bị.

Hai lưu ý slide nhấn mạnh:

  1. Không bao giờ vi phạm dependency rule (quy tắc phụ thuộc hướng vào trong). Đây là toàn bộ kiến trúc; mọi thứ khác là chi tiết.
  2. Không có số vòng cố định. Bốn vòng chỉ là ví dụ.
Hình Explicit Architecture của Herberto Graça và factory cho adapter

Hình “Explicit Architecture” của Herberto Graça (slide dùng làm minh hoạ) ghép tất cả lại: adapter chủ động bên trái, adapter bị động bên phải, port ở ranh giới, application layer và domain layer bên trong, thêm command bus, query bus, event bus. Nó là bản đồ tham khảo, không phải mẫu phải làm theo; chính tác giả ghi “hiểu hết, nhưng chỉ dùng thứ bạn cần”.

Slide nhắc “tạo factory cho adapter của một service”: có một nơi (cấu hình bean của Spring, hoặc một factory) quyết định cắm adapter nào vào port nào. Ví dụ chọn theo môi trường: FakePaymentGateway cho test, VnpayPaymentGateway cho production.

5.2. Vượt ranh giới: hai bài toán

Bài toán 1: controller đụng vào entity. Use case trả về entity, controller trả entity ra JSON. Vòng ngoài (web) phụ thuộc chi tiết của vòng trong, và mọi thay đổi entity lộ ra API.

Giải: dữ liệu vượt ranh giới bằng cấu trúc dữ liệu đơn giản (DTO, command, result). Use case nhận một Command và trả một Result do chính tầng use case định nghĩa; controller map request HTTP sang command và result sang response.

Bài toán 2: domain cần lưu dữ liệu. Use case cần lưu Booking. Gọi thẳng JpaBookingRepository là vòng trong phụ thuộc vòng ngoài, vi phạm quy tắc.

Giải: khai báo interface repository ở vòng trong (cạnh domain), cài đặt ở vòng ngoài. Lúc chạy, Spring inject adapter vào; lúc biên dịch, vòng trong chỉ biết interface. Đây chính là hình đảo ngược ở mục 1.

Chi tiết hai bài toán: DTO đặt ở đâu, code adapter JPA, tách domain model khỏi entity JPA
// vòng trong: package booking.domain.port
public interface BookingRepository {
    Optional<Booking> findById(BookingId id);
    void save(Booking booking);
}

// vòng ngoài: package booking.adapter.out.persistence
@Repository
class JpaBookingRepositoryAdapter implements BookingRepository {
    private final SpringDataBookingJpa jpa;          // interface Spring Data, chỉ adapter biết
    private final BookingEntityMapper mapper;
    JpaBookingRepositoryAdapter(SpringDataBookingJpa jpa, BookingEntityMapper mapper) { this.jpa = jpa; this.mapper = mapper; }

    public Optional<Booking> findById(BookingId id) { return jpa.findById(id.value()).map(mapper::toDomain); }
    public void save(Booking booking) { jpa.save(mapper.toEntity(booking)); }
}

5.3. Khi nào dùng clean architecture

  • Ưu theo slide: độc lập với framework, database, dịch vụ ngoài; dễ bảo trì và cộng tác; dễ test; linh hoạt; dễ mở rộng.
  • Nhược: mất thời gian dựng; framework buộc phải phá quy tắc ở vài chỗ (annotation Spring, JPA); phức tạp, phải học, và dễ làm sai (tạo đủ tầng nhưng logic vẫn nằm ở controller).

Chọn kiểu nào nên xuất phát từ architectural driver (luật nghiệp vụ, deadline, cỡ team, quality attribute), không phải từ trào lưu: xem Kiến trúc phần mềm thực dụng: architectural driver.

6. Functional architecture: pure core, I/O ở rìa

Ý chính: luật nghiệp vụ viết thành hàm thuần: nhận dữ liệu, trả quyết định. Mọi I/O nằm ở lớp vỏ: đọc trước, gọi core, rồi ghi.

Hàm thuần (pure function): cùng input luôn cho cùng output (deterministic), và không có side effect (không sửa trạng thái bên ngoài, không I/O). Kiến trúc hàm áp ý đó vào cả ứng dụng:

  • Core domain: chỉ gồm hàm thuần thể hiện luật nghiệp vụ.
  • I/O ở rìa: đọc dữ liệu (database, HTTP) trước, rồi ghi kết quả sau. Phụ thuộc một chiều, core không gọi ra ngoài.

Mark Seemann gọi hình này là “impureim sandwich”: lớp vỏ không thuần, nhân thuần, lớp vỏ không thuần.

// core thuần: không repository, không clock, không exception vì I/O
record CancelDecision(boolean cancel, String reason) {}

static CancelDecision decideCancel(Ride ride, Instant now) {
    if (ride.status() != RideStatus.WAITING) return new CancelDecision(false, "already " + ride.status());
    if (now.isBefore(ride.createdAt().plus(Duration.ofMinutes(10)))) return new CancelDecision(false, "not due");
    return new CancelDecision(true, "no driver in 10 minutes");
}

// vỏ: đọc, quyết định, ghi
void handleTimeout(RideId id) {
    Ride ride = rides.findById(id).orElseThrow();                 // I/O
    CancelDecision d = decideCancel(ride, clock.instant());        // thuần
    if (d.cancel()) rides.cancelIfWaiting(id, d.reason());         // I/O
}
  • Ưu: ranh giới test rõ: unit test cho core (không mock, chỉ input/output), integration test cho lớp vỏ. Domain cô lập hoàn toàn khỏi hạ tầng.
  • Nhược: chuyển tư duy từ hướng đối tượng/mệnh lệnh sang hàm mất thời gian, ít đội làm theo đúng nghĩa.
Core thuần trong Java 21 và vì sao nên truyền Clock

Không cần Haskell hay Scala. Trong Java 21, record + sealed interface + pattern matching đủ để viết phần lớn luật nghiệp vụ dạng hàm thuần, kể cả trong codebase hexagonal: domain service thuần, application service là lớp vỏ.

7. So sánh nhanh

Ý chính: ba kiểu giữa gần như là một: domain ở trong, hạ tầng ở ngoài, interface ở trong, cài đặt ở ngoài. Chúng khác nhau chủ yếu ở tên gọi và mức chi tiết bên trong.

Layered Hexagonal Onion Clean Functional core
Trung tâm Database ở đáy Ứng dụng Domain model Entities Hàm thuần
Hướng phụ thuộc Trên xuống dưới Vào trong qua port Vào tâm Vào trong Vỏ → core
Nói gì về bên trong Các tầng ngang Không Domain / domain service / app service Entities / use cases Thuần / không thuần
Chi phí ban đầu Thấp Trung bình Trung bình Trung bình–cao Phụ thuộc kỹ năng team
Hợp với CRUD, dự án nhỏ Nhiều kênh vào/ra Nghiệp vụ phức tạp Như onion Luật tính toán nặng

8. Giữ kiến trúc bằng test, không bằng review

Ý chính: quy tắc phụ thuộc chỉ có giá trị nếu không ai phá nó, mà review bằng mắt rất dễ sót một dòng import. Biến quy tắc thành test chạy trong CI.

ArchUnit đọc bytecode và kiểm tra quy tắc như một unit test, ví dụ “domain không phụ thuộc adapter, Spring hay JPA”. Mình chạy các quy tắc này (ArchUnit 1.4.1) trên khung codebase đặt vé ở phần 2: tất cả qua.

Với Spring Boot còn có Spring Modulith. Nó kiểm tra các module (package cấp cao nhất dưới package gốc) chỉ gọi nhau qua API công khai, sinh tài liệu và sơ đồ module, và cho test từng module độc lập (@ApplicationModuleTest).

ArchUnit: code quy tắc, kết quả khi cố tình vi phạm, và bẫy composition root
@AnalyzeClasses(packages = "com.example.flightbooking")
class ArchitectureTest {

    @ArchTest
    static final ArchRule domainIsPure = noClasses().that().resideInAPackage("..domain..")
        .should().dependOnClassesThat().resideInAnyPackage(
            "..application..", "..adapter..", "org.springframework..", "jakarta.persistence..");

    @ArchTest
    static final ArchRule onion = onionArchitecture()
        .domainModels("..domain.model..")
        .domainServices("..domain.service..", "..domain.port..")
        .applicationServices("..application..")
        .adapter("web", "..adapter.in.web..")
        .adapter("persistence", "..adapter.out.persistence..")
        .ignoreDependency(resideInAPackage("..config.."), DescribedPredicate.alwaysTrue());
}

Thêm một class trong domain.service có field kiểu InMemoryBookingRepository (một adapter) thì quy tắc đầu báo lỗi kèm dòng code:

FAIL domain is framework-free and depends on nothing outward
     Field <...domain.service.LeakyFare.repo> has type <...adapter.out.persistence.InMemoryBookingRepository>

Bài tập

Bài 1: chỉ ra vi phạm trong một codebase thật

Đề: một dự án có các package api.rest, app, domain.<tính năng>.{entity, repository, service, dto}, infrastructure.{repository, util}. Kiểm tra thấy:

  • (a) 5 class trong domain.*.service import infrastructure.util.DateUtil.
  • (b) Interface trong domain.*.repository kế thừa JpaRepository.
  • (c) domain.homestay.repository.HomestayDetailRepository là interface thuần, implementation nằm ở infrastructure.repository.

Đánh giá từng điểm.

Lời giải Bài 1: đánh giá ba điểm (a), (b), (c)
  • (a) Vi phạm rõ ràng: domain phụ thuộc hướng ra ngoài vào một tiện ích hạ tầng. Sửa: nếu DateUtil chỉ là hàm tính toán ngày thuần thì nó thuộc domain (hoặc một package shared không phụ thuộc gì), dời vào; nếu nó đọc đồng hồ hệ thống thì thay bằng Clock inject vào.
  • (b) Thoả hiệp phổ biến: domain phụ thuộc Spring Data. Chấp nhận được với dự án nhỏ, nhưng nó kéo theo entity JPA vào domain và làm unit test domain cần Spring. Bước nâng cấp: interface repository thuần trong domain (chỉ các method nghiệp vụ cần), adapter ở infrastructure dùng Spring Data bên trong.
  • (c) Đúng mẫu port/adapter: interface ở trong, cài đặt ở ngoài. Đây là hình mẫu để áp dụng cho (b).
  • Viết một quy tắc ArchUnit noClasses().that().resideInAPackage("..domain..").should().dependOnClassesThat().resideInAPackage("..infrastructure..") để (a) không quay lại.

Bài 2: tách luật nghiệp vụ thành hàm thuần

Đề: một service đặt phòng có đoạn kiểm tra: ngày nhận phòng không ở quá khứ (dùng LocalDate.now()), số đêm ≤ 365, số khách ≤ sức chứa, giảm 5% nếu ở từ 3 đêm. Tất cả nằm trong một method @Transactional cùng với truy vấn khoá lịch phòng và lưu booking. Tách thế nào để unit test luật mà không cần database?

Lời giải Bài 2: hàm thuần quote và lớp vỏ @Transactional
record StayRequest(LocalDate checkIn, LocalDate checkOut, int guests) {}
record Quote(long nights, BigDecimal subtotal, BigDecimal discount, BigDecimal total) {}

sealed interface QuoteResult permits QuoteResult.Ok, QuoteResult.Rejected {
    record Ok(Quote quote) implements QuoteResult {}
    record Rejected(String code) implements QuoteResult {}
}

static QuoteResult quote(StayRequest r, int capacity, List<BigDecimal> nightlyPrices, LocalDate today) {
    if (r.checkIn().isBefore(today)) return new QuoteResult.Rejected("CHECKIN_IN_PAST");
    long nights = ChronoUnit.DAYS.between(r.checkIn(), r.checkOut());
    if (nights <= 0 || nights > 365) return new QuoteResult.Rejected("INVALID_NIGHTS");
    if (r.guests() <= 0 || r.guests() > capacity) return new QuoteResult.Rejected("INVALID_GUESTS");
    if (nightlyPrices.size() != nights) return new QuoteResult.Rejected("NOT_AVAILABLE");
    BigDecimal subtotal = nightlyPrices.stream().reduce(BigDecimal.ZERO, BigDecimal::add);
    BigDecimal discount = nights >= 3 ? subtotal.multiply(new BigDecimal("0.05")) : BigDecimal.ZERO;
    return new QuoteResult.Ok(new Quote(nights, subtotal, discount, subtotal.subtract(discount)));
}

Lớp vỏ (application service, @Transactional):

  1. Khoá và đọc các đêm còn trống, đọc sức chứa.
  2. Gọi quote(..., LocalDate.now(clock)).
  3. switch trên kết quả: Rejected thì trả lỗi, Ok thì đánh dấu các đêm đã đặt và lưu booking.

Unit test quote với vài chục trường hợp chạy trong mili giây. Integration test chỉ cần vài kịch bản cho lớp vỏ (khoá đúng, lưu đúng, xung đột đồng thời).

Ghi nhớ

  • Phân biệt được luồng điều khiển với hướng phụ thuộc, và Dependency Inversion với Dependency Injection.
  • Giải thích được vì sao hexagonal, onion, clean là cùng một ý, và layered khác chúng ở đâu.
  • Biết đặt interface repository và DTO/command/result ở đâu, và vì sao entity JPA không được ra API.
  • Biết khi nào không nên áp dụng clean architecture, và ba thói quen rẻ nên giữ.
  • Biết tách luật nghiệp vụ thành hàm thuần (truyền Clock) và giữ quy tắc bằng ArchUnit.

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

Junior

Layered architecture là gì? “Tầng đóng” nghĩa là gì?

Là cách chia code thành các tầng ngang theo trách nhiệm (controller, service, repository), request đi từ trên xuống. Tầng đóng nghĩa là request không được nhảy cóc.

Controller phải qua service, không gọi thẳng repository. Nhờ vậy thay đổi trong một tầng ít ảnh hưởng tầng khác.

Vì sao không nên trả entity JPA thẳng ra API?

Vì API bị trói vào schema database: thêm cột là đổi JSON.

Ngoài ra dễ lộ field nhạy cảm, quan hệ lazy gây lỗi khi serialize hoặc truy vấn thêm ngoài ý muốn, và quan hệ hai chiều tạo vòng lặp. Dùng DTO (record) ở ranh giới, map trong controller hoặc use case.

Mid

Port và adapter trong hexagonal architecture là gì?

Port là interface do ứng dụng định nghĩa; adapter là implementation gắn với một công nghệ cụ thể.

  • Port vào là use case mà bên ngoài gọi (PlaceOrderUseCase); controller REST là adapter gọi nó.
  • Port ra là thứ ứng dụng cần (OrderRepository, PaymentGateway); class JPA hay HTTP client là adapter cài đặt nó.

Core chỉ biết port, nên đổi adapter không đụng core và test được core với adapter giả.

Dependency Inversion khác Dependency Injection thế nào?

Dependency Inversion là nguyên lý về hướng phụ thuộc; Dependency Injection là kỹ thuật cung cấp dependency từ bên ngoài.

DIP: module cấp cao và cấp thấp cùng phụ thuộc abstraction, và abstraction thuộc về phía cấp cao (interface repository nằm cạnh domain). DI: dependency được đưa vào, thường qua constructor, do container như Spring làm. Có thể dùng DI mà vẫn vi phạm DIP (inject class JPA cụ thể vào service).

Onion và clean architecture khác layered ở điểm nào cốt lõi?

Hướng phụ thuộc.

Layered: nghiệp vụ phụ thuộc persistence, database ở đáy. Onion/clean: domain ở tâm không phụ thuộc gì, database là chi tiết ở vòng ngoài. Interface repository khai báo ở trong và được cài đặt ở ngoài, nên luồng gọi vẫn đi tới database nhưng phụ thuộc mã nguồn chỉ hướng vào trong.

Domain cần lưu dữ liệu mà không được phụ thuộc database. Làm thế nào?

Khai báo interface repository ở trong (domain hoặc tầng application), cài đặt ở adapter hạ tầng, để Spring inject adapter vào lúc chạy.

Interface chỉ có các method nghiệp vụ cần; adapter cài đặt bằng JPA/JDBC. Domain chỉ biết interface. Nếu tách entity JPA khỏi domain model thì adapter chịu trách nhiệm map.

Senior

Khi nào bạn không áp dụng clean architecture?

Khi chi phí interface, mapper và tầng thêm không được bù lại: dự án nhỏ, team 1–3 người, vòng đời ngắn; dịch vụ gần như chỉ CRUD hoặc chuyển dữ liệu; công cụ nội bộ, thư viện.

Mình vẫn giữ ba thói quen rẻ: package theo tính năng, DTO ở ranh giới, interface repository ở trong, để nâng cấp module nào phức tạp lên sau.

Làm sao giữ quy tắc kiến trúc khi team lớn lên?

Biến quy tắc thành test chạy trong CI để PR vi phạm bị chặn.

  • ArchUnit: domain không import adapter/framework, kiểm tra onion, không vòng phụ thuộc giữa module.
  • Spring Modulith cho ranh giới module.
  • Ghi quyết định bằng ADR. Loại trừ có chủ ý composition root.

Review chỉ còn phải bàn những ngoại lệ có lý do.

Tách domain model khỏi entity JPA có đáng không?

Tuỳ độ phức tạp của aggregate: tách khi nhiều luật nghiệp vụ, dùng chung khi domain mỏng.

Tách cho domain thuần, không bị JPA ép (constructor rỗng, proxy, setter), schema và model tiến hoá riêng. Giá là mapper, mất dirty checking và lazy loading tự nhiên, phải tự mang version cho optimistic lock. Điều không thoả hiệp là interface repository nằm ở trong và entity không đi ra API.

Functional core, imperative shell giúp gì cho test?

Luật nghiệp vụ thành hàm thuần nên unit test chỉ là input/output, không mock; lớp vỏ chỉ cần ít integration test.

Hàm thuần nhận dữ liệu (kể cả thời điểm hiện tại) và trả quyết định, nên test chạy cực nhanh và bao phủ hết nhánh. Lớp vỏ chỉ đọc, gọi core, ghi, nên chỉ cần vài kịch bản I/O. Ranh giới giữa unit và integration test trở nên rõ ràng.

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
layered architecture /ˈleɪəd ˈɑːkɪtektʃə/ kiến trúc phân tầng “A layered architecture is fine for CRUD, but the domain ends up depending on persistence.”
ports and adapters /pɔːts ənd əˈdæptəz/ cổng và bộ chuyển đổi “With ports and adapters, the core only knows interfaces it owns.”
driving side /ˈdraɪvɪŋ saɪd/ phía gọi vào ứng dụng “Controllers and tests sit on the driving side.”
driven side /ˈdrɪvn saɪd/ phía ứng dụng gọi ra “The database and payment gateway are on the driven side.”
dependency rule /dɪˈpendənsi ruːl/ quy tắc phụ thuộc hướng vào trong “The one rule we never break is the dependency rule.”
dependency inversion /dɪˈpendənsi ɪnˈvɜːʃn/ đảo ngược phụ thuộc “Dependency inversion lets the repository interface live next to the domain.”
composition root /ˌkɒmpəˈzɪʃn ruːt/ nơi lắp ráp mọi object “Only the composition root is allowed to know every implementation.”
boundary /ˈbaʊndri/ ranh giới “Data crosses the boundary as simple DTOs, never as entities.”
pure function /pjʊə ˈfʌŋkʃn/ hàm thuần “Pricing rules are pure functions, so unit tests need no mocks.”

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.