Facade là mẫu thiết kế dùng để che giấu sự phức tạp của một hệ thống, rồi cung cấp cho client một giao diện đơn giản, dễ dùng hơn.
Nói thật dễ hiểu: Facade = một “mặt tiền” đơn giản đứng trước một hệ thống phức tạp.
- Ý tưởng cốt lõi
- Hình dung đời thường
- Khi nào cần Facade
- Vấn đề nếu không dùng Facade
- Facade giải quyết thế nào
- Cấu trúc của Facade
- Ví dụ cơ bản: Computer startup
- Điều hay ở ví dụ này
- Facade không thay thế subsystem
- Ví dụ thực tế hơn: Home Theater
- Lợi ích lớn nhất của Facade
- Facade khác Adapter thế nào
- Facade khác Decorator thế nào
- Facade khác Proxy thế nào
- Facade khác Bridge thế nào
- Khi nào nên dùng Facade
- Ví dụ thực tế backend: Order Service
- Vì sao ví dụ này rất đúng chất Facade
- Một hiểu nhầm phổ biến
- Ưu điểm và nhược điểm
- Khi nào không nên dùng
- Dấu hiệu nhận biết Facade rất nhanh
- Mẫu code ngắn gọn dễ nhớ
- Công thức nhớ 1 câu
- Chốt cực ngắn
- Bảng nhớ nhanh đến hiện tại
- Kết luận
flowchart TD
A[Client] --> B[Facade]
B --> C[Subsystem A]
B --> D[Subsystem B]
B --> E[Subsystem C]
B --> F[Subsystem D]
- Client không cần hiểu toàn bộ hệ thống.
- Client chỉ làm việc với một điểm vào đơn giản.
- Facade thay mặt client điều phối các subsystem.
Giả sử phía sau có rất nhiều class:
CPUMemoryHardDrivePowerSupply
Muốn khởi động máy tính, bạn phải gọi đúng thứ tự:
- bật nguồn
- nạp dữ liệu
- cấp bộ nhớ
- khởi động CPU
Việc này khá rối với client.
Facade sẽ cho client chỉ cần gọi:
computer.start();Còn bên trong computer.start() sẽ tự gọi tất cả bước cần thiết.
Ví dụ bạn đi nhà hàng.
Bên trong nhà hàng có rất nhiều bộ phận:
- lễ tân
- bếp
- thu ngân
- phục vụ
- kho nguyên liệu
Nhưng bạn không làm việc trực tiếp với từng bộ phận đó.
Bạn chỉ cần nói với một người phục vụ:
- gọi món
- thanh toán
- hỏi trạng thái món ăn
Người phục vụ chính là Facade.
flowchart LR
Customer[Khách hàng] --> Waiter[Phục vụ / Facade]
Waiter --> Reception[Lễ tân]
Waiter --> Kitchen[Bếp]
Waiter --> Cashier[Thu ngân]
Waiter --> Storage[Kho nguyên liệu]
Dùng khi:
- hệ thống có nhiều class và nhiều bước thao tác phức tạp
- client không nên biết quá nhiều chi tiết bên trong
- muốn cung cấp một API đơn giản cho phần phức tạp
- muốn giảm phụ thuộc giữa client và subsystem
Không có Facade, client có thể phải viết kiểu này:
CPU cpu = new CPU();
Memory memory = new Memory();
HardDrive hardDrive = new HardDrive();
hardDrive.read();
memory.load();
cpu.execute();Client phải biết:
- có những class nào
- gọi class nào trước
- thứ tự thao tác ra sao
Điều này làm code:
- khó dùng
- dễ sai
- phụ thuộc chặt vào hệ thống bên trong
Ta tạo một class trung gian như:
ComputerFacade computer = new ComputerFacade();
computer.start();Client chỉ dùng một class đơn giản.
Bên trong ComputerFacade sẽ phối hợp các subsystem.
Facade thường có:
Các class thật sự làm việc.
Lớp cung cấp API đơn giản, gọi các subsystem bên trong.
Chỉ làm việc với facade, hoặc ít nhất chủ yếu làm việc với facade.
classDiagram
class Client
class Facade {
+simpleOperation()
}
class SubsystemA {
+operationA()
}
class SubsystemB {
+operationB()
}
class SubsystemC {
+operationC()
}
Client --> Facade : uses
Facade --> SubsystemA : coordinates
Facade --> SubsystemB : coordinates
Facade --> SubsystemC : coordinates
public class CPU {
public void start() {
System.out.println("CPU started");
}
}public class Memory {
public void load() {
System.out.println("Memory loaded");
}
}public class HardDrive {
public void read() {
System.out.println("Hard drive read data");
}
}public class ComputerFacade {
private CPU cpu;
private Memory memory;
private HardDrive hardDrive;
public ComputerFacade() {
cpu = new CPU();
memory = new Memory();
hardDrive = new HardDrive();
}
public void startComputer() {
System.out.println("Starting computer...");
hardDrive.read();
memory.load();
cpu.start();
System.out.println("Computer started");
}
}public class Main {
public static void main(String[] args) {
ComputerFacade computer = new ComputerFacade();
computer.startComputer();
}
}sequenceDiagram
participant Client
participant ComputerFacade
participant HardDrive
participant Memory
participant CPU
Client->>ComputerFacade: startComputer()
ComputerFacade->>HardDrive: read()
ComputerFacade->>Memory: load()
ComputerFacade->>CPU: start()
ComputerFacade-->>Client: Computer started
Client không cần biết:
CPUMemoryHardDrive
khởi động thế nào, thứ tự ra sao.
Nó chỉ biết:
computer.startComputer();Đó chính là giá trị của Facade:
đơn giản hóa việc sử dụng hệ thống phức tạp.
Điểm này rất quan trọng.
Facade không xóa bỏ các class con bên trong. Các subsystem vẫn tồn tại bình thường.
Facade chỉ:
- đứng phía trước
- gom thao tác lại
- cung cấp lối vào đơn giản hơn
Tức là nếu cần, code khác vẫn có thể gọi trực tiếp subsystem.
Đây là ví dụ rất nổi tiếng.
Bạn có hệ thống xem phim ở nhà gồm:
DVDPlayerProjectorSoundSystemLights
Muốn xem phim, phải:
- bật đèn mờ
- bật máy chiếu
- bật âm thanh
- bật đầu DVD
- play phim
Nếu để client làm từng bước thì khá mệt.
public class DVDPlayer {
public void on() {
System.out.println("DVD Player on");
}
public void play(String movie) {
System.out.println("Playing movie: " + movie);
}
}public class Projector {
public void on() {
System.out.println("Projector on");
}
}public class SoundSystem {
public void on() {
System.out.println("Sound system on");
}
public void setVolume(int level) {
System.out.println("Volume set to " + level);
}
}public class Lights {
public void dim() {
System.out.println("Lights dimmed");
}
}public class HomeTheaterFacade {
private DVDPlayer dvdPlayer;
private Projector projector;
private SoundSystem soundSystem;
private Lights lights;
public HomeTheaterFacade(DVDPlayer dvdPlayer, Projector projector, SoundSystem soundSystem, Lights lights) {
this.dvdPlayer = dvdPlayer;
this.projector = projector;
this.soundSystem = soundSystem;
this.lights = lights;
}
public void watchMovie(String movie) {
System.out.println("Get ready to watch a movie...");
lights.dim();
projector.on();
soundSystem.on();
soundSystem.setVolume(10);
dvdPlayer.on();
dvdPlayer.play(movie);
}
}public class Main {
public static void main(String[] args) {
DVDPlayer dvd = new DVDPlayer();
Projector projector = new Projector();
SoundSystem sound = new SoundSystem();
Lights lights = new Lights();
HomeTheaterFacade homeTheater = new HomeTheaterFacade(dvd, projector, sound, lights);
homeTheater.watchMovie("Inception");
}
}flowchart TD
A[Client gọi watchMovie] --> B[Lights.dim]
B --> C[Projector.on]
C --> D[SoundSystem.on]
D --> E[SoundSystem.setVolume]
E --> F[DVDPlayer.on]
F --> G[DVDPlayer.play(movie)]
Client chỉ thấy vài method dễ hiểu.
Client không cần biết quá nhiều class bên trong.
Khi hệ thống bên trong thay đổi, có thể chỉ cần sửa facade.
Facade giúp gom các thao tác cấp cao vào một chỗ.
Cặp này rất dễ nhầm.
Mục tiêu:
- làm cho interface không tương thích trở nên tương thích
Ví dụ:
- hệ thống cần
play() - class cũ chỉ có
playMp3()
Mục tiêu:
- cung cấp giao diện đơn giản cho hệ thống phức tạp
Ví dụ:
- thay vì phải gọi 5 class, chỉ cần gọi
watchMovie()
- Adapter = chuyển đổi interface
- Facade = đơn giản hóa interface
Thêm chức năng cho một object bằng cách bọc nó.
Không thêm chức năng mới cho một object cụ thể, mà chỉ gom và che giấu độ phức tạp của nhiều object.
- Decorator = tăng tính năng
- Facade = đơn giản cách sử dụng
Kiểm soát truy cập tới object thật.
Ví dụ:
- lazy loading
- remote access
- security check
Cung cấp API gọn hơn cho cả hệ thống con.
- Proxy = đại diện để kiểm soát
- Facade = mặt tiền để đơn giản hóa
Tách abstraction và implementation thành 2 chiều độc lập.
Ẩn sự phức tạp của subsystem sau một giao diện đơn giản.
- Bridge = tổ chức cấu trúc để mở rộng
- Facade = đơn giản hóa việc sử dụng
Nên dùng khi:
- một nhóm class thường được dùng chung theo một quy trình
- muốn tạo điểm vào đơn giản cho module phức tạp
- muốn tách client khỏi chi tiết cài đặt
- đang thiết kế library hoặc module để người khác dễ dùng hơn
Ví dụ:
- hệ thống thanh toán
- hệ thống gửi email
- hệ thống multimedia
- hệ thống compile/build
- quy trình tạo report
- quy trình đăng ký user
Giả sử để đặt hàng thành công, bạn phải làm nhiều bước:
- kiểm tra tồn kho
- xử lý thanh toán
- tạo đơn hàng
- gửi email xác nhận
Nếu để client gọi từng bước thì vừa rối vừa nguy hiểm.
public class InventoryService {
public boolean checkStock(String productId) {
System.out.println("Checking stock for " + productId);
return true;
}
}public class PaymentService {
public boolean makePayment(double amount) {
System.out.println("Processing payment: " + amount);
return true;
}
}public class OrderService {
public void createOrder(String productId) {
System.out.println("Creating order for " + productId);
}
}public class EmailService {
public void sendConfirmation() {
System.out.println("Sending confirmation email");
}
}public class OrderFacade {
private InventoryService inventoryService;
private PaymentService paymentService;
private OrderService orderService;
private EmailService emailService;
public OrderFacade() {
inventoryService = new InventoryService();
paymentService = new PaymentService();
orderService = new OrderService();
emailService = new EmailService();
}
public void placeOrder(String productId, double amount) {
if (inventoryService.checkStock(productId) && paymentService.makePayment(amount)) {
orderService.createOrder(productId);
emailService.sendConfirmation();
System.out.println("Order placed successfully");
} else {
System.out.println("Order failed");
}
}
}public class Main {
public static void main(String[] args) {
OrderFacade facade = new OrderFacade();
facade.placeOrder("P100", 250.0);
}
}flowchart TD
A[Client gọi placeOrder] --> B{checkStock && makePayment?}
B -- Yes --> C[createOrder]
C --> D[sendConfirmation]
D --> E[Order placed successfully]
B -- No --> F[Order failed]
Client chỉ cần:
facade.placeOrder(...)Không cần biết bên trong là:
- kiểm kho trước
- rồi thanh toán
- rồi tạo order
- rồi gửi mail
Facade gom cả quy trình lại.
Nhiều người nghĩ Facade là “class God” ôm hết mọi thứ.
Không hẳn.
Facade tốt là facade:
- đơn giản
- rõ mục đích
- đại diện cho một luồng nghiệp vụ hoặc một module
- không nhét tất cả logic của cả hệ thống vào một lớp khổng lồ
Tức là:
- Facade nên là “cửa vào gọn”
- không nên thành “thùng rác logic”
- dễ dùng
- giảm độ phức tạp cho client
- giảm coupling với subsystem
- giúp tổ chức code tốt hơn
- phù hợp để thiết kế API/module
- có thể trở thành class quá to nếu thiết kế kém
- có thể che giấu quá nhiều, làm client khó truy cập chức năng chi tiết nếu cần
- đôi khi thêm một tầng trừu tượng không cần thiết với hệ thống nhỏ
Không nên dùng khi:
- hệ thống rất nhỏ, đơn giản
- client thực sự cần điều khiển trực tiếp từng subsystem
- thêm facade chỉ làm code dài hơn mà không đơn giản hơn bao nhiêu
Hãy tự hỏi:
“Client có đang phải gọi quá nhiều class hoặc quá nhiều bước cho một việc rất thường gặp không?”
Nếu có, Facade rất đáng cân nhắc.
Ví dụ:
- “xem phim”
- “đặt hàng”
- “khởi động máy”
- “gửi thông báo”
- “xuất báo cáo”
Mỗi việc này có thể là một facade method.
class SubsystemA {
void stepA() {
System.out.println("Step A");
}
}
class SubsystemB {
void stepB() {
System.out.println("Step B");
}
}
class SubsystemC {
void stepC() {
System.out.println("Step C");
}
}
class Facade {
private SubsystemA a = new SubsystemA();
private SubsystemB b = new SubsystemB();
private SubsystemC c = new SubsystemC();
public void operation() {
a.stepA();
b.stepB();
c.stepC();
}
}
public class Main {
public static void main(String[] args) {
Facade facade = new Facade();
facade.operation();
}
}Facade cung cấp một giao diện đơn giản để dùng một hệ thống phức tạp.
- Adapter: đổi interface
- Bridge: tách 2 chiều thay đổi
- Decorator: bọc thêm tính năng
- Facade: che sự phức tạp bằng một cửa vào đơn giản
| Mẫu | Ý tưởng chính |
|---|---|
| Singleton | Chỉ có 1 object duy nhất |
| Factory Method | Tạo 1 loại object linh hoạt |
| Abstract Factory | Tạo cả họ object liên quan |
| Builder | Tạo object từng bước |
| Prototype | Sao chép object từ mẫu có sẵn |
| Adapter | Chuyển interface không tương thích |
| Bridge | Tách abstraction và implementation |
| Decorator | Bọc thêm chức năng cho object |
| Facade | Đơn giản hóa hệ thống phức tạp |
Facade trong Java là mẫu thiết kế rất thực tế khi bạn muốn:
- làm API dễ dùng hơn
- ẩn bớt độ phức tạp
- gom một chuỗi thao tác phức tạp vào một method rõ nghĩa
- giảm coupling giữa client và subsystem
Nó đặc biệt hữu ích khi viết:
- service layer
- module API
- thư viện
- quy trình nghiệp vụ nhiều bước
Bước tiếp theo hợp lý trong nhóm structural patterns thường là Proxy hoặc Composite.
| Câu hỏi | Trả lời |
|---|---|
| Facade là gì? | Một lớp cung cấp giao diện đơn giản cho hệ thống phức tạp |
| Mục tiêu chính? | Giảm độ phức tạp cho client |
| Nó có thay thế subsystem không? | Không |
| Khi nào nên dùng? | Khi có nhiều bước hoặc nhiều class cho một tác vụ thường gặp |
| Nguy cơ chính? | Biến thành lớp quá to nếu ôm quá nhiều logic |
flowchart LR
A[Hệ thống phức tạp] --> B[Facade]
B --> C[API đơn giản]
C --> D[Client dễ dùng hơn]