Dispatcher Servlet은 어떻게 동작할까?

DispatcherServlet 은 Servlet 인터페이스를 구현한, HTTP 프로토콜로 들어오는 모든 요청을 먼저 받아 처리하는 Front Controller 이다.

Servlet 이란?

Java 언어를 기반으로, 클라이언트가 보내는 HTTP 요청을 처리하고 응답하는 역할을 담당하는 인터페이스 이다.

public interface Servlet {

    void init(ServletConfig config) throws ServletException;

    ServletConfig getServletConfig();

    void service(ServletRequest req, ServletResponse res) throws ServletException, IOException;

    String getServletInfo();

    void destroy();
}

위와 같은 메서드들이 정의되어 있다.

중요한 부분은 service(ServletRequest req, ServletResponse res) 인데, 클라이언트의 요청을 받아 처리하고 응답을 생성하는 핵심 메서드이다.

DispatcherServlet 은 이 Servlet 인터페이스의 구현체이고, 결과적으로 service() 메서드를 구현한 특정 메서드를 실행시켜 클라이언트의 요청을 처리하는 것이다.

위와 같은 상속 구조를 갖고 있고, DispatcherServlet 이 어떻게 사용자의 응답을 처리하는지 살펴보자.

HttpServlet | service()

service()는 클라이언트의 요청을 처리하는 메서드라고 했다.

Servlet 클래스를 상속하는 클래스 중, HttpServlet 이 해당 메서드를 Override 했다.

	@Override
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {

        HttpServletRequest request;
        HttpServletResponse response;

        try {
            request = (HttpServletRequest) req;
            response = (HttpServletResponse) res;
        } catch (ClassCastException e) {
            throw new ServletException(lStrings.getString("http.non_http"));
        }
        service(request, response);
    }

역할은, ServletRequest 를 HttpServletRequest로 변환하고 ServletResponse 를 HttpServletResponse로 변환한 뒤,

service(HttpServletRequest req, HttpServletResponse res) 로서 service() 메서드를 Overload(Override❌) 한 메서드를 호출한다.

이 Overload 한 메서드는 하위 클래스인 FrameWorkServlet 클래스에서 찾을 수 있다.

FrameWorkServlet | service()

	@Override
	protected void service(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		if (HTTP_SERVLET_METHODS.contains(request.getMethod())) {
			super.service(request, response);
		}
		else {
			processRequest(request, response);
		}
	}
    
    //	private static final Set<String> HTTP_SERVLET_METHODS =
	//		Set.of("DELETE", "HEAD", "GET", "OPTIONS", "POST", "PUT", "TRACE");

우리가 사용하는 대부분의 HTTP 요청은 GET, POST, PUT, DELETE 요청이므로

위 로직에 따라, super.service(request,response) 가 호출되어 FrameworkServlet의 상위 클래스의 service() 메서드가 호출될 것이다.

다시 HttpServlet 클래스에 service(HttpServletRequest req, HttpServletResponse res) 메서드가 Overload 되어 구현되어있으므로 돌아왔다.

HttpServlet | service()

    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        String method = req.getMethod();

        if (method.equals(METHOD_GET)) {
            long lastModified = getLastModified(req);
            if (lastModified == -1) {
                doGet(req, resp);
            } else {
                long ifModifiedSince;
                try {
                    ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                } catch (IllegalArgumentException iae) {
                    ifModifiedSince = -1;
                }
                if (ifModifiedSince < (lastModified / 1000 * 1000)) {
                    maybeSetLastModified(resp, lastModified);
                    doGet(req, resp);
                } else {
                    resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                }
            }

        } else if (method.equals(METHOD_HEAD)) {
            long lastModified = getLastModified(req);
            maybeSetLastModified(resp, lastModified);
            doHead(req, resp);

        } else if (method.equals(METHOD_POST)) {
            doPost(req, resp);

        } else if (method.equals(METHOD_PUT)) {
            doPut(req, resp);

        } else if (method.equals(METHOD_DELETE)) {
            doDelete(req, resp);

        } else if (method.equals(METHOD_OPTIONS)) {
            doOptions(req, resp);

        } else if (method.equals(METHOD_TRACE)) {
            doTrace(req, resp);

        } else {
            String errMsg = lStrings.getString("http.method_not_implemented");
            Object[] errArgs = new Object[1];
            errArgs[0] = method;
            errMsg = MessageFormat.format(errMsg, errArgs);

            resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
        }
    }

위와 같은 메서드로 구현되어 있다.

각 HTTP 메서드에 맞게 doXX 메서드를 호출하게끔 로직이 진행된다.

    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String msg = lStrings.getString("http.method_get_not_supported");
        sendMethodNotAllowed(req, resp, msg);
    }

위 메서드를 발견할 수 있었는데, protected 키워드를 보니 하위 클래스에서 새롭게 정의한 메서드가 있겠구나 생각이 들어서 하위 클래스를 탐색해보았다.

HttpServlet을 상속한 FrameWorkServlet 클래스에서 Override 한 doXX 메서드가 있음을 확인했다.

FrameWorkServlet | doGet()

	@Override
	protected final void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		processRequest(request, response);
	}

위와 같은 메서드로 정의되어 있는데, processRequest(request, response) 라는 메서드를 호출하게끔 되어있다.

FrameWorkServlet | processRequest()

protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		long startTime = System.currentTimeMillis();
		Throwable failureCause = null;

		LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
		LocaleContext localeContext = buildLocaleContext(request);

		RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
		ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);

		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
		asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());

		initContextHolders(request, localeContext, requestAttributes);

		try {
			doService(request, response);
		}
		catch (ServletException | IOException ex) {
			failureCause = ex;
			throw ex;
		}
		catch (Throwable ex) {
			failureCause = ex;
			throw new ServletException("Request processing failed: " + ex, ex);
		}

		finally {
			resetContextHolders(request, previousLocaleContext, previousAttributes);
			if (requestAttributes != null) {
				requestAttributes.requestCompleted();
			}
			logResult(request, response, failureCause, asyncManager);
			publishRequestHandledEvent(request, response, startTime, failureCause);
		}
	}

이러한 메서드가 있었다.

결론은 doService(request, response) 를 호출한다.

	protected abstract void doService(HttpServletRequest request, HttpServletResponse response)
			throws Exception;

근데, doService() 메서드는 추상 메서드였다.

즉, 추상 메서드로 역할을 정의해놓고 하위 클래스에서 구현한 메서드를 사용하게끔 하는 템플릿 메서드 패턴이 적용되어 있었다.

결과적으로 하위 클래스인 DispatcherServlet 에서 구현한 doService(HttpServletRequest request, HttpServletResponse response) 가 호출된다.

DispatcherServlet | doService()

	@Override
	protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
		
        .
        .
        .

		try {
			doDispatch(request, response);
		}
		finally {
			if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
				// Restore the original attribute snapshot, in case of an include.
				if (attributesSnapshot != null) {
					restoreAttributesAfterInclude(request, attributesSnapshot);
				}
			}
			if (this.parseRequestPath) {
				ServletRequestPathUtils.setParsedRequestPath(previousRequestPath, request);
			}
		}
	}

DispatcherServlet 의 doService() 메서드는 다시, doDispatch() 메서드를 호출한다.

DispatcherServlet | doDispatch()

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HttpServletRequest processedRequest = request;
		HandlerExecutionChain mappedHandler = null;
		boolean multipartRequestParsed = false;

		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

		try {
			ModelAndView mv = null;
			Exception dispatchException = null;

			try {
				processedRequest = checkMultipart(request);
				multipartRequestParsed = (processedRequest != request);

				// Determine handler for the current request.
				mappedHandler = getHandler(processedRequest);
				if (mappedHandler == null) {
					noHandlerFound(processedRequest, response);
					return;
				}

				// Determine handler adapter for the current request.
				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

				// Process last-modified header, if supported by the handler.
				String method = request.getMethod();
				boolean isGet = HttpMethod.GET.matches(method);
				if (isGet || HttpMethod.HEAD.matches(method)) {
					long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
					if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
						return;
					}
				}

				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}

				// Actually invoke the handler.
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

				if (asyncManager.isConcurrentHandlingStarted()) {
					return;
				}

				applyDefaultViewName(processedRequest, mv);
				mappedHandler.applyPostHandle(processedRequest, response, mv);
			}
			catch (Exception ex) {
				dispatchException = ex;
			}
			catch (Throwable err) {
				// As of 4.3, we're processing Errors thrown from handler methods as well,
				// making them available for @ExceptionHandler methods and other scenarios.
				dispatchException = new ServletException("Handler dispatch failed: " + err, err);
			}
			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
		}
		catch (Exception ex) {
			triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
		}
		catch (Throwable err) {
			triggerAfterCompletion(processedRequest, response, mappedHandler,
					new ServletException("Handler processing failed: " + err, err));
		}
		finally {
			if (asyncManager.isConcurrentHandlingStarted()) {
				// Instead of postHandle and afterCompletion
				if (mappedHandler != null) {
					mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
				}
			}
			else {
				// Clean up any resources used by a multipart request.
				if (multipartRequestParsed) {
					cleanupMultipart(processedRequest);
				}
			}
		}
	}

doDispatch() 메서드는 위와 같다.

mappedHandler = getHandler(processedRequest) 부분에서 요청 url을 기반으로 적절한 핸들러(Controller)를 찾는다.

그리고 HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler()) 부분에서 찾은 핸들러를 실행하기 위한 핸들러 Adapter를 찾는다.

mv = ha.handle(processedRequest, response, mappedHandler.getHandler()) 부분에서 핸들러 어뎁터를 실행하여 요청을 처리할 수 있는 Controller 로직을 실행하게 된다.

참고한 블로그 : https://zzang9ha.tistory.com/441

Servlet 이란?
HttpServlet | service()
FrameWorkServlet | service()
HttpServlet | service()
FrameWorkServlet | doGet()
FrameWorkServlet | processRequest()
DispatcherServlet | doService()
DispatcherServlet | doDispatch()

내 블로그 - 관리자 홈 전환	`Q` `Q`
새 글 쓰기	`W` `W`

글 수정 (권한 있는 경우)	`E` `E`
댓글 영역으로 이동	`C` `C`

이 페이지의 URL 복사	`S` `S`
맨 위로 이동	`T` `T`
티스토리 홈 이동	`H` `H`
단축키 안내	`Shift` + `/` `⇧` + `/`

Dispatcher Servlet은 어떻게 동작할까?

Servlet 이란?

HttpServlet | service()

FrameWorkServlet | service()

HttpServlet | service()

FrameWorkServlet | doGet()

FrameWorkServlet | processRequest()

DispatcherServlet | doService()

DispatcherServlet | doDispatch()

티스토리툴바

단축키

내 블로그

블로그 게시글

모든 영역