IoC 컨테이너

Kkd·2024년 12월 31일
Inversion Of ControlLazy loadingSpringSpring Beandependency injection
0

매일메일 개념정리

목록 보기
56/93

IoC 컨테이너란?

IoC(제어의 역전) 컨테이너는 객체의 생성 및 관리를 개발자가 아닌 프레임워크(컨테이너)가 대신하도록 하는 개념입니다. 이는 객체의 생성, 초기화, 의존성 설정, 생명 주기 관리를 IoC 컨테이너가 수행하게 함으로써, 개발자는 비즈니스 로직 구현에 집중할 수 있도록 합니다.

스프링 프레임워크에서 IoC 컨테이너는 핵심 컴포넌트이며, 애플리케이션의 빈(bean)을 관리합니다.

IoC 컨테이너의 동작 방식

  1. 빈(Bean) 등록:

    • 개발자가 애플리케이션에서 사용할 객체를 정의.
    • 예: XML 파일, Java Config 클래스에서 빈으로 등록.

  2. 빈(Bean) 생성:

    • IoC 컨테이너가 등록된 빈을 필요에 따라 생성.

  3. 의존성 주입:

    • 빈 간의 관계(의존성)를 주입하여 필요한 객체가 서로 연결되도록 설정.
    • Setter Injection, Constructor Injection 등을 지원.

  4. 빈 관리 및 제공:

    • 애플리케이션 실행 중 IoC 컨테이너가 빈을 관리하고 필요한 경우 제공.

IoC 컨테이너의 구성 요소

  1. BeanFactory:

    • 가장 기본적인 IoC 컨테이너.
    • 지연 로딩(Lazy Loading) 방식으로 빈을 생성.
    • 메모리 효율적이지만, 복잡한 환경에서는 잘 사용하지 않음.

  2. ApplicationContext:

    • BeanFactory를 확장한 IoC 컨테이너.
    • 빈 생성 및 의존성 주입 외에도 이벤트 발행/구독, 메시지 리소스 처리 등 추가 기능을 제공.
    • 일반적으로 Spring 애플리케이션에서 기본 IoC 컨테이너로 사용.

IoC 컨테이너가 제공하는 주요 기능

  1. 의존성 주입 (Dependency Injection):

    • 객체 간의 의존성을 직접 설정하지 않고 IoC 컨테이너에 의해 자동으로 주입.
    @Component
public class MyService {
    private final MyRepository repository;

    // Constructor Injection
    public MyService(MyRepository repository) {
        this.repository = repository;
    }
}

  2. 객체 생명 주기 관리:

    • 객체의 생성부터 소멸까지의 생명 주기를 IoC 컨테이너가 책임짐.
    @Component
public class MyBean {
    @PostConstruct
    public void init() {
        System.out.println("Initializing bean");
    }

    @PreDestroy
    public void destroy() {
        System.out.println("Destroying bean");
    }
}

  3. AOP (Aspect-Oriented Programming):

    • IoC 컨테이너를 통해 객체에 부가적인 기능(예: 로깅, 트랜잭션 관리)을 쉽게 추가 가능.

  4. 빈 스코프 관리:

    • IoC 컨테이너는 빈의 스코프를 관리.
    • 스코프 예시: Singleton, Prototype, Request, Session.

IoC의 분류

  1. 인터페이스 주입 (Interface Injection)

    • 객체의 의존성을 설정할 때 인터페이스를 통해 주입받는 방식입니다.
    • 의존성을 주입받을 객체가 반드시 특정 인터페이스를 구현해야 합니다.
    • 사용 사례는 적으며, 일반적으로 잘 사용되지 않는 방식입니다.

    예시 (Java 코드):

    public interface Service {
    void perform();
}

public interface ServiceConsumer {
    void setService(Service service);
}

public class MyService implements Service {
    @Override
    public void perform() {
        System.out.println("Performing service");
    }
}

public class MyConsumer implements ServiceConsumer {
    private Service service;

    @Override
    public void setService(Service service) {
        this.service = service;
    }
}

  1. Setter 주입 (Setter Injection)

    • 의존성을 Setter 메서드를 통해 주입받는 방식입니다.
    • 선택적인 의존성을 처리하기에 적합합니다.
    • Spring에서 자주 사용되며, 객체를 생성한 후 Setter를 호출해 의존성을 설정합니다.

    예시 (Spring 코드):

    @Component
public class MyService {
    public void perform() {
        System.out.println("Performing service");
    }
}

@Component
public class MyConsumer {
    private MyService service;

    @Autowired
    public void setService(MyService service) {
        this.service = service;
    }

    public void execute() {
        service.perform();
    }
}

  1. 생성자 주입 (Constructor Injection)

    • 의존성을 객체의 생성자를 통해 주입받는 방식입니다.
    • 의존성이 필수적일 경우 적합하며, 불변 객체를 생성하는 데 유리합니다.
    • Spring에서 권장하는 방식 중 하나로, 의존성을 명시적으로 주입받을 수 있습니다.

    예시 (Spring 코드):

    @Component
public class MyService {
    public void perform() {
        System.out.println("Performing service");
    }
}

@Component
public class MyConsumer {
    private final MyService service;

    @Autowired
    public MyConsumer(MyService service) {
        this.service = service;
    }

    public void execute() {
        service.perform();
    }
}

  1. 컨텍스트 룩업 (Context Lookup)

    • 의존성을 컨테이너에서 직접 조회해서 가져오는 방식입니다.
    • 의존성 관리가 코드에 노출되기 때문에 IoC 원칙에 덜 부합하며, 사용이 권장되지 않습니다.
    • Service Locator 패턴과 유사합니다.

    예시 (Spring 코드):

    public class MyConsumer {
    public void execute() {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MyService service = context.getBean(MyService.class);
        service.perform();
    }
}

IoC 분류별 특징 비교

IoC 방식특징장점단점
인터페이스 주입인터페이스를 통해 의존성 주입의존성 명시적 선언구현이 번거로움, 사용 적음
Setter 주입Setter 메서드를 통해 의존성 주입선택적 의존성 처리 가능객체 생성 후 추가 설정 필요
생성자 주입생성자를 통해 의존성 주입불변 객체 생성 가능, 의존성 명시적 선언의존성이 많을 경우 생성자 복잡
컨텍스트 룩업컨테이너에서 의존성 직접 조회즉시 객체 사용 가능IoC 원칙에 덜 부합

Spring에서의 IoC 권장 방식

Spring에서는 생성자 주입을 기본적으로 권장하며, 필수 의존성을 명확히 설정하고 불변성을 유지하기에 적합합니다. Setter 주입은 선택적인 의존성을 설정하거나 필요에 따라 활용할 수 있습니다.

컨텍스트 룩업은 의존성을 코드에 노출시키므로 Spring IoC 컨테이너의 장점을 해치며, 인터페이스 주입은 구현이 번거롭고 유지보수에 비효율적이기 때문에 잘 사용되지 않습니다.

IoC 컨테이너의 장점

  1. 코드 재사용성 증가:

    • 의존성 설정 및 객체 생성을 컨테이너에 위임하여 비즈니스 로직에 집중 가능.

  2. 유연한 구성:

    • 객체 간의 의존성을 쉽게 변경 가능.
    • XML, Java Config, 애너테이션을 활용한 다양한 설정 지원.

  3. 테스트 용이성:

    • Mock 객체를 주입하여 단위 테스트를 쉽게 작성 가능.

  4. 객체 관리 간소화:

    • 객체의 생명 주기와 의존성 주입을 컨테이너가 처리.

예제 코드: IoC 컨테이너를 활용한 Spring 애플리케이션

Java Config

@Configuration
public class AppConfig {
    @Bean
    public MyRepository myRepository() {
        return new MyRepository();
    }

    @Bean
    public MyService myService(MyRepository repository) {
        return new MyService(repository);
    }
}

빈 사용

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MyService service = context.getBean(MyService.class);
        service.performTask();
    }
}

정리

IoC 컨테이너는 객체 관리의 제어권을 개발자가 아닌 프레임워크로 넘기는 방식으로, 애플리케이션을 모듈화하고 관리하기 쉽게 만들어줍니다. Spring IoC 컨테이너는 Java 기반 애플리케이션 개발의 핵심으로, 의존성 주입과 객체 생명 주기 관리를 자동으로 처리하며, 유연성과 테스트 가능성을 크게 향상시킵니다.

추가 학습 자료

profile
Kkd
🌱
이전 포스트

Spring Boot Actuator

다음 포스트

Lazy Loading(지연 로딩)

0개의 댓글