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

Composite Pattern: xử lý một đối tượng và cả một cụm theo cùng một cách

TL;DR: Composite sắp xếp các đối tượng thành một cấu trúc cây dạng bộ phận - toàn thể (part-whole), rồi cho client xử lý một đối tượng lá (leaf) và một cụm nhiều đối tượng (composite) qua cùng một interface. Nhờ đệ quy (recursion), gọi size() trên cả cây cũng viết y hệt như gọi trên một file lẻ. Hợp nhất khi dữ liệu tự nhiên có dạng cây; gượng ép khi cấu trúc không thật sự phân cấp.

Bạn từng viết code kiểu này chưa: có một danh sách gồm cả "món lẻ" lẫn "nhóm món", và để tính tổng bạn phải hỏi if từng phần tử "mày là món lẻ hay là nhóm?" rồi rẽ hai nhánh xử lý khác nhau. Càng lồng sâu, đống if/else càng rối. Composite sinh ra để xoá cái phân biệt đó: lá và cụm nhìn giống nhau trong mắt client, nên bạn chỉ viết một lối xử lý duy nhất.

Composite là gì

Composite là một pattern thuộc nhóm cấu trúc (Structural). Ý tưởng gốc chỉ có một câu: gom các đối tượng vào một cây, trong đó có hai loại nút. Nút lá (leaf) là phần tử cơ bản, không chứa gì bên trong. Nút cụm (composite) là phần tử chứa các nút con, mà con lại có thể là lá hoặc cụm khác. Điểm mấu chốt: cả hai loại nút đều cài đặt cùng một interface, nên client gọi method mà không cần biết đang cầm lá hay cụm.

Hình ảnh dễ nhất là cây thư mục trong máy bạn. Một file là lá: nó có dung lượng cố định, không chứa gì thêm. Một folder là cụm: nó chứa file và folder con khác. Khi bạn hỏi "folder này nặng bao nhiêu?", câu trả lời là cộng dung lượng của mọi thứ bên trong, mà "mọi thứ bên trong" lại có thể là folder con, nên phải cộng tiếp xuống nữa. Đó chính là đệ quy: dung lượng một cụm = tổng dung lượng các con, và mỗi con tự biết trả lời câu hỏi dung lượng của chính nó.

Một ví dụ khác cùng bản chất là sơ đồ tổ chức công ty: một nhân viên là lá, một phòng ban là cụm chứa nhân viên và phòng ban con. Muốn đếm tổng số người của cả một khối, bạn cộng dồn xuống theo đúng cách như vậy.

Vấn đề khi không có Composite

Giả sử bạn không dùng Composite, mà để file và folder là hai kiểu tách rời, không chung interface. Lúc tính dung lượng, client buộc phải phân biệt từng phần tử:

# Cach lam roi: client phai tu phan biet la vs cum
def total_size(node):
    if isinstance(node, File):
        return node.kb
    elif isinstance(node, Folder):
        s = 0
        for child in node.children:
            s += total_size(child)   # lai phai goi de quy thu cong
        return s
    else:
        raise TypeError("khong biet xu ly kieu nay")

Đoạn này chạy được, nhưng nó dồn hết trách nhiệm lên client. Mỗi khi thêm một loại nút mới (ví dụ "shortcut" hay "file nén"), bạn phải quay lại sửa total_size và mọi hàm khác từng phân biệt kiểu như vậy. Logic "đi xuống cây" bị lặp ở khắp nơi và dễ sót nhánh. Bản chất vấn đề: client phải biết cấu trúc bên trong của cây, trong khi lẽ ra nó chỉ nên hỏi "nặng bao nhiêu?" và nhận câu trả lời.

Cách hoạt động

Composite giải quyết bằng cách để chính các nút tự chịu trách nhiệm. Ta khai báo một interface chung (ở đây là Node) với method size(). File cài đặt size() bằng cách trả về dung lượng của nó. Folder cài đặt size() bằng cách cộng size() của các con. Vì mỗi con cũng là một Node, lời gọi lan xuống toàn cây một cách đệ quy mà client không cần biết.

from abc import ABC, abstractmethod

class Node(ABC):                      # interface chung cho ca la lan cum
    def __init__(self, name):
        self.name = name
    @abstractmethod
    def size(self):                  # tra ve dung luong (KB)
        ...
    @abstractmethod
    def show(self, indent=0):        # in cay
        ...

class File(Node):                    # LA: khong chua gi ben trong
    def __init__(self, name, kb):
        super().__init__(name)
        self._kb = kb
    def size(self):
        return self._kb
    def show(self, indent=0):
        print(" " * indent + f"- {self.name} ({self._kb} KB)")

class Folder(Node):                  # COMPOSITE: chua File hoac Folder khac
    def __init__(self, name):
        super().__init__(name)
        self._children = []
    def add(self, node):
        self._children.append(node)
        return self
    def size(self):                  # cong de quy moi thu ben trong
        return sum(child.size() for child in self._children)
    def show(self, indent=0):
        print(" " * indent + f"+ {self.name}/ ({self.size()} KB)")
        for child in self._children:
            child.show(indent + 2)

# Dung cay thu muc
root = Folder("du_an")
root.add(File("README.md", 3))
src = Folder("src")
src.add(File("main.py", 12))
src.add(File("utils.py", 8))
img = Folder("assets")
img.add(File("logo.png", 40))
img.add(File("banner.jpg", 120))
src.add(img)
root.add(src)

# Client xu ly la va cum theo CUNG mot cach
root.show()
print()
print("Tong dung luong du_an:", root.size(), "KB")
print("Rieng src:", src.size(), "KB")
+ du_an/ (183 KB) - README.md (3 KB) + src/ (180 KB) - main.py (12 KB) - utils.py (8 KB) + assets/ (160 KB) - logo.png (40 KB) - banner.jpg (120 KB) Tong dung luong du_an: 183 KB Rieng src: 180 KB

Để ý dòng cuối: root.size() và src.size() được gọi y hệt nhau, dù root là cây to nhiều tầng còn src là một nhánh nhỏ hơn. Đó là cái lợi lớn nhất của Composite: client không phân biệt lá với cụm. Bạn cũng có thể gọi size() trực tiếp trên một File, nó vẫn hợp lệ vì File cùng interface Node.

Cái đẹp nằm ở Folder.size(): nó chỉ cộng child.size() mà không cần biết child là file hay folder. Nếu là folder con, lời gọi tự đi sâu thêm một tầng. Toàn bộ vòng lặp if/else phân loại ở phần trước biến mất, thay bằng một dòng sum đệ quy gọn gàng. Đây cũng là lúc pattern này gặp lại hai nguyên tắc nền: các nút được ghép vào nhau (composition) và giao tiếp qua một interface chung. Nếu bạn chưa đọc, tôi có nói kỹ ở bài Program to interface & Composition over inheritance.

Khi nào nên và khi nào không

Dùng Composite khi thoả cả hai điều: dữ liệu của bạn tự nhiên có dạng cây phân cấp (cây thư mục, menu nhiều tầng, cây danh mục sản phẩm, cấu trúc DOM, biểu thức toán học lồng nhau), và bạn muốn xử lý lá với cụm đồng nhất qua một số thao tác chung (tính tổng, in ra, render, tìm kiếm). Khi hai điều này đúng, Composite xoá sạch đống if phân loại và cho phép thêm loại nút mới mà không sửa client.

Đừng ép Composite khi cấu trúc không thật sự phân cấp. Nếu dữ liệu của bạn chỉ là một danh sách phẳng, hoặc quan hệ giữa các phần tử là mạng lưới lộn xộn chứ không phải cây cha - con rõ ràng, gò nó vào Composite chỉ thêm tầng trừu tượng vô ích mà chẳng được gì.

Một cạm bẫy nữa nằm ở interface chung. Để lá và cụm thật sự thay thế được cho nhau, nhiều người nhét cả những method chỉ hợp với cụm (như add(), remove()) vào interface chung. Hậu quả: một File cũng lòi ra method add(), mà gọi add() lên một file thì vô nghĩa. Bạn phải chọn giữa hai hướng, và mỗi hướng có giá của nó:

  • Đặt add()/remove() ở interface chung: lá và cụm hoàn toàn đồng nhất, client không bao giờ phải ép kiểu. Đổi lại, lá phải cài đặt các method vô nghĩa đó (thường là ném lỗi hoặc bỏ trống), tức là sự an toàn kiểu bị nới lỏng.
  • Chỉ đặt add()/remove() ở cụm (như ví dụ trên của tôi): lá sạch sẽ, không có method thừa. Đổi lại, khi cần thêm con, client phải biết mình đang cầm một cụm. Đây là lựa chọn tôi thích hơn cho phần lớn trường hợp vì nó trung thực với thực tế: chỉ folder mới chứa được thứ khác.

Trong hệ thống thật

Cây thư mục là ví dụ dễ hình dung nhất, nhưng trong hệ thống thật Composite xuất hiện ở nhiều chỗ khác, thường là những chỗ bạn dùng nó mà không gọi tên nó ra:

  • Cây danh mục sản phẩm: một sàn thương mại điện tử có "Điện tử" chứa "Điện thoại" chứa "Điện thoại Android", và lá là sản phẩm cụ thể. Câu hỏi "doanh thu tháng này của ngành hàng Điện tử là bao nhiêu?" chính là một revenue() đệ quy: lá trả về doanh thu của chính nó, nút cụm cộng doanh thu các con.
  • Cây tổ chức phòng ban: khối chứa phòng, phòng chứa nhóm, nhóm chứa nhân viên. Đếm tổng nhân sự hay cộng quỹ lương của cả một khối đều là cùng một phép đệ quy, và nó chạy y hệt nhau dù bạn hỏi ở cấp khối hay cấp nhóm.
  • Cây bình luận nhiều tầng: một comment là lá khi chưa ai trả lời, và thành cụm ngay khi có reply, mà reply lại có reply. Render cả luồng, đếm tổng số phản hồi, hay ẩn cả nhánh khi xoá comment gốc: viết một lần, dùng cho mọi tầng.
  • Cây quyền và nhóm người dùng: một nhóm chứa người dùng, và chứa cả nhóm con. Khi kiểm tra "user này có quyền invoice.delete không?", bạn hỏi đệ quy xuống các nhóm con thay vì phải liệt kê phẳng toàn bộ thành viên. Nhớ chặn nhóm lồng vòng (A chứa B, B chứa A), vì đệ quy sẽ chạy mãi nếu không đánh dấu nút đã thăm.
  • Cây điều kiện lọc: màn hình tìm kiếm nâng cao, nơi một nút AND hoặc OR chứa các điều kiện con, mà con lại có thể là một nhóm AND/OR khác. Gọi evaluate(row) ở nút gốc là cả cây tự chạy xuống. Đây cũng là chỗ Composite gặp Interpreter: cây biểu thức là phần Composite, còn việc diễn giải cây đó thành kết quả là phần Interpreter.
  • Quét dung lượng cây thư mục thật: các công cụ kiểu du, WinDirStat hay ncdu đi đúng cây thư mục và cộng dồn hệt như ví dụ ở trên.
  • Cây component trong UI: DOM của trình duyệt, cây widget của Flutter, cây component của React. Một div chứa các nút con, và thao tác render hay đo kích thước lan xuống đệ quy qua cả cây.
Lưu ý cho backend: cây nằm trong cơ sở dữ liệu quan hệ. Phần lớn cây kể trên không có sẵn trong bộ nhớ, chúng nằm trong một bảng với cột parent_id. Nếu bạn dựng Composite rồi để mỗi nút tự đi tìm con của mình lúc duyệt, mỗi lần gọi size() sẽ bắn thêm một truy vấn, và một cây vài nghìn nút thành vài nghìn truy vấn: đúng bài N+1 truy vấn. Cách xử lý là tải cả cây trong một lần rồi mới dựng Composite trong bộ nhớ, bằng truy vấn đệ quy (WITH RECURSIVE có trong PostgreSQL, MySQL 8, SQLite) hoặc bằng cách lưu khác như materialized path (/1/7/23/) và nested set. Composite lo phần cấu trúc trong bộ nhớ, nó không lo giùm bạn phần truy vấn.

Trade-off

Composite trả cho bạn sự đồng nhất ở phía client, và lấy lại bằng một interface chung lỏng hơn cùng vài rủi ro của đệ quy. Cụ thể:

Được:

  • Client xử lý lá và cụm hoàn toàn giống nhau, nên mọi đoạn if isinstance(node, Folder) ở phía gọi biến mất.
  • Thêm loại nút mới không phải đụng vào code duyệt: nút mới chỉ cần cài đúng interface Node là mọi hàm cũ chạy được với nó.
  • Đệ quy diễn đạt bài toán dạng cây rất tự nhiên: "kích thước của cụm bằng tổng kích thước các con" đọc gần như đúng câu định nghĩa bằng tiếng Việt.
  • Mọi nhánh đều là một cây hợp lệ, nên bạn lôi src ra dùng và test độc lập y như dùng root.

Phải trả giá:

  • Interface chung bị kéo về mẫu số chung: muốn lá và cụm thay thế được nhau tuyệt đối thì lá phải mang những method vô nghĩa với nó, như add() hay remove(), rồi cài đặt chúng bằng cách ném lỗi.
  • Dễ nuốt lỗi kiểu: khi mọi thứ đều là Node, bạn ghép được bất cứ gì vào bất cứ đâu. Ràng buộc kiểu "chỉ danh mục lá mới được chứa sản phẩm" không còn ai chặn giúp, bạn phải tự kiểm tra lúc chạy.
  • Đệ quy sâu có thể tràn ngăn xếp (Python mặc định giới hạn quanh 1000 mức) hoặc chạy chậm nếu mỗi câu hỏi lại quét lại cả cây. Lúc đó phải chuyển sang duyệt bằng vòng lặp với ngăn xếp tường minh, hoặc cache kết quả ở nút cụm và nhớ xoá cache khi cây đổi.
  • Với dữ liệu nằm ở cơ sở dữ liệu, như đã nói ở trên, rất dễ dính N+1 truy vấn nếu dựng cây một cách hồn nhiên.

Nếu bạn muốn tách hẳn việc duyệt cây ra khỏi cấu trúc cây, để client chỉ cần for node in tree mà không quan tâm duyệt theo chiều sâu hay chiều rộng, đó là việc của Iterator. Composite và Iterator đi với nhau rất hợp: một bên dựng cây, một bên đi trên cây.

Tóm tắt

  • Composite tổ chức đối tượng thành cây bộ phận - toàn thể, gồm nút lá (không chứa gì) và nút cụm (chứa các con).
  • Cả lá và cụm cùng một interface, nên client xử lý một đối tượng và cả một cụm theo cùng một cách, nhờ đệ quy.
  • Nó xoá đống if phân loại "lá hay cụm" ở phía client, và cho thêm loại nút mới mà không sửa code gọi.
  • Hợp khi dữ liệu tự nhiên có dạng cây; gượng khi cấu trúc không phân cấp thật sự.
  • Cân nhắc kỹ interface chung: nhét add() vào lá cho đồng nhất, hay giữ lá sạch và chấp nhận client phải biết đâu là cụm.

Nguồn tham khảo

  • Gamma, Helm, Johnson, Vlissides (Gang of Four), Design Patterns: Elements of Reusable Object-Oriented Software, Addison-Wesley, 1994 - chương Composite, mục Structural Patterns.
Series Design Patterns - nhóm Cấu trúc (Structural). Composite là một mẫu trong nhóm này. Nếu cần ôn nền tảng: Program to interface & Composition over inheritance và Lập trình hướng đối tượng là gì?. Xem toàn bộ lộ trình ở mục lục Design Patterns.

- Kai

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

0 lượt thích

Đăng nhận xét