Java Design Patterns: Singleton, Factory, Builder

Design Patterns คืออะไร

Design Patterns คือ solution ที่ผ่านการพิสูจน์แล้วสำหรับปัญหาที่พบบ่อยใน software design แบ่งเป็น Creational, Structural, Behavioral

Singleton Pattern

// Thread-safe Singleton
public class DatabaseConnection {
    private static volatile DatabaseConnection instance;
    private Connection connection;

    private DatabaseConnection() {
        // private constructor
        connection = createConnection();
    }

    public static DatabaseConnection getInstance() {
        if (instance == null) {
            synchronized (DatabaseConnection.class) {
                if (instance == null) {
                    instance = new DatabaseConnection();
                }
            }
        }
        return instance;
    }

    public Connection getConnection() { return connection; }
}

// Enum Singleton (แนะนำ)
public enum AppConfig {
    INSTANCE;

    private final String apiUrl = "https://api.example.com";
    public String getApiUrl() { return apiUrl; }
}

Factory Pattern

public interface Notification {
    void send(String message);
}

public class EmailNotification implements Notification {
    @Override
    public void send(String message) {
        System.out.println("Email: " + message);
    }
}

public class SMSNotification implements Notification {
    @Override
    public void send(String message) {
        System.out.println("SMS: " + message);
    }
}

// Factory
public class NotificationFactory {
    public static Notification create(String type) {
        return switch (type.toLowerCase()) {
            case "email" -> new EmailNotification();
            case "sms" -> new SMSNotification();
            default -> throw new IllegalArgumentException("Unknown type: " + type);
        };
    }
}

// ใช้งาน
Notification n = NotificationFactory.create("email");
n.send("สวัสดี!");

Builder Pattern

public class User {
    private final String name;
    private final String email;
    private final String phone;
    private final String address;

    private User(Builder builder) {
        this.name = builder.name;
        this.email = builder.email;
        this.phone = builder.phone;
        this.address = builder.address;
    }

    public static class Builder {
        private final String name;  // required
        private final String email; // required
        private String phone;       // optional
        private String address;     // optional

        public Builder(String name, String email) {
            this.name = name;
            this.email = email;
        }

        public Builder phone(String phone) {
            this.phone = phone;
            return this;
        }

        public Builder address(String address) {
            this.address = address;
            return this;
        }

        public User build() {
            return new User(this);
        }
    }
}

// ใช้งาน
User user = new User.Builder("สมชาย", "somchai@example.com")
    .phone("0812345678")
    .address("กรุงเทพฯ")
    .build();

Observer Pattern

public interface Observer {
    void update(String event, Object data);
}

public class EventBus {
    private Map<String, List<Observer>> listeners = new HashMap<>();

    public void subscribe(String event, Observer observer) {
        listeners.computeIfAbsent(event, k -> new ArrayList<>()).add(observer);
    }

    public void publish(String event, Object data) {
        listeners.getOrDefault(event, List.of())
            .forEach(o -> o.update(event, data));
    }
}

สรุป

Design Patterns ช่วยให้โค้ดมีโครงสร้างที่ดี maintainable และ reusable ควรเรียนรู้ patterns หลักๆ เช่น Singleton, Factory, Builder, Observer, Strategy ครับ