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

Facade Pattern: một cửa vào gọn cho hệ thống con rắc rối

TL;DR: Facade (mặt tiền) là một class đứng trước một hệ thống con phức tạp và cho client một giao diện đơn giản, thống nhất. Thay vì phải biết cả chục class và đúng trình tự gọi bên trong, client chỉ gọi một hai method. Mục tiêu: giảm sự lệ thuộc (coupling) giữa client và mớ chi tiết bên trong, tạo một điểm vào gọn gàng.

Bạn từng mở một thư viện xử lý ảnh, video hay thanh toán rồi thấy cả rừng class, mỗi việc nhỏ phải gọi qua bốn năm bước theo đúng thứ tự? Client viết một lần thì còn được, viết mười chỗ là mười lần lặp lại cái trình tự đó, và hễ thư viện đổi bên trong là cả mười chỗ vỡ. Facade sinh ra để dẹp đúng nỗi đau này. Bài này tôi sẽ đi từ ý tưởng gốc tới một ví dụ Python chạy được.

Facade là gì

Facade (đọc là "fơ-xát", nghĩa đen là "mặt tiền") là một class trung gian. Nó gói toàn bộ sự phức tạp của một hệ thống con (subsystem, tức nhiều class hợp lại làm một việc lớn) sau một giao diện đơn giản. Client nói cho Facade biết mình cần gì, Facade lo phần rối rắm bên trong.

Hãy hình dung lễ tân khách sạn. Bạn muốn đặt phòng, gọi taxi, đặt bàn ăn. Bạn không tự đi tìm bộ phận buồng phòng, hãng taxi và bếp. Bạn nói với lễ tân một câu, họ điều phối hết phía sau. Lễ tân chính là facade: một cửa vào duy nhất che đi cả một hệ thống bộ phận bên trong.

Cái điều khiển TV cũng vậy. Một nút nguồn của bạn kích hoạt cả chuỗi thao tác: cấp điện, khởi động bảng mạch, bật màn hình, dò kênh cuối. Bạn không cần biết chuỗi đó, bạn chỉ bấm một nút.

Facade không xoá bỏ sự phức tạp, nó chỉ giấu đi sau một lớp mỏng. Các class bên trong vẫn còn nguyên và vẫn dùng trực tiếp được. Facade chỉ là lối vào tiện lợi cho phần lớn nhu cầu thường gặp.

Vấn đề: client phải biết quá nhiều

Giả sử ta có hệ con chuyển đổi video. Muốn đổi một file sang định dạng khác phải qua nhiều bước, mỗi bước một class riêng: đọc file, tách audio, encode phần hình, rồi ghép hình với tiếng lại. Nếu không có facade, client phải tự biết đủ cả bốn class lẫn đúng trình tự gọi:

video = VideoFile("phim-nghi-mat.mp4")
demuxer = Demuxer()
audio = AudioProcessor().extract(video, demuxer)
stream = VideoEncoder().encode(video, "webm")
result = Muxer().merge(stream, audio, "webm")

Đoạn này có ba vấn đề. Một, client bị buộc phải hiểu chi tiết bên trong của một việc mà đáng lẽ nó chỉ cần "đổi file này sang webm". Hai, cái trình tự năm dòng này sẽ bị copy đi khắp nơi cần chuyển đổi. Ba, ngày mai hệ con đổi cách làm (thêm bước lọc nhiễu, đổi thứ tự encode), mọi chỗ copy đều phải sửa tay. Client bị dính chặt (coupling) vào ruột của hệ con.

Cách hoạt động: gói tất cả sau một method

Facade nhận trách nhiệm biết cả bốn class và đúng trình tự. Client chỉ gọi một method convert. Dưới đây là hệ con đầy đủ cộng với facade, chạy được ngay:

# Subsystem: cac buoc con phuc tap
class VideoFile:
    def __init__(self, path):
        self.path = path
        self.fmt = path.split(".")[-1]

class AudioTrack:
    def __init__(self, data): self.data = data

class Demuxer:
    def read(self, video):
        print(f"[Demuxer] doc file {video.path} (dinh dang {video.fmt})")
        return AudioTrack(f"audio-tu-{video.path}")

class AudioProcessor:
    def extract(self, video, demuxer):
        track = demuxer.read(video)
        print(f"[AudioProcessor] tach audio: {track.data}")
        return track

class VideoEncoder:
    def encode(self, video, target):
        print(f"[VideoEncoder] encode hinh sang {target}")
        return f"video-stream-{target}"

class Muxer:
    def merge(self, video_stream, audio_track, target):
        print(f"[Muxer] ghep hinh + tieng thanh file .{target}")
        return f"ket-qua.{target}"


# Facade: mot cua vao gon
class VideoConverter:
    def convert(self, filename, target_format):
        video = VideoFile(filename)
        demuxer = Demuxer()
        audio = AudioProcessor().extract(video, demuxer)
        stream = VideoEncoder().encode(video, target_format)
        result = Muxer().merge(stream, audio, target_format)
        print(f"[Facade] xong: {result}")
        return result


# Client: chi 1 dong
out = VideoConverter().convert("phim-nghi-mat.mp4", "webm")
print("Client nhan ve:", out)
[Demuxer] doc file phim-nghi-mat.mp4 (dinh dang mp4) [AudioProcessor] tach audio: audio-tu-phim-nghi-mat.mp4 [VideoEncoder] encode hinh sang webm [Muxer] ghep hinh + tieng thanh file .webm [Facade] xong: ket-qua.webm Client nhan ve: ket-qua.webm

Toàn bộ nhu cầu của client giờ gói trong một dòng: VideoConverter().convert("phim-nghi-mat.mp4", "webm"). Client không còn biết Demuxer, Muxer hay thứ tự các bước là gì. Nếu mai này hệ con đổi cách làm bên trong, chỉ mình VideoConverter cần sửa, còn những client đi qua facade thì giữ nguyên.

Nói cho chính xác: lợi ích đó chỉ áp dụng cho các chỗ gọi qua facade. Nơi nào trong hệ thống vẫn gọi thẳng Demuxer, VideoEncoder hay Muxer thì hệ con đổi là vẫn phải sửa tay như cũ. Facade chỉ thật sự bảo vệ bạn khi nó là con đường duy nhất tới hệ con đó; nếu nửa hệ thống vẫn gọi tắt vào bên trong thì lợi ích gần như biến mất, bạn vừa phải nuôi thêm một tầng, vừa vẫn phải đi sửa từng chỗ gọi tắt. Nên giữ ranh giới bằng biện pháp cụ thể: một quy ước nội bộ ghi rõ "chuyển đổi video thì đi qua VideoConverter", giới hạn phần export của module (Python thì khai báo __all__, đặt tên các class nội bộ có gạch dưới ở đầu như _Demuxer), hoặc đơn giản là bắt các lần gọi tắt ngay ở review code.

Để ý một điểm quan trọng: facade chỉ điều phối, nó không tự làm việc nặng. Nó không tự encode, không tự tách audio, nó gọi lại đúng các class chuyên trách. Đó là ranh giới giúp facade không bị phình to. Ý này gắn với SOLID: mỗi class giữ một trách nhiệm, facade chỉ giữ trách nhiệm "làm điểm vào".

Khi nào nên dùng, khi nào không

Dùng Facade khi bạn có một hệ con nhiều bước, nhiều class, mà phần lớn client chỉ cần một luồng dùng chung. Nó hợp lý khi bạn muốn giảm coupling giữa client và ruột của hệ con, hoặc muốn dựng một điểm vào gọn cho một thư viện rắc rối. Nó cũng hữu ích khi bạn phân tầng hệ thống: mỗi tầng để lộ một facade cho tầng trên gọi.

Facade cũng thường là bước đầu để lập trình theo interface: cửa vào gọn nghĩa là chỗ tốt để sau này rút thành một abstraction cho client phụ thuộc vào.

Cạm bẫy: đừng để Facade phình thành God object. Khi tiện tay, người ta hay dồn mọi thứ vào facade cho tới lúc nó ôm hết logic của cả hệ thống, biết mọi thứ, làm mọi thứ. Lúc đó bạn có một class khổng lồ khó test, khó sửa, đúng thứ mà nguyên tắc thiết kế muốn tránh. Facade chỉ nên điều phối, không tự làm việc nặng; việc nặng vẫn để cho các class chuyên trách. Nếu một facade phình quá, hãy tách thành nhiều facade nhỏ theo từng nhóm nhu cầu.
  • Facade không cấm truy cập trực tiếp. Nó chỉ là lối đi tắt cho nhu cầu phổ biến. Khi cần điều khiển tinh vi mà facade không lo tới, client vẫn được phép gọi thẳng các class trong hệ con. Đừng thiết kế facade theo kiểu bịt hết mọi đường khác.
  • Đừng thêm facade khi hệ con vốn đã đơn giản. Nếu client chỉ gọi một class với một method, bọc thêm một lớp facade chỉ tạo tầng trung gian thừa.

Trong hệ thống thật

Bỏ ví dụ video sang một bên, đây là những chỗ tôi gặp facade nhiều nhất trong code sản phẩm.

Tầng service gói nhiều repository cộng các bước nghiệp vụ cho một use case. Một hàm OrderService.place_order() bên trong phải kiểm tồn kho qua InventoryRepository, tính giá và khuyến mãi qua PricingEngine, ghi đơn qua OrderRepository, tạo giao dịch qua PaymentGateway, rồi đẩy một job gửi mail xác nhận. Controller chỉ thấy đúng một hàm nhận cart_id và trả về order_id, không biết gì về năm thành phần kia.

Client SDK của một API. Lấy hết danh sách khách hàng thật ra là: gọi GET /customers?page=1, đọc header phân trang, lặp tiếp các trang, gặp lỗi 429 thì chờ theo Retry-After rồi thử lại, gặp 5xx thì backoff. SDK gói tất cả vào client.customers.list_all(). Người dùng SDK không phải viết lại vòng lặp phân trang và logic retry ở mỗi chỗ gọi.

Module thanh toán. Một lần trừ tiền với Stripe gồm ít nhất ba bước: tạo payment intent, đưa người dùng qua bước xác thực 3D Secure nếu ngân hàng yêu cầu, rồi capture khoản tiền đã giữ. Gói lại thành Payment.charge(order, card_token) thì phần còn lại của hệ thống không phải học vòng đời của intent.

Lớp bọc một thư viện bên thứ ba phức tạp. Xuất PDF từ HTML với WeasyPrint hay wkhtmltopdf cần dựng config font, base URL cho ảnh, lề trang, rồi mới render. Bọc thành PdfRenderer.render(html, out_path), và lợi ích kèm theo là hôm nào đổi thư viện, bạn chỉ sửa một file. Ở đây facade dễ bị nhầm với Adapter: Adapter đổi một interface có sẵn cho khớp cái bạn cần, còn Facade dựng một interface mới đơn giản hơn cho cả một nhóm class. Nó cũng khác Proxy, vì Proxy giữ nguyên interface của đối tượng gốc và chen vào để kiểm soát lượt truy cập.

Trade-off

Facade không miễn phí. Trước khi thêm một cái, tôi cân hai cột này.

Được:

  • Client chỉ phải học một cửa vào thay vì cả chục class và đúng trình tự gọi giữa chúng.
  • Giảm coupling với chi tiết bên trong: hệ con đổi kiến trúc mà chữ ký của facade không đổi thì client không biết gì cả.
  • Đổi hoặc refactor hệ con ít ảnh hưởng tới các client đi qua facade, nên bạn dám dọn dẹp bên trong hơn.
  • Là chỗ tốt để đặt tập trung log, metric, retry, timeout hay cache: một điểm vào nghĩa là một chỗ để gắn, thay vì rải khắp nơi.
  • Vẽ ra một ranh giới rõ giữa các tầng, hợp với kiểu mỗi tầng chỉ để lộ một facade cho tầng trên.

Phải trả giá:

  • Facade rất dễ phình thành God object. Mỗi lần ai đó cần thêm một việc, chỗ tiện tay nhất luôn là nhét thêm một method vào đây. Xem thêm ở bài anti-pattern thường gặp.
  • Nó có thể giấu mất tính năng người ta cần. Facade lo được 80% nhu cầu, 20% còn lại không có đường ra, thế là người ta lách qua mặt nó gọi thẳng hệ con, và bạn quay lại đúng điểm xuất phát.
  • Thêm một tầng phải bảo trì và phải test: mỗi thay đổi của hệ con lại kéo theo một lần sửa facade.
  • Nó không làm hệ con bớt phức tạp. Sự phức tạp chỉ dời sang chỗ khác, và giờ nó nằm trong một file mà ai cũng phải đọc khi debug.
  • Che quá kín thì người mới đọc code khó lần ra chuyện gì thật sự xảy ra khi gọi một hàm, stack trace cũng dài thêm một tầng.

Tóm tắt

  • Facade là một class cho client một giao diện đơn giản, thống nhất, che đi sự phức tạp của một hệ thống con nhiều class, nhiều bước.
  • Nó giải quyết nỗi đau client phải biết quá nhiều: thay vì thuộc lòng cả trình tự gọi, client chỉ gọi một hai method.
  • Lợi ích chính là giảm coupling giữa client và ruột hệ con, cộng một điểm vào gọn dễ dùng lại.
  • Facade chỉ điều phối, không tự ôm việc nặng. Đừng để nó phình thành God object, và đừng cấm client truy cập trực tiếp hệ con khi thật sự cần.
Series Design Patterns - nhóm Structural. Facade thuộc nhóm Structural (cách các class và đối tượng ghép lại thành cấu trúc lớn hơn). Nếu chưa nắm phần nền, đọc lại SOLID và Program to interface & Composition over inheritance. 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