👋 Chào mừng đến với Nocoem — kiến thức Backend, System Design và lập trình. Khám phá ngay

What is SOLID in Programming? The SOLID principles of Object-Oriented Programming

SOLID - năm nguyên tắc nền tảng giúp lập trình viên tạo ra phần mềm hướng đối tượng dễ bảo trì, linh hoạt và vững chắc.

 


TL;DR: SOLID là năm nguyên tắc thiết kế hướng đối tượng (do Robert C. Martin tổng hợp) giúp code dễ đọc, dễ sửa, ít vỡ khi thêm tính năng. Cả bài gói trong 20 giây:
  • S - Single Responsibility: một class chỉ nên có một lý do để thay đổi.
  • O - Open/Closed: mở để mở rộng, đóng với sửa đổi.
  • L - Liskov Substitution: lớp con phải thay thế được lớp cha mà không làm hỏng hành vi mong đợi.
  • I - Interface Segregation: nhiều interface nhỏ đúng việc, hơn một interface to bắt ai cũng phải cài đặt thừa.
  • D - Dependency Inversion: phụ thuộc vào cái trừu tượng, không phụ thuộc vào chi tiết cụ thể.

Phần còn lại của bài đi qua từng chữ kèm ví dụ Python chạy được, sau đó là cách năm nguyên tắc móc vào nhau, SOLID trong code backend thật, và cái giá phải trả khi áp chúng.

Bạn đã bao giờ mở một file code cũ, muốn sửa một dòng nhỏ thôi, mà kết cục là ba chỗ khác vỡ theo chưa? Tôi thì gặp hoài. Phần lớn những "quả bom hẹn giờ" kiểu đó không phải do thuật toán sai, mà do thiết kế: các class ôm quá nhiều việc, dính chặt vào nhau, đụng vào một chỗ là kéo theo cả dây. SOLID chính là bộ năm nguyên tắc ra đời để chữa đúng căn bệnh này. Trong bài này tôi sẽ đi qua từng chữ cái, mỗi nguyên tắc kèm một ví dụ Python bạn chạy thử được và một ví von đời thường cho dễ nhớ.

SOLID là gì?

SOLID là từ viết tắt của năm nguyên tắc thiết kế hướng đối tượng (Object-Oriented Design, OOD). Bộ nguyên tắc này được Robert C. Martin (hay còn gọi là "Uncle Bob") giới thiệu, còn cái tên viết tắt "SOLID" thì do Michael Feathers đặt.

Năm chữ cái đó là:

  • S - Single-Responsibility Principle (Nguyên tắc đơn trách nhiệm, SRP)
  • O - Open-Closed Principle (Nguyên tắc đóng-mở, OCP)
  • L - Liskov Substitution Principle (Nguyên tắc thay thế Liskov, LSP)
  • I - Interface Segregation Principle (Nguyên tắc phân tách giao diện, ISP)
  • D - Dependency Inversion Principle (Nguyên tắc đảo ngược phụ thuộc, DIP)

Một lưu ý trước khi bắt đầu: SOLID là nguyên tắc hướng dẫn, không phải luật cứng. Mục tiêu cuối cùng là code dễ bảo trì và dễ mở rộng - nếu áp máy móc tới mức đẻ ra hàng chục class rối rắm cho một script 50 dòng thì bạn đang đi ngược lại tinh thần của nó. Tôi sẽ nói thêm ở phần cạm bẫy cuối bài.

S - Single-Responsibility Principle (SRP)

A class should have one reason to change.

Nguyên tắc đơn trách nhiệm nói rằng một class chỉ nên có một lý do để thay đổi. Nói cách khác, mỗi class nên gánh đúng một trách nhiệm được định nghĩa rõ ràng, chứ không ôm đồm nhiều thứ chẳng liên quan.

Vì sao đáng quan tâm? Khi mỗi class chỉ lo một việc, những thay đổi được cô lập lại: sửa phần này không đụng phần kia. Code cũng dễ test hơn, ít trùng lặp hơn, và tính module (modularity) tốt hơn.

Ví von: hãy nghĩ tới một con dao Thụy Sĩ nhồi nhét dao, kéo, mở nút chai, dũa móng tay. Nghe tiện, nhưng khi cái kéo hỏng bạn phải tháo cả con dao ra sửa, và lỡ tay là cùn luôn lưỡi dao. Ngược lại, một bộ dụng cụ nhà bếp mỗi món một việc thì hỏng cái nào thay cái đó, chẳng ảnh hưởng phần còn lại.

Để minh hoạ, giả sử ta có class FileManager như sau:

# file_manager_srp.py
from pathlib import Path
from zipfile import ZipFile

class FileManager:
    def __init__(self, filename):
        self.path = Path(filename)

    def read(self, encoding="utf-8"):
        return self.path.read_text(encoding)

    def write(self, data, encoding="utf-8"):
        self.path.write_text(data, encoding)

    def compress(self):
        with ZipFile(self.path.with_suffix(".zip"), mode="w") as archive:
            archive.write(self.path)

    def decompress(self):
        with ZipFile(self.path.with_suffix(".zip"), mode="r") as archive:
            archive.extractall()

Class FileManager này đang ôm hai trách nhiệm khác nhau: quản lý file (qua read() và write()) và xử lý nén/giải nén Zip (qua compress() và decompress()). Nó vi phạm SRP vì có tới hai lý do độc lập để phải thay đổi cách cài đặt bên trong. Cách chữa là tách thành hai class nhỏ hơn, mỗi class lo đúng một mối quan tâm:

# file_manager_srp.py
from pathlib import Path
from zipfile import ZipFile

class FileManager:
    def __init__(self, filename):
        self.path = Path(filename)

    def read(self, encoding="utf-8"):
        return self.path.read_text(encoding)

    def write(self, data, encoding="utf-8"):
        self.path.write_text(data, encoding)

class ZipFileManager:
    def __init__(self, filename):
        self.path = Path(filename)

    def compress(self):
        with ZipFile(self.path.with_suffix(".zip"), mode="w") as archive:
            archive.write(self.path)

    def decompress(self):
        with ZipFile(self.path.with_suffix(".zip"), mode="r") as archive:
            archive.extractall()

Giờ bạn có hai class, mỗi class một trách nhiệm. FileManager lo việc đọc/ghi file, còn ZipFileManager lo nén/giải nén định dạng Zip. Cả hai đều nhỏ hơn nên dễ quản lý, dễ suy luận (reason about), dễ test và dễ gỡ lỗi hơn.

Lưu ý: khái niệm "trách nhiệm" ở đây khá chủ quan. Một trách nhiệm duy nhất không đồng nghĩa với một phương thức duy nhất - nó gắn với nhiệm vụ cốt lõi mà class đại diện trong bài toán của bạn, chứ không phải đếm số phương thức. Sự chủ quan đó không nên là cái cớ để bỏ qua SRP, nhưng cũng đừng chẻ nhỏ tới mức vô nghĩa.

O - Open-Closed Principle (OCP)

Software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification.

Nguyên tắc đóng-mở nói rằng một thực thể phần mềm nên mở để mở rộng nhưng đóng với sửa đổi. Nghĩa là bạn nên thêm được hành vi mới mà không phải sửa vào mã nguồn đã có và đang chạy tốt.

Vì sao cần? Vì mỗi lần bạn thò tay vào sửa code cũ là một lần bạn có nguy cơ làm vỡ thứ đang chạy ngon. Nếu thêm tính năng bằng cách bổ sung code mới thay vì sửa code cũ, rủi ro sinh lỗi giảm hẳn.

Ví von: ổ cắm điện trên tường. Bạn không đục tường đi lại dây mỗi khi mua thiết bị mới - bạn chỉ việc cắm phích vào ổ có sẵn. Ổ cắm "đóng" với chuyện sửa đổi, nhưng "mở" cho vô số thiết bị mới cắm vào.

Hãy xem class Shape sau:

# shapes_ocp.py
from math import pi

class Shape:
    def __init__(self, shape_type, **kwargs):
        self.shape_type = shape_type
        if self.shape_type == "rectangle":
            self.width = kwargs["width"]
            self.height = kwargs["height"]
        elif self.shape_type == "circle":
            self.radius = kwargs["radius"]

    def calculate_area(self):
        if self.shape_type == "rectangle":
            return self.width * self.height
        elif self.shape_type == "circle":
            return pi * self.radius**2

Hàm khởi tạo của Shape nhận đối số shape_type ("rectangle" hoặc "circle") cùng một tập đối số từ khoá qua cú pháp **kwargs. Nếu là "rectangle" thì cần thêm "width" và "height"; nếu là "circle" thì cần "radius". Phương thức .calculate_area() tính diện tích tuỳ theo .shape_type.

Chạy thử:

>>> from shapes_ocp import Shape

>>> rectangle = Shape("rectangle", width=10, height=5)
>>> rectangle.calculate_area()

>>> circle = Shape("circle", radius=5)
>>> circle.calculate_area()
Kết quả:
50
78.53981633974483

Class chạy được đấy, nhưng nhìn là thấy có mùi. Thử tưởng tượng bạn cần thêm một hình mới, ví dụ hình vuông. Bạn sẽ phải thêm một nhánh elif nữa vào cả .__init__() lẫn .calculate_area(). Nghĩa là mỗi lần thêm hình là một lần sửa class cũ - vi phạm thẳng nguyên tắc đóng-mở. Giải pháp là biến Shape thành lớp cơ sở trừu tượng (abstract base class, ABC):

# shapes_ocp.py
from abc import ABC, abstractmethod
from math import pi

class Shape(ABC):
    def __init__(self, shape_type):
        self.shape_type = shape_type

    @abstractmethod
    def calculate_area(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        super().__init__("circle")
        self.radius = radius

    def calculate_area(self):
        return pi * self.radius**2

class Rectangle(Shape):
    def __init__(self, width, height):
        super().__init__("rectangle")
        self.width = width
        self.height = height

    def calculate_area(self):
        return self.width * self.height

class Square(Shape):
    def __init__(self, side):
        super().__init__("square")
        self.side = side

    def calculate_area(self):
        return self.side**2

Ở đây tôi đã tái cấu trúc (refactor) hoàn toàn Shape thành một ABC. Nó định nghĩa "hợp đồng" (API) mà mọi loại hình phải tuân theo: thuộc tính .shape_type và phương thức .calculate_area() bắt buộc phải được ghi đè trong mọi class con. Giờ muốn thêm hình mới, bạn chỉ việc tạo một class con mới - không cần đụng vào Shape. Class được "đóng" với sửa đổi nhưng "mở" cho mở rộng, và cách làm này cũng khiến các class trở nên đa hình (polymorphic).

Ngoài kế thừa còn cách khác: dùng lớp cơ sở trừu tượng (ABC) chỉ là một cách đạt OCP. Trong nhiều trường hợp, composition (kết hợp đối tượng) và Strategy Pattern (truyền hành vi vào như một đối tượng có thể thay thế) còn linh hoạt hơn kế thừa sâu, nhất là khi hành vi thay đổi độc lập với kiểu dữ liệu. ABC vẫn rất hợp để định nghĩa "hợp đồng"; hãy chọn cách nào giữ code phẳng và dễ thay thế nhất.

L - Liskov Substitution Principle (LSP)

Subtypes must be substitutable for their base types.

Nguyên tắc thay thế Liskov (đặt theo tên nhà khoa học máy tính Barbara Liskov, người nêu ý tưởng này năm 1987) nói rằng: ở bất cứ đâu code trông đợi một đối tượng thuộc kiểu cơ sở, bạn phải thay được bằng đối tượng thuộc kiểu con của nó mà không làm sai tính đúng đắn của chương trình.

Nói thẳng ra: class con phải cư xử đúng như "lời hứa" của class cha, không được phá vỡ kỳ vọng của người gọi. Nếu ai đó đang dùng class cha và bạn tráo vào một class con, mọi thứ vẫn phải chạy đúng.

Ví von: hợp đồng thuê nhà ghi "chìa khoá mở được cửa chính". Bất kỳ bản sao chìa nào (kiểu con) cũng phải mở được cửa đó. Nếu bạn đưa tôi một chiếc chìa "trông giống hệt" nhưng lại khoá luôn cửa thay vì mở, thì nó đã phá vỡ hợp đồng - dù về hình thức vẫn là "cái chìa".

Xét class Rectangle:

# shapes_lsp.py
class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def calculate_area(self):
        return self.width * self.height

Vì hình vuông trong toán học là một hình chữ nhật đặc biệt (các cạnh bằng nhau), bạn có thể nảy ra ý cho Square kế thừa từ Rectangle để tái dùng code. Rồi bạn ghi đè cơ chế gán thuộc tính, để hễ đặt .width thì .height cũng đổi theo và ngược lại:

# shapes_lsp.py
# ...

class Square(Rectangle):
    def __init__(self, side):
        super().__init__(side, side)

    def __setattr__(self, key, value):
        super().__setattr__(key, value)
        if key in ("width", "height"):
            self.__dict__["width"] = value
            self.__dict__["height"] = value

Hàm khởi tạo chỉ nhận một cạnh, đúng như người ta trông đợi ở hình vuông. Phương thức đặc biệt .__setattr__() móc vào cơ chế gán thuộc tính của Python: khi bạn đặt một trong hai thuộc tính, thuộc tính còn lại cũng được đặt cùng giá trị. Thử chạy:

>>> from shapes_lsp import Square

>>> square = Square(5)
>>> vars(square)

>>> square.width = 7
>>> vars(square)

>>> square.height = 9
>>> vars(square)
Kết quả:
{'width': 5, 'height': 5}
{'width': 7, 'height': 7}
{'width': 9, 'height': 9}

Object Square luôn giữ được là hình vuông hợp lệ, đổi lại chút phí phạm bộ nhớ nhỏ. Nghe thì ổn, nhưng nó vi phạm LSP: bạn không thể tráo một Rectangle bằng một Square. Vì sao? Vì người dùng Rectangle ngầm giả định .width và .height là hai thuộc tính độc lập - đổi cái này không đụng cái kia. Square phá vỡ giả định đó, gây ra những hậu quả bất ngờ và khó gỡ lỗi (ví dụ code đặt width=7 rồi height=9 mà mong diện tích 63, nhưng lại nhận 81).

Bài học: dù hình vuông là hình chữ nhật trong toán học, hai class đại diện cho chúng không nên có quan hệ cha-con nếu bạn muốn tuân thủ LSP. Cách chữa là tạo một lớp cơ sở chung để cả hai cùng mở rộng:

# shapes_lsp.py
from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def calculate_area(self):
        pass

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def calculate_area(self):
        return self.width * self.height

class Square(Shape):
    def __init__(self, side):
        self.side = side

    def calculate_area(self):
        return self.side ** 2

Shape giờ là kiểu mà bạn có thể thay thế đa hình bằng Rectangle hoặc Square - hai class này là "anh em ruột" (siblings), không phải quan hệ cha-con. Mỗi loại có bộ thuộc tính riêng, hàm khởi tạo riêng, và điểm chung duy nhất là khả năng tính diện tích. Nhờ vậy, bạn dùng chúng thay thế cho nhau (interchangeably) khi chỉ quan tâm tới hành vi chung:

>>> from shapes_lsp import Rectangle, Square

>>> def get_total_area(shapes):
...     return sum(shape.calculate_area() for shape in shapes)

>>> get_total_area([Rectangle(10, 5), Square(5)])
Kết quả:
75

Hàm get_total_area() chỉ cần biết mỗi phần tử có .calculate_area(), còn nó là hình gì thì không quan trọng. Đó chính là tinh thần của nguyên tắc thay thế Liskov.

I - Interface Segregation Principle (ISP)

Clients should not be forced to depend on interfaces they do not use.

Nguyên tắc phân tách giao diện nói rằng bên sử dụng (client) không nên bị buộc phụ thuộc vào những phương thức nó chẳng dùng tới. Thay vì một giao diện to đùng, chung chung, hãy tạo nhiều giao diện nhỏ, chuyên biệt.

Ở đây, "client" là các class con, còn "giao diện" là tập các phương thức và thuộc tính mà class cha bắt chúng phải triển khai. Nếu một class không cần một số phương thức, thì đừng nhét chúng vào giao diện chung - hãy tách ra thành các giao diện riêng.

Ví von: thực đơn nhà hàng. Bạn không thích một tờ menu 200 món dày như từ điển mà 90% bạn chẳng bao giờ gọi. Menu tách theo nhóm - đồ uống, món chính, tráng miệng - để bạn chỉ cầm đúng phần mình cần thì gọn hơn nhiều.

Xét phân cấp class cho các loại máy in:

# printers_isp.py
from abc import ABC, abstractmethod

class Printer(ABC):
    @abstractmethod
    def print(self, document):
        pass

    @abstractmethod
    def fax(self, document):
        pass

    @abstractmethod
    def scan(self, document):
        pass

class OldPrinter(Printer):
    def print(self, document):
        print(f"Printing {document} in black and white...")

    def fax(self, document):
        raise NotImplementedError("Fax functionality not supported")

    def scan(self, document):
        raise NotImplementedError("Scan functionality not supported")

class ModernPrinter(Printer):
    def print(self, document):
        print(f"Printing {document} in color...")

    def fax(self, document):
        print(f"Faxing {document}...")

    def scan(self, document):
        print(f"Scanning {document}...")

Lớp cơ sở Printer ép mọi class con phải triển khai print(), fax() và scan(). Nhưng OldPrinter là máy in đời cũ, đâu có fax hay scan - nó buộc phải "cắm" hai phương thức vô dụng chỉ để ném lỗi NotImplementedError. Đây là vi phạm ISP: class bị ép lộ ra một giao diện nó không cần và không triển khai được. Cách chữa là chẻ giao diện to thành nhiều giao diện nhỏ, rồi lắp ghép qua đa kế thừa:

# printers_isp.py
from abc import ABC, abstractmethod

class Printer(ABC):
    @abstractmethod
    def print(self, document):
        pass

class Fax(ABC):
    @abstractmethod
    def fax(self, document):
        pass

class Scanner(ABC):
    @abstractmethod
    def scan(self, document):
        pass

class OldPrinter(Printer):
    def print(self, document):
        print(f"Printing {document} in black and white...")

class NewPrinter(Printer, Fax, Scanner):
    def print(self, document):
        print(f"Printing {document} in color...")

    def fax(self, document):
        print(f"Faxing {document}...")

    def scan(self, document):
        print(f"Scanning {document}...")

Giờ Printer, Fax và Scanner là ba giao diện tách biệt, mỗi cái một trách nhiệm. OldPrinter chỉ kế thừa Printer nên không dính phương thức thừa. Còn NewPrinter cần đủ ba chức năng thì kế thừa cả ba. Thiết kế này cho phép bạn lắp ra đủ loại máy với các bộ chức năng khác nhau - vừa linh hoạt, vừa dễ mở rộng.

D - Dependency Inversion Principle (DIP)

Abstractions should not depend on details. Details should depend on abstractions. High-level modules should not depend on low-level modules; both should depend on abstractions.

Uncle Bob có một câu rất hay: "Nếu nguyên tắc đóng-mở nêu ra mục tiêu của kiến trúc hướng đối tượng, thì nguyên tắc đảo ngược phụ thuộc nêu ra cơ chế chính để đạt được nó."

Nguyên tắc đảo ngược phụ thuộc nói rằng module cấp cao không nên phụ thuộc vào module cấp thấp; cả hai nên cùng phụ thuộc vào trừu tượng (abstraction). Nghĩa là khi viết code, hãy phụ thuộc vào giao diện / lớp trừu tượng, chứ đừng dính chặt vào một cài đặt cụ thể.

Ví von: đèn bàn của bạn không hàn cứng vào đường dây điện của một nhà máy điện cụ thể. Nó cắm vào ổ cắm chuẩn (trừu tượng). Nhờ vậy, điện đến từ thuỷ điện, điện gió hay pin dự phòng đều được - đèn chẳng cần biết và chẳng cần đổi.

Giả sử bạn có một class FrontEnd lo hiển thị dữ liệu, và hiện đang lấy dữ liệu từ cơ sở dữ liệu:

# app_dip.py
class FrontEnd:
    def __init__(self, back_end):
        self.back_end = back_end

    def display_data(self):
        data = self.back_end.get_data_from_database()
        print("Display data:", data)

class BackEnd:
    def get_data_from_database(self):
        return "Data from the database"

FrontEnd đang phụ thuộc trực tiếp vào BackEnd và phương thức cụ thể get_data_from_database() của nó - hai class dính chặt vào nhau (tightly coupled). Giờ ứng dụng lớn lên, bạn muốn đọc thêm dữ liệu từ một REST API. Nếu chỉ thêm phương thức mới vào BackEnd, bạn buộc phải sửa cả FrontEnd (vì nó đang gọi tên phương thức cứng) - điều mà nguyên tắc đóng-mở không muốn xảy ra.

Cách chữa: cho các class phụ thuộc vào một trừu tượng DataSource thay vì vào cài đặt cụ thể:

# app_dip.py
from abc import ABC, abstractmethod

class FrontEnd:
    def __init__(self, data_source):
        self.data_source = data_source

    def display_data(self):
        data = self.data_source.get_data()
        print("Display data:", data)

class DataSource(ABC):
    @abstractmethod
    def get_data(self):
        pass

class Database(DataSource):
    def get_data(self):
        return "Data from the database"

class API(DataSource):
    def get_data(self):
        return "Data from the API"

DataSource là trừu tượng cung cấp giao diện chung: phương thức .get_data(). Giờ FrontEnd chỉ phụ thuộc vào giao diện đó, chứ không quan tâm dữ liệu đến từ đâu. Database và API là hai cài đặt cụ thể, cả hai đều tuân theo DataSource. Dùng như sau:

>>> from app_dip import API, Database, FrontEnd

>>> db_front_end = FrontEnd(Database())
>>> db_front_end.display_data()

>>> api_front_end = FrontEnd(API())
>>> api_front_end.display_data()
Kết quả:
Display data: Data from the database
Display data: Data from the API

Bạn khởi tạo FrontEnd lần đầu với một Database, lần sau với một API - mỗi lần gọi .display_data() kết quả sẽ tuỳ theo nguồn dữ liệu bạn "cắm" vào. Bạn thậm chí đổi nguồn ngay lúc chạy bằng cách gán lại thuộc tính .data_source. Cách truyền phụ thuộc vào từ bên ngoài như vầy chính là tiêm phụ thuộc (dependency injection) - một kỹ thuật phổ biến đi kèm với DIP.

Trong dự án thật: DIP chính là nền của nhiều mẫu quen thuộc. Dependency Injection có sẵn trong FastAPI (qua Depends); Repository Pattern tách tầng nghiệp vụ khỏi cách lưu trữ cụ thể (đổi giữa PostgreSQL, MongoDB hay một API mà nghiệp vụ không hay biết); Service Layer phụ thuộc vào interface của repository chứ không dính trực tiếp vào SQLAlchemy hay Django ORM. Bản chất vẫn là cặp FrontEnd/DataSource ở trên, chỉ ở quy mô lớn hơn.
Cách rất Pythonic cho DIP và ISP: từ Python 3.8, typing.Protocol (PEP 544) cho phép structural subtyping (kiểu con theo cấu trúc, hay "duck typing có kiểm tra kiểu"). Thay vì bắt Database kế thừa một ABC, bạn khai báo một Protocol chỉ gồm các phương thức cần thiết (ví dụ get_data()); bất kỳ class nào có đủ những phương thức đó đều được coi là "khớp" mà không phải kế thừa gì. Cách này giữ được tinh thần duck typing của Python nhưng vẫn để công cụ như mypy bắt lỗi kiểu, và thường gọn hơn ABC.

DIP là nguyên tắc, DI là kỹ thuật

Hai thứ hay bị gộp làm một:
  • Dependency Inversion Principle (DIP) là một nguyên tắc thiết kế. Nó nói về hướng của phụ thuộc: module cấp cao và module cấp thấp cùng phụ thuộc vào một abstraction, thay vì cấp cao dính thẳng vào cấp thấp.
  • Dependency Injection (DI) là một kỹ thuật. Nó nói về cách một đối tượng nhận phụ thuộc của mình: truyền từ bên ngoài vào qua constructor, qua tham số hàm hay qua setter, thay vì tự khởi tạo bên trong.

DI là cách phổ biến nhất để đạt DIP, nhưng dùng DI không tự động nghĩa là bạn đã tuân thủ DIP. Nếu constructor của OrderService nhận vào đúng một class cụ thể StripeGateway, bạn vẫn đang tiêm phụ thuộc mà vẫn dính chặt vào Stripe: muốn đổi cổng thanh toán, hoặc muốn thay bằng bản giả lúc test, là phải sửa OrderService. Chỉ khi tham số đó mang kiểu trừu tượng PaymentGateway thì bạn mới thật sự đảo ngược phụ thuộc. Nói ngắn: DI trả lời "phụ thuộc đến từ đâu", DIP trả lời "phụ thuộc vào cái gì". Cùng ý này nhìn từ góc khác, tôi có viết riêng một bài về program to an interface, not an implementation.

Năm nguyên tắc gắn với nhau thế nào?

Ở trên tôi trình bày từng nguyên tắc riêng cho dễ theo dõi, nhưng trong thực tế chúng bổ trợ nhau chứ không rời rạc:

  • SRP tự nhiên dẫn tới ISP. Khi bạn chẻ trách nhiệm cho đúng, mỗi nhóm hành vi thành một giao diện nhỏ, chuyên biệt, thay vì một interface to ôm đủ thứ.
  • DIP là cơ chế chính để đạt OCP. Nhờ mọi thứ phụ thuộc vào trừu tượng, bạn thêm một cài đặt mới (class con, nguồn dữ liệu mới) mà không phải sửa code cũ, đúng tinh thần "mở để mở rộng, đóng với sửa đổi".
  • LSP bảo vệ tính đa hình mà OCP dựa vào. OCP chạy được là vì bạn "cắm" class con vào chỗ vốn dành cho class cha. Nếu class con phá vỡ hợp đồng (như bẫy Square/Rectangle), việc cắm đó sẽ vỡ và kéo OCP sụp theo.
SRP một trách nhiệm ISP giao diện nhỏ chẻ nhỏ DIP phụ thuộc trừu tượng LSP con thay được cha OCP mở rộng không sửa cơ chế đạt bảo vệ đa hình

Nói ngắn gọn: SRP và ISP lo cho việc chia nhỏ đúng chỗ; DIP và LSP lo cho việc ghép các mảnh lại một cách an toàn để có thể mở rộng.

Cạm bẫy thường gặp:
  • Áp SOLID quá đà. SOLID là nguyên tắc, không phải luật. Nhồi năm nguyên tắc vào một script nhỏ có thể đẻ ra cả rừng interface và class chỉ để làm một việc tầm thường - over-engineering còn hại hơn cả code "xấu" nhưng đơn giản. Áp khi độ phức tạp thực sự đòi hỏi.
  • Nhầm SRP là "một phương thức". Một trách nhiệm gắn với một lý do để thay đổi, không phải đếm số phương thức. Một class có mười phương thức vẫn có thể chỉ có một trách nhiệm.
  • Bẫy Square/Rectangle của LSP. Quan hệ "là một" (is-a) trong toán học không đảm bảo quan hệ kế thừa hợp lệ trong code. Nếu class con làm hẹp đi hành vi mà class cha đã hứa, đó là vi phạm LSP - dù nghe rất "hợp lý".
  • Đảo ngược phụ thuộc không phải là "cứ thêm một interface". Trừu tượng chỉ đáng tạo khi thực sự có nhiều cài đặt hoặc bạn cần cô lập sự thay đổi. Một interface với đúng một class triển khai duy nhất, mãi mãi, thường chỉ là tầng gián tiếp thừa.

Khi nào KHÔNG cần áp đủ SOLID?

SOLID sinh lời khi code sống lâu và còn phải mở rộng. Với những thứ nhỏ, ngắn hạn thì áp đủ năm nguyên tắc thường lỗ nhiều hơn lãi:

  • Script tự động hoá vài chục dòng, chạy một lần rồi bỏ.
  • Prototype hay bản thử nghiệm chỉ để kiểm chứng ý tưởng.
  • Tool nội bộ ngắn hạn, ít người dùng, ít khả năng thay đổi.
  • CRUD đơn giản chưa có luật nghiệp vụ phức tạp: thêm tầng trừu tượng lúc này chỉ tổ rối.

Nguyên tắc thực dụng: viết cho chạy trước, rồi tái cấu trúc theo SOLID khi thấy "mùi" (sửa một chỗ vỡ nhiều chỗ, class phình to, đổi thư viện mà phải sửa khắp nơi). Đừng trả giá trừu tượng trước khi thật sự cần.

Góc nhìn Python: năm nguyên tắc không "nặng" như nhau khi làm backend Python (FastAPI, Django, Flask). Theo kinh nghiệm của tôi: SRP và DIP đáng đầu tư nhất (DIP giúp test dễ nhờ thay thế phụ thuộc bằng bản giả); OCP cần tới khi hệ thống bắt đầu mở rộng; ISP dùng vừa phải; còn LSP ít khi phải nghĩ trực tiếp vì duck typing của Python thường giấu bớt vấn đề kiểu, nhưng nó vẫn vỡ nếu class con phá vỡ hành vi mà nơi gọi mong đợi.

SOLID trong code backend thật

Ví dụ hình học dễ hiểu nhưng hơi xa việc hằng ngày. Đây là những chỗ tôi thực sự chạm vào năm nguyên tắc này khi viết backend:

  • SRP ở tầng service và repository. Một hàm create_order() vừa truy vấn dữ liệu, vừa tính luật nghiệp vụ, vừa gửi email xác nhận là ba lý do để thay đổi nằm chung một chỗ. Tách ra: repository lo đọc ghi dữ liệu, service lo nghiệp vụ, notifier lo thông báo. Đổi nhà cung cấp email thì chỉ notifier phải sửa, service không biết cũng chẳng sao.
  • OCP khi cắm thêm cổng thanh toán hay kênh thông báo. Nếu handler là một chuỗi if provider == "momo" rồi elif provider == "vnpay", thêm cổng thứ ba là lại mở đúng file cũ ra sửa, kéo theo rủi ro cho hai cổng đang chạy tốt. Cho mỗi cổng một class riêng cùng một interface rồi tra trong registry, thêm cổng mới chỉ là thêm một file. Đây cũng chính là Strategy Pattern ở quy mô production.
  • LSP khi viết nhiều cài đặt cho cùng một interface storage. LocalStorage và S3Storage cùng cài save(): nếu bản local ném FileNotFoundError còn bản S3 ném một lỗi hoàn toàn khác kiểu cho cùng một tình huống, thì nơi gọi bắt lỗi kiểu nào cũng sai một nửa. Hợp đồng không chỉ là tên method và kiểu trả về, nó gồm cả lỗi được phép ném ra và các điều kiện biên.
  • ISP khi interface repository phình to. Một Repository ôm đủ get, list, create, update, delete, bulk_import, archive sẽ bắt cả những cài đặt chỉ đọc (ví dụ repository lấy dữ liệu từ API bên thứ ba) phải viết một đống method chỉ để ném NotImplementedError. Tách thành ReadOnlyRepository và WritableRepository là hết chuyện.
  • DIP để test không cần mạng. Service phụ thuộc vào một PaymentGateway trừu tượng: chạy thật thì tiêm bản gọi API nhà cung cấp, chạy test thì tiêm một FakeGateway trả về kết quả định sẵn. Không có DIP, muốn test một luồng đặt hàng là phải dựng cả sandbox bên ngoài và cầu cho nó không sập.

Trade-off

SOLID không miễn phí. Nói cho sòng phẳng thì đây là hai mặt của nó.

Được:

  • Chỗ thay đổi được khoanh gọn: sửa một tính năng chỉ đụng một hai file, không phải rà cả module rồi hồi hộp chờ deploy.
  • Dễ test: phụ thuộc là abstraction nên thay bằng test double (fake, stub) là chạy được, không cần database hay mạng thật.
  • Thay cài đặt mà không đụng logic: đổi lưu trữ từ local sang S3, đổi nguồn dữ liệu từ database sang API, phần nghiệp vụ giữ nguyên.
  • Review code có tiêu chí chung: thay vì "tôi thấy nó xấu", người review gọi được đúng tên vấn đề, kiểu "class này có hai lý do để thay đổi" hay "interface này bắt cài đặt viết method thừa".

Phải trả giá:

  • Áp máy móc sinh ra cả rừng interface chỉ có đúng một cài đặt và mãi mãi chỉ một: đọc code phải nhảy thêm một lớp mà chẳng đổi được gì.
  • Tách quá nhỏ làm luồng khó đọc: một request đi qua bảy class, muốn hiểu đầu đuôi phải mở bảy file.
  • SRP rất dễ bị hiểu sai thành "một class một method", kết quả là hàng chục class một dòng chẳng nói lên điều gì.
  • Abstraction cũng là code phải bảo trì: yêu cầu đổi thì interface đổi theo, và một abstraction đặt sai chỗ còn khó gỡ hơn một đoạn code trùng lặp.
  • Với script chạy một lần hay prototype ngắn, SOLID gần như chỉ là chi phí: viết thẳng, chạy được, xoá đi, thế là xong.

Tóm tắt

Tuân theo SOLID mang lại vài lợi ích rõ ràng:

  • Linh hoạt hơn - thêm tính năng mới mà không phá vỡ chức năng cũ; dùng trừu tượng để giảm sự dính chặt (coupling) giữa các phần.
  • Tái sử dụng tốt hơn - các class và giao diện tập trung một trách nhiệm dễ tái dùng trong nhiều ngữ cảnh.
  • Tổ chức code tốt hơn - chia thành các module nhỏ, dễ hiểu, dễ test.
  • Ít lỗi hơn - mở rộng bằng cách thêm code mới thay vì sửa code cũ, nên giảm nguy cơ làm vỡ thứ đang chạy.

Nhớ nhanh năm chữ: SRP (một class, một lý do đổi) · OCP (mở để mở rộng, đóng với sửa đổi) · LSP (class con thay được class cha) · ISP (giao diện nhỏ, chuyên biệt) · DIP (phụ thuộc vào trừu tượng). Đừng thờ phụng chúng một cách máy móc - hãy dùng chúng như la bàn để nhận ra khi nào thiết kế đang bắt đầu "có mùi".

Năm nguyên tắc này là nền cho mọi mẫu thiết kế trong series Design Patterns. Nếu muốn thấy ngay một ví dụ về chuyện áp nguyên tắc sai chỗ thì đọc tiếp Singleton và vì sao nó hay bị làm sai.

Nguồn tham khảo

- Kai

Thấy bài viết hữu ích?

0 lượt thích

Đăng nhận xét