[SPRING] DispatcherServlet

/**
Central dispatcher for HTTP request handlers/controllers, e.g. for web UI controllers or HTTP-based remote service exporters. 
Dispatches to registered handlers for processing a web request, providing convenient mapping and exception handling facilities.
*/
public class DispatcherServlet extends FrameworkServlet {
}


/**
Base servlet for Spring's web framework.
Provides integration with a Spring application context, in a JavaBean-based overall solution.
*/
public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {
}


public abstract class HttpServletBean extends HttpServlet implements EnvironmentCapable, EnvironmentAware {
}

public final class ApplicationFilterChain implements FilterChain {

    ...

    private void internalDoFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {

        // Call the next filter if there is one (다음 Filter 가 있다면, 호출합니다.)
        if (pos < n) {
            ApplicationFilterConfig filterConfig = filters[pos++];
            try {
                Filter filter = filterConfig.getFilter();

                ...  // (중략)

                filter.doFilter(request, response, this);
            } catch (IOException | ServletException | RuntimeException e) {
                ...
            } catch (Throwable e) {
                ...
            }
            return;
        }

        // We fell off the end of the chain -- call the servlet instance
        // (FilterChain 의 끝에 도착 -> Servlet 객체를 호출합니다.)
        try {

            ...  // (중략)
            
            servlet.service(request, response); // <-- 여기
        } catch (IOException | ServletException | RuntimeException e) {
            ...
        } catch (Throwable e) {
            ...
        } finally {
            ...
        }
    }
}

public abstract class HttpServlet extends GenericServlet {
   ...

    @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);
    }

    ...

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

        String method = req.getMethod();

        if (method.equals(METHOD_GET)) {
            ...
            // If-Modified-Since(Last-Modified) (캐시 분기)
            doGet(req, resp);
            // or 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");

            ...

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

public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {

	...

	@Override
	protected final void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		processRequest(request, response);  // <-- 여기
	}

	// Process this request, publishing an event regardless of the outcome.
	// The actual event handling is performed by the abstract doService template method.
	protected final void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

		...

		try {
		    doService(request, response);  // <-- 여기
		}
		catch (ServletException | IOException ex) {
            	...
		}
		catch (Throwable ex) {
            ...
		}

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

public class DispatcherServlet extends FrameworkServlet {

    ...

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

		// Keep a snapshot of the request attributes in case of an include,
		// to be able to restore the original attributes after the include.
                // (attributeSnapShow 저장)
		Map<String, Object> attributesSnapshot = null;
		while(...) {
		    attributesSnapshot.put(attrName, request.getAttribute(attrName));
		}

		// Make framework objects available to handlers and view objects.
                // (HttpServletRequest 에 WebApplicationContext, localeResolver 등 저장)
		request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
		request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
		request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
		request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());

		...

		try {
			doDispatch(request, response);
		}
		finally {
			...
		}
	}

	...
}

public class DispatcherServlet extends FrameworkServlet {

	...

	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 {
				// Convert the request into a multipart request, and make multipart resolver available.
				// If no multipart resolver is set, simply use the existing request.
				// (checkMultiPart() 의 경우, multipart 요청이면 MultipartHttpServletRequest 객체를 반환합니다.)
				processedRequest = checkMultipart(request);
				multipartRequestParsed = (processedRequest != request);

				...  // (중략)

				// Determine handler for the current request.
				// (HandlerExecutionChain 객체를 얻습니다.)
				// ( = 우리가 작성한 Controller/Method 를 의미합니다.)
				mappedHandler = getHandler(processedRequest);
				if (mappedHandler == null) {
					noHandlerFound(processedRequest, response);
					return;
				}


				// Determine handler adapter for the current request.
				// (HandlerAdapter 객체를 얻습니다.)
				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

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

				// Apply preHandle methods of registered interceptors. (in HandlerExecutionChain)
				// (등록된 인터셉터의 preHandle 을 실행합니다.)
				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
					return;
				}

				// Actually invoke the handler.
				// (HandlerAdapter handel() 메서드를 호출합니다.)
				// (ModelAndView 를 반환받습니다.)
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler()); // <-- 여기

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

				applyDefaultViewName(processedRequest, mv);
				// Apply postHandle methods of registered interceptors.
				// (등록된 인터셉터의 postHandle 을 실행합니다.)
				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 NestedServletException("Handler dispatch failed", err);
			}
			processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
		}
		catch (Exception ex) {
			triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
		}
		catch (Throwable err) {
			triggerAfterCompletion(processedRequest, response, mappedHandler,
					new NestedServletException("Handler processing failed", 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);
				}
			}
		}
	}

	...

	@Nullable
	protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
		if (this.handlerMappings != null) {
			for (HandlerMapping mapping : this.handlerMappings) {
				HandlerExecutionChain handler = mapping.getHandler(request);
				if (handler != null) {
					return handler;
				}
			}
		}
		return null;
	}

	...

	// Return the HandlerAdapter for this handler object.
	protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
		if (this.handlerAdapters != null) {
			for (HandlerAdapter adapter : this.handlerAdapters) {
				if (adapter.supports(handler)) {
					return adapter;
				}
			}
		}
		throw new ServletException("No adapter for handler [" + handler +
				"]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
	}
}

// mv 가 null 이 아니면 render() 호출한다. render() 내에서 다이어그램의 viewResolver, view 과정이 수행된다.
private void processDispatchResult(HttpServletRequest request, HttpServletResponse response, @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv, @Nullable Exception exception) throws Exception {
   boolean errorView = false;
   if (exception != null) {
      ...
   }

   if (mv != null && !mv.wasCleared()) {
      this.render(mv, request, response);
      if (errorView) {
         WebUtils.clearErrorRequestAttributes(request);
      }
   } else if (this.logger.isTraceEnabled()) {
      this.logger.trace("No view rendering, null ModelAndView returned.");
   }

   if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
      if (mappedHandler != null) {
         mappedHandler.triggerAfterCompletion(request, response, (Exception)null);
      }

   }
}

public abstract class AbstractHandlerMethodAdapter extends WebContentGenerator implements HandlerAdapter, Ordered {

	...

	@Override
	@Nullable
	public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {

		// RequestMappingHandlerAdapter.handleInternal() 호출
		return handleInternal(request, response, (HandlerMethod) handler);
	}

	...

}

public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter {
   
	...

	@Override
	protected ModelAndView handleInternal(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

		ModelAndView mav;
		checkRequest(request); // 세션 필수 여부, HTTP Method 체크

		...  // (중략)

		// Execute invokeHandlerMethod in synchronized block if required.
		if (this.synchronizeOnSession) {
			HttpSession session = request.getSession(false);
			if (session != null) {
				Object mutex = WebUtils.getSessionMutex(session);
				synchronized (mutex) {
					mav = invokeHandlerMethod(request, response, handlerMethod);
				}
			}
			else {
				// No HttpSession available -> no mutex necessary
				mav = invokeHandlerMethod(request, response, handlerMethod);
			}
		}
		else {
			// No synchronization on session demanded at all...
			mav = invokeHandlerMethod(request, response, handlerMethod);
		}

		if (!response.containsHeader(HEADER_CACHE_CONTROL)) {
			if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
				applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
			}
			else {
				prepareResponse(response);
			}
		}

		return mav;
	}

	...
}

public class RequestMappingHandlerAdapter extends AbstractHandlerMethodAdapter {
   
	...

	@Nullable
	protected ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {

		ServletWebRequest webRequest = new ServletWebRequest(request, response);
		try {

			ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod); // <-- 여기

			...  // (중략 : asyncManager, mavContainer 등의 설정)

			// Invoke the method and handle the return value 
			// through one of the configured HandlerMethodReturnValueHandlers.
			invocableMethod.invokeAndHandle(webRequest, mavContainer);

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

			return getModelAndView(mavContainer, modelFactory, webRequest);
		}
		finally {
			webRequest.requestCompleted();
		}
	}

	...
}

public class ServletInvocableHandlerMethod extends InvocableHandlerMethod {
	...

	// Invoke the method and handle the return value 
	// through one of the configured HandlerMethodReturnValueHandlers.
	public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {

		Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
		setResponseStatus(webRequest);

		if (returnValue == null) {
			if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {
				disableContentCachingIfNecessary(webRequest);
				mavContainer.setRequestHandled(true);
				return;
			}
		}
		else if (StringUtils.hasText(getResponseStatusReason())) {
			mavContainer.setRequestHandled(true);
			return;
		}

		mavContainer.setRequestHandled(false);
		Assert.state(this.returnValueHandlers != null, "No return value handlers");
		try {
			// returnValue 처리!!
			this.returnValueHandlers.handleReturnValue(
					returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
		}
		catch (Exception ex) {
			if (logger.isTraceEnabled()) {
				logger.trace(formatErrorForReturnValue(returnValue), ex);
			}
			throw ex;
		}
	}

	...
}

public class HandlerMethodReturnValueHandlerComposite implements HandlerMethodReturnValueHandler {

	protected final Log logger = LogFactory.getLog(getClass());

	private final List<HandlerMethodReturnValueHandler> returnValueHandlers = new ArrayList<>();
	
	...
}

public class RequestResponseBodyMethodProcessor extends AbstractMessageConverterMethodProcessor {

	...
	
	@Override
	public boolean supportsReturnType(MethodParameter returnType) {
		return (AnnotatedElementUtils.hasAnnotation(returnType.getContainingClass(), ResponseBody.class) ||
				returnType.hasMethodAnnotation(ResponseBody.class));
	}
	
	...
	
	@Override
	public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
			ModelAndViewContainer mavContainer, NativeWebRequest webRequest)
			throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {

		mavContainer.setRequestHandled(true);
		ServletServerHttpRequest inputMessage = createInputMessage(webRequest);
		ServletServerHttpResponse outputMessage = createOutputMessage(webRequest);

		// Try even with null return value. ResponseBodyAdvice could get involved.
		writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage); // <-- 여기서 HttpMessageConverter converters 가 사용되어 변환 처리
	}
	
	...

resolvers = {HandlerMethodArgumentResolverComposite@16108} 
- argumentResolvers = {LinkedList@16583}  size = 36
  0 = {ProxyingHandlerMethodArgumentResolver@16599} 
  1 = {RequestParamMethodArgumentResolver@16600} 
  2 = {RequestParamMapMethodArgumentResolver@16601} 
  3 = {PathVariableMethodArgumentResolver@16602} 
  4 = {PathVariableMapMethodArgumentResolver@16603} 
  5 = {MatrixVariableMethodArgumentResolver@16604} 
  6 = {MatrixVariableMapMethodArgumentResolver@16605} 
  7 = {ServletModelAttributeMethodProcessor@16606} 
  8 = {RequestResponseBodyMethodProcessor@16589} 
  9 = {RequestPartMethodArgumentResolver@16607} 
  ...

public class InvocableHandlerMethod extends HandlerMethod {

	...   

	private HandlerMethodArgumentResolverComposite resolvers = new HandlerMethodArgumentResolverComposite();
	// private final List<HandlerMethodArgumentResolver> argumentResolvers = new LinkedList<>();
	// private final Map<MethodParameter, HandlerMethodArgumentResolver> argumentResolverCache = new ConcurrentHashMap<>(256);

	...   

	@Nullable
	public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {

		// 여기서 Object -> DTO 로 변환
		Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs); 
		if (logger.isTraceEnabled()) {
			logger.trace("Arguments: " + Arrays.toString(args));
		}
		return doInvoke(args);
	}

	// Get the method argument values for the current request, 
	// checking the provided argument values and falling back to the configured argument resolvers.
	// The resulting array will be passed into doInvoke.
	protected Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception {

		MethodParameter[] parameters = getMethodParameters();
		if (ObjectUtils.isEmpty(parameters)) {
			return EMPTY_ARGS;
		}

		Object[] args = new Object[parameters.length];
		for (int i = 0; i < parameters.length; i++) {
			MethodParameter parameter = parameters[i];
			parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
			args[i] = findProvidedArgument(parameter, providedArgs);
			if (args[i] != null) {
				continue;
			}
			if (!this.resolvers.supportsParameter(parameter)) {
				throw new IllegalStateException(formatArgumentError(parameter, "No suitable resolver"));
			}
			try {
				args[i] = this.resolvers.resolveArgument(parameter, mavContainer, request, this.dataBinderFactory);
			}
			catch (Exception ex) {
				// Leave stack trace for later, exception may actually be resolved and handled...
				if (logger.isDebugEnabled()) {
					String exMsg = ex.getMessage();
					if (exMsg != null && !exMsg.contains(parameter.getExecutable().toGenericString())) {
						logger.debug(formatArgumentError(parameter, exMsg));
					}
				}
				throw ex;
			}
		}
		return args;
	}

	...

	@Nullable
	protected Object doInvoke(Object... args) throws Exception {
      
		// getBridgedMethod : 우리가 작성한 Controller/Method
		ReflectionUtils.makeAccessible(getBridgedMethod());
		try {
			return getBridgedMethod().invoke(getBean(), args);
		}
		catch (IllegalArgumentException ex) {
			assertTargetBean(getBridgedMethod(), getBean(), args);
			String text = (ex.getMessage() != null ? ex.getMessage() : "Illegal argument");
			throw new IllegalStateException(formatInvokeError(text, args), ex);
		}
		catch (InvocationTargetException ex) {
			// Unwrap for HandlerExceptionResolvers ...
			Throwable targetException = ex.getTargetException();
			if (targetException instanceof RuntimeException) {
				throw (RuntimeException) targetException;
			}
			else if (targetException instanceof Error) {
				throw (Error) targetException;
			}
			else if (targetException instanceof Exception) {
				throw (Exception) targetException;
			}
			else {
				throw new IllegalStateException(formatInvokeError("Invocation failure", args), targetException);
			}
		}
	}

}

// getArgumentResolver() 통해, resolver 들의 supportsParameter 여부 판단 -> 한개 획득
// resolveArgument
public class HandlerMethodArgumentResolverComposite implements HandlerMethodArgumentResolver {

	...   

	@Override
	@Nullable
	public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {

		HandlerMethodArgumentResolver resolver = getArgumentResolver(parameter);
		if (resolver == null) {
			throw new IllegalArgumentException("Unsupported parameter type [" +
					parameter.getParameterType().getName() + "]. supportsParameter should be called first.");
		}
		return resolver.resolveArgument(parameter, mavContainer, webRequest, binderFactory);
	}

	@Nullable
	private HandlerMethodArgumentResolver getArgumentResolver(MethodParameter parameter) {
		HandlerMethodArgumentResolver result = this.argumentResolverCache.get(parameter);
		if (result == null) {
			for (HandlerMethodArgumentResolver resolver : this.argumentResolvers) {
				if (resolver.supportsParameter(parameter)) {
					result = resolver;
					this.argumentResolverCache.put(parameter, result);
					break;
				}
			}
		}
		return result;
	}

	...
}

public class RequestResponseBodyMethodProcessor extends AbstractMessageConverterMethodProcessor {
   
	...

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

	...

	// HttpMessageConverter 들을 순회하며 변환
	@Override
	public Object resolveArgument(MethodParameter parameter, @Nullable ModelAndViewContainer mavContainer, NativeWebRequest webRequest, @Nullable WebDataBinderFactory binderFactory) throws Exception {
      
		...

		Object arg = readWithMessageConverters(webRequest, parameter, parameter.getNestedGenericParameterType());

		...

		return adaptArgumentIfNecessary(arg, parameter);
	}

	...
}

ReflectionUtils.makeAccessible(getBridgedMethod());

try {
   return getBridgedMethod().invoke(getBean(), args);
}