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

Builder Pattern: dựng đối tượng phức tạp từng bước, hết cảnh nhồi tham số

TL;DR: Builder là mẫu Creational giúp bạn dựng một đối tượng phức tạp từng bước, tách quá trình dựng khỏi biểu diễn cuối. Nó thay cho kiểu hàm khởi tạo nhồi cả chục tham số optional (telescoping constructor) khó đọc, dễ nhầm thứ tự. Bạn gọi .set_x().set_y().build() đọc rõ như đặt món. Nhưng lưu ý: trong Python nhiều khi @dataclass cộng keyword arguments đã đủ, chỉ cần Builder khi có nhiều bước, validation hoặc nhiều biến thể build.

Bạn đã bao giờ nhìn một dòng gọi hàm kiểu Pizza("L", True, False, True, False) và phải đếm ngón tay xem cái True thứ hai là "nấm" hay "thịt xông khói" chưa? Đó là dấu hiệu bạn đang cần một cách dựng đối tượng tử tế hơn. Bài này nói về Builder: mẫu thiết kế sinh ra để chữa đúng cơn đau đó.

Builder là gì?

Builder (tạm dịch: "người dựng") là một mẫu thuộc nhóm Creational (khởi tạo). Ý tưởng gọn: thay vì tạo xong đối tượng trong một lời gọi duy nhất với đủ mọi tham số, bạn dựng nó từng bước, khai báo từng phần một, rồi mới "chốt" ra sản phẩm cuối. Nói cách khác, Builder tách quá trình dựng ra khỏi biểu diễn cuối cùng của đối tượng.

Hình dung việc gọi món ở quán. Bạn không hét một tràng "cho tôi cỡ lớn có phô mai không nấm có thịt không ô liu" để nhân viên tự hiểu. Bạn nói từng phần: chọn cỡ, thêm phô mai, thêm thịt, ghi chú nướng kỹ, rồi cuối cùng "chốt đơn". Mỗi bước là một câu rõ ràng, và chỉ khi bạn chốt thì món mới thật sự được làm. Builder trong code hoạt động y hệt: mỗi bước cấu hình một phần, và build() chính là lúc "chốt đơn".

Vấn đề: telescoping constructor

Trước khi thấy Builder đẹp ở đâu, phải thấy cái xấu nó thay thế. Giả sử bạn có class Pizza với nhiều tuỳ chọn, phần lớn là optional. Cách ngây thơ là nhét hết vào hàm khởi tạo:

class PizzaBad:
    def __init__(self, size, cheese=False, mushroom=False, bacon=False, olive=False):
        self.size = size
        self.cheese = cheese
        self.mushroom = mushroom
        self.bacon = bacon
        self.olive = olive

# Goi ra: mot day True/False, khong ai doc noi thu tu
p = PizzaBad("L", True, False, True, False)

Dòng PizzaBad("L", True, False, True, False) là một cơn ác mộng khi đọc. Cái True đầu là gì? False ở giữa là "nấm" hay "thịt"? Muốn biết phải nhảy về xem lại chữ ký hàm. Thêm một tuỳ chọn mới (vd "ớt") là cả codebase phải sửa lại các lời gọi. Đây gọi là telescoping constructor (hàm khởi tạo phình dần theo số tham số optional): càng nhiều tuỳ chọn, chữ ký càng dài, lời gọi càng tối nghĩa và càng dễ đặt sai thứ tự.

Builder hoạt động thế nào?

Builder tách phần "thu thập cấu hình" ra một class riêng. Mỗi method cấu hình trả về chính nó (return self) để bạn nối chuỗi lời gọi lại, gọi là method chaining (nối chuỗi method) hay phong cách fluent (trôi chảy). Đến khi gọi build(), nó mới kiểm tra hợp lệ (validation) rồi tạo ra đối tượng thật:

class Pizza:
    def __init__(self, size, toppings, note):
        self.size = size
        self.toppings = toppings
        self.note = note
    def __str__(self):
        tp = ", ".join(self.toppings) or "khong topping"
        extra = f" (ghi chu: {self.note})" if self.note else ""
        return f"Pizza {self.size}: {tp}{extra}"

class PizzaBuilder:
    def __init__(self):
        self._size = "M"          # gia tri mac dinh hop ly
        self._toppings = []
        self._note = ""

    def size(self, s):            # moi buoc tra ve self de noi chuoi
        self._size = s
        return self

    def add(self, topping):
        self._toppings.append(topping)
        return self

    def note(self, text):
        self._note = text
        return self

    def build(self):              # chot don: kiem tra roi tao doi tuong that
        if self._size not in ("S", "M", "L"):
            raise ValueError(f"Size khong hop le: {self._size}")
        if len(self._toppings) > 5:
            raise ValueError("Toi da 5 topping")
        return Pizza(self._size, list(self._toppings), self._note)

# Goi ra doc nhu dat mon: tung buoc ro rang, khong so nham thu tu
pizza = (PizzaBuilder()
         .size("L")
         .add("cheese")
         .add("bacon")
         .note("nuong ky")
         .build())
print(pizza)

# Bo qua buoc nao cung duoc, phan con lai lay mac dinh
plain = PizzaBuilder().add("olive").build()
print(plain)
Pizza L: cheese, bacon (ghi chu: nuong ky) Pizza M: olive

So với dãy True, False, True, False lúc nãy, chuỗi .size("L").add("cheese").add("bacon").note("nuong ky").build() tự giải thích: mỗi bước có tên, đọc là hiểu, và không có chuyện đặt nhầm thứ tự tham số. Builder còn gánh giúp hai việc:

  • Giá trị mặc định gọn. Bỏ qua bước nào thì phần đó lấy mặc định (cỡ M, không ghi chú), không phải truyền None lằng nhằng.
  • Validation tập trung. Mọi kiểm tra dồn vào build(). Đối tượng Pizza chỉ ra đời khi đã hợp lệ, nên phần còn lại của code không phải phòng thủ với trạng thái nửa vời.

Builder khác fluent API

Hai khái niệm này hay đi cùng nhau nên rất nhiều người đồng nhất chúng, nhưng chúng nằm ở hai tầng khác hẳn.

Fluent API chỉ là một phong cách gọi hàm: mỗi method trả về self để bạn nối chuỗi lời gọi. Nó dùng được cho bất cứ thứ gì, kể cả query builder hay một đối tượng cấu hình mà bạn sửa tại chỗ, không nhất thiết phải dựng ra một đối tượng thành phẩm nào.

Builder là một pattern với ý định cụ thể: tách quá trình dựng ra khỏi đối tượng thành phẩm, dựng từng bước rồi build() ra sản phẩm cuối, thường kèm kiểm tra hợp lệ ở bước chốt.

Nghĩa là Builder không bắt buộc phải fluent. Đoạn dưới vẫn là Builder đầy đủ dù không method nào trả về self:

class ReportBuilder:
    def __init__(self):
        self._title = ""
        self._lines = []

    def set_title(self, t):       # khong return self: van la Builder
        self._title = t

    def add_line(self, line):
        self._lines.append(line)

    def build(self):              # buoc chot: validate roi tao san pham
        if not self._title:
            raise ValueError("Bao cao phai co tieu de")
        return self._title + "\n" + "\n".join(self._lines)

b = ReportBuilder()
b.set_title("Bao cao thang 9")
b.add_line("- Doanh thu: 120")
b.add_line("- Chi phi: 80")
print(b.build())
Bao cao thang 9 - Doanh thu: 120 - Chi phi: 80
Chốt: Builder hay được viết theo phong cách fluent vì đọc sướng hơn, nhưng fluent không tự động là Builder, và Builder cũng có thể không fluent (gọi từng method set rồi build()). Thứ quyết định là ý định tách quá trình dựng khỏi sản phẩm, không phải cái dấu chấm nối chuỗi.

Khi nào dùng, khi nào KHÔNG nên

Đây là phần quan trọng nhất, vì Builder rất dễ bị lạm dụng trong Python. Trong Python thường bạn không cần Builder đầy đủ như trên. Python có keyword arguments (tham số gọi theo tên) và @dataclass, hai thứ này đã giải quyết phần lớn nỗi đau telescoping constructor:

from dataclasses import dataclass, field

@dataclass
class HttpRequest:
    url: str
    method: str = "GET"
    headers: dict = field(default_factory=dict)
    timeout: int = 30

# Goi theo ten: ro rang, khong lo thu tu, bo qua duoc cai co mac dinh
req = HttpRequest(url="https://thuandv.top", method="POST", timeout=10)
print(req)
HttpRequest(url='https://thuandv.top', method='POST', headers={}, timeout=10)

Nhìn HttpRequest(url=..., method="POST", timeout=10): đã rõ như Builder, mà không cần viết thêm một class builder nào. Vì gọi theo tên nên thứ tự không còn quan trọng, và tham số có mặc định thì bỏ qua thoải mái. Với đa số đối tượng cấu hình, dataclass cộng keyword args là đủ, đừng đẻ thêm Builder cho mệt.

Vậy khi nào Builder mới thật sự đáng? Khi việc dựng có tính "quá trình", chứ không chỉ là gán một mớ trường:
  • Có nhiều bước và bước lặp lại. Như add() gọi nhiều lần để dồn dần vào một danh sách, hay dựng cây/truy vấn theo từng nhánh. Kiểu này keyword args không diễn đạt gọn được.
  • Cần validation phức tạp lúc chốt. Khi các trường ràng buộc lẫn nhau và bạn muốn kiểm tra một lần ở build(), đảm bảo đối tượng ra đời là luôn hợp lệ.
  • Có nhiều biến thể build. Cùng một quá trình dựng nhưng cho ra vài dạng sản phẩm khác nhau, hoặc cần tái dùng cấu hình rồi build ra nhiều đối tượng.

Ngược lại, KHÔNG nên dùng Builder khi: đối tượng đơn giản, chỉ vài trường; hoặc trường hợp mà @dataclass và keyword args đã lo xong. Thêm một class builder lúc đó chỉ là tầng trừu tượng thừa, nhiều code hơn mà không đổi lại được gì. Giống mọi pattern khác, chỉ áp dụng khi cơn đau (chữ ký phình, dựng nhiều bước, validation rối) đã thật sự xuất hiện.

Trong hệ thống thật

Bỏ pizza sang một bên, đây là những chỗ bạn gặp Builder (hoặc ít nhất là tinh thần của nó) trong code thật:

  • Query builder của SQLAlchemy. Chuỗi select(User).where(User.age > 18).order_by(User.name) là phong cách fluent quen thuộc nhất với dev Python. Mỗi bước bồi thêm một mảnh vào truy vấn, và câu SQL chỉ thật sự được dựng khi đem đi thực thi.
  • Dựng một request HTTP phức tạp. Khi một lần gọi cần gắn header, chính sách retry, timeout, auth rồi mới gửi đi, gộp hết vào một lời gọi là không đọc nổi. Dựng từng bước rồi send() thì rõ hơn nhiều.
  • Đối tượng cấu hình nhiều lớp. Cấu hình thật thường gồm bốn tầng chồng lên nhau: giá trị mặc định, file cấu hình, biến môi trường, tham số dòng lệnh. Mỗi tầng là một bước đổ thêm vào builder, rồi build() validate một lần duy nhất trước khi app khởi động.
  • Test data builder. Trong test, thay vì chép đi chép lại một đối tượng mẫu đầy đủ trường, bạn viết UserBuilder().with_email("a@b.com").build(): mặc định lo phần còn lại, test chỉ nói đúng thứ nó quan tâm. Đây là chỗ Builder lãi nhất mà ít người nghĩ tới.
  • Dựng tài liệu hoặc báo cáo nhiều phần. Một file PDF, một email HTML hay một báo cáo được góp dần theo từng khối (tiêu đề, bảng, biểu đồ, chân trang), rồi mới kết xuất một lần ở cuối.

Trade-off

Builder không miễn phí. Đây là hai mặt của nó để bạn cân trước khi viết thêm một class:

Được:

  • Chỗ gọi đọc ra ý nghĩa thay vì một dãy tham số trần trụi, không phải nhảy về xem lại chữ ký hàm.
  • Gom toàn bộ kiểm tra hợp lệ về một chỗ là build(), nên đối tượng đã ra đời là luôn hợp lệ.
  • Dựng dần theo nhiều nhánh điều kiện rất dễ: cứ if rồi gọi thêm một bước, không phải bày một đống biến tạm trước đó.
  • Sản phẩm có thể bất biến (immutable) vì mọi thứ được chốt đúng một lần lúc build.

Phải trả giá:

  • Thêm hẳn một class phải bảo trì song song với sản phẩm. Thêm một trường là sửa hai nơi.
  • Trạng thái dựng dở dang nằm trong builder có thể bị dùng nhầm, hoặc bị chia sẻ giữa hai lần build mà bạn không để ý.
  • Trong Python, Builder thường bị @dataclass cộng tham số từ khoá đánh bại về độ gọn. Đây là lý do chính khiến nó hay trở thành over-engineering.
  • Quên gọi build() là lỗi rất dễ mắc: bạn cầm về cái builder thay vì sản phẩm, và thường chỉ vỡ ra ở tận runtime.

Tóm tắt

  • Builder dựng một đối tượng phức tạp từng bước và tách quá trình dựng khỏi biểu diễn cuối, thay cho telescoping constructor khó đọc.
  • Cơ chế: mỗi method cấu hình return self để nối chuỗi (fluent), build() là nơi validate rồi tạo đối tượng thật.
  • Lợi ích: lời gọi tự giải thích, mặc định gọn, validation tập trung, đối tượng ra đời là hợp lệ.
  • Trong Python thường @dataclass cộng keyword arguments đã đủ. Chỉ dùng Builder khi có nhiều bước, validation phức tạp hoặc nhiều biến thể build. Đối tượng đơn giản thì đừng over-engineer.
Series Design Patterns. Bài này thuộc nhóm Creational, đọc cùng Factory Method để thấy hai cách khác nhau để giấu việc khởi tạo. Nếu bạn chưa nắm nền tảng, đọc lại DRY và SOLID trước. 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