Decorator

# 1. 기본 데코레이터 - 실행 시간 측정
import time
import functools

def timer(func):
    @functools.wraps(func)  # 원본 함수 메타데이터 보존
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        end = time.perf_counter()
        print(f"{func.__name__} 실행 시간: {end - start:.4f}초")
        return result
    return wrapper

@timer
def slow_function():
    time.sleep(1)
    return "완료"

slow_function()  # 출력: slow_function 실행 시간: 1.0012초

# 2. 인자를 받는 데코레이터 - 재시도 로직
def retry(max_attempts=3, delay=1):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(1, max_attempts + 1):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == max_attempts:
                        raise
                    print(f"시도 {attempt} 실패, {delay}초 후 재시도...")
                    time.sleep(delay)
        return wrapper
    return decorator

@retry(max_attempts=3, delay=2)
def fetch_data(url):
    # API 호출 로직
    pass

# 3. 클래스 데코레이터 - 싱글톤 패턴
def singleton(cls):
    instances = {}
    @functools.wraps(cls)
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

@singleton
class Database:
    def __init__(self):
        print("DB 연결 생성")

db1 = Database()  # 출력: DB 연결 생성
db2 = Database()  # 출력 없음 (같은 인스턴스 반환)
print(db1 is db2)  # True

// 1. 메서드 데코레이터 - 로깅
function Log(target: any, key: string, descriptor: PropertyDescriptor) {
    const original = descriptor.value;

    descriptor.value = function(...args: any[]) {
        console.log(`[LOG] ${key} 호출됨, 인자:`, args);
        const result = original.apply(this, args);
        console.log(`[LOG] ${key} 반환값:`, result);
        return result;
    };

    return descriptor;
}

class Calculator {
    @Log
    add(a: number, b: number): number {
        return a + b;
    }
}

const calc = new Calculator();
calc.add(2, 3);
// 출력: [LOG] add 호출됨, 인자: [2, 3]
// 출력: [LOG] add 반환값: 5

// 2. 클래스 데코레이터 - 의존성 주입 (NestJS 스타일)
function Controller(prefix: string) {
    return function(target: Function) {
        Reflect.defineMetadata('prefix', prefix, target);
    };
}

function Get(path: string) {
    return function(target: any, key: string, descriptor: PropertyDescriptor) {
        Reflect.defineMetadata('path', path, target, key);
        Reflect.defineMetadata('method', 'GET', target, key);
    };
}

@Controller('/users')
class UserController {
    @Get('/:id')
    getUser(id: string) {
        return { id, name: '홍길동' };
    }
}

// 3. 프로퍼티 데코레이터 - 유효성 검사
function MinLength(min: number) {
    return function(target: any, propertyKey: string) {
        let value: string;

        const getter = () => value;
        const setter = (newVal: string) => {
            if (newVal.length < min) {
                throw new Error(`${propertyKey}는 최소 ${min}자 이상이어야 합니다`);
            }
            value = newVal;
        };

        Object.defineProperty(target, propertyKey, {
            get: getter,
            set: setter,
            enumerable: true,
            configurable: true
        });
    };
}

class User {
    @MinLength(2)
    name: string;

    @MinLength(8)
    password: string;
}

const user = new User();
user.name = "김";  // Error: name는 최소 2자 이상이어야 합니다