생성 패턴(Creational Patterns): 객체 생성의 캡슐화

public class DatabasePool {
    private static volatile DatabasePool instance;
    private final HikariDataSource dataSource;
 
    private DatabasePool() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:postgresql://localhost/mydb");
        this.dataSource = new HikariDataSource(config);
    }
 
    // Double-Checked Locking (멀티스레드 안전)
    public static DatabasePool getInstance() {
        if (instance == null) {
            synchronized (DatabasePool.class) {
                if (instance == null) {
                    instance = new DatabasePool();
                }
            }
        }
        return instance;
    }
 
    public Connection getConnection() throws SQLException {
        return dataSource.getConnection();
    }
}

// Spring: Singleton 스코프 (기본값)
@Component
@Scope("singleton") // DI 컨테이너가 인스턴스 관리
public class DatabasePool {
    // 직접 Singleton 패턴을 구현할 필요 없음
    // 테스트 시 Mock으로 대체 용이
}

// 직접 생성: 새로운 타입 추가 시 모든 생성 코드 수정 필요
Notification notification;
if (type.equals("email")) {
    notification = new EmailNotification();
} else if (type.equals("sms")) {
    notification = new SmsNotification();
}
// 새 타입마다 else if 추가... → OCP 위반

// 생성자 인터페이스 정의
public abstract class NotificationFactory {
    public abstract Notification createNotification();
 
    // 템플릿 메서드와 결합 가능
    public void send(String message) {
        Notification notification = createNotification();
        notification.setMessage(message);
        notification.deliver();
    }
}
 
public class EmailNotificationFactory extends NotificationFactory {
    @Override
    public Notification createNotification() {
        return new EmailNotification();
    }
}
 
public class SmsNotificationFactory extends NotificationFactory {
    @Override
    public Notification createNotification() {
        return new SmsNotification();
    }
}

// Abstract Factory
public interface UIFactory {
    Button createButton();
    TextField createTextField();
    Dialog createDialog();
}
 
// 구체 팩토리: Windows 플랫폼
public class WindowsUIFactory implements UIFactory {
    public Button createButton() { return new WindowsButton(); }
    public TextField createTextField() { return new WindowsTextField(); }
    public Dialog createDialog() { return new WindowsDialog(); }
}
 
// 구체 팩토리: macOS 플랫폼
public class MacUIFactory implements UIFactory {
    public Button createButton() { return new MacButton(); }
    public TextField createTextField() { return new MacTextField(); }
    public Dialog createDialog() { return new MacDialog(); }
}
 
// 클라이언트 코드: 구체 팩토리에 의존하지 않음
public class Application {
    private final UIFactory factory;
 
    public Application(UIFactory factory) {
        this.factory = factory;
    }
 
    public void createUI() {
        Button button = factory.createButton();
        TextField field = factory.createTextField();
    }
}

// 매개변수가 많으면 가독성이 급격히 저하
new HttpRequest("GET", "/api/users", null, headers, timeout, retry, cache, auth);

public class HttpRequest {
    private final String method;
    private final String url;
    private final Map<String, String> headers;
    private final int timeout;
    private final int retryCount;
    private final boolean cacheEnabled;
 
    private HttpRequest(Builder builder) {
        this.method = builder.method;
        this.url = builder.url;
        this.headers = Map.copyOf(builder.headers); // 불변 복사
        this.timeout = builder.timeout;
        this.retryCount = builder.retryCount;
        this.cacheEnabled = builder.cacheEnabled;
    }
 
    public static class Builder {
        private final String method; // 필수
        private final String url;    // 필수
        private Map<String, String> headers = new HashMap<>();
        private int timeout = 30000;
        private int retryCount = 3;
        private boolean cacheEnabled = false;
 
        public Builder(String method, String url) {
            this.method = method;
            this.url = url;
        }
 
        public Builder header(String key, String value) {
            this.headers.put(key, value);
            return this; // Fluent API
        }
 
        public Builder timeout(int ms) {
            this.timeout = ms;
            return this;
        }
 
        public Builder retry(int count) {
            this.retryCount = count;
            return this;
        }
 
        public Builder cache(boolean enabled) {
            this.cacheEnabled = enabled;
            return this;
        }
 
        public HttpRequest build() {
            // 유효성 검증
            if (method == null || url == null) {
                throw new IllegalStateException("method and url are required");
            }
            return new HttpRequest(this);
        }
    }
}
 
// 사용: 가독성이 높은 Fluent API
HttpRequest request = new HttpRequest.Builder("POST", "/api/orders")
    .header("Content-Type", "application/json")
    .header("Authorization", "Bearer token")
    .timeout(5000)
    .retry(5)
    .cache(true)
    .build();

public interface DocumentPrototype extends Cloneable {
    DocumentPrototype clone();
}
 
public class SpreadsheetTemplate implements DocumentPrototype {
    private List<Sheet> sheets;
    private Map<String, Style> styles;
    private Configuration config;
 
    // 깊은 복사 (Deep Copy)
    @Override
    public SpreadsheetTemplate clone() {
        SpreadsheetTemplate copy = new SpreadsheetTemplate();
        copy.sheets = this.sheets.stream()
            .map(Sheet::clone)
            .collect(Collectors.toList());
        copy.styles = new HashMap<>(this.styles);
        copy.config = this.config.clone();
        return copy;
    }
}
 
// 프로토타입 레지스트리
public class TemplateRegistry {
    private final Map<String, DocumentPrototype> templates = new HashMap<>();
 
    public void register(String key, DocumentPrototype prototype) {
        templates.put(key, prototype);
    }
 
    public DocumentPrototype create(String key) {
        return templates.get(key).clone();
    }
}

public class ConnectionPool {
    private final Queue<Connection> available = new ConcurrentLinkedQueue<>();
    private final Set<Connection> inUse = ConcurrentHashMap.newKeySet();
    private final int maxSize;
 
    public ConnectionPool(int maxSize) {
        this.maxSize = maxSize;
        // 초기 커넥션 생성
        for (int i = 0; i < maxSize; i++) {
            available.add(createConnection());
        }
    }
 
    public synchronized Connection acquire() {
        Connection conn = available.poll();
        if (conn != null) {
            inUse.add(conn);
            return conn;
        }
        throw new PoolExhaustedException("No available connections");
    }
 
    public synchronized void release(Connection conn) {
        inUse.remove(conn);
        if (conn.isValid()) {
            available.offer(conn);
        } else {
            available.offer(createConnection()); // 손상된 커넥션 교체
        }
    }
}

// 1. 생성자 주입 (Constructor Injection) -- 가장 권장
public class OrderService {
    private final PaymentGateway paymentGateway;
    private final InventoryService inventoryService;
 
    public OrderService(PaymentGateway paymentGateway,
                        InventoryService inventoryService) {
        this.paymentGateway = paymentGateway;
        this.inventoryService = inventoryService;
    }
}
 
// 2. 세터 주입 (Setter Injection) -- 선택적 의존성
public class ReportService {
    private CacheService cache;
 
    public void setCacheService(CacheService cache) {
        this.cache = cache;
    }
}
 
// 3. 메서드 주입 (Method Injection) -- 호출 시점에 결정
public class NotificationService {
    public void send(NotificationChannel channel, String message) {
        channel.deliver(message);
    }
}

// 팩토리 대신 부분 적용으로 객체 생성
const createLogger = (level: string) => (module: string) => (message: string) => {
    console.log(`[${level}][${module}] ${message}`);
};
 
const errorLogger = createLogger("ERROR");
const authErrorLogger = errorLogger("auth");
authErrorLogger("Login failed"); // [ERROR][auth] Login failed

// 의존성을 환경(Environment)으로 전달
type Reader<Env, A> = (env: Env) => A;
 
interface AppEnv {
    db: Database;
    logger: Logger;
    cache: CacheService;
}
 
const getUser: Reader<AppEnv, Promise<User>> =
    (env) => env.db.query("SELECT * FROM users WHERE id = ?");
 
const logAndGetUser: Reader<AppEnv, Promise<User>> =
    (env) => {
        env.logger.info("Fetching user");
        return getUser(env);
    };

// 각 함수는 독립적으로 구현
const validate = (input: RawOrder): Result<ValidOrder> => { /* ... */ };
const enrich = (order: ValidOrder): Result<EnrichedOrder> => { /* ... */ };
const persist = (order: EnrichedOrder): Result<SavedOrder> => { /* ... */ };
 
// Kleisli 합성으로 파이프라인 구성
const processOrder = compose(validate, enrich, persist);