Spring MVC 동작 원리 — DispatcherServlet부터 응답까지

public class MyServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        resp.getWriter().write("Hello Servlet");
    }
}

컨테이너 시작 → init() → [요청마다] service() → doGet()/doPost() → destroy() → 컨테이너 종료

모든 HTTP 요청 → [DispatcherServlet] → 적절한 핸들러에 위임

HttpServlet
  └── HttpServletBean
        └── FrameworkServlet
              └── DispatcherServlet

HTTP 요청
  → Servlet Filter
    → DispatcherServlet
      → HandlerMapping (어떤 핸들러가 처리할지 결정)
        → HandlerAdapter (핸들러를 실제로 실행)
          → Controller (비즈니스 로직)
        ← ModelAndView 또는 @ResponseBody
      → ViewResolver (뷰 이름 → 실제 뷰 객체)
        → View (렌더링)
    ← DispatcherServlet
  ← Servlet Filter
HTTP 응답

@RestController
@RequestMapping("/api/users")
public class UserController {

    @GetMapping("/{id}")       // GET /api/users/1
    public UserResponse getUser(@PathVariable Long id) { ... }

    @PostMapping               // POST /api/users
    public UserResponse createUser(@RequestBody UserRequest request) { ... }
}

@Controller
public class ViewController {

    @GetMapping("/hello")
    public String hello(Model model) {
        model.addAttribute("name", "Spring");
        return "hello";  // → ViewResolver가 hello.html을 찾아서 렌더링
    }
}

@RestController  // = @Controller + @ResponseBody
public class ApiController {

    @GetMapping("/api/hello")
    public Map<String, String> hello() {
        return Map.of("message", "Hello Spring");
        // → HttpMessageConverter가 JSON으로 변환해서 응답 본문에 직접 씀
    }
}

HTTP 요청
  → [Filter]                  ← Servlet Container 레벨 (스프링 바깥)
    → [DispatcherServlet]
      → [Interceptor preHandle]  ← 스프링 MVC 레벨 (스프링 안)
        → [Controller]
      ← [Interceptor postHandle]
    ← [DispatcherServlet]
  ← [Filter]
HTTP 응답

// Filter 구현
@Component
public class LoggingFilter implements Filter {

    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
                         FilterChain chain) throws IOException, ServletException {
        // 전처리
        log.info("Request: {}", ((HttpServletRequest) request).getRequestURI());

        chain.doFilter(request, response);  // 다음 필터 또는 서블릿 호출

        // 후처리
        log.info("Response status: {}", ((HttpServletResponse) response).getStatus());
    }
}

// Interceptor 구현
@Component
public class AuthInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
                             Object handler) throws Exception {
        // 컨트롤러 실행 전. false를 리턴하면 요청 처리 중단
        String token = request.getHeader("Authorization");
        if (token == null) {
            response.setStatus(401);
            return false;
        }
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response,
                           Object handler, ModelAndView modelAndView) throws Exception {
        // 컨트롤러 실행 후, 뷰 렌더링 전
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
                                Object handler, Exception ex) throws Exception {
        // 뷰 렌더링까지 완료된 후. 리소스 정리 용도
    }
}

public interface HandlerMethodArgumentResolver {
    // 이 리졸버가 해당 파라미터를 처리할 수 있는지
    boolean supportsParameter(MethodParameter parameter);

    // 실제 파라미터 값을 만들어서 리턴
    Object resolveArgument(MethodParameter parameter, ...);
}

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface CurrentUser {}

@Component
public class CurrentUserArgumentResolver implements HandlerMethodArgumentResolver {

    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        return parameter.hasParameterAnnotation(CurrentUser.class);
    }

    @Override
    public Object resolveArgument(MethodParameter parameter, ...) {
        HttpServletRequest request = // ...
        return extractUserFromToken(request.getHeader("Authorization"));
    }
}

@GetMapping("/api/profile")
public UserProfile getProfile(@CurrentUser User user) {
    // user가 자동으로 주입됨
    return userService.getProfile(user.getId());
}

@RestController
public class UserController {

    @GetMapping("/api/users/{id}")
    public UserResponse getUser(@PathVariable Long id) {
        return userService.findById(id)
                .orElseThrow(() -> new UserNotFoundException(id));
    }

    @ExceptionHandler(UserNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleNotFound(UserNotFoundException e) {
        return ResponseEntity.status(404)
                .body(new ErrorResponse("USER_NOT_FOUND", e.getMessage()));
    }
}

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(UserNotFoundException.class)
    public ResponseEntity<ErrorResponse> handleNotFound(UserNotFoundException e) {
        return ResponseEntity.status(404)
                .body(new ErrorResponse("NOT_FOUND", e.getMessage()));
    }

    @ExceptionHandler(IllegalArgumentException.class)
    public ResponseEntity<ErrorResponse> handleBadRequest(IllegalArgumentException e) {
        return ResponseEntity.badRequest()
                .body(new ErrorResponse("BAD_REQUEST", e.getMessage()));
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleAll(Exception e) {
        log.error("Unhandled exception", e);
        return ResponseEntity.internalServerError()
                .body(new ErrorResponse("INTERNAL_ERROR", "서버 내부 오류"));
    }
}

@RestControllerAdvice
public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {

    // 스프링 기본 예외들은 부모 클래스가 알아서 처리
    // 커스텀 예외만 추가로 정의하면 된다

    @ExceptionHandler(BusinessException.class)
    public ResponseEntity<ErrorResponse> handleBusiness(BusinessException e) {
        return ResponseEntity.status(e.getStatus())
                .body(new ErrorResponse(e.getCode(), e.getMessage()));
    }
}

요청: JSON (HTTP Body) → HttpMessageConverter → 자바 객체
응답: 자바 객체 → HttpMessageConverter → JSON (HTTP Body)

// 요청 JSON → 자바 객체 (역직렬화)
@PostMapping("/api/users")
public UserResponse createUser(@RequestBody UserRequest request) {
    // { "name": "홍길동", "email": "hong@example.com" }
    // → UserRequest(name="홍길동", email="hong@example.com")
}

// 자바 객체 → 응답 JSON (직렬화)
@GetMapping("/api/users/{id}")
public UserResponse getUser(@PathVariable Long id) {
    return new UserResponse(1L, "홍길동", "hong@example.com");
    // → { "id": 1, "name": "홍길동", "email": "hong@example.com" }
}

implementation('org.springframework.boot:spring-boot-starter-web') {
    exclude group: 'org.springframework.boot', module: 'spring-boot-starter-tomcat'
}
implementation 'org.springframework.boot:spring-boot-starter-undertow'

@Bean
public ServletRegistrationBean<DispatcherServlet> adminServlet(ApplicationContext context) {
    DispatcherServlet servlet = new DispatcherServlet();
    AnnotationConfigWebApplicationContext adminContext = new AnnotationConfigWebApplicationContext();
    adminContext.register(AdminConfig.class);
    servlet.setApplicationContext(adminContext);

    return new ServletRegistrationBean<>(servlet, "/admin/*");
}

@Async
public CompletableFuture<UserResponse> findUserAsync(Long id) {
    UserResponse user = userRepository.findById(id);
    return CompletableFuture.completedFuture(user);
}

@GetMapping("/api/notifications")
public DeferredResult<ResponseEntity<String>> getNotification() {
    DeferredResult<ResponseEntity<String>> result = new DeferredResult<>(30000L);

    // 다른 스레드에서 결과를 세팅
    eventService.waitForEvent(event -> {
        result.setResult(ResponseEntity.ok(event.getMessage()));
    });

    return result;  // 서블릿 스레드는 바로 반환됨
}