Đến nội dung chính
Sổ ôn Backend

Tìm kiếm

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

SOLID qua ví dụ Java: năm nguyên lý, cách nhận ra vi phạm và khi nào không cần

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

Cả bài trong một trang: ý chính, sơ đồ, điểm phỏng vấn.

SOLID qua ví dụ Java: năm nguyên lý, cách nhận ra vi phạm và khi nào không cần

1SOLID để làm gì

SOLID là năm cách giảm chi phí thay đổi: một thay đổi nghiệp vụ chạm ít file, ít người, ít test hơn.

Chữ Ý một dòng
S, O Một actor một class; thêm biến thể bằng class mới
L Lớp con giữ hợp đồng lớp cha
I, D Interface theo vai trò; nghiệp vụ sở hữu interface

2Một actor, một lý do thay đổi

SRP không phải "ít method": class chỉ phục vụ một actor, tức một nhóm người có thể yêu cầu nó đổi. Báo cáo mẫu trộn tài chính, vận hành và IT.

flowchart TD
  J["DailyReportJob: điều phối"] --> R["RevenueCalculator: tài chính"]
  J --> C["CsvFormatter: vận hành"]
  J --> S["ReportSender: gửi mail"]

3Thêm biến thể qua điểm mở rộng

OCP: thêm loại khách STAFF giảm 30% bằng một class mới implement DiscountPolicy, RevenueCalculator không đổi dòng nào.

interface DiscountPolicy {
  boolean supports(CustomerType type);
  BigDecimal apply(BigDecimal amount);
}
// Spring inject List<DiscountPolicy>

4Hợp đồng của lớp con

LSP: chỗ nào chạy đúng với kiểu cha phải chạy đúng với mọi kiểu con. Compiler chỉ kiểm chữ ký; hợp đồng hành vi phải kiểm bằng contract test.

  • Tiền điều kiện không mạnh hơn cha
  • Hậu điều kiện không yếu hơn cha
  • Bất biến giữ nguyên
  • Không ném RuntimeException mới mà client không lường

5Interface nhỏ và hướng phụ thuộc

ISP: client chỉ thấy method nó dùng. DIP: interface như ReportSender đặt ở package nghiệp vụ, hạ tầng implement; DI chỉ là cách lắp ráp.

Khái niệm Trả lời câu hỏi
DIP Interface đặt ở đâu, ai import ai
IoC Ai điều khiển luồng chạy
DI Object lấy dependency bằng cách nào

6Khi nào SOLID gây hại

Áp cho thay đổi tưởng tượng chỉ thêm class và tầng gián tiếp. Đo bằng chi phí thay đổi, không bằng số nguyên lý tuân thủ.

  • Interface một cài đặt thường thừa, trừ ranh giới hạ tầng
  • Rule of three: biến thể thứ ba thì rút điểm mở rộng
  • Mười class luôn sửa cùng nhau tệ hơn một class

💡 Ghi nhớ

  • S: tách theo actor, không theo số method.

  • O: tập biến thể đóng thì sealed + switch cũng hợp lệ.

  • I: method rỗng hoặc UnsupportedOperationException là dấu hiệu vi phạm.

  • D: abstraction thuộc về phía nghiệp vụ.

⭐ Điểm phỏng vấn

Tự trả lời trước, rồi bấm từng câu để xem đáp án.

  • Trách nhiệm trong SRP là gì?

    Một actor có thể yêu cầu class thay đổi.

  • DIP khác DI thế nào?

    DIP là hướng phụ thuộc, DI là kỹ thuật lắp ráp.

  • Ví dụ vi phạm LSP?

    Lớp con ném exception với đầu vào cha nhận.

⚠️ Lỗi thường gặp

  • Tạo interface, factory "để sau này mở rộng" khi chỉ có một cài đặt.

  • Interface "của nghiệp vụ" trả Page<BookingEntity> của Spring Data.

  • Tách microservice chỉ vì SRP.

“Giải thích SOLID” là câu hỏi mở màn của rất nhiều buổi phỏng vấn, và câu trả lời thuộc lòng năm định nghĩa thường bị hỏi vặn ngay: “đo SRP thế nào”, “OCP có luôn tốt không”, “DIP khác DI ra sao”. Bài này gom năm nguyên lý về một chỗ với ví dụ Java từ hệ thống đặt phòng, cách nhận ra vi phạm, và giới hạn của từng nguyên lý. Các bài khác đã đi sâu từng phần đều được link ở đúng chỗ.

Sơ đồ tóm tắt:

flowchart LR
  CHG["Yêu cầu thay đổi"] --> S["S: ai yêu cầu? tách theo actor"]
  CHG --> O["O: biến thể mới? thêm class qua điểm mở rộng"]
  O --> L["L: cài đặt mới giữ hợp đồng"]
  L --> CT["Contract test cho mọi cài đặt"]
  CHG --> I["I: client chỉ thấy method nó dùng"]
  CHG --> D["D: nghiệp vụ sở hữu interface, hạ tầng implement"]
  D --> DI["DI/Spring: lắp ráp ở composition root"]

1. Single Responsibility: một actor, một lý do thay đổi

Ý chính: SRP không nói “class chỉ làm một việc” hay “ít method”; nó nói class chỉ nên phục vụ một actor, tức một nhóm người có thể yêu cầu nó thay đổi. Hai nhóm yêu cầu thay đổi cùng một class là hai trách nhiệm.

// Ba actor trong một class: tài chính (cách tính tiền), vận hành (định dạng báo cáo), IT (gửi mail)
public class BookingReportService {
    public void sendDailyReport(List<Booking> bookings) {
        StringBuilder csv = new StringBuilder("code,type,net\n");
        for (Booking b : bookings) {
            BigDecimal net = switch (b.type()) {                  // tài chính đổi chiết khấu: sửa ở đây
                case REGULAR -> b.amount();
                case VIP -> b.amount().multiply(new BigDecimal("0.90"));
                case CORPORATE -> b.amount().multiply(new BigDecimal("0.85"));
            };
            csv.append(b.code()).append(',').append(b.type()).append(',').append(net).append('\n');  // vận hành đổi cột: sửa ở đây
        }
        new SmtpClient("smtp.hotel.vn", 587).send("finance@hotel.vn", csv.toString());              // đổi nhà cung cấp mail: sửa ở đây
    }
}

Cách đo một class có vi phạm không (dùng được trong code review):

  • Tên: tên tự nhiên nhất là Manager, Helper, Util hoặc cần chữ “And” (CalculateAndSend).
  • Ai yêu cầu: liệt kê các ticket gần nhất chạm vào class; đến từ mấy nhóm khác nhau?
  • Thay đổi cùng nhau: các nhóm method có bao giờ đổi độc lập? git log của file cho thấy commit “sửa định dạng” và commit “sửa chiết khấu” xen kẽ.
  • Test: muốn test cách tính tiền mà phải dựng SMTP giả là dấu hiệu rõ.

Tách theo actor: RevenueCalculator (tài chính), CsvFormatter (vận hành), ReportSender (hạ tầng gửi), và DailyReportJob chỉ điều phối. Lời giải đầy đủ ở Bài tập 1; cách đặt tên và tách hàm ở clean code.

2. Open/Closed: mở để mở rộng, đóng để sửa đổi

Ý chính: khi yêu cầu mới là “thêm một biến thể” (loại khách, cổng thanh toán, kênh thông báo), thiết kế sao cho thêm biến thể = thêm class mới qua một điểm mở rộng (interface, strategy, plugin), không phải mở lại class đang chạy ổn và đã được test.

interface DiscountPolicy {
    boolean supports(CustomerType type);
    BigDecimal apply(BigDecimal amount);
}

final class RevenueCalculator {
    private final List<DiscountPolicy> policies;           // Spring inject mọi bean DiscountPolicy
    RevenueCalculator(List<DiscountPolicy> policies) { this.policies = List.copyOf(policies); }

    BigDecimal net(Booking b) {
        return policies.stream().filter(p -> p.supports(b.type())).findFirst()
                .orElseThrow(() -> new IllegalStateException("no policy for " + b.type()))
                .apply(b.amount());
    }
}
// Thêm khách STAFF giảm 30%: thêm một class implement DiscountPolicy, RevenueCalculator không đổi dòng nào.

Dấu hiệu đang vi phạm: switch/if-else theo loại lặp lại ở nhiều nơi, instanceof rải rác, mỗi tính năng mới đều sửa cùng một class trung tâm. Ví dụ refactor đầy đủ với Strategy ở design pattern qua refactor và với registry các handler ở Adapter và Factory.

3. Liskov Substitution: lớp con giữ hợp đồng của lớp cha

Ý chính: chỗ nào chạy đúng với kiểu cha thì phải chạy đúng khi đưa vào bất kỳ kiểu con nào. “Đúng” là theo hợp đồng hành vi, không chỉ theo chữ ký method: compiler kiểm chữ ký, còn hợp đồng thì chỉ test và review kiểm được.

Bốn quy tắc của hợp đồng (Design by Contract):

  • Tiền điều kiện không được mạnh hơn: lớp con không đòi hỏi nhiều hơn ở đầu vào. Cha nhận mọi key, con ném exception với key “chưa đăng ký” là vi phạm.
  • Hậu điều kiện không được yếu hơn: lớp con hứa ít nhất những gì cha hứa. Cha hứa “trả true thì đã trừ tiền”, con trả true mà không trừ là vi phạm.
  • Bất biến giữ nguyên: điều luôn đúng với cha (số dư không âm, danh sách đã sắp xếp) phải luôn đúng với con.
  • Không ném exception mới mà client không lường: Java chặn checked exception mới ở mức biên dịch, nhưng RuntimeException thì không ai chặn.

Ví dụ kinh điển Square extends Rectangle (setter làm vỡ bất biến của hình chữ nhật) đã có ở kế thừa và đa hình. Hai ví dụ backend hay gặp hơn:

interface PaymentGateway {
    /** Trả về Charged thì tiền đã bị trừ thật ở phía ngân hàng. */
    ChargeResult charge(String orderId, Money amount);
}

// Vi phạm hậu điều kiện: "để test cho tiện" mà lọt lên staging hay production
class AlwaysSuccessGateway implements PaymentGateway {
    public ChargeResult charge(String orderId, Money amount) { return new Charged("fake-" + orderId); }
}
  • Collection chỉ đọc: List.of(...) là một List nhưng add ném UnsupportedOperationException. JDK cố ý chọn vậy (gọi là optional operation, ghi trong Javadoc của List) để giữ số interface ít; cái giá là client nhận List không biết chắc gọi add được không. Trong API của bạn, đừng bắt chước: trả kiểu cho thấy rõ khả năng (ví dụ nhận Collection<? extends T> để đọc, trả bản sao khi client cần sửa).

4. Interface Segregation: interface theo vai trò của client

Ý chính: không bắt client phụ thuộc vào method nó không dùng. Thay một interface to bằng vài interface nhỏ đặt tên theo vai trò (role interface); một class vẫn có thể implement nhiều vai trò.

// Interface "to": lễ tân phải mang method gán phòng, kế toán phải mang method check-in
interface HotelStaffOperations { void checkIn(Booking b); void assignRoom(Booking b, Room r); void issueInvoice(Booking b); }

// Theo vai trò
interface CheckInDesk   { void checkIn(Booking b); }
interface RoomAssigner  { void assignRoom(Booking b, Room r); }
interface Invoicing     { void issueInvoice(Booking b); }

class FrontDeskService implements CheckInDesk, RoomAssigner { ... }   // implement đúng vai trò nó có
  • Lợi ích thật: client và test chỉ thấy phần nó cần (mock một method thay vì mười); thay đổi ở method này không bắt biên dịch lại client không dùng nó.
  • Trong Spring Data, thay vì để mọi repository kế thừa JpaRepository (hơn 30 method, gồm cả deleteAll), có thể kế thừa Repository<T, ID> và chỉ khai báo method cần dùng: service đọc-chỉ không có cách nào gọi nhầm delete.
  • Ví dụ ISP với nhân viên khách sạn và RoomAssignable ở abstract class và interface.

5. Dependency Inversion: nghiệp vụ sở hữu abstraction

Ý chính: module cấp cao (quy tắc nghiệp vụ) không phụ thuộc module cấp thấp (database, mail, HTTP client); cả hai phụ thuộc abstraction, và abstraction được định nghĩa theo nhu cầu của phía cấp cao, đặt ở package của nghiệp vụ. “Đảo” là đảo hướng phụ thuộc trong mã nguồn so với hướng lời gọi lúc chạy.

// package booking.domain: nghiệp vụ nói nó cần gì, bằng ngôn ngữ của nó
public interface ReportSender { void send(String to, String body); }

// package booking.infra.mail: hạ tầng phụ thuộc vào domain, không ngược lại
public class SmtpReportSender implements ReportSender { ... }
Khái niệm Là gì Trả lời câu hỏi
Dependency Inversion (DIP) nguyên lý thiết kế interface đặt ở đâu, ai import ai
Inversion of Control (IoC) nguyên lý rộng hơn: framework gọi code của bạn ai điều khiển luồng chạy
Dependency Injection (DI) kỹ thuật: dependency được đưa từ ngoài vào (constructor) object lấy dependency bằng cách nào

DI mà không DIP: Spring inject JpaBookingRepository cụ thể, hoặc interface “của nghiệp vụ” lại trả Page<BookingEntity> của Spring Data, thì nghiệp vụ vẫn dính hạ tầng. DIP mà không cần container: tự new adapter ở main rồi truyền vào. Đi sâu ở IoC và DI và áp DIP cho cả codebase thành hexagonal/clean architecture ở kiến trúc codebase.

6. Khi nào SOLID gây hại

Ý chính: SOLID là công cụ giảm chi phí của thay đổi đã biết hoặc rất có thể xảy ra; áp cho thay đổi tưởng tượng thì chỉ thêm class, thêm tầng gián tiếp và khó đọc hơn.

  • Interface có đúng một cài đặt “để sau này mở rộng” thường là thừa. Ngoại lệ hợp lý: ranh giới với hạ tầng (repository, gateway) để test nghiệp vụ không cần hạ tầng thật, đúng tinh thần DIP.
  • Rule of three: biến thể thứ hai xuất hiện thì cân nhắc, thứ ba thì rút điểm mở rộng. Lúc đó bạn đã biết cái gì thật sự thay đổi.
  • Đo bằng chi phí thay đổi, không bằng số nguyên lý được “tuân thủ”: một thay đổi nghiệp vụ điển hình chạm bao nhiêu file, cần sửa bao nhiêu test, bao nhiêu người phải review.
  • KISS và YAGNI (không làm thứ chưa cần) cân bằng với SOLID; xem phần độ phức tạp ở clean code.

Bài tập

Bài 1: refactor báo cáo doanh thu theo S, O, D

Đề: refactor BookingReportService ở mục 1 sao cho: thêm loại khách mới không sửa class tính tiền; đổi định dạng báo cáo không chạm logic tiền; test được mà không cần SMTP. Chạy với ba booking 1.000.000 (REGULAR), 2.000.000 (VIP, giảm 10%), 4.000.000 (CORPORATE, giảm 15%).

Lời giải Bài 1
import java.math.BigDecimal;
import java.util.*;

public class Report {
    enum CustomerType { REGULAR, VIP, CORPORATE }
    record Booking(String code, CustomerType type, BigDecimal amount) {}

    // O: thêm loại khách = thêm một policy
    interface DiscountPolicy { boolean supports(CustomerType t); BigDecimal apply(BigDecimal amount); }

    static final class NoDiscount implements DiscountPolicy {
        public boolean supports(CustomerType t) { return t == CustomerType.REGULAR; }
        public BigDecimal apply(BigDecimal a) { return a; }
    }

    static final class PercentDiscount implements DiscountPolicy {
        private final CustomerType type; private final int percent;
        PercentDiscount(CustomerType type, int percent) { this.type = type; this.percent = percent; }
        public boolean supports(CustomerType t) { return t == type; }
        public BigDecimal apply(BigDecimal a) {
            return a.multiply(BigDecimal.valueOf(100 - percent)).divide(BigDecimal.valueOf(100));
        }
    }

    // S: chỉ đổi khi quy tắc tính tiền đổi (tài chính)
    static final class RevenueCalculator {
        private final List<DiscountPolicy> policies;
        RevenueCalculator(List<DiscountPolicy> policies) { this.policies = List.copyOf(policies); }
        BigDecimal net(Booking b) {
            return policies.stream().filter(p -> p.supports(b.type())).findFirst()
                    .orElseThrow(() -> new IllegalStateException("no policy for " + b.type()))
                    .apply(b.amount());
        }
    }

    // S: chỉ đổi khi định dạng đổi (vận hành)
    static final class CsvFormatter {
        String format(List<Booking> bookings, RevenueCalculator calc) {
            StringBuilder sb = new StringBuilder("code,type,net\n");
            for (Booking b : bookings) {
                sb.append(b.code()).append(',').append(b.type()).append(',')
                  .append(calc.net(b).toPlainString()).append('\n');
            }
            return sb.toString();
        }
    }

    // D: interface thuộc phía nghiệp vụ; SMTP chỉ là một cài đặt
    interface ReportSender { void send(String to, String body); }

    static final class ConsoleSender implements ReportSender {
        public void send(String to, String body) { System.out.print("to " + to + ":\n" + body); }
    }

    // Chỉ điều phối, không chứa quy tắc
    static final class DailyReportJob {
        private final RevenueCalculator calc; private final CsvFormatter fmt; private final ReportSender sender;
        DailyReportJob(RevenueCalculator calc, CsvFormatter fmt, ReportSender sender) {
            this.calc = calc; this.fmt = fmt; this.sender = sender;
        }
        void run(List<Booking> bookings) { sender.send("finance@hotel.vn", fmt.format(bookings, calc)); }
    }

    public static void main(String[] args) {
        var calc = new RevenueCalculator(List.of(new NoDiscount(),
                new PercentDiscount(CustomerType.VIP, 10), new PercentDiscount(CustomerType.CORPORATE, 15)));
        var bookings = List.of(
                new Booking("B1", CustomerType.REGULAR, new BigDecimal("1000000")),
                new Booking("B2", CustomerType.VIP, new BigDecimal("2000000")),
                new Booking("B3", CustomerType.CORPORATE, new BigDecimal("4000000")));
        new DailyReportJob(calc, new CsvFormatter(), new ConsoleSender()).run(bookings);

        List<String> sent = new ArrayList<>();                 // "test": sender giả ghi lại nội dung
        new DailyReportJob(calc, new CsvFormatter(), (to, body) -> sent.add(body)).run(bookings);
        System.out.println("captured lines = " + sent.get(0).lines().count());
    }
}
to finance@hotel.vn:
code,type,net
B1,REGULAR,1000000
B2,VIP,1800000
B3,CORPORATE,3400000
captured lines = 4

Kiểm lại theo thước đo ở mục 1: đổi chiết khấu VIP chỉ chạm một dòng cấu hình policy; thêm cột vào CSV chỉ chạm CsvFormatter; test không cần mạng. Không tạo interface cho CsvFormatter vì chưa có định dạng thứ hai (YAGNI); ReportSender có interface vì nó là ranh giới hạ tầng.

Bài 2: contract test cho Liskov

Đề: interface RateLimiter { boolean tryAcquire(String key); } có hợp đồng: mỗi key được tối đa limit lần true; key chưa gặp bao giờ cũng hợp lệ (không ném exception). Viết một bộ kiểm tra hợp đồng chạy lại cho mọi cài đặt, rồi dùng nó bắt hai cài đặt vi phạm: AlwaysAllow (luôn true, “cho môi trường dev”) và RegisteredOnly (ném exception với key chưa đăng ký).

Lời giải Bài 2
import java.util.*;
import java.util.function.*;

public class Contract {
    /** Hợp đồng: mỗi key tối đa `limit` lần true (hậu điều kiện); key lạ hợp lệ (tiền điều kiện). */
    interface RateLimiter { boolean tryAcquire(String key); }

    static final class FixedWindow implements RateLimiter {
        private final int limit; private final Map<String, Integer> used = new HashMap<>();
        FixedWindow(int limit) { this.limit = limit; }
        public boolean tryAcquire(String key) { return used.merge(key, 1, Integer::sum) <= limit; }
    }

    static final class AlwaysAllow implements RateLimiter {          // làm yếu hậu điều kiện
        public boolean tryAcquire(String key) { return true; }
    }

    static final class RegisteredOnly implements RateLimiter {       // làm mạnh tiền điều kiện
        private final RateLimiter inner; private final Set<String> known;
        RegisteredOnly(RateLimiter inner, Set<String> known) { this.inner = inner; this.known = known; }
        public boolean tryAcquire(String key) {
            if (!known.contains(key)) throw new IllegalArgumentException("unknown key " + key);
            return inner.tryAcquire(key);
        }
    }

    /** Một bộ kiểm tra, chạy cho MỌI cài đặt: đó là cách biến LSP thành thứ CI kiểm được. */
    static List<String> verify(IntFunction<RateLimiter> factory) {
        List<String> broken = new ArrayList<>();
        int limit = 3;
        RateLimiter rl = factory.apply(limit);
        int granted = 0;
        try {
            for (int i = 0; i < 10; i++) if (rl.tryAcquire("user-1")) granted++;
        } catch (RuntimeException e) {
            broken.add("ném " + e.getClass().getSimpleName() + " với key hợp lệ");
        }
        if (granted > limit) broken.add("cho " + granted + " lần, vượt limit " + limit);
        try {
            factory.apply(limit).tryAcquire("never-seen");
        } catch (RuntimeException e) {
            broken.add("key lạ ném " + e.getClass().getSimpleName());
        }
        return broken;
    }

    public static void main(String[] args) {
        Map<String, IntFunction<RateLimiter>> impls = new LinkedHashMap<>();
        impls.put("FixedWindow", FixedWindow::new);
        impls.put("AlwaysAllow", n -> new AlwaysAllow());
        impls.put("RegisteredOnly", n -> new RegisteredOnly(new FixedWindow(n), Set.of("user-1")));
        impls.forEach((name, f) -> {
            List<String> broken = verify(f);
            System.out.println(name + " -> " + (broken.isEmpty() ? "OK" : "VI PHẠM: " + broken));
        });
    }
}
FixedWindow -> OK
AlwaysAllow -> VI PHẠM: [cho 10 lần, vượt limit 3]
RegisteredOnly -> VI PHẠM: [key lạ ném IllegalArgumentException]

Với JUnit 5, cùng ý tưởng viết thành một abstract test class (hoặc interface có @Test default method) với method trừu tượng createLimiter(int limit); mỗi cài đặt có một lớp test con chỉ override method tạo. Thêm cài đặt mới (Redis, token bucket ở rate limiting) là được kiểm hợp đồng ngay. Nếu thật sự cần “luôn cho qua” ở dev, đó là cấu hình (limit rất lớn), không phải một cài đặt nói dối hợp đồng.

Ghi nhớ

  • Giải thích được SRP theo actor và đưa ra ba cách đo một class có vi phạm không.
  • Biết khi nào dùng điểm mở rộng (interface) và khi nào switch trên sealed type tốt hơn.
  • Nêu được bốn quy tắc hợp đồng của Liskov và cách kiểm bằng contract test.
  • Nhận ra interface “to” qua method rỗng hoặc UnsupportedOperationException.
  • Phân biệt được DIP, IoC, DI và biết abstraction nên đặt ở package nào.
  • Biết khi nào áp SOLID là quá tay.

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

SOLID là gì và vì sao cần nó trong công việc hằng ngày?

Là năm nguyên lý thiết kế hướng đối tượng (Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion) nhằm giảm chi phí thay đổi code.

Hằng ngày nó thể hiện ở: sửa một quy tắc nghiệp vụ chỉ chạm một chỗ (S), thêm cổng thanh toán mới mà không mở lại code cũ (O), cài đặt mới không làm hỏng chỗ đang dùng interface (L), mock trong test chỉ vài method (I), test nghiệp vụ không cần database thật (D). Nói thêm giới hạn: áp cho thay đổi chưa xảy ra thì thành over-engineering.

Trách nhiệm trong SRP là gì? Làm sao đo một class có vi phạm SRP không?

Trách nhiệm là một lý do để thay đổi, gắn với một actor, tức nhóm người có thể yêu cầu class đó đổi; class vi phạm khi phục vụ nhiều actor.

Cách đo: tên cần “And” hoặc là Manager/Helper; ticket chạm class đến từ nhiều nhóm; các nhóm method đổi độc lập trong git log; test một phần phải dựng giả phần không liên quan (test tính tiền mà cần SMTP). Ví dụ AuthenticationManager vừa kiểm mật khẩu, vừa sinh JWT, vừa ghi audit log, vừa gửi email cảnh báo đăng nhập lạ là bốn actor (bảo mật, API, compliance, sản phẩm); tách thành CredentialVerifier, TokenIssuer, AuditLogger, LoginAlertNotifier, giữ một lớp điều phối mỏng.

Open/Closed có luôn tốt không? Nhận ra code vi phạm OCP thế nào?

Không; nó tốt khi biến thể mới thật sự hay xuất hiện, còn thêm điểm mở rộng cho thứ không đổi chỉ thêm tầng gián tiếp.

Dấu hiệu vi phạm: switch/if-else theo loại lặp ở nhiều nơi, instanceof rải rác, new thẳng class cài đặt trong nghiệp vụ, mỗi tính năng đều sửa cùng một class trung tâm. Với tập biến thể đóng và ổn định, sealed interface + switch đủ trường hợp là lựa chọn tốt vì compiler bắt chỗ quên. Cách làm thực dụng: thêm điểm mở rộng khi biến thể thứ hai hoặc thứ ba xuất hiện.

OCP và Dependency Inversion liên quan thế nào? Kế thừa có phải cách tốt để đạt OCP không?

OCP thường đạt được nhờ DIP: code nghiệp vụ phụ thuộc abstraction nên thay hoặc thêm cài đặt mà không sửa nó.

Kế thừa đạt được OCP nhưng ràng buộc chặt: lớp con phụ thuộc chi tiết của lớp cha (fragile base class), chỉ chọn được lúc biên dịch, và dễ vỡ Liskov. Composition (inject một strategy qua interface) linh hoạt hơn: đổi lúc chạy, test riêng, ghép nhiều hành vi. Template Method vẫn có chỗ khi khung thuật toán thật sự cố định; so sánh đầy đủ ở Template Method hay composition.

Liskov Substitution là gì? Cho ví dụ vi phạm ngoài Square/Rectangle.

Mọi chỗ dùng kiểu cha phải chạy đúng khi đưa vào kiểu con: con không đòi hỏi nhiều hơn ở đầu vào, không hứa ít hơn ở đầu ra, giữ bất biến và không ném exception bất ngờ.

Ví dụ backend: PaymentGateway hứa “trả Charged thì tiền đã bị trừ” mà một cài đặt fake trả Charged luôn; RateLimiter mà một cài đặt ném exception với key chưa đăng ký; List.of ném UnsupportedOperationException khi add (JDK cố ý chấp nhận). Cách bắt: contract test viết một lần cho interface và chạy cho mọi cài đặt; dấu hiệu trong code là client phải instanceof để xử lý riêng một lớp con.

Interface Segregation khác Single Responsibility thế nào?

SRP nhìn từ phía class cài đặt (nó thay đổi vì mấy lý do); ISP nhìn từ phía client (nó bị bắt phụ thuộc vào bao nhiêu method không dùng).

Một class có thể đúng SRP mà interface của nó vẫn quá to cho từng client; khi đó tách interface theo vai trò (CheckInDesk, RoomAssigner) và class implement cả hai. Dấu hiệu vi phạm ISP: cài đặt phải để method rỗng hoặc ném UnsupportedOperationException, mock trong test phải stub nhiều method không liên quan, đổi một method bắt biên dịch lại client không dùng nó.

Giải thích chữ D trong SOLID. Nó khác Dependency Injection thế nào?

Dependency Inversion: 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 (định nghĩa theo nhu cầu của nghiệp vụ, đặt ở package nghiệp vụ); DI là kỹ thuật đưa dependency từ ngoài vào.

DI mà không DIP: Spring inject JpaBookingRepository cụ thể, hoặc interface repository trả kiểu của Spring Data, nghiệp vụ vẫn dính hạ tầng. DIP mà không cần DI container: tự new adapter ở hàm main rồi truyền qua constructor. Trong thực tế hai thứ đi cùng nhau: DIP quyết định hình dạng phụ thuộc, Spring lắp ráp.

Vì sao Spring khuyên “code to an interface”? Có phải lúc nào cũng cần interface không?

Vì phụ thuộc vào interface cho phép thay cài đặt (test, môi trường, nhà cung cấp) và cho Spring tạo JDK proxy cho AOP; nhưng không phải lúc nào cũng cần.

Đáng có interface: ranh giới với hạ tầng (repository, gateway, sender), chỗ có nhiều cài đặt thật, API công khai của module. Không cần: service nội bộ có một cài đặt và không ai thay; Spring Boot mặc định proxy bằng CGLIB nên @Transactional vẫn chạy với class. Interface một cài đặt “cho chắc” làm code dài hơn và nhảy định nghĩa khó hơn mà không mua được gì.

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
reason to change /ˈriː.zən tə tʃeɪndʒ/ lý do thay đổi “SRP means a class has one reason to change, one actor behind it.”
cohesion /koʊˈhiː.ʒən/ độ gắn kết “Splitting a cohesive class into ten pieces makes changes harder.”
extension point /ɪkˈsten.ʃən pɔɪnt/ chỗ cắm biến thể mới “I add an extension point once the second variant shows up.”
precondition /ˌpriː.kənˈdɪʃ.ən/ tiền điều kiện “A subtype must not strengthen the preconditions.”
postcondition /ˌpoʊst.kənˈdɪʃ.ən/ hậu điều kiện “Returning success without charging weakens the postcondition.”
invariant /ɪnˈver.i.ənt/ điều luôn đúng “The balance-never-negative invariant must hold for every subtype.”
contract test /ˈkɑːn.trækt test/ test hợp đồng chạy cho mọi cài đặt “Every implementation runs the same contract test suite.”
role interface /roʊl ˈɪn.t̬ɚ.feɪs/ interface theo vai trò “We split the fat interface into role interfaces per client.”
high-level policy /ˌhaɪ ˈlev.əl ˈpɑː.lə.si/ quy tắc nghiệp vụ cấp cao “The high-level policy owns the interface; infrastructure implements it.”
over-engineering /ˌoʊ.vɚ.en.dʒɪˈnɪr.ɪŋ/ thiết kế quá mức cần “An interface with one implementation is often over-engineering.”

Ghi chép tự tổng hợp từ tài liệu chính thức và kinh nghiệm thực tế.