Skip to content

Latest commit

 

History

History
883 lines (632 loc) · 19.3 KB

FACADE.md

File metadata and controls

883 lines (632 loc) · 19.3 KB

Facade Pattern trong Java

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.


Mục lục

  1. Ý tưởng cốt lõi
  2. Hình dung đời thường
  3. Khi nào cần Facade
  4. Vấn đề nếu không dùng Facade
  5. Facade giải quyết thế nào
  6. Cấu trúc của Facade
  7. Ví dụ cơ bản: Computer startup
  8. Điều hay ở ví dụ này
  9. Facade không thay thế subsystem
  10. Ví dụ thực tế hơn: Home Theater
  11. Lợi ích lớn nhất của Facade
  12. Facade khác Adapter thế nào
  13. Facade khác Decorator thế nào
  14. Facade khác Proxy thế nào
  15. Facade khác Bridge thế nào
  16. Khi nào nên dùng Facade
  17. Ví dụ thực tế backend: Order Service
  18. Vì sao ví dụ này rất đúng chất Facade
  19. Một hiểu nhầm phổ biến
  20. Ưu điểm và nhược điểm
  21. Khi nào không nên dùng
  22. Dấu hiệu nhận biết Facade rất nhanh
  23. Mẫu code ngắn gọn dễ nhớ
  24. Công thức nhớ 1 câu
  25. Chốt cực ngắn
  26. Bảng nhớ nhanh đến hiện tại
  27. Kết luận

Tổng quan nhanh

flowchart TD
    A[Client] --> B[Facade]
    B --> C[Subsystem A]
    B --> D[Subsystem B]
    B --> E[Subsystem C]
    B --> F[Subsystem D]
Loading
  • 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.

1. Ý tưởng cốt lõi

Giả sử phía sau có rất nhiều class:

  • CPU
  • Memory
  • HardDrive
  • PowerSupply

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.


2. Hình dung đời thường

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]
Loading

3. Khi nào cần Facade

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

4. Vấn đề nếu không dùng Facade

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

5. Facade giải quyết thế nào

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.


6. Cấu trúc của Facade

Facade thường có:

a) Subsystem classes

Các class thật sự làm việc.

b) Facade

Lớp cung cấp API đơn giản, gọi các subsystem bên trong.

c) Client

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
Loading

7. Ví dụ cơ bản: Computer startup

Subsystem 1: CPU

public class CPU {
    public void start() {
        System.out.println("CPU started");
    }
}

Subsystem 2: Memory

public class Memory {
    public void load() {
        System.out.println("Memory loaded");
    }
}

Subsystem 3: HardDrive

public class HardDrive {
    public void read() {
        System.out.println("Hard drive read data");
    }
}

Facade

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");
    }
}

Client dùng

public class Main {
    public static void main(String[] args) {
        ComputerFacade computer = new ComputerFacade();
        computer.startComputer();
    }
}

Luồng xử lý

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
Loading

8. Điều hay ở ví dụ này

Client không cần biết:

  • CPU
  • Memory
  • HardDrive

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.


9. Facade không thay thế subsystem

Đ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.


10. Ví dụ thực tế hơn: Home Theater

Đây là ví dụ rất nổi tiếng.

Bạn có hệ thống xem phim ở nhà gồm:

  • DVDPlayer
  • Projector
  • SoundSystem
  • Lights

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.

Subsystems

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");
    }
}

Facade

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);
    }
}

Dùng

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");
    }
}

Luồng “xem phim”

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)]
Loading

11. Lợi ích lớn nhất của Facade

a) Đơn giản hóa cách dùng

Client chỉ thấy vài method dễ hiểu.

b) Giảm phụ thuộc vào subsystem

Client không cần biết quá nhiều class bên trong.

c) Dễ bảo trì hơn

Khi hệ thống bên trong thay đổi, có thể chỉ cần sửa facade.

d) Tăng khả năng tổ chức code

Facade giúp gom các thao tác cấp cao vào một chỗ.


12. Facade khác Adapter thế nào

Cặp này rất dễ nhầm.

Adapter

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()

Facade

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()

Tóm gọn

  • Adapter = chuyển đổi interface
  • Facade = đơn giản hóa interface

13. Facade khác Decorator thế nào

Decorator

Thêm chức năng cho một object bằng cách bọc nó.

Facade

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.

Tóm gọn

  • Decorator = tăng tính năng
  • Facade = đơn giản cách sử dụng

14. Facade khác Proxy thế nào

Proxy

Kiểm soát truy cập tới object thật.

Ví dụ:

  • lazy loading
  • remote access
  • security check

Facade

Cung cấp API gọn hơn cho cả hệ thống con.

Tóm gọn

  • Proxy = đại diện để kiểm soát
  • Facade = mặt tiền để đơn giản hóa

15. Facade khác Bridge thế nào

Bridge

Tách abstraction và implementation thành 2 chiều độc lập.

Facade

Ẩn sự phức tạp của subsystem sau một giao diện đơn giản.

Tóm gọn

  • Bridge = tổ chức cấu trúc để mở rộng
  • Facade = đơn giản hóa việc sử dụng

16. Khi nào nên dùng Facade

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

17. Ví dụ thực tế backend: Order Service

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.

Subsystems

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");
    }
}

Facade

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");
        }
    }
}

Client dùng

public class Main {
    public static void main(String[] args) {
        OrderFacade facade = new OrderFacade();
        facade.placeOrder("P100", 250.0);
    }
}

Luồng đặt hàng

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]
Loading

18. Vì sao ví dụ này rất đúng chất Facade

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.


19. Một hiểu nhầm phổ biến

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”

20. Ưu điểm và nhược điểm

Ưu điểm

  • 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

Nhược điểm

  • 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ỏ

21. Khi nào không nên dùng

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

22. Dấu hiệu nhận biết Facade rất nhanh

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.


23. Mẫu code ngắn gọn dễ nhớ

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();
    }
}

24. Công thức nhớ 1 câu

Facade cung cấp một giao diện đơn giản để dùng một hệ thống phức tạp.


25. Chốt cực ngắn

  • 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

26. Bảng nhớ nhanh đến hiện tại

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

27. Kết luận

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.


Tóm tắt siêu nhanh

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]
Loading