Bài 13: NGUYÊN LÝ SOLID – 5 NGUYÊN TẮC VÀNG TRONG THIẾT KẾ PHẦN MỀM

Chào các kiến trúc sư phần mềm tương lai! Hôm nay chúng ta sẽ học về SOLID – 5 nguyên lý thiết kế quan trọng nhất trong lập trình hướng đối tượng. Đây không chỉ là lý thuyết, mà là kim chỉ nam để viết code dễ bảo trì, mở rộng và ít lỗi!

I. PHẦN LÝ THUYẾT

1. SOLID là gì?

SOLID là viết tắt của 5 nguyên lý thiết kế phần mềm, được đặt ra bởi Robert C. Martin (Uncle Bob):

  1. S – Single Responsibility Principle (SRP)
  2. O – Open/Closed Principle (OCP)
  3. L – Liskov Substitution Principle (LSP)
  4. I – Interface Segregation Principle (ISP)
  5. D – Dependency Inversion Principle (DIP)

2. Tại sao SOLID quan trọng?

Code không tuân theo SOLID:

  • Khó hiểu, khó bảo trì
  • Thay đổi một tính năng → phá vỡ nhiều tính năng khác
  • Khó test, khó tái sử dụng
  • “Spaghetti code” – mì ống rối rắm

Code tuân theo SOLID:

  • Dễ đọc, dễ bảo trì
  • Dễ mở rộng, ít rủi ro khi thay đổi
  • Dễ test, dễ tái sử dụng
  • Giảm thiểu “technical debt”

II. PHẦN THỰC HÀNH

Nguyên lý 1: SINGLE RESPONSIBILITY PRINCIPLE (SRP)

Một lớp chỉ nên có một lý do để thay đổi – Mỗi lớp chỉ nên có một trách nhiệm duy nhất.

Ví dụ vi phạm SRP:

// VI PHẠM SRP: Lớp này làm QUÁ NHIỀU việc
class Student {
    private String name;
    private String email;
    
    // Constructor, getter, setter...
    
    // 1. Quản lý thông tin sinh viên (OK)
    public void updateEmail(String newEmail) {
        this.email = newEmail;
    }
    
    // 2. Lưu vào database (KHÔNG NÊN ở đây)
    public void saveToDatabase() {
        // Code kết nối và lưu vào database
        System.out.println("Lưu sinh viên vào database...");
    }
    
    // 3. Gửi email (KHÔNG NÊN ở đây)
    public void sendEmail(String subject, String body) {
        // Code gửi email
        System.out.println("Gửi email đến: " + email);
    }
    
    // 4. In báo cáo (KHÔNG NÊN ở đây)
    public void printReport() {
        // Code in báo cáo
        System.out.println("In báo cáo sinh viên...");
    }
}

Ví dụ tuân thủ SRP:

// TUÂN THỦ SRP: Mỗi lớp một trách nhiệm

// 1. Lớp chứa thông tin sinh viên
class Student {
    private String name;
    private String email;
    
    public Student(String name, String email) {
        this.name = name;
        this.email = email;
    }
    
    public String getName() { return name; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}
// 2. Lớp chịu trách nhiệm lưu trữ
class StudentRepository {
    public void save(Student student) {
        // Code lưu vào database
        System.out.println("Lưu sinh viên " + student.getName() + " vào database");
    }
    
    public void delete(Student student) {
        System.out.println("Xóa sinh viên " + student.getName() + " khỏi database");
    }
}
// 3. Lớp chịu trách nhiệm gửi email
class EmailService {
    public void sendEmail(Student student, String subject, String body) {
        // Code gửi email
        System.out.println("Gửi email đến: " + student.getEmail());
        System.out.println("Tiêu đề: " + subject);
        System.out.println("Nội dung: " + body);
    }
}
// 4. Lớp chịu trách nhiệm in ấn
class ReportService {
    public void printStudentReport(Student student) {
        // Code in báo cáo
        System.out.println("=== BÁO CÁO SINH VIÊN ===");
        System.out.println("Tên: " + student.getName());
        System.out.println("Email: " + student.getEmail());
    }
}
// 5. Lớp điều phối (Facade/Service)
class StudentService {
    private StudentRepository repository;
    private EmailService emailService;
    private ReportService reportService;
    
    public StudentService() {
        this.repository = new StudentRepository();
        this.emailService = new EmailService();
        this.reportService = new ReportService();
    }
    
    public void registerStudent(Student student) {
        repository.save(student);
        emailService.sendEmail(student, "Chào mừng", "Chào mừng bạn đến với trường!");
        reportService.printStudentReport(student);
    }
}

Nguyên lý 2: OPEN/CLOSED PRINCIPLE (OCP)

Các lớp/phần mềm nên mở cho việc mở rộng nhưng đóng cho việc sửa đổi – Có thể thêm tính năng mới mà không cần sửa code cũ.

Ví dụ vi phạm OCP:

// VI PHẠM OCP: Mỗi khi thêm hình mới phải sửa class AreaCalculator
class AreaCalculator {
    public double calculateArea(Object shape) {
        if (shape instanceof Circle) {
            Circle circle = (Circle) shape;
            return Math.PI * circle.getRadius() * circle.getRadius();
        } else if (shape instanceof Square) {
            Square square = (Square) shape;
            return square.getSide() * square.getSide();
        } else if (shape instanceof Rectangle) {
            Rectangle rectangle = (Rectangle) shape;
            return rectangle.getWidth() * rectangle.getHeight();
        }
        // Thêm hình tam giác? Phải thêm if-else mới!
        throw new IllegalArgumentException("Hình không được hỗ trợ");
    }
}
class Circle {
    private double radius;
    public Circle(double radius) { this.radius = radius; }
    public double getRadius() { return radius; }
}
class Square {
    private double side;
    public Square(double side) { this.side = side; }
    public double getSide() { return side; }
}
class Rectangle {
    private double width, height;
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    public double getWidth() { return width; }
    public double getHeight() { return height; }
}

Ví dụ tuân thủ OCP:

// TUÂN THỦ OCP: Sử dụng abstraction để mở rộng

// 1. Interface hoặc abstract class định nghĩa hành vi chung
interface Shape {
    double calculateArea();
}
// 2. Các lớp cụ thể implement interface
class Circle implements Shape {
    private double radius;
    
    public Circle(double radius) {
        this.radius = radius;
    }
    
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
}

class Square implements Shape {
    private double side;
    
    public Square(double side) {
        this.side = side;
    }
    
    @Override
    public double calculateArea() {
        return side * side;
    }
}

class Rectangle implements Shape {
    private double width, height;
    
    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }
    
    @Override
    public double calculateArea() {
        return width * height;
    }
}
// 3. Thêm hình mới KHÔNG cần sửa AreaCalculator
class Triangle implements Shape {
    private double base, height;
    
    public Triangle(double base, double height) {
        this.base = base;
        this.height = height;
    }
    
    @Override
    public double calculateArea() {
        return 0.5 * base * height;
    }
}
// 4. AreaCalculator chỉ làm một việc: tính tổng diện tích
class AreaCalculator {
    public double calculateTotalArea(List<Shape> shapes) {
        double totalArea = 0;
        for (Shape shape : shapes) {
            totalArea += shape.calculateArea(); // Đa hình!
        }
        return totalArea;
    }
}
// 5. Sử dụng
public class OCPDemo {
    public static void main(String[] args) {
        List<Shape> shapes = new ArrayList<>();
        shapes.add(new Circle(5));
        shapes.add(new Square(4));
        shapes.add(new Rectangle(3, 6));
        shapes.add(new Triangle(4, 5)); // Thêm mới dễ dàng!
        
        AreaCalculator calculator = new AreaCalculator();
        double totalArea = calculator.calculateTotalArea(shapes);
        System.out.println("Tổng diện tích: " + totalArea);
    }
}

Nguyên lý 3: LISKOV SUBSTITUTION PRINCIPLE (LSP)

Các đối tượng của lớp con phải có thể thay thế đối tượng của lớp cha mà không làm thay đổi tính đúng đắn của chương trình – Lớp con không được vi phạm hành vi của lớp cha.

Ví dụ vi phạm LSP:

// VI PHẠM LSP: Lớp con làm thay đổi hành vi của lớp cha
class Rectangle {
    protected int width;
    protected int height;
    
    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }
    
    public int getWidth() { return width; }
    public int getHeight() { return height; }
    
    public void setWidth(int width) { this.width = width; }
    public void setHeight(int height) { this.height = height; }
    
    public int calculateArea() {
        return width * height;
    }
}

// Square IS-A Rectangle (về mặt toán học)
// Nhưng về mặt hành vi, Square vi phạm LSP
class Square extends Rectangle {
    public Square(int side) {
        super(side, side);
    }
    
    // VI PHẠM: Thay đổi hành vi setWidth, setHeight
    @Override
    public void setWidth(int width) {
        super.setWidth(width);
        super.setHeight(width); // Luôn giữ hình vuông
    }
    
    @Override
    public void setHeight(int height) {
        super.setWidth(height); // Luôn giữ hình vuông
        super.setHeight(height);
    }
}

// Vấn đề: Code client không hoạt động đúng
class TestLSP {
    public static void testRectangle(Rectangle rectangle) {
        rectangle.setWidth(5);
        rectangle.setHeight(4);
        
        // Mong đợi: 5 * 4 = 20
        // Nhưng nếu rectangle thực chất là Square: 4 * 4 = 16
        System.out.println("Diện tích: " + rectangle.calculateArea());
    }
    
    public static void main(String[] args) {
        Rectangle rect = new Rectangle(5, 4);
        testRectangle(rect); // OK: 20
        
        Square square = new Square(5);
        testRectangle(square); // SAI: 16 thay vì 20
    }
}

Ví dụ tuân thủ LSP:

// TUÂN THỦ LSP: Sử dụng composition và interface

// 1. Interface chung cho tất cả hình
interface Shape {
    int calculateArea();
}

// 2. Các lớp implement riêng biệt
class Rectangle implements Shape {
    private int width;
    private int height;
    
    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }
    
    public int getWidth() { return width; }
    public int getHeight() { return height; }
    
    public void setWidth(int width) { this.width = width; }
    public void setHeight(int height) { this.height = height; }
    
    @Override
    public int calculateArea() {
        return width * height;
    }
}

class Square implements Shape {
    private int side;
    
    public Square(int side) {
        this.side = side;
    }
    
    public int getSide() { return side; }
    public void setSide(int side) { this.side = side; }
    
    @Override
    public int calculateArea() {
        return side * side;
    }
}

// 3. Hoặc dùng inheritance nhưng không vi phạm LSP
abstract class ShapeBase {
    public abstract int calculateArea();
}

class GoodRectangle extends ShapeBase {
    private int width, height;
    
    public GoodRectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }
    
    // Có thể thay đổi kích thước độc lập
    public void resize(int width, int height) {
        this.width = width;
        this.height = height;
    }
    
    @Override
    public int calculateArea() {
        return width * height;
    }
}

class GoodSquare extends ShapeBase {
    private int side;
    
    public GoodSquare(int side) {
        this.side = side;
    }
    
    // Chỉ có thể resize đồng đều
    public void resize(int side) {
        this.side = side;
    }
    
    @Override
    public int calculateArea() {
        return side * side;
    }
}

// 4. Code client hoạt động đúng với mọi Shape
class ShapeProcessor {
    public void processShapes(List<Shape> shapes) {
        for (Shape shape : shapes) {
            System.out.println("Diện tích: " + shape.calculateArea());
            // Không cần biết shape là Rectangle hay Square
        }
    }
}

Nguyên lý 4: INTERFACE SEGREGATION PRINCIPLE (ISP)

Không nên ép client phụ thuộc vào interface mà họ không sử dụng – Tách interface lớn thành các interface nhỏ, chuyên biệt.

Ví dụ vi phạm ISP:

// VI PHẠM ISP: Interface "béo", chứa quá nhiều phương thức
interface Worker {
    void work();
    void eat();
    void sleep();
    void code();
    void design();
    void test();
    void deploy();
}

// Developer phải implement tất cả phương thức
class Developer implements Worker {
    @Override
    public void work() { System.out.println("Developer working..."); }
    
    @Override
    public void eat() { System.out.println("Developer eating..."); }
    
    @Override
    public void sleep() { System.out.println("Developer sleeping..."); }
    
    @Override
    public void code() { System.out.println("Developer coding..."); }
    
    // Vấn đề: Developer không thiết kế, test, deploy
    @Override
    public void design() { 
        throw new UnsupportedOperationException("Developer không thiết kế");
    }
    
    @Override
    public void test() { 
        // Developer có thể test nhưng không phải chuyên
        System.out.println("Developer testing...");
    }
    
    @Override
    public void deploy() { 
        throw new UnsupportedOperationException("Developer không deploy");
    }
}

// Robot cũng phải implement eat(), sleep() - VÔ LÝ!
class Robot implements Worker {
    @Override
    public void work() { System.out.println("Robot working..."); }
    
    @Override
    public void eat() { 
        throw new UnsupportedOperationException("Robot không ăn");
    }
    
    @Override
    public void sleep() { 
        throw new UnsupportedOperationException("Robot không ngủ");
    }
    
    @Override
    public void code() { System.out.println("Robot coding..."); }
    
    @Override
    public void design() { System.out.println("Robot designing..."); }
    
    @Override
    public void test() { System.out.println("Robot testing..."); }
    
    @Override
    public void deploy() { System.out.println("Robot deploying..."); }
}

Ví dụ tuân thủ ISP:

// TUÂN THỦ ISP: Tách interface thành các interface nhỏ, chuyên biệt

// 1. Interface cơ bản
interface Workable {
    void work();
}

// 2. Interface cho sinh vật sống
interface LivingBeing {
    void eat();
    void sleep();
}

// 3. Interface chuyên biệt cho từng vai trò
interface Coder {
    void code();
}

interface Designer {
    void design();
}

interface Tester {
    void test();
}

interface Deployer {
    void deploy();
}

// 4. Các lớp chỉ implement interface cần thiết
class Developer implements Workable, LivingBeing, Coder, Tester {
    @Override
    public void work() { System.out.println("Developer working..."); }
    
    @Override
    public void eat() { System.out.println("Developer eating..."); }
    
    @Override
    public void sleep() { System.out.println("Developer sleeping..."); }
    
    @Override
    public void code() { System.out.println("Developer coding..."); }
    
    @Override
    public void test() { System.out.println("Developer testing..."); }
    // Không có design(), deploy() → không cần implement
}

class Robot implements Workable, Coder, Designer, Tester, Deployer {
    @Override
    public void work() { System.out.println("Robot working..."); }
    
    @Override
    public void code() { System.out.println("Robot coding..."); }
    
    @Override
    public void design() { System.out.println("Robot designing..."); }
    
    @Override
    public void test() { System.out.println("Robot testing..."); }
    
    @Override
    public void deploy() { System.out.println("Robot deploying..."); }
    // Không có eat(), sleep() → không cần implement
}

// 5. Interface tổng hợp cho những người đa năng
interface FullStackDeveloper extends Workable, Coder, Designer, Tester {
    // Đầy đủ chức năng của FullStack Developer
}

class SeniorDeveloper implements FullStackDeveloper, LivingBeing {
    @Override
    public void work() { System.out.println("Senior Developer working..."); }
    
    @Override
    public void eat() { System.out.println("Senior Developer eating..."); }
    
    @Override
    public void sleep() { System.out.println("Senior Developer sleeping..."); }
    
    @Override
    public void code() { System.out.println("Senior Developer coding..."); }
    
    @Override
    public void design() { System.out.println("Senior Developer designing..."); }
    
    @Override
    public void test() { System.out.println("Senior Developer testing..."); }
}

Nguyên lý 5: DEPENDENCY INVERSION PRINCIPLE (DIP)

Các module cấp cao không nên phụ thuộc vào module cấp thấp. Cả hai nên phụ thuộc vào abstraction – Sử dụng interface/abstraction, không phụ thuộc vào implementation cụ thể.

Ví dụ vi phạm DIP:

// VI PHẠM DIP: Module cấp cao phụ thuộc trực tiếp vào module cấp thấp

// Module cấp thấp: Data Access Layer
class MySQLDatabase {
    public void connect() {
        System.out.println("Kết nối MySQL...");
    }
    
    public void save(String data) {
        System.out.println("Lưu vào MySQL: " + data);
    }
}

class MongoDB {
    public void connect() {
        System.out.println("Kết nối MongoDB...");
    }
    
    public void insert(String data) {
        System.out.println("Insert vào MongoDB: " + data);
    }
}

// Module cấp cao: Business Logic Layer
class UserService {
    private MySQLDatabase database; // PHỤ THUỘC CỨNG vào MySQL
    
    public UserService() {
        this.database = new MySQLDatabase(); // Tạo dependency trực tiếp
    }
    
    public void saveUser(String userData) {
        database.connect();
        database.save(userData);
    }
    
    // Vấn đề: Muốn đổi sang MongoDB phải sửa code
}

Ví dụ tuân thủ DIP:

// TUÂN THỦ DIP: Cả module cao và thấp đều phụ thuộc vào abstraction

// 1. Abstraction (Interface)
interface Database {
    void connect();
    void save(String data);
}

// 2. Module cấp thấp: Implement interface
class MySQLDatabase implements Database {
    @Override
    public void connect() {
        System.out.println("Kết nối MySQL...");
    }
    
    @Override
    public void save(String data) {
        System.out.println("Lưu vào MySQL: " + data);
    }
}

class MongoDB implements Database {
    @Override
    public void connect() {
        System.out.println("Kết nối MongoDB...");
    }
    
    @Override
    public void save(String data) {
        System.out.println("Insert vào MongoDB: " + data);
    }
}

class PostgreSQL implements Database {
    @Override
    public void connect() {
        System.out.println("Kết nối PostgreSQL...");
    }
    
    @Override
    public void save(String data) {
        System.out.println("Lưu vào PostgreSQL: " + data);
    }
}

// 3. Module cấp cao: Phụ thuộc vào interface, không phải implementation
class UserService {
    private Database database; // Phụ thuộc vào abstraction
    
    // Dependency Injection: Nhận dependency từ bên ngoài
    public UserService(Database database) {
        this.database = database;
    }
    
    public void saveUser(String userData) {
        database.connect();
        database.save(userData);
    }
    
    // Có thể thay đổi database dễ dàng mà không sửa code
}

// 4. Cấu hình dependency (thường ở lớp khởi tạo ứng dụng)
class Application {
    public static void main(String[] args) {
        // Có thể dễ dàng thay đổi database
        Database database = new MySQLDatabase(); // Hoặc new MongoDB(), new PostgreSQL()
        
        // Inject dependency vào service
        UserService userService = new UserService(database);
        
        // Sử dụng service
        userService.saveUser("Nguyễn Văn A");
    }
}

// 5. Sử dụng Factory Pattern để tạo dependency
class DatabaseFactory {
    public static Database createDatabase(String type) {
        switch (type.toLowerCase()) {
            case "mysql": return new MySQLDatabase();
            case "mongodb": return new MongoDB();
            case "postgresql": return new PostgreSQL();
            default: throw new IllegalArgumentException("Database không hỗ trợ: " + type);
        }
    }
}

// 6. Sử dụng Dependency Injection Container (Spring-like)
class Container {
    private Map<Class<?>, Object> dependencies = new HashMap<>();
    
    public void register(Class<?> interfaceType, Object implementation) {
        dependencies.put(interfaceType, implementation);
    }
    
    @SuppressWarnings("unchecked")
    public <T> T resolve(Class<T> interfaceType) {
        return (T) dependencies.get(interfaceType);
    }
}

class DIPDemo {
    public static void main(String[] args) {
        // Cấu hình container
        Container container = new Container();
        container.register(Database.class, new MongoDB());
        container.register(UserService.class, 
                          new UserService(container.resolve(Database.class)));
        
        // Lấy service từ container
        UserService userService = container.resolve(UserService.class);
        userService.saveUser("Trần Thị B");
    }
}

III. CÂU HỎI VÀ BÀI TẬP

Phần A: Câu hỏi lý thuyết (5 phút)

  1. Câu 1: Nguyên lý SRP nói “một lớp chỉ nên có một lý do để thay đổi”. “Lý do để thay đổi” được hiểu như thế nào?
  2. Câu 2: Tại sao OCP quan trọng trong việc phát triển phần mềm có thể mở rộng?
  3. Câu 3: Cho ví dụ thực tế về vi phạm LSP và cách khắc phục.
  4. Câu 4: ISP khuyên nên có nhiều interface nhỏ thay vì một interface lớn. Lợi ích là gì?
  5. Câu 5: Dependency Injection và DIP có mối quan hệ như thế nào?

Phần B: Bài tập thực hành (25 phút)

Bài 1: Refactor code vi phạm SRP

Cho code sau vi phạm SRP:

class Order {
    private List<Item> items;
    private Customer customer;
    
    public void addItem(Item item) { /* ... */ }
    public void removeItem(Item item) { /* ... */ }
    public double calculateTotal() { /* ... */ }
    
    // VI PHẠM SRP:
    public void saveToDatabase() { /* ... */ }
    public void printInvoice() { /* ... */ }
    public void sendEmailConfirmation() { /* ... */ }
    public void processPayment() { /* ... */ }
}

Hãy refactor theo SRP, tạo các lớp có trách nhiệm riêng biệt.

Bài 2: Áp dụng OCP cho hệ thống discount

Cho hệ thống tính discount:

class DiscountCalculator {
    public double calculateDiscount(String customerType, double amount) {
        if (customerType.equals("REGULAR")) {
            return amount * 0.1;
        } else if (customerType.equals("VIP")) {
            return amount * 0.2;
        } else if (customerType.equals("SUPER_VIP")) {
            return amount * 0.3;
        }
        return 0;
    }
}

Khi thêm loại khách hàng mới phải sửa code. Hãy refactor theo OCP.

Bài 3: Sửa lỗi vi phạm LSP

Cho hệ thống đa phương tiện:

class MediaPlayer {
    public void playAudio() { /* ... */ }
    public void playVideo() { /* ... */ }
}

class AudioPlayer extends MediaPlayer {
    @Override
    public void playAudio() { /* OK */ }
    
    @Override
    public void playVideo() { 
        throw new UnsupportedOperationException("AudioPlayer không phát video");
    }
}

Refactor để tuân thủ LSP.

Phần C: Thử thách nâng cao (20 phút)

Bài 4: Thiết kế hệ thống thanh toán với SOLID

Thiết kế hệ thống thanh toán hỗ trợ nhiều phương thức:

  1. Credit Card
  2. PayPal
  3. Bank Transfer
  4. Cryptocurrency

Yêu cầu:

  • Tuân thủ OCP: Dễ thêm phương thức mới
  • Tuân thủ DIP: Business logic không phụ thuộc vào implementation cụ thể
  • Tuân thủ ISP: Interface thanh toán không quá “béo”
  • Tuân thủ LSP: Mọi payment method có thể thay thế nhau
  • Tuân thủ SRP: Mỗi lớp một trách nhiệm

Bài 5: Refactor hệ thống báo cáo lớn

Cho hệ thống báo cáo phức tạp:

class ReportGenerator {
    public void generateReport(String type, Data data) {
        if (type.equals("PDF")) {
            // 500 dòng code tạo PDF
        } else if (type.equals("EXCEL")) {
            // 400 dòng code tạo Excel
        } else if (type.equals("HTML")) {
            // 300 dòng code tạo HTML
        } else if (type.equals("CSV")) {
            // 200 dòng code tạo CSV
        }
        // Còn 10 loại report khác...
        
        // Và còn code gửi email, lưu database, in ấn...
    }
}

Hãy refactor toàn bộ theo 5 nguyên lý SOLID.

IV. TÓM TẮT BÀI HỌC

  • SRP: Một lớp, một trách nhiệm
  • OCP: Mở để mở rộng, đóng để sửa đổi
  • LSP: Lớp con thay thế được lớp cha
  • ISP: Interface nhỏ, chuyên biệt
  • DIP: Phụ thuộc vào abstraction, không phải implementation

Lợi ích của SOLID:

  • Code dễ đọc, dễ hiểu
  • Dễ bảo trì, ít bug
  • Dễ test, dễ mở rộng
  • Giảm coupling, tăng cohesion
  • Dễ làm việc nhóm

“SOLID không phải là mục đích, mà là phương tiện. Mục đích là viết code sạch, dễ bảo trì và có thể mở rộng.” – Robert C. Martin

P.S.: Thử thách đặc biệt: Hãy tìm một project open source trên GitHub, phân tích xem nó có tuân thủ SOLID không. Chỉ ra ít nhất 3 điểm vi phạm và đề xuất cách refactor!

Comments are closed.