psj.log

Unit 7.3 — IoC 컨테이너의 역할
F-LAB JAVA · 5주차 · Phase 7 · 제어의 역전 (IoC)
🏆 Phase 7 완주 — IoC 의 실체, 컨테이너
📌 학습 목표
이 Unit을 끝내면 다음을 답할 수 있어야 한다.
 IoC 컨테이너 란 무엇인가?
 객체 생성·연결·생명주기 관리 의 의미는?
 IoC 컨테이너 = Spring ApplicationContext 인가?
 IoC 컨테이너 없이 IoC 를 구현 하면?
 컨테이너가 하는 일 은?
 Spring 외 IoC 컨테이너 예 는?
 컨테이너의 이점 은?
 빈 (Bean) 과 컨테이너 관계는?
 Phase 7 전체 의 종합은?
🎯 핵심 한 문장
IoC 컨테이너는 객체의 생성·연결·생명주기를 대신 관리하는 외부 주체로, Spring 의 ApplicationContext 가 그 실체이며, 컨테이너 없이도 main 이나 팩토리에서 IoC 를 구현할 수 있지만 컨테이너는 이를 체계적·자동으로 처리한다.
IoC 컨테이너는 IoC 의 "외부 주체" 를 실체화한 것으로, 객체 (빈) 를 생성 하고, 의존성을 연결 (주입) 하며, 생성부터 소멸까지 생명주기 를 관리한다.
Spring 에서는 ApplicationContext (또는 BeanFactory) 가 IoC 컨테이너 역할을 하며, 설정 (@Configuration/@Bean, 컴포넌트 스캔) 을 읽어 빈을 만들고 조립한다.
IoC 컨테이너 없이도 IoC 는 가능하다 — main 이나 DaoFactory 가 직접 new 로 객체를 만들고 주입하면 그것도 IoC 다.
다만 객체가 많아지면 수동 조립이 복잡해지므로, 컨테이너가 설정 기반으로 체계적이고 자동으로 생성·주입·관리하며, Spring 외에도 Google Guice, Java EE CDI 등이 IoC 컨테이너 역할을 한다.
비유 — 오케스트라 지휘자
IoC 컨테이너 = 오케스트라 지휘자:
컨테이너 없이 (자율 연주):
  - 각 연주자가 알아서 시작
  - main 이 일일이 "너 시작, 너 다음"
  - 곡 커지면 혼란
컨테이너 (지휘자):
  - 지휘자(컨테이너)가 전체 조율
  - 연주자(빈) 생성·배치
  - 누가 누구와 협연(의존성)
  - 시작·종료(생명주기)
컨테이너가 하는 일:
  1. 연주자 모으기 (빈 생성)
  2. 자리 배치 (의존성 연결)
  3. 지휘 (생명주기)
ApplicationContext = 지휘자
빈 = 연주자
지휘자 없이도 (main):
  - 가능하지만
  - 소규모만
  - 커지면 지휘자 필요
→ IoC 컨테이너 = 객체 생성·연결·생명주기 관리 (지휘자), Spring ApplicationContext.
🧭 9개 섹션 로드맵
1. IoC 컨테이너란
2. 객체 생성·연결·생명주기
3. ApplicationContext
4. 컨테이너 없이 IoC
5. 컨테이너가 하는 일
6. Spring 외 IoC 컨테이너
7. 컨테이너의 이점
8. Phase 7 완주 정리
9. 면접 + 자기 점검
1️⃣ IoC 컨테이너란
1.1 IoC 컨테이너
IoC 컨테이너:
  객체의 생성·연결·생명주기를
  대신 관리하는 외부 주체.
  - IoC 의 "외부" 실체화
  - 객체 관리 전담
1.2 IoC 주체
IoC 의 주체:
  Unit 7.1:
    - 제어가 외부로
  외부 = ?
    - 다른 객체
    - 프레임워크
    - IoC 컨테이너 ← 체계적
→ 컨테이너가 그 외부
1.3 역할
컨테이너 역할:
  1. 생성: 객체 만듦
  2. 연결: 의존성 주입
  3. 관리: 생명주기
→ 객체 관리 전담
1.4 ILIC 의 맥락
// IoC 컨테이너 (Spring)
@Configuration
public class AppConfig {
    @Bean
    public ConnectionMaker connectionMaker() {
        return new CustomerAConnectionMaker();
    }
    @Bean
    public ShipmentDao shipmentDao() {
        return new ShipmentDao(connectionMaker());   // 연결
    }
}
// 컨테이너가 생성·연결·관리
// ApplicationContext ctx = 
//     new AnnotationConfigApplicationContext(AppConfig.class);
// ShipmentDao dao = ctx.getBean(ShipmentDao.class);
class ShipmentDao {
    ShipmentDao(ConnectionMaker cm) { }
}
interface ConnectionMaker { Connection makeConnection(); }
class CustomerAConnectionMaker implements ConnectionMaker {
    public Connection makeConnection() { return null; }
}
1.5 자기 점검 답변
IoC 컨테이너란 무엇인가?
답:
컨테이너:
객체 관리 외부 주체
IoC 주체:
외부의 실체화
역할:
생성/연결/관리
전담:
객체 관리
2️⃣ 객체 생성·연결·생명주기
2.1 세 가지 관리
세 가지 관리:
1. 생성 (Creation)
   - 객체 인스턴스화
2. 연결 (Wiring)
   - 의존성 주입
3. 생명주기 (Lifecycle)
   - 생성 ~ 소멸
2.2 생성
생성:
  컨테이너가:
    - 빈 정의 읽음
    - 객체 생성
    - new 대신
→ 객체 생성 권한
2.3 연결
연결 (의존성 주입):
  컨테이너가:
    - 의존성 파악
    - 자동 주입
    - 조립
→ A 가 B 필요하면 B 주입
2.4 생명주기
생명주기:
  컨테이너가:
    - 생성 (@PostConstruct)
    - 사용
    - 소멸 (@PreDestroy)
→ 전 과정 관리
2.5 ILIC 의 맥락
@Component
public class ShipmentService {
    private final ShipmentDao shipmentDao;
    // 1. 생성 + 2. 연결 (컨테이너가)
    public ShipmentService(ShipmentDao shipmentDao) {
        this.shipmentDao = shipmentDao;   // 컨테이너가 주입
    }
    // 3. 생명주기 (컨테이너가 호출)
    @PostConstruct
    public void init() {
        log.info("서비스 초기화");   // 생성 후
    }
    @PreDestroy
    public void cleanup() {
        log.info("서비스 종료");   // 소멸 전
    }
}
// 컨테이너가 생성·연결·생명주기 모두
2.6 자기 점검 답변
객체 생성·연결·생명주기 관리의 의미는?
답:
생성:
객체 인스턴스화
연결:
의존성 주입
생명주기:
생성 ~ 소멸
컨테이너:
전 과정 관리
3️⃣ ApplicationContext
3.1 ApplicationContext
ApplicationContext:
  Spring 의 IoC 컨테이너:
    - 빈 생성·관리
    - DI
    - 부가 기능 (i18n, 이벤트)
3.2 BeanFactory 와 관계
BeanFactory vs ApplicationContext:
BeanFactory:
  - 기본 컨테이너
  - 빈 생성·DI
ApplicationContext:
  - BeanFactory 확장
  - + 부가 기능
  - 실무 표준
3.3 생성
// ApplicationContext 생성
ApplicationContext ctx = 
    new AnnotationConfigApplicationContext(AppConfig.class);
// 빈 가져오기
ShipmentDao dao = ctx.getBean(ShipmentDao.class);
// 컨테이너가 생성·연결한 빈
3.4 설정 방식
설정 방식:
  - @Configuration + @Bean (자바 설정)
  - @ComponentScan (자동 스캔)
  - XML (전통)
→ 컨테이너가 설정 읽고 조립
3.5 ILIC 의 맥락
// ApplicationContext (ILIC)
@Configuration
@ComponentScan("com.ilic")
public class IlicConfig {
    @Bean
    public ConnectionMaker connectionMaker() {
        return new CustomerAConnectionMaker();
    }
}
// 컨테이너 생성
public class IlicApp {
    public static void main(String[] args) {
        ApplicationContext ctx = 
            new AnnotationConfigApplicationContext(IlicConfig.class);
        // 컨테이너가 조립한 빈 사용
        ShipmentDao dao = ctx.getBean(ShipmentDao.class);
        // dao 는 ConnectionMaker 주입된 상태
    }
}
// Spring Boot 는 자동 (SpringApplication.run)
@Component
class ShipmentDao {
    ShipmentDao(ConnectionMaker cm) { }
}
interface ConnectionMaker { Connection makeConnection(); }
class CustomerAConnectionMaker implements ConnectionMaker {
    public Connection makeConnection() { return null; }
}
3.6 자기 점검 답변
IoC 컨테이너 = Spring ApplicationContext인가?
답:
ApplicationContext:
Spring IoC 컨테이너
BeanFactory:
기본, 확장이 AC
생성:
new AnnotationConfig...
설정:
@Bean/@ComponentScan
4️⃣ 컨테이너 없이 IoC
4.1 컨테이너 없이도 IoC
컨테이너 없이 IoC:
  main 이나 팩토리:
    - 직접 new
    - 직접 주입
    - 그것도 IoC
→ 컨테이너는 필수 X
4.2 main 에서 IoC
// main 에서 IoC (컨테이너 없이)
public class App {
    public static void main(String[] args) {
        // 직접 생성·주입 (IoC)
        ConnectionMaker cm = new NConnectionMaker();
        ShipmentDao dao = new ShipmentDao(cm);   // 주입
        // main 이 외부 주체 (IoC)
    }
}
// 컨테이너 없어도 제어 역전
4.3 팩토리에서 IoC
// 팩토리에서 IoC
public class DaoFactory {
    public ShipmentDao shipmentDao() {
        return new ShipmentDao(connectionMaker());   // 조립
    }
    public ConnectionMaker connectionMaker() {
        return new NConnectionMaker();
    }
}
// DaoFactory 가 외부 주체 (IoC)
4.4 컨테이너의 필요성
컨테이너 필요성:
  객체 적을 때:
    - 수동 조립 OK
  객체 많을 때 (102 테이블, 431 API):
    - 수동 복잡
    - 컨테이너 자동화 필요
4.5 ILIC 의 맥락
// 컨테이너 없이 IoC (수동)
public class ManualIoC {
    public static void main(String[] args) {
        // 수동 조립 (IoC, 컨테이너 X)
        ConnectionMaker cm = new CustomerAConnectionMaker();
        ShipmentDao shipmentDao = new ShipmentDao(cm);
        BookingDao bookingDao = new BookingDao(cm);
        InvoiceDao invoiceDao = new InvoiceDao(cm);
        ShipmentService service = 
            new ShipmentService(shipmentDao, bookingDao, invoiceDao);
        // ... 수십 개 객체 수동 조립
        // → 복잡 (컨테이너 필요)
    }
}
// 컨테이너 (자동)
@Configuration
@ComponentScan("com.ilic")
class IlicConfig { }
// 컨테이너가 자동 조립 (수동 X)
class ShipmentDao { ShipmentDao(ConnectionMaker cm) {} }
class BookingDao { BookingDao(ConnectionMaker cm) {} }
class InvoiceDao { InvoiceDao(ConnectionMaker cm) {} }
class ShipmentService { ShipmentService(ShipmentDao a, BookingDao b, InvoiceDao c) {} }
interface ConnectionMaker { Connection makeConnection(); }
class CustomerAConnectionMaker implements ConnectionMaker {
    public Connection makeConnection() { return null; }
}
4.6 자기 점검 답변
IoC 컨테이너 없이 IoC를 구현하면?
답:
컨테이너 없이도:
main/팩토리 IoC
main:
직접 생성·주입
팩토리:
조립 객체
필요성:
객체 많으면 컨테이너
5️⃣ 컨테이너가 하는 일
5.1 하는 일
컨테이너가 하는 일:
1. 빈 정의 읽기 (설정)
2. 빈 생성
3. 의존성 주입
4. 생명주기 관리
5. 빈 제공 (getBean)
5.2 빈 정의
빈 정의 읽기:
  설정 소스:
    - @Configuration/@Bean
    - @Component 스캔
    - XML
  → 어떤 빈, 어떻게 조립
5.3 의존성 해결
의존성 해결:
  컨테이너가:
    - 의존성 파악 (생성자/필드)
    - 필요한 빈 찾음
    - 자동 주입
  → 조립 자동
5.4 빈 등록·제공
// 빈 등록·제공
ApplicationContext ctx = ...;
// 타입으로
ShipmentDao dao = ctx.getBean(ShipmentDao.class);
// 이름으로
Object bean = ctx.getBean("shipmentDao");
// 컨테이너가 관리하는 빈 제공
5.5 ILIC 의 맥락
// 컨테이너가 하는 일 (ILIC)
@Configuration
@ComponentScan("com.ilic")
public class IlicConfig {
    // 1. 빈 정의
    @Bean
    public ConnectionMaker connectionMaker() {
        return new CustomerAConnectionMaker();
    }
}
@Service
public class ShipmentService {
    // 2. 의존성 (컨테이너가 해결)
    private final ShipmentDao shipmentDao;
    public ShipmentService(ShipmentDao shipmentDao) {
        this.shipmentDao = shipmentDao;   // 컨테이너 주입
    }
}
// 컨테이너 작업:
// 1. IlicConfig + 컴포넌트 스캔 읽기
// 2. ConnectionMaker, ShipmentDao, ShipmentService 빈 생성
// 3. 의존성 자동 주입 (ShipmentDao → Service)
// 4. 생명주기 관리
// 5. getBean 으로 제공
@Component
class ShipmentDao { ShipmentDao(ConnectionMaker cm) {} }
interface ConnectionMaker { Connection makeConnection(); }
class CustomerAConnectionMaker implements ConnectionMaker {
    public Connection makeConnection() { return null; }
}
5.6 자기 점검 답변
컨테이너가 하는 일은?
답:
하는 일:
빈 정의/생성/주입/관리/제공
빈 정의:
설정 읽기
의존성 해결:
자동 주입
제공:
getBean
6️⃣ Spring 외 IoC 컨테이너
6.1 다른 컨테이너
Spring 외 IoC 컨테이너:
  - Google Guice
  - Java EE CDI (Weld)
  - Dagger (안드로이드)
  - PicoContainer
6.2 Guice
Google Guice:
  - 경량 DI 프레임워크
  - 애노테이션 기반
  - @Inject
  → IoC 컨테이너
6.3 CDI
Java EE CDI:
  Contexts and Dependency Injection:
    - 표준 (JSR)
    - @Inject, @Named
    - Java EE/Jakarta EE
  → 표준 IoC 컨테이너
6.4 Dagger
Dagger:
  - 컴파일 타임 DI
  - 안드로이드 주로
  - 런타임 오버헤드 ↓
  - 코드 생성
6.5 공통점
공통점:
  모두 IoC 컨테이너:
    - 객체 생성·주입
    - 의존성 관리
    - 제어 역전
  → 같은 정신
6.6 ILIC 의 맥락
// Spring DI (ILIC 사용)
@Service
public class ShipmentService {
    private final ShipmentDao dao;
    public ShipmentService(ShipmentDao dao) {   // Spring DI
        this.dao = dao;
    }
}
// 비교: Guice 스타일 (개념)
// public class ShipmentService {
//     @Inject
//     public ShipmentService(ShipmentDao dao) { }   // Guice
// }
// 비교: CDI 스타일 (개념)
// @ApplicationScoped
// public class ShipmentService {
//     @Inject ShipmentDao dao;   // CDI
// }
// 모두 IoC 컨테이너 (제어 역전, 자동 주입)
// ILIC 는 Spring 사용
class ShipmentDao { }
6.7 자기 점검 답변
Spring 외 IoC 컨테이너 예는?
답:
다른 컨테이너:
Guice, CDI, Dagger
Guice:
경량 DI
CDI:
Java EE 표준
공통:
제어 역전, DI
7️⃣ 컨테이너의 이점
7.1 이점 정리
컨테이너 이점:
1. 자동 조립
2. 설정 중앙화
3. 생명주기 관리
4. 부가 기능
5. 테스트
7.2 자동 조립
자동 조립:
  수동 (main):
    - 수십 개 new
    - 순서 관리
  컨테이너:
    - 자동 생성·주입
    - 의존성 해결
7.3 설정 중앙화
설정 중앙화:
  빈 설정:
    - @Configuration 한 곳
    - 또는 스캔
  → 조립 한눈에
7.4 부가 기능
부가 기능 (ApplicationContext):
  - AOP
  - 트랜잭션
  - 이벤트
  - i18n
  - 프로파일
→ 컨테이너가 제공
7.5 ILIC 의 맥락
// 컨테이너 이점 (ILIC)
@SpringBootApplication
public class IlicApplication {
    public static void main(String[] args) {
        SpringApplication.run(IlicApplication.class, args);
        // 컨테이너가:
        // 1. 102 테이블 관련 DAO 자동 조립
        // 2. 431 API 컨트롤러 자동 등록
        // 3. 서비스 의존성 자동 주입
        // 4. 트랜잭션, AOP 적용
        // 5. 생명주기 관리
        // → 수동이면 불가능한 규모
    }
}
// 빈은 그냥 선언만
@Service
class ShipmentService {
    private final ShipmentDao dao;
    ShipmentService(ShipmentDao dao) { this.dao = dao; }
    // 컨테이너가 알아서 조립
}
@Repository
class ShipmentDao { }
7.6 자기 점검 답변
컨테이너의 이점은?
답:
이점:
자동 조립
설정 중앙화
자동 조립:
수동 new 제거
부가 기능:
AOP, 트랜잭션
규모:
큰 앱 가능
8️⃣ Phase 7 완주 정리
8.1 Phase 7 학습 종합
Phase 7 — 제어의 역전 (IoC)
Unit 7.1 — IoC 개념 ★깊이
  - 제어 역전 (외부가 결정)
  - 전통 vs IoC
Unit 7.2 — 프레임워크 vs 라이브러리
  - 제어권 (IoC 여부)
  - Hollywood Principle
Unit 7.3 — IoC 컨테이너
  - 생성·연결·생명주기
  - ApplicationContext
8.2 핵심 메시지
Phase 7 핵심 메시지:
  "IoC 는 객체 제어를 외부로 넘기는 것.
   프레임워크가 그 외부 (호출당함).
   IoC 컨테이너 (ApplicationContext) 가
   객체 생성·연결·생명주기를 관리한다."
8.3 진화 과정
진화 과정:
전략 주입 (Phase 6)
    ↓ 개념화
IoC (Phase 7.1)
    ↓ 프레임워크
프레임워크 IoC (Phase 7.2)
    ↓ 실체
IoC 컨테이너 (Phase 7.3)
    ↓ (다음)
Spring 컨테이너 상세 (Phase 8)
8.4 다음 Phase 예고
Phase 7 → Phase 8:
  - IoC 컨테이너 → Spring 상세
Phase 8 — Spring 컨테이너 (8.3·8.4 ★깊이):
  - 빈팩토리/ApplicationContext
  - getBean
  - 싱글톤 레지스트리 ★깊이
  - DI ★깊이
8.5 자기 점검 답변
Phase 7의 종합은?
답:
3 Unit:
IoC 개념
프레임워크 vs 라이브러리
IoC 컨테이너
메시지:
제어 외부로
컨테이너 관리
진화:
전략 → IoC → 컨테이너
다음:
Spring 컨테이너 상세
9️⃣ 면접 + 자기 점검
9.1 면접 단골 질문 매핑
Q
핵심 답변
IoC 컨테이너?
객체 생성·연결·생명주기 관리
생성·연결·생명주기?
3가지 관리
ApplicationContext?
Spring IoC 컨테이너
컨테이너 없이 IoC?
main/팩토리도 IoC
컨테이너가 하는 일?
빈 정의/생성/주입/관리
Spring 외?
Guice, CDI, Dagger
이점?
자동 조립, 부가 기능
빈?
컨테이너 관리 객체
다음?
Spring 컨테이너 상세
IoC 정신?
제어 외부로
9.2 자기 점검 체크리스트
컨테이너
 정의
3가지 관리
 생성/연결/생명주기
ApplicationContext
 Spring 컨테이너
컨테이너 없이
 main/팩토리
하는 일
 빈 관리
Spring 외
 Guice/CDI
이점
 자동 조립
9.3 추가 심화 질문
Q1: BeanFactory vs ApplicationContext?
답:
BeanFactory: 기본 (지연 로딩)
ApplicationContext: 확장 (즉시 로딩)
AC: AOP, 이벤트, i18n
실무 = AC
Q2: 컨테이너 초기화 시점?
답:
ApplicationContext: 시작 시 빈 생성 (eager)
BeanFactory: 요청 시 (lazy)
@Lazy 로 지연 가능
시작 시 오류 발견 (AC 장점)
Q3: 컨테이너 종료?
답:
close() / 자동
@PreDestroy 호출
싱글톤 정리
리소스 해제
Q4: 여러 컨테이너?
답:
부모-자식 컨테이너
웹: Root + Servlet
계층 구조
빈 공유/분리
Q5: 컨테이너와 메모리?
답:
싱글톤 빈 (기본)
컨테이너가 보유
메모리 효율
→ Unit 8.3 싱글톤
🎯 핵심 요약 — 3줄 정리
1. IoC 컨테이너
객체의 생성·연결·생명주기를 관리하는 외부 주체
Spring 의 ApplicationContext 가 실체
2. 컨테이너 없이도 IoC
main/팩토리 직접 조립도 IoC
객체 많으면 컨테이너 자동화 필요
3. 컨테이너의 일과 종류
빈 정의/생성/주입/생명주기/제공
Spring 외 Guice, CDI, Dagger
🏆 Phase 7 완주 — 제어의 역전 (IoC)
🌱 Phase 7 — 제어의 역전 (IoC)
  ✅ Unit 7.1 IoC 개념 ★깊이
  ✅ Unit 7.2 프레임워크 vs 라이브러리
  ✅ Unit 7.3 IoC 컨테이너의 역할 ← 여기, Phase 7 완주
→ IoC (제어 외부로)
→ 프레임워크 (호출당함)
→ IoC 컨테이너 (ApplicationContext)
📚 다음으로...
Phase 8 — Spring 컨테이너 (5주차 마지막!)
Phase 8 — Spring 컨테이너 (8.3·8.4 ★깊이)
  Unit 8.1 — 빈 팩토리와 ApplicationContext
  Unit 8.2 — getBean()의 동작
  Unit 8.3 — 싱글톤 레지스트리 ★깊이
  Unit 8.4 — 의존관계 주입 DI ★깊이 (+ 종합 졸업 시험)
5주차 누적 진행
✅ Part A — 동시성 마무리 (7 Unit)
🌱 Part B — 토비의 스프링
  ✅ Phase 3~6 (12 Unit)
  ✅ Phase 7 — IoC (3 Unit) ← 완주
  ⏭ Phase 8 — Spring 컨테이너 (4 Unit, 마지막)
총: 22/26 Unit
🏆 Phase 7 완주 — IoC 의 실체, 컨테이너

5주차 Unit 7.3 — IoC 컨테이너의 역할

댓글