의존성 주입과 IoC 컨테이너

// 1. 추상화 (의존성: ILogger)
interface ILogger {
  log(message: string): void;
}

// 2. 구체적인 의존성 구현체 (저수준 모듈)
class ConsoleLogger implements ILogger {
  log(message: string): void {
    console.log(`[Console Log]: ${message}`);
  }
}

class FileLogger implements ILogger {
  log(message: string): void {
    console.log(`[File Log]: ${message}`);
    // 실제 파일 시스템에 쓰는 로직
  }
}

// 3. 의존성을 주입받는 객체 (고수준 모듈)
class UserService {
  private logger: ILogger; // ILogger 인터페이스에 의존

  // 1. 생성자 주입 (Constructor Injection): 가장 일반적이고 권장되는 방식
  constructor(logger: ILogger) {
    this.logger = logger;
  }

  // 2. 메서드 주입 (Method Injection): 특정 메서드 실행 시 필요한 의존성
  public registerUser(username: string, email: string, logger?: ILogger): void {
    const activeLogger = logger || this.logger; // 메서드 인자가 우선, 없으면 생성자 주입된 것 사용
    activeLogger.log(`Registering user: ${username}, ${email}`);
    // 사용자 등록 로직
  }

  // 3. 속성(Setter) 주입 (Property/Setter Injection): public 속성 또는 setter 메서드를 통해 주입
  public setLogger(logger: ILogger): void {
    this.logger = logger;
  }

  public processUserData(data: any): void {
    this.logger.log(`Processing user data: ${JSON.stringify(data)}`);
    // 데이터 처리 로직
  }
}

// 사용 예시 (DI 적용)
// 생성자 주입
const consoleLogger = new ConsoleLogger();
const userServiceWithConsole = new UserService(consoleLogger);
userServiceWithConsole.registerUser("Alice", "alice@example.com");
userServiceWithConsole.processUserData({ id: 1, name: "Alice" });

// 다른 로거로 쉽게 교체 (테스트 용이성)
const fileLogger = new FileLogger();
const userServiceWithFile = new UserService(fileLogger);
userServiceWithFile.registerUser("Bob", "bob@example.com");

// 메서드 주입 예시
userServiceWithConsole.registerUser("Charlie", "charlie@example.com", fileLogger); // 일시적으로 fileLogger 사용

// 속성 주입 예시
const userServiceWithSetter = new UserService(new ConsoleLogger()); // 일단 ConsoleLogger로 초기화
userServiceWithSetter.setLogger(new FileLogger()); // 나중에 FileLogger로 변경
userServiceWithSetter.processUserData({ id: 3, name: "David" });

import "reflect-metadata"; // 타입스크립트 데코레이터를 사용하려면 필요
import { Container, injectable, inject } from "inversify";

// 1. 심볼(Symbol) 또는 문자열을 사용하여 서비스(인터페이스)를 식별합니다.
const TYPES = {
  ILogger: Symbol.for("ILogger"),
  UserService: Symbol.for("UserService"),
};

// 2. 추상화 (인터페이스)
interface ILogger {
  log(message: string): void;
}

// 3. 구현체 (InversifyJS의 @injectable 데코레이터 사용)
@injectable()
class ConsoleLogger implements ILogger {
  log(message: string): void {
    console.log(`[Console Log by Inversify]: ${message}`);
  }
}

@injectable()
class FileLogger implements ILogger {
  log(message: string): void {
    console.log(`[File Log by Inversify]: ${message}`);
  }
}

// 4. 의존성을 주입받는 클래스 (InversifyJS의 @inject 데코레이터 사용)
@injectable()
class UserService {
  private logger: ILogger;

  // 생성자 주입을 @inject 데코레이터로 명시
  constructor(@inject(TYPES.ILogger) logger: ILogger) {
    this.logger = logger;
  }

  registerUser(username: string): void {
    this.logger.log(`User registered: ${username}`);
  }
}

// 5. IoC 컨테이너 설정 (바인딩)
const container = new Container();

// ILogger 심볼에 ConsoleLogger 구현체를 바인딩
container.bind<ILogger>(TYPES.ILogger).to(ConsoleLogger);

// ILogger 심볼에 FileLogger 구현체를 바인딩하려면 아래 라인을 활성화
// container.bind<ILogger>(TYPES.ILogger).to(FileLogger);

// UserService 심볼에 UserService 클래스를 바인딩
container.bind<UserService>(TYPES.UserService).to(UserService);

// 6. 컨테이너를 통해 객체 요청 (주입은 컨테이너가 알아서 처리)
const userService = container.get<UserService>(TYPES.UserService);
userService.registerUser("Grace");

// 런타임에 로거 구현체를 변경하고 싶다면, 바인딩만 변경하면 됩니다.
// container.rebind<ILogger>(TYPES.ILogger).to(FileLogger);
// const anotherUserService = container.get<UserService>(TYPES.UserService);
// anotherUserService.registerUser("Heidi");