Singleton

# Python 싱글톤 구현 예제
from threading import Lock
from typing import Optional


# 1. 데코레이터를 활용한 싱글톤 (가장 Pythonic)
def singleton(cls):
    """싱글톤 데코레이터"""
    instances = {}
    lock = Lock()

    def get_instance(*args, **kwargs):
        if cls not in instances:
            with lock:  # 스레드 안전
                if cls not in instances:
                    instances[cls] = cls(*args, **kwargs)
        return instances[cls]

    return get_instance


@singleton
class DatabaseConnection:
    """데코레이터 방식 싱글톤"""
    def __init__(self, host: str = "localhost"):
        self.host = host
        self.connected = False
        print(f"DB 연결 생성: {host}")

    def connect(self):
        self.connected = True
        print("DB 연결됨")


# 2. 메타클래스를 활용한 싱글톤 (고급)
class SingletonMeta(type):
    """싱글톤 메타클래스"""
    _instances = {}
    _lock = Lock()

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            with cls._lock:
                if cls not in cls._instances:
                    instance = super().__call__(*args, **kwargs)
                    cls._instances[cls] = instance
        return cls._instances[cls]


class Logger(metaclass=SingletonMeta):
    """메타클래스 방식 싱글톤"""
    def __init__(self):
        self.logs = []
        print("Logger 인스턴스 생성")

    def log(self, message: str):
        self.logs.append(message)
        print(f"[LOG] {message}")


# 3. __new__를 활용한 싱글톤 (클래식)
class ConfigManager:
    """__new__ 오버라이드 방식"""
    _instance: Optional['ConfigManager'] = None
    _lock = Lock()

    def __new__(cls):
        if cls._instance is None:
            with cls._lock:
                if cls._instance is None:
                    cls._instance = super().__new__(cls)
                    cls._instance._initialized = False
        return cls._instance

    def __init__(self):
        if self._initialized:
            return
        self._initialized = True
        self.config = {}
        print("ConfigManager 초기화")

    def set(self, key: str, value):
        self.config[key] = value

    def get(self, key: str, default=None):
        return self.config.get(key, default)


# 4. 모듈 레벨 싱글톤 (가장 간단, Python 권장)
# config.py 파일로 분리하면 자동으로 싱글톤
class _AppConfig:
    def __init__(self):
        self.debug = False
        self.version = "1.0.0"

app_config = _AppConfig()  # 모듈 로드 시 한 번만 생성


# 사용 예제
if __name__ == "__main__":
    # 데코레이터 싱글톤 테스트
    db1 = DatabaseConnection("mysql://prod")
    db2 = DatabaseConnection("mysql://dev")  # 무시됨
    print(f"같은 인스턴스? {db1 is db2}")  # True
    print(f"호스트: {db1.host}")  # mysql://prod

    # 메타클래스 싱글톤 테스트
    logger1 = Logger()
    logger2 = Logger()  # 기존 인스턴스 반환
    logger1.log("첫 번째 로그")
    print(f"같은 인스턴스? {logger1 is logger2}")  # True

    # __new__ 싱글톤 테스트
    config1 = ConfigManager()
    config1.set("api_key", "secret123")
    config2 = ConfigManager()
    print(f"API Key: {config2.get('api_key')}")  # secret123

// Java 싱글톤 구현 예제

// 1. Eager Initialization (즉시 초기화)
public class EagerSingleton {
    // 클래스 로딩 시점에 인스턴스 생성
    private static final EagerSingleton INSTANCE = new EagerSingleton();

    private EagerSingleton() {
        System.out.println("EagerSingleton 생성");
    }

    public static EagerSingleton getInstance() {
        return INSTANCE;
    }

    public void doSomething() {
        System.out.println("작업 수행");
    }
}


// 2. Lazy Initialization with Double-Checked Locking
public class ThreadSafeSingleton {
    // volatile: 멀티스레드 환경에서 가시성 보장
    private static volatile ThreadSafeSingleton instance;

    private ThreadSafeSingleton() {
        System.out.println("ThreadSafeSingleton 생성");
    }

    public static ThreadSafeSingleton getInstance() {
        if (instance == null) {  // 첫 번째 체크 (성능)
            synchronized (ThreadSafeSingleton.class) {
                if (instance == null) {  // 두 번째 체크 (안전)
                    instance = new ThreadSafeSingleton();
                }
            }
        }
        return instance;
    }
}


// 3. Bill Pugh Singleton (권장 방식)
public class BillPughSingleton {
    private BillPughSingleton() {
        System.out.println("BillPughSingleton 생성");
    }

    // 내부 정적 클래스 - 외부 클래스 로딩 시 로딩되지 않음
    private static class SingletonHolder {
        // getInstance() 호출 시점에 로딩 및 초기화
        private static final BillPughSingleton INSTANCE = new BillPughSingleton();
    }

    public static BillPughSingleton getInstance() {
        return SingletonHolder.INSTANCE;  // 지연 로딩 + 스레드 안전
    }
}


// 4. Enum Singleton (Joshua Bloch 권장)
public enum EnumSingleton {
    INSTANCE;

    private String config;

    public void setConfig(String config) {
        this.config = config;
    }

    public String getConfig() {
        return config;
    }

    public void doSomething() {
        System.out.println("Enum 싱글톤 작업: " + config);
    }
}


// 5. 실무 예제: Logger 싱글톤
public class Logger {
    private static volatile Logger instance;
    private final java.util.List logs;
    private final java.io.PrintWriter writer;

    private Logger() {
        this.logs = new java.util.ArrayList<>();
        this.writer = new java.io.PrintWriter(System.out);
    }

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

    public synchronized void log(String level, String message) {
        String logEntry = String.format("[%s] %s: %s",
            java.time.LocalDateTime.now(), level, message);
        logs.add(logEntry);
        writer.println(logEntry);
        writer.flush();
    }

    public void info(String message) { log("INFO", message); }
    public void error(String message) { log("ERROR", message); }
    public void debug(String message) { log("DEBUG", message); }
}


// 사용 예제
public class Main {
    public static void main(String[] args) {
        // Bill Pugh 싱글톤 테스트
        BillPughSingleton s1 = BillPughSingleton.getInstance();
        BillPughSingleton s2 = BillPughSingleton.getInstance();
        System.out.println("같은 인스턴스: " + (s1 == s2));  // true

        // Enum 싱글톤 테스트 (직렬화 안전, 리플렉션 방어)
        EnumSingleton.INSTANCE.setConfig("production");
        EnumSingleton.INSTANCE.doSomething();

        // Logger 싱글톤 테스트
        Logger logger = Logger.getInstance();
        logger.info("애플리케이션 시작");
        logger.debug("디버그 메시지");
        logger.error("에러 발생!");
    }
}

// TypeScript 싱글톤 구현 예제

// 1. 기본 싱글톤 패턴
class BasicSingleton {
    private static instance: BasicSingleton;

    // private 생성자로 외부 인스턴스화 방지
    private constructor() {
        console.log('BasicSingleton 생성');
    }

    public static getInstance(): BasicSingleton {
        if (!BasicSingleton.instance) {
            BasicSingleton.instance = new BasicSingleton();
        }
        return BasicSingleton.instance;
    }

    public doSomething(): void {
        console.log('작업 수행');
    }
}


// 2. 제네릭 싱글톤 데코레이터
function Singleton any>(constructor: T) {
    let instance: InstanceType | null = null;

    return class extends constructor {
        constructor(...args: any[]) {
            if (instance) {
                return instance;
            }
            super(...args);
            instance = this as InstanceType;
        }
    } as T;
}

@Singleton
class ConfigService {
    private config: Map = new Map();

    public set(key: string, value: any): void {
        this.config.set(key, value);
    }

    public get(key: string): T | undefined {
        return this.config.get(key) as T;
    }
}


// 3. 모듈 싱글톤 (ES6 모듈 활용 - 권장)
// logger.ts 파일로 분리
class Logger {
    private logs: string[] = [];

    log(level: 'INFO' | 'WARN' | 'ERROR', message: string): void {
        const timestamp = new Date().toISOString();
        const entry = `[${timestamp}] ${level}: ${message}`;
        this.logs.push(entry);
        console.log(entry);
    }

    info(message: string): void { this.log('INFO', message); }
    warn(message: string): void { this.log('WARN', message); }
    error(message: string): void { this.log('ERROR', message); }

    getLogs(): readonly string[] {
        return this.logs;
    }
}

// 모듈 레벨에서 단일 인스턴스 export
export const logger = new Logger();


// 4. 실무 예제: API 클라이언트 싱글톤
interface RequestConfig {
    baseURL: string;
    timeout: number;
    headers: Record;
}

class ApiClient {
    private static instance: ApiClient;
    private config: RequestConfig;

    private constructor(config: Partial = {}) {
        this.config = {
            baseURL: config.baseURL || 'https://api.example.com',
            timeout: config.timeout || 10000,
            headers: {
                'Content-Type': 'application/json',
                ...config.headers
            }
        };
        console.log('ApiClient 초기화:', this.config.baseURL);
    }

    public static getInstance(config?: Partial): ApiClient {
        if (!ApiClient.instance) {
            ApiClient.instance = new ApiClient(config);
        }
        return ApiClient.instance;
    }

    public setAuthToken(token: string): void {
        this.config.headers['Authorization'] = `Bearer ${token}`;
    }

    public async get(endpoint: string): Promise {
        const url = `${this.config.baseURL}${endpoint}`;
        console.log(`GET ${url}`);
        // 실제 구현에서는 fetch 또는 axios 사용
        const response = await fetch(url, {
            headers: this.config.headers
        });
        return response.json();
    }

    public async post(endpoint: string, data: any): Promise {
        const url = `${this.config.baseURL}${endpoint}`;
        console.log(`POST ${url}`, data);
        const response = await fetch(url, {
            method: 'POST',
            headers: this.config.headers,
            body: JSON.stringify(data)
        });
        return response.json();
    }
}


// 5. 의존성 주입을 고려한 싱글톤 (테스트 용이)
interface ILogger {
    log(message: string): void;
}

class ProductionLogger implements ILogger {
    private static instance: ProductionLogger;

    private constructor() {}

    static getInstance(): ProductionLogger {
        if (!ProductionLogger.instance) {
            ProductionLogger.instance = new ProductionLogger();
        }
        return ProductionLogger.instance;
    }

    log(message: string): void {
        console.log(`[PROD] ${message}`);
    }
}

// 테스트용 Mock
class MockLogger implements ILogger {
    public logs: string[] = [];

    log(message: string): void {
        this.logs.push(message);
    }
}

// 서비스에서 인터페이스로 주입받음
class UserService {
    constructor(private logger: ILogger) {}

    createUser(name: string): void {
        this.logger.log(`사용자 생성: ${name}`);
    }
}


// 사용 예제
const singleton1 = BasicSingleton.getInstance();
const singleton2 = BasicSingleton.getInstance();
console.log('같은 인스턴스:', singleton1 === singleton2);  // true

// API 클라이언트 사용
const api = ApiClient.getInstance({ baseURL: 'https://api.myapp.com' });
api.setAuthToken('my-jwt-token');

// 테스트에서 Mock 주입
const mockLogger = new MockLogger();
const userService = new UserService(mockLogger);
userService.createUser('홍길동');
console.log('로그 기록:', mockLogger.logs);  // ['사용자 생성: 홍길동']