이번 3주차에서는 스프링의 핵심 개념인 IoC와 DI를 시작으로,
객체 생성부터 HTTP 요청 처리까지의 전체 흐름을 학습했습니다.

특히 부록 1~4를 통해 Bean 생성 → Filter → DispatcherServlet → 응답 처리까지
실제 실행 흐름을 따라가며 스프링의 내부 구조를 이해하는 데 집중했습니다.

3주차 워크북 정리

---

1. Spring이 무엇인가 → “프레임워크”

Spring은
자바 애플리케이션을 쉽게 만들도록 도와주는 프레임워크

핵심은 “뼈대 제공”

자주 쓰는 기능 구조를 미리 만들어둠
개발자는 그 안에 코드만 채움

2. 프레임워크 vs 라이브러리 → “제어권 차이”

★ 라이브러리 : 내가 필요할 때 호출
제어권 → 개발자

★ 프레임워크 : 내가 코드를 넣으면 알아서 실행
제어권 → 프레임워크

3. IoC → 제어권이 넘어간 상태

프레임워크를 쓰면 발생하는 핵심 개념 제어의 역전 (IoC)

객체 생성 / 실행 흐름 / 생명주기
→ 개발자가 아니라 프레임워크가 관리

즉, “내가 실행하는 구조” → “프레임워크가 실행하는 구조”

4. DI → IoC를 실제로 구현하는 방법

IoC만으로는 추상적이기 때문에 이를 구현하는 방법이 필요한데, 그게 DI

객체가 필요한 의존성을 직접 생성 ❌
외부에서 주입받음 ⭕

5. 왜 DI가 필요한가 → 결합도 문제 해결

문서에서 핵심 예시: 커피 머신

기존 (강한 결합)

• CoffeeMachine 내부에서 직접 객체 생성
• 부품 바꾸려면 전체 코드 수정 필요

DI 적용 (느슨한 결합)

• 인터페이스 + 외부 주입
• Bean만 바꾸면 동작 변경 가능

결과

• 유지보수 쉬움
• 확장 쉬움

6. Spring에서 IoC + DI가 어떻게 구현되는가

★ “컨테이너” 개념 ★

Spring 컨테이너

• 객체(Bean)를 생성하고 관리
• 의존성 자동 주입

Bean

• Spring이 관리하는 객체

동작 흐름

• 클래스 정의
• 어노테이션으로 관계 설정
• 컨테이너가 객체 생성
• 필요한 곳에 주입

7. DI 방식 (구체화 단계)

DI를 실제 코드로 적용하는 방법

① 생성자 주입 (권장)

• 필수 의존성 보장
• 객체 생성 시 완성됨

② Setter 주입

• 런타임 주입
• Null 위험

③ 필드 주입

• 간단하지만 구조 파악 어려움
• 테스트 어려움

8. 웹 구조로 확장 → Servlet 등장

서블릿
HTTP 요청을 처리하는 자바 프로그램

흐름
1. 요청 → Servlet Container
2. Servlet 실행
3. 응답 반환

9. Spring에서의 Servlet → DispatcherServlet

Spring은 서블릿을 더 발전시킴
핵심: DispatcherServlet

모든 요청을 받는 중앙 컨트롤러
요청 → Controller로 전달 → 응답 생성

전체 흐름

Spring (프레임워크)
→ 제어권이 프레임워크로 이동 (IoC)
→ 의존성도 외부에서 관리 (DI)
→ 이를 컨테이너 + Bean으로 구현
→ 웹에서는 Servlet으로 요청 처리
→ Spring은 DispatcherServlet으로 통합 관리

개념 핵심 요약

---

• Spring은 프레임워크다
• 프레임워크는 제어권을 가져간다 → IoC
• 객체 관리도 외부에서 한다 → DI
• 이를 Spring 컨테이너 + Bean으로 구현
• 웹 요청은 Servlet이 처리
• Spring에서는 DispatcherServlet이 전체 흐름 제어

---

[부록]

이 포스팅을 시작하며 첨부한 이번주 워크북 자료 사진인데,
이번주는 부록도 있어서 부록에 해당하는 내용까지 정리해보겠습니다.

---

부록 ① - 스프링 해체 분석기 - Bean

1-1 핵심 흐름

Application 실행
→ ComponentScan
→ Bean 정의 수집
→ Bean 생성 (싱글톤)
→ 의존성 분석
→ DI 수행
→ ApplicationContext에 저장

1-2 주요 개념

ApplicationContext

• Bean을 생성 / 관리 / 조회하는 컨테이너

Bean 생성 과정

• 클래스 스캔
• Bean 정의 등록
• 싱글톤 객체 생성

DI (의존성 주입)

• 생성 시점에 자동 주입
• 타입 기반으로 Bean 탐색 후 주입

1-3 내부 동작 핵심

AbstractAutowireCapableBeanFactory
: Bean 생성 + DI 수행 핵심 엔진

BeanPostProcessor
: Bean 생성 후 개입하는 후처리 단계

AutowiredAnnotationBeanPostProcessor
: @Autowired 찾아서 실제 주입 수행

1-4 핵심 정리

★ Spring은 실행 시점에 객체를 모두 생성하고, 의존성까지 연결해 둔다

---

부록 ② - 스프링 해체 분석기 - 전체 구조

2-1 전체 흐름

Filter → DispatcherServlet → Interceptor → Controller → 응답

2-2 단계별 흐름

1. Filter

• 요청 전처리
• 서블릿 컨테이너에서 실행

2. DispatcherServlet

• 모든 요청을 받는 Front Controller
• 전체 흐름 제어

3. HandlerMapping

• URL → Controller 매핑

4. HandlerAdapter

• Controller 실행 방식 결정

5.Interceptor

• Controller 전/후 처리
• preHandle → 실행 → postHandle → afterCompletion

6. Controller Controller

• 비즈니스 로직 실행

7. 응답 처리

1) HTML (SSR)
: ViewResolver → View 렌더링
2) JSON (REST)
: HttpMessageConverter → JSON 변환

부록2 핵심 정리★★★

DispatcherServlet이 중심이 되어 요청을 적절한 Controller로 전달하고 응답을 생성한다

---

부록 ③ - 스프링 해체 분석기 - 필터

3-1 Filter 개념

Filter란? Servlet 전에 요청을 가로채는 객체

3-2 실행 구조

ApplicationFilterChain

→ Filter1 → Filter2 → Filter3 ...

*순차적으로 실행

3-3 동작 방식

doFilter(request, response, chain)

→ 로직 수행
→ chain.doFilter()

다음 필터 호출

3-4 핵심 구성

FilterChain

• 필터들을 순서대로 실행하는 구조

ApplicationFilterChain

• 실제 필터 실행 담당
• Tomcat 내부에서 관리

주요 메서드

• init → 초기화
• doFilter → 실행
• destroy → 종료

3-5 확장 구조

• GenericFilterBean : 기본 필터 구현 클래스
• OncePerRequestFilter :요청당 1번만 실행 보장

3-6 핵심 흐름

요청 → FilterChain 실행 → 모든 Filter 통과 → Servlet 전달

부록3 핵심 정리 ★★★

Filter는 요청을 가장 먼저 처리하며, 여러 개가 체인 형태로 순차 실행된다

---

부록 ④ - 스프링 해체 분석기 - 서블릿 & 핸들러

4-1 시작 지점

ApplicationFilterChain
→ servlet.service(request, response)

→ 필터를 모두 통과한 요청이 서블릿으로 진입

4-2 어떤 서블릿이 처리하나?

구조:

HttpServlet → FrameworkServlet → DispatcherServlet

• DispatcherServlet이 핵심이지만
• 실제 호출은 HttpServlet부터 시작됨

4-3 HttpServlet 역할

기능

• HTTP 메서드 판단
• GET / POST / PUT / DELETE ...
  : 요청 메서드에 따라 분기 처리

흐름

service()
→ doGet / doPost ...

: HTTP 요청 종류 결정

4-4 FrameworkServlet 역할

기능

• ApplicationContext 기반 기능 제공
• 요청 처리 전 환경 세팅

하는 일

• Context 세팅
• 인터셉터 준비
• request/response 확장 처리

핵심 흐름

HttpServlet.service()
→ FrameworkServlet.service()
→ super.service() (다시 HttpServlet)
→ doGet/doPost 실행
→ processRequest()

: 구조상 “핑퐁” 형태로 실행됨

4-5 DispatcherServlet 진입

시작

FrameworkServlet
→ DispatcherServlet.doService()

doService 역할

• 요청 전처리
• 필요한 정보 request에 세팅
  
  

핵심 진입
doService()
→ doDispatch()

4-6 doDispatch (핵심 메서드)

: DispatcherServlet의 핵심 로직

전체 흐름
1. HandlerMapping → Handler 찾기
2. HandlerAdapter → 실행 방법 찾기
3. Interceptor preHandle
4. Handler 실행 (Controller)
5. 응답 처리
6. Interceptor postHandle / afterCompletion

4-7 HandlerMapping

역할 : 요청 → Controller 매핑

내부 동작

• MappingRegistry에서 정보 조회
• @RequestMapping 기반 매칭

4-8 HandlerAdapter

역할 : 다양한 Controller 실행을 통일

이유

Controller 구현 방식이 다양하기 때문:

• @Controller
• HttpServlet
• 인터페이스 기반 등

주요 Adapter
: RequestMappingHandlerAdapter (가장 많이 사용)

내부 동작
handle()
→ invokeHandlerMethod()
→ invokeAndHandle()

4-9 Controller 실행 과정

내부 처리

• 파라미터 바인딩
• ModelAndView 준비
• 실제 메서드 호출

실행 방식 :리플렉션 + 프록시 (AOP 기반)

4-10 응답 처리

JSON 처리 흐름

HandlerMethodReturnValueHandler
→ RequestResponseBodyMethodProcessor
→ HttpMessageConverter

실제 변환
MappingJackson2HttpMessageConverter
→ JSON 직렬화

특징

• JSON → ModelAndView 안 거침
• 바로 응답 반환

4-11 후처리

Interceptor

postHandle
→ afterCompletion

마지막 단계

• 이벤트 발행
• 스레드 정리

---

3주차 워크북과 부록들은 단순히 개념을 외우는 것이 아니라,
Bean 생성부터 요청 처리까지의 흐름을 한 번에 연결해서 이해할 수 있었던 주차였습니다.

앞으로는 코드 작성뿐만 아니라,
내부에서 어떤 일이 일어나는지까지 함께 생각하며 학습해보려고 합니다.