Spring MVCÇëÇó´¦Àí¹ý³Ì¡£ÄãÕâÑù»Ø´ð±£Ö¤Í¨¹ýÃæÊÔ£¡

/** ÎļþÉÏ´«½âÎöÆ÷ */
private?MultipartResolver multipartResolver;

/** ÇøÓò½âÎöÆ÷£¬ÓÃÓÚ¹ú¼Ê»¯ */
private?LocaleResolver localeResolver;

/** Ö÷Ìâ½âÎöÆ÷ */
private?ThemeResolver themeResolver;

/** HandlerÓ³ÉäÐÅÏ¢ */
private?List<HandlerMapping> handlerMappings;

/** HandlerÊÊÅäÆ÷*/
private?List<HandlerAdapter> handlerAdapters;

/** HandlerÖ´ÐÐÒì³£½âÎöÆ÷ */
private?List<HandlerExceptionResolver> handlerExceptionResolvers;

/** ÇëÇóµ½ÊÓͼµÄת»»Æ÷ */
private?RequestToViewNameTranslator viewNameTranslator;

/** SpringMVCÔÊÐíÖض¨ÏòʱЯ´ø²ÎÊý£¬´æÔÚsessionÖУ¬ÓÃÍê¾ÍÏú»Ù£¬ËùÒÔ½ÐFlashMap */
private?FlashMapManager flashMapManager;

/** ÊÓͼ½âÎöÆ÷ */
private?List<ViewResolver> viewResolvers;

@Controller
public?class?IndexController {

????@RequestMapping("/index/home")
????public?String?home(String?id, Student student,?@RequestParam("code")?String?code) {
????????System.out.println(student.getName());
????????return?"index";
????}

????@ResponseBody
????@RequestMapping("/index/list")
????public?String?list() {
????????return?"success";
????}
}

public?class?Student?{

????private?String name;
????private?Integer gender;

???// getter¡¢setter
}

/**
?* Exposes the DispatcherServlet-specific request attributes and delegates to {@link #doDispatch}
?* for the actual dispatching.
?*/
@Override
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.
?Map<String,?Object> attributesSnapshot =?null;
?if?(WebUtils.isIncludeRequest(request)) {
??attributesSnapshot =?new?HashMap<>();
??Enumeration<?> attrNames = request.getAttributeNames();
??while?(attrNames.hasMoreElements()) {
???String?attrName = (String) attrNames.nextElement();
???if?(this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
????attributesSnapshot.put(attrName, request.getAttribute(attrName));
???}
??}
?}

?// Make framework objects available to handlers and view objects.
?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());

?if?(this.flashMapManager !=?null) {
??FlashMap inputFlashMap =?this.flashMapManager.retrieveAndUpdate(request, response);
??if?(inputFlashMap !=?null) {
???request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
??}
??request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE,?new?FlashMap());
??request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE,?this.flashMapManager);
?}

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

/**
?* ʵ¼Ê´¦ÀíÇëÇóµÄ·½·¨
?*/
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.
???// Ϊµ±Ç°ÇëÇóÕÒµ½Ò»¸öºÏÊʵĴ¦ÀíÆ÷£¨Handler£©
???// ·µ»ØÖµÊÇÒ»¸öHandlerExecutionChain£¬Ò²¾ÍÊÇ´¦ÀíÆ÷Ö´ÐÐÁ´
???mappedHandler = getHandler(processedRequest);
???if?(mappedHandler ==?null) {
????noHandlerFound(processedRequest, response);
????return;
???}

???// Determine handler adapter for the current request.
???// ¸ù¾ÝHandlerExecutionChainЯ´øµÄHandlerÕÒµ½ºÏÊʵÄHandlerAdapter
???HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

???// Process last-modified header, if supported by the handler.
???// ´¦ÀíGETÇëÇóµÄ»º´æ
???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;
????}
???}

???// Ö´ÐÐÀ¹½ØÆ÷µÄpreHandle·½·¨
???if?(!mappedHandler.applyPreHandle(processedRequest, response)) {
????return;
???}

???// Actually invoke the handler.
???// ÀûÓÃHandlerAdapterÀ´Ö´ÐÐHandlerÀï¶ÔÓ¦µÄ´¦Àí·½·¨
???mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

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

???// Èç¹ûûÓÐÉèÖÃÊÓͼ£¬ÔòÓ¦ÓÃĬÈϵÄÊÓͼÃû
???applyDefaultViewName(processedRequest, mv);
???// Ö´ÐÐÀ¹½ØÆ÷µÄ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);
??}
??// ¸ù¾ÝModelAndView¶ÔÏó½âÎöÊÓͼ
??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);
???}
??}
?}
}

/**
?* Return the HandlerExecutionChain for this request.
?* ΪÕâ¸örequest·µ»ØÒ»¸öHandlerExecutionChain
?*/
@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.
??*?@param?handler the handler object to find an adapter for
??*?@throws?ServletException if no HandlerAdapter can be found for the handler. This is a fatal error.
??*/
?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");
?}

/**
?* Handle the result of handler selection and handler invocation, which is
?* either a ModelAndView or an Exception to be resolved to a ModelAndView.
?*/
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?(exception?instanceof?ModelAndViewDefiningException) {
???logger.debug("ModelAndViewDefiningException encountered",?exception);
???mv = ((ModelAndViewDefiningException)?exception).getModelAndView();
??}
??else?{
???Object handler = (mappedHandler !=?null?? mappedHandler.getHandler() :?null);
???mv = processHandlerException(request, response, handler,?exception);
???errorView = (mv !=?null);
??}
?}

?// Did the handler return a view to render?
?if?(mv !=?null?&& !mv.wasCleared()) {
??// Ö÷Òªµ÷Óø÷½·¨äÖȾÊÓͼ
??render(mv, request, response);
??if?(errorView) {
???WebUtils.clearErrorRequestAttributes(request);
??}
?}
?else?{
??if?(logger.isTraceEnabled()) {
???logger.trace("No view rendering, null ModelAndView returned.");
??}
?}

?if?(WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
??// Concurrent handling started during a forward
??return;
?}

?if?(mappedHandler !=?null) {
??// Exception (if any) is already handled..
??mappedHandler.triggerAfterCompletion(request, response,?null);
?}
}

/**
?* Render the given ModelAndView.
?* <p>This is the last stage in handling a request. It may involve resolving the view by name.
?*?@param?mv the ModelAndView to render
?*?@param?request current HTTP servlet request
?*?@param?response current HTTP servlet response
?*?@throws?ServletException if view is missing or cannot be resolved
?*?@throws?Exception if there's a problem rendering the view
?*/
protected?void?render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response)?throws?Exception?{
?// Determine locale for request and apply it to the response.
?Locale locale =
???(this.localeResolver !=?null???this.localeResolver.resolveLocale(request) : request.getLocale());
?response.setLocale(locale);

?View view;
?String viewName = mv.getViewName();
?if?(viewName !=?null) {
??// We need to resolve the view name.
??// ¸ù¾Ý¸ø¶¨µÄÊÓͼÃû³Æ£¬½âÎö»ñÈ¡View¶ÔÏó
??view = resolveViewName(viewName, mv.getModelInternal(), locale, request);
??if?(view ==?null) {
???throw?new?ServletException("Could not resolve view with name '"?+ mv.getViewName() +
?????"' in servlet with name '"?+ getServletName() +?"'");
??}
?}
?else?{
??// No need to lookup: the ModelAndView object contains the actual View object.
??view = mv.getView();
??if?(view ==?null) {
???throw?new?ServletException("ModelAndView ["?+ mv +?"] neither contains a view name nor a "?+
?????"View object in servlet with name '"?+ getServletName() +?"'");
??}
?}

?// Delegate to the View object for rendering.
?if?(logger.isTraceEnabled()) {
??logger.trace("Rendering view ["?+ view +?"] ");
?}
?try?{
??if?(mv.getStatus() !=?null) {
???response.setStatus(mv.getStatus().value());
??}
??view.render(mv.getModelInternal(), request, response);
?}
?catch?(Exception ex) {
??if?(logger.isDebugEnabled()) {
???logger.debug("Error rendering view ["?+ view +?"]", ex);
??}
??throw?ex;
?}
}

@Nullable
protected?View resolveViewName(String?viewName,?@Nullable?Map<String,?Object> model,
??Locale locale, HttpServletRequest request) throws Exception {

?if?(this.viewResolvers !=?null) {
??for?(ViewResolver viewResolver :?this.viewResolvers) {
???View view = viewResolver.resolveViewName(viewName, locale);
???if?(view !=?null) {
????return?view;
???}
??}
?}
?return?null;
}

<!-- ¶¨ÒåÊÓͼÎļþ½âÎö -->
<bean?class="org.springframework.web.servlet.view.InternalResourceViewResolver">
?<property?name="prefix"?value="/WEB-INF/views/"?/>
?<property?name="suffix"?value=".html"?/>
</bean>

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

/**
?* This implementation expects the handler to be an {@link HandlerMethod}.
?*/
@Override
@Nullable
public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
??throws Exception {

?return?handleInternal(request, response, (HandlerMethod) handler);
}

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

?ModelAndView mav;
?// УÑéÖ¸¶¨µÄÇëÇóÒÔ»ñÈ¡ÊÜÖ§³ÖµÄ·½·¨ÀàÐÍ£¨GET¡¢POSTµÈ£©ºÍËùÐèµÄsession
?checkRequest(request);

?// 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...
??// ÕæÕýÖ´ÐÐhandlerµÄ·½·¨
??mav = invokeHandlerMethod(request, response, handlerMethod);
?}

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

?return?mav;
}

/**
?* Invoke the {@link?RequestMapping} handler method preparing a {@link?ModelAndView}
?* if view resolution is required.
?* Ö´ÐÐ@RequestMapping±ê×¢µÄhandler·½·¨£¬Èç¹ûÐèÒª½âÎöÊÓͼ¾Í×¼±¸Ò»¸öModelAndView
?*/
@Nullable
protected?ModelAndView?invokeHandlerMethod(HttpServletRequest request,
??HttpServletResponse response, HandlerMethod handlerMethod)?throws?Exception?{

?ServletWebRequest webRequest =?new?ServletWebRequest(request, response);
?try?{
??WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
??ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);

??// HandlerMethod½Ó¿Ú·â×°Ö´Ðз½·¨µÄÐÅÏ¢£¬Ìṩ¶Ô·½·¨²ÎÊý£¬·½·¨·µ»ØÖµ£¬·½·¨×¢Ê͵ȵıã½Ý·ÃÎÊ¡£
??ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
??if?(this.argumentResolvers !=?null) {
???invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
??}
??if?(this.returnValueHandlers !=?null) {
???invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
??}
??invocableMethod.setDataBinderFactory(binderFactory);
??invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);

??// ModelAndViewContainer¿ÉÒÔ¿´×öModelAndViewµÄÉÏÏÂÎÄÈÝÆ÷£¬¹ØÁª×ÅModelºÍViewµÄÐÅÏ¢
??ModelAndViewContainer mavContainer =?new?ModelAndViewContainer();
??mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
??modelFactory.initModel(webRequest, mavContainer, invocableMethod);
??mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);

??AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
??asyncWebRequest.setTimeout(this.asyncRequestTimeout);

??WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
??asyncManager.setTaskExecutor(this.taskExecutor);
??asyncManager.setAsyncWebRequest(asyncWebRequest);
??asyncManager.registerCallableInterceptors(this.callableInterceptors);
??asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);

??if?(asyncManager.hasConcurrentResult()) {
???Object result = asyncManager.getConcurrentResult();
???mavContainer = (ModelAndViewContainer) asyncManager.getConcurrentResultContext()[0];
???asyncManager.clearConcurrentResult();
???LogFormatUtils.traceDebug(logger, traceOn -> {
????String formatted = LogFormatUtils.formatValue(result, !traceOn);
????return?"Resume with async result ["?+ formatted +?"]";
???});
???invocableMethod = invocableMethod.wrapConcurrentResult(result);
??}

??// ÕæÕýÖ´ÐÐHandlerµÄ·½·¨
??invocableMethod.invokeAndHandle(webRequest, mavContainer);
??if?(asyncManager.isConcurrentHandlingStarted()) {
???return?null;
??}

??// »ñÈ¡ModelAndeView¶ÔÏó
??return?getModelAndView(mavContainer, modelFactory, webRequest);
?}
?finally?{
??webRequest.requestCompleted();
?}
}

/**
?* Invoke the method and handle the return value through one of the
?* configured {@link?HandlerMethodReturnValueHandler HandlerMethodReturnValueHandlers}.
?*?@param?webRequest the current request
?*?@param?mavContainer the ModelAndViewContainer for this request
?*?@param?providedArgs "given" arguments matched by type (not resolved)
?*/
public?void?invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
??Object... providedArgs)?throws?Exception?{

?// Ö´ÐÐhandlerµÄ·½·¨
?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?{
??this.returnValueHandlers.handleReturnValue(
????returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
?}
?catch?(Exception ex) {
??if?(logger.isTraceEnabled()) {
???logger.trace(formatErrorForReturnValue(returnValue), ex);
??}
??throw?ex;
?}
}

/**
?* Invoke the method after resolving its argument values in the context of the given request.
?* <p>Argument values are commonly resolved through
?* {@link?HandlerMethodArgumentResolver HandlerMethodArgumentResolvers}.
?* The {@code?providedArgs} parameter however may supply argument values to be used directly,
?* i.e. without argument resolution. Examples of provided argument values include a
?* {@link?WebDataBinder}, a {@link?SessionStatus}, or a thrown exception instance.
?* Provided argument values are checked before argument resolvers.
?* <p>Delegates to {@link?#getMethodArgumentValues} and calls {@link?#doInvoke} with the
?* resolved arguments.
?*?@param?request the current request
?*?@param?mavContainer the ModelAndViewContainer for this request
?*?@param?providedArgs "given" arguments matched by type, not resolved
?*?@return?the raw value returned by the invoked method
?*?@throws?Exception raised if no suitable argument resolver can be found,
?* or if the method raised an exception
?*?@see?#getMethodArgumentValues
?*?@see?#doInvoke
?*/
@Nullable
public?Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
??Object... providedArgs) throws?Exception?{

?// »ñÈ¡²ÎÊý
?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.
?* <p>The resulting array will be passed into {@link #doInvoke}.
?* @since 5.1.2
?*/
protected?Object[] getMethodArgumentValues(NativeWebRequest request,?@Nullable?ModelAndViewContainer mavContainer,
??Object... providedArgs) throws Exception {

?// »ñÈ¡·½·¨ÉÏËùÓеIJÎÊý
?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;
}

/**
?* Iterate over registered
?* {@link HandlerMethodArgumentResolver HandlerMethodArgumentResolvers}
?* and invoke the one that supports it.
?* @throws IllegalArgumentException if no suitable argument resolver is found
?*/
@Override
@Nullable
public?Object?resolveArgument(MethodParameter parameter,?@Nullable?ModelAndViewContainer mavContainer,
??NativeWebRequest webRequest,?@Nullable?WebDataBinderFactory binderFactory) throws Exception {

?// »ñÈ¡ºÏÊʵIJÎÊý½âÎöÆ÷
?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);
}

/**
?* Find a registered {@link HandlerMethodArgumentResolver} that supports
?* the given method parameter.
?*/
@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;
}

/**
?* Resolve the argument from the model or if not found instantiate it with
?* its default if it is available. The model attribute is then populated
?* with request values via data binding and optionally validated
?* if {@code @java.validation.Valid} is present on the argument.
?* @throws BindException if data binding and validation result in an error
?* and the next method parameter is not of type {@link Errors}
?* @throws Exception if WebDataBinder initialization fails
?*/
@Override
@Nullable
public?final?Object?resolveArgument(MethodParameter parameter,?@Nullable?ModelAndViewContainer mavContainer,
??NativeWebRequest webRequest,?@Nullable?WebDataBinderFactory binderFactory) throws Exception {

?Assert.state(mavContainer !=?null,?"ModelAttributeMethodProcessor requires ModelAndViewContainer");
?Assert.state(binderFactory !=?null,?"ModelAttributeMethodProcessor requires WebDataBinderFactory");

?// »ñÈ¡²ÎÊýÃû
?String?name = ModelFactory.getNameForParameter(parameter);
?// »ñÈ¡²ÎÊýÉϵÄModelAttribute×¢½â
?ModelAttribute ann = parameter.getParameterAnnotation(ModelAttribute.class);
?if?(ann !=?null) {
??mavContainer.setBinding(name, ann.binding());
?}

?Object?attribute =?null;
?BindingResult bindingResult =?null;

?if?(mavContainer.containsAttribute(name)) {
??attribute = mavContainer.getModel().get(name);
?}
?else?{
??// Create attribute instance
??try?{
???// ´´½¨²ÎÊýÀàÐ͵ÄʵÀý£¨Î´×¢ÈëÖµ£©£¬µ×²ã¾ÍÊÇͨ¹ý·´Éäµ÷Óù¹Ôì·½·¨
???attribute = createAttribute(name, parameter, binderFactory, webRequest);
??}
??catch?(BindException ex) {
???if?(isBindExceptionRequired(parameter)) {
????// No BindingResult parameter -> fail with BindException
????throw?ex;
???}
???// Otherwise, expose null/empty value and associated BindingResult
???if?(parameter.getParameterType() == Optional.class) {
????attribute = Optional.empty();
???}
???bindingResult = ex.getBindingResult();
??}
?}

?if?(bindingResult ==?null) {
??// Bean property binding and validation;
??// skipped in case of binding failure on construction.
??WebDataBinder binder = binderFactory.createBinder(webRequest, attribute, name);
??if?(binder.getTarget() !=?null) {
???if?(!mavContainer.isBindingDisabled(name)) {
????// ÕæÕýÖ´Ðа󶨣¨Öµ×¢È룩µÄ·½·¨
????bindRequestParameters(binder, webRequest);
???}
???validateIfApplicable(binder, parameter);
???if?(binder.getBindingResult().hasErrors() && isBindExceptionRequired(binder, parameter)) {
????throw?new?BindException(binder.getBindingResult());
???}
??}
??// Value type adaptation, also covering java.util.Optional
??if?(!parameter.getParameterType().isInstance(attribute)) {
???attribute = binder.convertIfNecessary(binder.getTarget(), parameter.getParameterType(), parameter);
??}
??bindingResult = binder.getBindingResult();
?}

?// Add resolved attribute and BindingResult at the end of the model
?Map<String,?Object> bindingResultModel = bindingResult.getModel();
?mavContainer.removeAttributes(bindingResultModel);
?mavContainer.addAllAttributes(bindingResultModel);

?return?attribute;
}

/**
?* This implementation downcasts {@link?WebDataBinder} to
?* {@link?ServletRequestDataBinder} before binding.
?*?@see?ServletRequestDataBinderFactory
?*/
@Override
protected?void?bindRequestParameters(WebDataBinder binder, NativeWebRequest request)?{
?ServletRequest servletRequest = request.getNativeRequest(ServletRequest.class);
?Assert.state(servletRequest !=?null,?"No ServletRequest");
?ServletRequestDataBinder servletBinder = (ServletRequestDataBinder) binder;
?// Ö´Ðа󶨵ķ½·¨
?servletBinder.bind(servletRequest);
}

public?void?bind(ServletRequest request)?{
?// »ñÈ¡ËùÓвÎÊýµÄ¼üÖµ¶Ô
?MutablePropertyValues mpvs =?new?ServletRequestParameterPropertyValues(request);
?// ´¦ÀíÎļþÉÏ´«ÇëÇó
?MultipartRequest multipartRequest = WebUtils.getNativeRequest(request, MultipartRequest.class);
?if?(multipartRequest !=?null) {
??bindMultipart(multipartRequest.getMultiFileMap(), mpvs);
?}
?// °ÑurlÖÐЯ´øµÄ²ÎÊýÒ²¼ÓÈëµ½MutablePropertyValues
?addBindValues(mpvs, request);
?// Ö´Ðа󶨣¨×¢ÈëÖµ£©
?doBind(mpvs);
}

/**
?* Invoke the method and handle the return value through one of the
?* configured {@link?HandlerMethodReturnValueHandler HandlerMethodReturnValueHandlers}.
?*?@param?webRequest the current request
?*?@param?mavContainer the ModelAndViewContainer for this request
?*?@param?providedArgs "given" arguments matched by type (not resolved)
?*/
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?{
??// ÕæÕý´¦Àí²»Í¬ÀàÐÍ·µ»ØÖµµÄ·½·¨
??this.returnValueHandlers.handleReturnValue(
????returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
?}
?catch?(Exception ex) {
??if?(logger.isTraceEnabled()) {
???logger.trace(formatErrorForReturnValue(returnValue), ex);
??}
??throw?ex;
?}
}

/**
?* Iterate over registered {@link?HandlerMethodReturnValueHandler HandlerMethodReturnValueHandlers} and invoke the one that supports it.
?*?@throws?IllegalStateException if no suitable {@link?HandlerMethodReturnValueHandler} is found.
?*/
@Override
public?void?handleReturnValue(@Nullable Object returnValue, MethodParameter returnType,
??ModelAndViewContainer mavContainer, NativeWebRequest webRequest)?throws?Exception?{

?// ¸ù¾Ý·µ»ØÖµ¸ö·µ»ØÖµÀàÐÍÑ¡È¡ºÏÊʵÄHandlerMethodReturnValueHandler
?HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType);
?if?(handler ==?null) {
??throw?new?IllegalArgumentException("Unknown return value type: "?+ returnType.getParameterType().getName());
?}
?// ÕæÕýµÄ´¦Àí·µ»ØÖµ
?handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
}

@Nullable
private?HandlerMethodReturnValueHandler selectHandler(@Nullable?Object?value, MethodParameter returnType) {
?boolean?isAsyncValue = isAsyncReturnValue(value, returnType);
?for?(HandlerMethodReturnValueHandler handler :?this.returnValueHandlers) {
??if?(isAsyncValue && !(handler?instanceof?AsyncHandlerMethodReturnValueHandler)) {
???continue;
??}
??if?(handler.supportsReturnType(returnType)) {
???return?handler;
??}
?}
?return?null;
}

@Override
public?void?handleReturnValue(@Nullable?Object?returnValue, MethodParameter returnType,
??ModelAndViewContainer mavContainer, NativeWebRequest webRequest)
??throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {

?// ÉèÖøÃÇëÇóÊÇ·ñÒÑÔÚ´¦Àí³ÌÐòÖÐÍêÈ«´¦Àí£¬ÀýÈç@ResponseBody·½·¨²»ÐèÒªÊÓͼ½âÎöÆ÷£¬´Ë´¦¾Í¿ÉÒÔÉèÖÃΪtrue¡£
?// µ±¿ØÖÆÆ÷·½·¨ÉùÃ÷ÀàÐÍΪServletResponse»òOutputStreamµÄ²ÎÊýʱ£¬Ò²¿ÉÒÔÉèÖô˱ê־Ϊtrue¡£?
?// Õâ¸öÊôÐÔÉèÖóÉtrueÖ®ºó£¬ÉϲãgetModelAndView»ñÈ¡ModelAndViewʱ»á·µ»ØNull£¬ÒòΪ²»ÐèÒªÊÓͼ¡£
?// ĬÈÏֵΪfalse
?mavContainer.setRequestHandled(true);
?ServletServerHttpRequest inputMessage = createInputMessage(webRequest);
?ServletServerHttpResponse outputMessage = createOutputMessage(webRequest);

?// Try even with null return value. ResponseBodyAdvice could get involved.
?// µ×²ã¾ÍÊÇÀûÓÃjava.io.OutputStreamWriterÀà°Ñ·µ»Øֵдµ½ÍøÂçIO
?writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage);
}