Những design pattern phổ biến nào xuất hiện trong Java?

Question

Accepted Answer

**Design pattern** là các giải pháp tái sử dụng được cho những vấn đề thiết kế phần mềm lặp đi lặp lại. Bản chất OOP và hệ sinh thái của Java làm cho một số pattern đặc biệt phổ biến — biết chúng giúp bạn nhận diện, trao đổi, và áp dụng các cấu trúc đã được kiểm chứng. Chúng được chia thành các nhóm creational, structural, và behavioral.

## Singleton (creational) — một instance dùng chung

```java
public class Config {
    private static final Config INSTANCE = new Config();   // instance duy nhất
    private Config() {}                                     // constructor private
    public static Config getInstance() { return INSTANCE; }
}
// (enum singleton là một idiom còn an toàn hơn). Dùng cho config dùng chung, connection pool.
```

## Factory (creational) — đóng gói việc tạo object

```java
public static Shape createShape(String type) {
    return switch (type) {                 // ẩn class cụ thể khỏi caller
        case "circle" -> new Circle();
        case "square" -> new Square();
        default -> throw new IllegalArgumentException();
    };
}
// caller phụ thuộc vào Shape, không phải các class cụ thể — giảm coupling.
```

## Builder (creational) — xây dựng object phức tạp từng bước

```java
User user = new User.Builder()
    .name("Ann")
    .email("ann@x.com")
    .age(30)
    .build();    // xây dựng dễ đọc; tránh các telescoping constructor khổng lồ
```

## Strategy (behavioral) — các thuật toán có thể hoán đổi

```java
interface PaymentStrategy { void pay(double amount); }
class CreditCard implements PaymentStrategy { public void pay(double a) {...} }
class PayPal implements PaymentStrategy { public void pay(double a) {...} }

// hoán đổi hành vi tại runtime — lambda làm điều này dễ dàng trong Java hiện đại
processor.setStrategy(new PayPal());
```

## Observer (behavioral) — publish/subscribe

```java
// subject thông báo cho các observer đã đăng ký về thay đổi (event, listener)
button.addActionListener(e -> handleClick());   // event GUI dùng cái này khắp nơi
```

## Decorator (structural) — bọc lại để thêm hành vi

```java
// I/O stream của Java CHÍNH LÀ decorator pattern:
BufferedReader r = new BufferedReader(new FileReader("f.txt"));
// BufferedReader bọc FileReader, thêm buffering
```

## Nơi các pattern xuất hiện trong chính Java

```text
Singleton  → Runtime.getRuntime()
Factory    → Calendar.getInstance(), DriverManager
Builder    → StringBuilder, Stream.Builder
Observer   → event listener, java.util.Observer
Decorator  → java.io stream (BufferedReader bọc FileReader)
Iterator   → interface Iterator / Collections
Strategy   → Comparator, functional interface
```

## Một lưu ý về việc lạm dụng

```text
Pattern là công cụ, không phải mục tiêu. Áp dụng chúng nơi không phù hợp sẽ TĂNG độ phức tạp.
Dùng chúng khi chúng thực sự giải quyết vấn đề của bạn — nhiều cái giờ đơn giản hơn với lambda.
```

## Tại sao điều này quan trọng

Design pattern cung cấp một vốn từ vựng chung và các giải pháp đã được kiểm chứng cho những vấn đề thiết kế phổ biến, điều này có giá trị cho việc giao tiếp ("dùng Strategy ở đây"), nhận diện cấu trúc trong code có sẵn, và tránh phát minh lại những giải pháp có lỗi.

Chúng xuất hiện khắp các thư viện của chính Java (I/O decorator, factory method, builder, event dựa trên observer), nên hiểu chúng giúp bạn dùng và mở rộng thư viện chuẩn một cách hiệu quả.

Biết các pattern chính — Singleton, Factory, Builder, Strategy, Observer, Decorator — và nơi mỗi cái phù hợp là dấu ấn của các developer giàu kinh nghiệm và là một chủ đề phỏng vấn thường gặp.

Cũng quan trọng không kém là khả năng phán đoán để áp dụng chúng một cách phù hợp (giải quyết vấn đề thực) thay vì ép dùng, đặc biệt khi các tính năng hiện đại như lambda đơn giản hóa nhiều pattern kinh điển.