의존성 주입과 IoC 컨테이너

의존성 주입(Dependency Injection, DI)은 객체 지향 프로그래밍에서 객체 간의 결합도를 낮추고 코드의 재사용성과 테스트 용이성을 높이는 디자인 패턴입니다.

타입스크립트에서 DI를 사용하면 타입 안정성과 함께 이러한 이점을 누릴 수 있습니다.

의존성 주입의 개념과 이점

DI는 객체가 자신의 의존성을 직접 생성하는 대신, 외부에서 의존성을 받아 사용하는 방식입니다.

주요 이점은 다음과 같습니다.

결합도 감소
테스트 용이성 향상
코드 재사용성 증가
관심사의 분리

타입스크립트에서의 의존성 주입 구현

생성자 주입

interface Logger {
    log(message: string): void;
}
 
class ConsoleLogger implements Logger {
    log(message: string): void {
        console.log(message);
    }
}
 
class UserService {
    constructor(private logger: Logger) {}
 
    createUser(name: string): void {
        // 사용자 생성 로직
        this.logger.log(`User created: ${name}`);
    }
}
 
// 사용
const logger = new ConsoleLogger();
const userService = new UserService(logger);
userService.createUser("Alice");

메서드 주입

class UserService {
    private logger: Logger;
 
    setLogger(logger: Logger): void {
        this.logger = logger;
    }
 
    createUser(name: string): void {
        if (!this.logger) {
            throw new Error("Logger is not set");
        }
        // 사용자 생성 로직
        this.logger.log(`User created: ${name}`);
    }
}
 
// 사용
const userService = new UserService();
userService.setLogger(new ConsoleLogger());
userService.createUser("Bob");

프로퍼티 주입

class UserService {
    logger: Logger;
 
    createUser(name: string): void {
        if (!this.logger) {
            throw new Error("Logger is not set");
        }
        // 사용자 생성 로직
        this.logger.log(`User created: ${name}`);
    }
}
 
// 사용
const userService = new UserService();
userService.logger = new ConsoleLogger();
userService.createUser("Charlie");

IoC 컨테이너

IoC(Inversion of Control) 컨테이너는 객체의 생성과 생명주기를 관리하고, 객체 간의 의존성을 자동으로 연결해주는 프레임워크입니다.

이는 의존성 관리를 중앙화하고 애플리케이션의 구조를 더욱 유연하게 만듭니다.

대표적인 IoC 컨테이너 라이브러리

InversifyJS

InversifyJS는 타입스크립트를 위한 강력한 IoC 컨테이너 라이브러리입니다.

import { injectable, inject, Container } from "inversify";
import "reflect-metadata";
 
@injectable()
class UserService {
    constructor(@inject("Logger") private logger: Logger) {}
 
    createUser(name: string): void {
        this.logger.log(`User created: ${name}`);
    }
}
 
const container = new Container();
container.bind<Logger>("Logger").to(ConsoleLogger);
container.bind<UserService>(UserService).toSelf();
 
const userService = container.get<UserService>(UserService);
userService.createUser("David");

TypeDI

TypeDI는 더 간단한 API를 제공하는 DI 컨테이너입니다.

import { Container, Service, Inject } from "typedi";
 
@Service()
class UserService {
    constructor(@Inject("Logger") private logger: Logger) {}
 
    createUser(name: string): void {
        this.logger.log(`User created: ${name}`);
    }
}
 
Container.set("Logger", new ConsoleLogger());
const userService = Container.get(UserService);
userService.createUser("Eve");

데코레이터를 활용한 의존성 주입

데코레이터를 사용하면 의존성 주입을 더 선언적으로 구현할 수 있습니다.

function Injectable() {
    return function(target: any) {
        // 의존성 주입 로직
    };
}
 
function Inject(key: string) {
    return function(target: any, propertyKey: string | symbol, parameterIndex: number) {
        // 주입 로직
    };
}
 
@Injectable()
class UserService {
    constructor(@Inject("Logger") private logger: Logger) {}
    // ...
}

장점 : 코드가 더 선언적이고 읽기 쉬워집니다.

단점 : 데코레이터는 아직 실험적 기능이며, 런타임 의존성이 생깁니다.

단위 테스트와 의존성 주입

의존성 주입을 사용하면 단위 테스트가 훨씬 쉬워집니다.

describe('UserService', () => {
    it('should create a user', () => {
        const mockLogger: Logger = {
            log: jest.fn()
        };
        const userService = new UserService(mockLogger);
        userService.createUser("Frank");
        expect(mockLogger.log).toHaveBeenCalledWith("User created: Frank");
    });
});

순환 의존성 해결

순환 의존성은 두 클래스가 서로를 의존할 때 발생합니다.

이를 해결하기 위한 전략

의존성 주입을 인터페이스 기반으로 변경
중재자 패턴 사용
지연 초기화 사용

interface UserRepository {
    save(user: User): void;
}
 
@injectable()
class UserService {
    private userRepo: UserRepository;
 
    constructor(@inject("UserRepositoryFactory") private userRepoFactory: () => UserRepository) {}
 
    createUser(name: string): void {
        if (!this.userRepo) {
            this.userRepo = this.userRepoFactory();
        }
        // 사용자 생성 및 저장 로직
    }
}

대규모 애플리케이션에서의 의존성 관리

모듈화 : 기능별로 모듈을 분리하고, 각 모듈에 대한 DI 컨테이너 설정
계층화 : 데이터 접근, 비즈니스 로직, 프레젠테이션 계층으로 분리
인터페이스 기반 프로그래밍 : 구체적인 구현보다 인터페이스에 의존

성능 최적화

지연 초기화 : 필요한 시점에 객체 생성
싱글톤 사용 : 적절한 경우 객체를 재사용
팩토리 패턴 : 복잡한 객체 생성 로직 캡슐화

@injectable()
class ExpensiveService {
    @lazy private expensiveObject: ExpensiveObject;
 
    doSomething(): void {
        this.expensiveObject.method();
    }
}

Best Practices와 주의사항

인터페이스 기반 의존성 정의 : 구체적인 구현보다 추상화에 의존
생성자 주입 선호 : 객체 생성 시점에 모든 의존성 명시
순환 의존성 주의 : 설계 재검토 또는 중재자 패턴 고려
테스트 용이성 고려 : 모의 객체(mock)를 쉽게 주입할 수 있도록 설계
과도한 추상화 주의 : 불필요한 복잡성 증가 방지
문서화 : DI 설정과 의존성 그래프 명확히 문서화
일관된 명명 규칙 : 인터페이스와 구현체의 명명 규칙 통일
생명주기 관리 : 객체의 생성과 소멸 시점 명확히 정의
컨테이너 설정 모듈화 : 대규모 애플리케이션에서 설정 파일 분리
버전 관리 : 의존성 주입 설정의 버전 관리 및 변경 이력 추적

의존성 주입은 단순히 기술적인 패턴이 아니라 소프트웨어 설계 철학의 일부입니다.

NestJS 혹은 Spring 같은 프레임워크에서는 의존성 주입을 기본적으로 지원하며, 백엔드에서는 이를 통해 코드의 유지보수성과 테스트 용이성을 높일 수 있습니다.

이를 통해 관심사의 분리, 단일 책임 원칙 등 좋은 객체 지향 설계 원칙을 실현할 수 있습니다.

이전으로 다음으로