SpringMVC Source Learning: Container Initialization + MVC Initialization + Request Distribution Processing + Parameter Resolution + Return Value Resolution + View Resolution

SpringMVC Source Learning: Container Initialization + MVC Initialization + Request Distribution Processing + Parameter Resolution + Return Value Resolution + View Resolution

1. Preface
2. Initialization

  1. Container Initialization
    Ways to find the root container

Container Creation Method
Load profile information

  1. Initialization of MVC
    File Upload Parser

Zone Information Parser
handler Mapping Information Resolution

  1. Implementation principle of HandlerMapping

3. Processing of Request Response

  1. Request Distribution
  2. Request Processing
    Parameter parsing process

Pass Page Parameters
Return Value Resolution

  1. View Resolution
    view resolver

1. Preface

springMVC 5.0.2RELEASE


Configuration of Front End Controller:



        <!--Load the configuration file under the class path-->
    <!--Create objects at server startup. The smaller the value, the higher the priority, and the first to create objects-->

    <!--Note that not /*, but /* intercepts requests such as *.jsp-->

springmvc.xml Configuration

Copy <?Xml version="1.0" encoding="UTF-8"?>

<!-- Turn on Annotation Scan -->
<context:component-scan base-package="com.smday"/>

<!-- View Parser Object -->
<bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/pages/"/>
    <property name="suffix" value=".jsp"/>
<!-- open SpringMVC Support for framework notes -->
<!--Release static resources-->

2. Initialization

The startup of Dispatcher Servlet is closely related to the startup process of Servlet, which we can see from the inheritance diagram above.

  1. Container Initialization
    The init() method defined in the Servlet is the initialization method of its life cycle. Next, the GenericServlet does not give a specific implementation. The init() method in HttpServletBean gives a specific implementation:

HttpServletBean.init() method (ignoring logs)

Copy @Override

public final void init() throws ServletException {
    //Set the bean property based on the initialization parameters (we set the contextConfigLocation so we can get it)
    PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
    if (!pvs.isEmpty()) {
        try {
            //Packaging Dispatcher Servlet
            BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
            //Get the resource loader to load the springMVC configuration file
            ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
            //Register a ResourceEditor
            bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));
            //This method is empty and can be overridden to initialize BeanWrapper
            //Finally, the value spirng-mvc.xml read by init-param is stored in the contextConfigLocation
            bw.setPropertyValues(pvs, true);

    // Initialize subclasses


Let's see what FrameworfServlet.initServletBean() does (basically logging, timing, omitting these parts):


 * Overridden method of {@link HttpServletBean}, invoked after any bean properties
 * have been set. Creates this servlet's WebApplicationContext.
protected final void initServletBean() throws ServletException {
    //Initialization of WebApplicationContext
    this.webApplicationContext = initWebApplicationContext();
    //Is also an empty implementation, allowing subclasses to customize

So the highlight is on the initWebApplicationContext method, so let's first see what happens after execution:

You can see that the nine components of springMVC are assigned, in addition to the webApplicationContext.

Let's take a look at the source code and see its internal implementation: FrameworkServlet.initWebApplicationContext()

Copy protected WebApplicationContext initWebApplicationContext() {

//Root Container Find
WebApplicationContext rootContext =
WebApplicationContext wac = null;
if (this.webApplicationContext != null) {
    //Dispatcher Servlet was injected at build time and webApplicationContext already exists - > Direct use
    wac = this.webApplicationContext;
    if (wac instanceof ConfigurableWebApplicationContext) {
        ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
        if (!cwac.isActive()) {
            //If the context does not have refresh-->set the parent context, the application context id, and so on
            if (cwac.getParent() == null) {
                //Injected context instance without explicit parent - > set root application context as parent
if (wac == null) {
    //No context instances were injected during construction -->Query from ServletContext
    wac = findWebApplicationContext();
if (wac == null) {
    // Create a local one without --> in the ServletContext
    wac = createWebApplicationContext(rootContext);
if (!this.refreshEventReceived) {
    //Trigger onfresh manually if context does not support refresh or if it was already refresh at initialization
//Save the currently established context in the ServletContext using an attribute name related to the current Servlet name
if (this.publishContext) {
    // Publish context as servlet context property
    String attrName = getServletContextAttributeName();
    getServletContext().setAttribute(attrName, wac);
return wac;

Ways to find the root container
Copy WebApplicationContext rootContext =



Copy//SpringMVC supports the easy coexistence of Spring containers with the Web, and Spring containers are considered root containers and are usually loaded by ContextLoaderListener.
public static WebApplicationContext getWebApplicationContext(ServletContext sc) {

//String ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE = WebApplicationContext.class.getName() + ".ROOT"
return getWebApplicationContext(sc, WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);


public static WebApplicationContext getWebApplicationContext(ServletContext sc, String attrName) {

//Find values for keys based on ServletName.ROOT
Object attr = sc.getAttribute(attrName);
if (attr == null) {
    return null;
return (WebApplicationContext) attr;

If both the Spring container and the Web container exist, the configuration of Spring needs to be loaded using ContextLoaderListener, and it will be key ed as

WebApplicationContext.class.getName() + ".ROOT is stored in the ServletContext.

Container Creation Method
When you build without any Context instance injection and no WebApplicationContext is found in the ServletContext, a local Context is created, which allows you to explicitly pass in the parent container as a parameter.

Copy protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) {

//Default: DEFAULT_CONTEXT_CLASS = XmlWebApplicationContext.class; contextClass can be specified in initialization parameters
Class<?> contextClass = getContextClass();
if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
    throw new ApplicationContextException(
        "Fatal initialization error in servlet with name '" + getServletName() +
        "': custom WebApplicationContext class [" + contextClass.getName() +
        "] is not of type ConfigurableWebApplicationContext");
//Get Configurable WebApplicationContext object
ConfigurableWebApplicationContext wac =
    (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);

String configLocation = getContextConfigLocation();
if (configLocation != null) {

return wac;

We can see that during this process, the IoC container of the Web container is created, also known as the XmlWebApplicationContext, which establishes the entire spring application in the Web container.


Copy protected void configureAndRefreshWebApplicationContext (Configurable WebApplicationContext wac) {

//Omit setting some values to the ConfigurableWebApplicationContext object...
//Each context refresh calls initPropertySources
ConfigurableEnvironment env = wac.getEnvironment();
if (env instanceof ConfigurableWebEnvironment) {
    ((ConfigurableWebEnvironment) env).initPropertySources(getServletContext(), getServletConfig());
//Initialize the webApplication container, restart

Load profile information
In fact, refresh() is the key method, which you should be familiar with when you first learned about the initialization of spring containers, or is it a three-step process:

BeanDefinition's esource location, where we located classpath:springmvc.xml.

During the beanDefinition loading process, springMVC made some changes, such as defining a namespace resolution MvcNamespaceHandler for mvc.

Next comes the registration of the beanDefinition in IoC, where the beanName:beanDefinition is stored as a key-value pair in the beandefinitionMap.

  1. Initialization of MVC
    Initialization of MVC is performed in Dispatcher Servlet's initStratefies method. With the method name, we can conclude that nine components are initialized here, essentially getting objects from the IoC container:

Copy protected void initStrategies(ApplicationContext context) {

    //File Upload Parser
    //Regional information parser, related to internationalization
    //theme resolver
    //handler Mapping Information Resolution
    //Adapter for handler
    //handler exception parser
    //View Name Converter
    //view resolver
    //Flash Map Manager

File Upload Parser
Copy private void initMultipartResolver(ApplicationContext context) {

try {
    this.multipartResolver = context.getBean(MULTIPART_RESOLVER_BEAN_NAME, MultipartResolver.class);
catch (NoSuchBeanDefinitionException ex) {
    // By default, multipartResolver is not configured.
    this.multipartResolver = null;

The profile upload parser is also simple, simply registering the MultipartResolver in the container opens the file upload function.

Zone Information Parser
Copy private void initLocaleResolver(ApplicationContext context) {

try {
    this.localeResolver = context.getBean(LOCALE_RESOLVER_BEAN_NAME, LocaleResolver.class);

catch (NoSuchBeanDefinitionException ex) {
    // Create objects with reflection using default policy
    this.localeResolver = getDefaultStrategy(context, LocaleResolver.class);

The Dispatcher Servlet.properties file in the peer directory of org.springframework.web.servlet.Dispatcher Servlet specifies the default policy for initializing several components.

handler Mapping Information Resolution
Handler Mappings exist to find the corresponding Controller controller Controller for HTTP requests.

Copy private void initHandlerMappings(ApplicationContext context) {

    this.handlerMappings = null;
    //Import HandlerMappings from all IoC containers, including their parent context
    if (this.detectAllHandlerMappings) {
        Map<String, HandlerMapping> matchingBeans =
                BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
        if (!matchingBeans.isEmpty()) {
            this.handlerMappings = new ArrayList<>(matchingBeans.values());
            // We keep HandlerMappings in sorted order.
    else {
        try {
            //Attempt to get from container
            HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
            this.handlerMappings = Collections.singletonList(hm);
        catch (NoSuchBeanDefinitionException ex) {
            // Ignore, we'll add a default HandlerMapping later.
    //Make sure there is at least one handler Mapping
    if (this.handlerMappings == null) {
        this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);

The next few operations are almost the same, so let's not go into details.

In general, the MVC initialization process is based on the IoC container initialization, after all, the component objects are removed from the container.

  1. Implementation principle of HandlerMapping

Handler Mapping plays a very important role in Spring MVC and we say it can find a corresponding Controller controller for HTTP requests, so let's take a closer look at what's hidden there.

HandlerMapping is an interface that contains a getHandler method that allows you to obtain a handlerExecutionChain corresponding to an HTTP request, which holds handler and interceptor lists in the handlerExecutionChain object, and methods related to setting interceptors.You can tell that these configured interceptors provide a wave of enhancements to the functionality provided by handler objects.

Let's take one of these HandlerMapping s as an example and focus on:

Copy protected void initHandlerMethods() {

//Get beanName in all contexts
String[] beanNames = (this.detectHandlerMethodsInAncestorContexts ?
                      BeanFactoryUtils.beanNamesForTypeIncludingAncestors(obtainApplicationContext(), Object.class) :

for (String beanName : beanNames) {
    if (!beanName.startsWith(SCOPED_TARGET_NAME_PREFIX)) {
        Class<?> beanType = null;
        //Get lass for corresponding beanName
        beanType = obtainApplicationContext().getType(beanName);
        //Determine whether it is a controller class
        if (beanType != null && isHandler(beanType)) {
            //Processing methods in the controller

isHandler method: Determines if the class has @Controller or @RequestMapping annotations

Copy @Override

protected boolean isHandler(Class<?> beanType) {
    return (AnnotatedElementUtils.hasAnnotation(beanType, Controller.class) ||
            AnnotatedElementUtils.hasAnnotation(beanType, RequestMapping.class));

detectHandlerMethods method:

Copy protected void detectHandler Methods (final Object handler) {

//Get the type of controller
Class<?> handlerType = (handler instanceof String ?
                        obtainApplicationContext().getType((String) handler) : handler.getClass());
if (handlerType != null) {
    //Processing the type again, mainly for cglib
    final Class<?> userType = ClassUtils.getUserClass(handlerType);
    //Traverse the method, process the information in the annotation, get the RequestMappingInfo object, get the methods array
    Map<Method, T> methods = MethodIntrospector.selectMethods(userType,
                                                              (MethodIntrospector.MetadataLookup<T>) method -> {
  return getMappingForMethod(method, userType);
    //Traverse methods[Method,{path}]
    for (Map.Entry<Method, T> entry : methods.entrySet()) {
        //Check method accessibility, such as private, static, SpringProxy
        Method invocableMethod = AopUtils.selectInvocableMethod(entry.getKey(), userType);
        //Get the final request path
        T mapping = entry.getValue();
        registerHandlerMethod(handler, invocableMethod, mapping);

Properties of the mapping object:

Elements stored in the methods object:

The registration method is implemented in AbstractHandlerMethodMapping:

Copy public void register(T mapping, Object handler, Method method) {

try {
    //Object of processing method
    HandlerMethod handlerMethod = createHandlerMethod(handler, method);
    //Determining the Uniqueness of Mapping
    assertUniqueMethodMapping(handlerMethod, mapping);
    //Correspond mapping information and controller methods
    this.mappingLookup.put(mapping, handlerMethod);
    //Map path to processor (one method may handle multiple url s)
    List<String> directUrls = getDirectUrls(mapping);
    for (String url : directUrls) {
        this.urlLookup.add(url, mapping);
    //Capitalized English abbreviation for controller name #method name
    String name = null;
    if (getNamingStrategy() != null) {
        name = getNamingStrategy().getName(handlerMethod, mapping);
        addMappingName(name, handlerMethod);
    //Cross-domain Request Related Configuration
    CorsConfiguration corsConfig = initCorsConfiguration(handler, method, mapping);
    if (corsConfig != null) {
        this.corsLookup.put(handlerMethod, corsConfig);
    //Register all configurations in the registry uniformly
    this.registry.put(mapping, new MappingRegistration<>(mapping, handlerMethod, directUrls, name));
finally {

At this point, all Controller s and the methods labeled with the @RequestMapping annotation are parsed and registered in HashMap, so that the corresponding request path matches the processing method, and HandlerMapping is initialized.

3. Processing of Request Response

  1. Request Distribution
    One thing we need to make clear is that when a request comes, where is the first execution? The Servlet service method. We just need to look at one of its subclasses:

service method overridden by FrameworkServlet:

Copy @Override

protected void service(HttpServletRequest request, HttpServletResponse response)
        throws ServletException, IOException {
    //Get Request Method
    HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
    //Intercept PATCH requests
    if (HttpMethod.PATCH == httpMethod || httpMethod == null) {
        processRequest(request, response);
    else {
        super.service(request, response);

In fact, the final call is to the processRequest method, which also calls the real doService() method, in which the details are not discussed. Let's go straight ahead and see what Dispatcher Servlet's doService does (Dispatcher Servlet class is really the core of the core, building both the IoC container and responsible for request distribution):

Copy @Override

protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
//Ignore a large list of preliminary preparations to enable it to handle view objects
//Next to real distribution
doDispatch(request, response);


Copy 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 {
        //Wrap the request if it is a file upload request, or return it as it is
        processedRequest = checkMultipart(request);
        //File Upload Request Identifier
        multipartRequestParsed = (processedRequest != request);

        //Find the appropriate handler for the current request request
        mappedHandler = getHandler(processedRequest);
        //If no handler can handle the request, jump to the error page
        if (mappedHandler == null) {
            noHandlerFound(processedRequest, response);
        //Find the appropriate adapter for the current request request
        HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

        String method = request.getMethod();
        boolean isGet = "GET".equals(method);
        if (isGet || "HEAD".equals(method)) {
            //Determines whether getLastModified is supported or returns -1 if not
            long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
            if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
        //Execute the preHandle method for registering interceptors
        if (!mappedHandler.applyPreHandle(processedRequest, response)) {
        // The way requests are actually handled
        mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

        if (asyncManager.isConcurrentHandlingStarted()) {
        //If the mv!=null &&mv object does not have a View, set a default ViewName for the MV object
        applyDefaultViewName(processedRequest, mv);
        //Execute the applyPostHandle method for registering interceptors
        mappedHandler.applyPostHandle(processedRequest, response, mv);
    //View parsing and rendering
    processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);

It is important to note that mappedHandler and HandlerAdapter are lookups that are traversed from the corresponding set, and that once they find an executable target, they stop looking, and we can artificially define priorities and determine the order between them.

  1. Request Processing
    The handleInternal method of the RequestMappingHandlerAdapter, which contains the logic to actually process the request.

Copy @Override
protected ModelAndView handleInternal(HttpServletRequest request,

                                  HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
//Define return value variable
ModelAndView mav;
//Check supportedMethods and requireSession for requests

// See if synchronizeOnSession is on, defaulting to false
if (this.synchronizeOnSession) {
    HttpSession session = request.getSession(false);
    //Httpsession available
    if (session != null) {
        Object mutex = WebUtils.getSessionMutex(session);
        //Lock, all requests serialized
        synchronized (mutex) {
            mav = invokeHandlerMethod(request, response, handlerMethod);
    else {
        // No Httpsession available ->No locks necessary
        mav = invokeHandlerMethod(request, response, handlerMethod);
else {
    // Normal Call Handling Method
    mav = invokeHandlerMethod(request, response, handlerMethod);
//Check if the response header contains Cache-Control
if (!response.containsHeader(HEADER_CACHE_CONTROL)) {
    if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
        applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
    else {

return mav;

The invokeHandlerMethod method of the RequestMappingHandlerAdapter really returns mv.

Copy @Nullable
protected ModelAndView invokeHandlerMethod(HttpServletRequest request,

                                       HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
//Wrap HttpServletRequest to produce a request object for ServletWebRequest to process the web
ServletWebRequest webRequest = new ServletWebRequest(request, response);
try {
    //Create a factory for the WebDataBinder object
    WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
    //Create Factory for Model Object
    ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
    //Wrap handlerMethod objects to create ServletInvocableHandlerMethod objects
    //Set related properties to invocableMethod (invokeAndHandle method is last called by invocableMethod object)
    ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
    if (this.argumentResolvers != null) {
    if (this.returnValueHandlers != null) {
    //Create a ModelAndViewContainer object that holds a map with data stored in the domain
    ModelAndViewContainer mavContainer = new ModelAndViewContainer();
    modelFactory.initModel(webRequest, mavContainer, invocableMethod);

    AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    //Omit Asynchronous Processing
    //Normal call
    invocableMethod.invokeAndHandle(webRequest, mavContainer);
    if (asyncManager.isConcurrentHandlingStarted()) {
        return null;
    //Get ModelAndView object
    return getModelAndView(mavContainer, modelFactory, webRequest);
finally {

invokeAndHandle method of ServletInvocableHandlerMethod: Reflect the call method to get the return value.

Copy public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,Object... providedArgs) throws Exception {

//Get parameters and return values by reflection
Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
//Set Response Status

if (returnValue == null) {
    if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {
else if (StringUtils.hasText(getResponseStatusReason())) {

Assert.state(this.returnValueHandlers != null, "No return value handlers");
try {
    //Processing return values
        returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
catch (Exception ex) {
    if (logger.isTraceEnabled()) {
        logger.trace(getReturnValueHandlingErrorMessage("Error handling return value", returnValue), ex);
    throw ex;

Parameter parsing process
What we can know is that when you pass parameters, you can pass parameters like Map, Basic Type, POJO, ModelMap, and so on. What happens after parsing?It is easier to analyze with a specific example:

Copy @RequestMapping ('/handle03/{id}')

public String handle03(@PathVariable("id") String sid,
                       Map<String,Object> map){
    return "success";


  • Gets the method parameter value of the current request.

private Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,Object... providedArgs) throws Exception {

//Get Parameter Object
MethodParameter[] parameters = getMethodParameters();
//Create an array of equal size to store parameter values
Object[] args = new Object[parameters.length];
for (int i = 0; i < parameters.length; i++) {
    MethodParameter parameter = parameters[i];
    args[i] = resolveProvidedArgument(parameter, providedArgs);
    if (args[i] != null) {
    if (this.argumentResolvers.supportsParameter(parameter)) {
        //Parameter processor processing parameters (strategies with different types of processing parameters for different types of parameters)
        args[i] = this.argumentResolvers.resolveArgument(
            parameter, mavContainer, request, this.dataBinderFactory);
    if (args[i] == null) {
        throw new IllegalStateException();
return args;

resolveArgument method:

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

//Get annotation information
NamedValueInfo namedValueInfo = getNamedValueInfo(parameter);
//Wrapping parameter objects
MethodParameter nestedParameter = parameter.nestedIfOptional();
//Gets the property name specified by @PathVariable
Object resolvedName = resolveStringValue(namedValueInfo.name);
if (resolvedName == null) {
    throw new IllegalArgumentException(
        "Specified name must not resolve to null: [" + namedValueInfo.name + "]");
//Find and get parameter values from url based on name
Object arg = resolveName(resolvedName.toString(), nestedParameter, webRequest);
//No match
if (arg == null) {
    //If there is a default value, look for it
    if (namedValueInfo.defaultValue != null) {
        arg = resolveStringValue(namedValueInfo.defaultValue);
    //If required is false, name may not be specified, but defaults to true.
    else if (namedValueInfo.required && !nestedParameter.isOptional()) {
        handleMissingValue(namedValueInfo.name, nestedParameter, webRequest);
    arg = handleNullValue(namedValueInfo.name, arg, nestedParameter.getNestedParameterType());
//Although matched, the parameter passed in in the path is handled by default if it is "" and has a default name
else if ("".equals(arg) && namedValueInfo.defaultValue != null) {
    arg = resolveStringValue(namedValueInfo.defaultValue);

if (binderFactory != null) {
    WebDataBinder binder = binderFactory.createBinder(webRequest, null, namedValueInfo.name);
        arg = binder.convertIfNecessary(arg, parameter.getParameterType(), parameter);   
handleResolvedValue(arg, namedValueInfo.name, parameter, mavContainer, webRequest);
return arg;

getNameValueInfo method:

Copy private NamedValueInfo getNamedValueInfo(MethodParameter parameter) {

    //Get from Cache
    NamedValueInfo namedValueInfo = this.namedValueInfoCache.get(parameter);
    if (namedValueInfo == null) {
        //Create a namedValueInfo object
        namedValueInfo = createNamedValueInfo(parameter);
        //If the property name is not specified in the comment, the default is the parameter name
        namedValueInfo = updateNamedValueInfo(parameter, namedValueInfo);
        //Update Cache
        this.namedValueInfoCache.put(parameter, namedValueInfo);
    return namedValueInfo;

createNamedValueInfo: Gets the information for the @PathVariable annotation and encapsulates it as a NamedValueInfo object

Copy @Override

protected NamedValueInfo createNamedValueInfo(MethodParameter parameter) {
    PathVariable ann = parameter.getParameterAnnotation(PathVariable.class);
    Assert.state(ann != null, "No PathVariable annotation");
    return new PathVariableNamedValueInfo(ann);


Copy private NamedValueInfo updateNamedValueInfo(MethodParameter parameter, NamedValueInfo info){

String name = info.name;
if (info.name.isEmpty()) {
    //Parameter name if no name is specified in the comment
    name = parameter.getParameterName();
    if (name == null) {
        throw new IllegalArgumentException(
            "Name for argument type [" + parameter.getNestedParameterType().getName() +
            "] not available, and parameter name information not found in class file either.");
String defaultValue = (ValueConstants.DEFAULT_NONE.equals(info.defaultValue) ? null : info.defaultValue);
return new NamedValueInfo(name, info.required, defaultValue);

resolveName method:

The process of parameter parsing:

Based on the method object, get an array of parameter objects and create an array to store the parameters.
Traverses through the parameter object array and parses it according to the parameter parser argumentResolver.
Error if there is no parameter parser.
When parsing a parameter, try to get information about the comment first, using @PathVariable as an example.
Gets the parameter value from the url based on the specified name, or defaults to the parameter name you passed in if it is not specified.
Pass Page Parameters
We may store key-value pairs into the domain through Map, Model, ModelMap, and so on, which are part of the request processing.

What we're interested in is the class ModelAndViewContainer, which contains BindingAwareModelMap by default.

A BindingAwareModelMap has already been initialized with the MapMethodProcessor parameter processor when parsing parameters.

Of course, the focus here is still on parameter parsing. As to why the data is encapsulated in the map, it's very simple. It's all about reflecting the execution method and put ting the data in, of course, the final data also exists in the ModelAndViewContainer.

Return Value Resolution
Omit the procedure to find the return value parser, because the return value is the view name, so the parser is ViewNameMethodReturnValueHandler.

Copy @Override
public void handleReturnValue(@Nullable Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {

if (returnValue instanceof CharSequence) {
    //Get View Name
    String viewName = returnValue.toString();
    //Set to mavContainer
    //Is it isRedirectViewName
    if (isRedirectViewName(viewName)) {
else if (returnValue != null){
    // should not happen
    throw new UnsupportedOperationException("Unexpected return type: " +
                                            returnType.getParameterType().getName() + " in method: " + returnType.getMethod());

isRedirectViewName method

Copy protected Boolean isRedirectViewName {

    //Does it conform to the custom redirectPatterns or the name beginning with redirect:
    return (PatternMatchUtils.simpleMatch(this.redirectPatterns, viewName) || viewName.startsWith("redirect:"));

Finally, get the mv object through getModelAndView, let's take a closer look:

Copy @Nullable
private ModelAndView getModelAndView(ModelAndViewContainer mavContainer,ModelFactory modelFactory, NativeWebRequest webRequest) throws Exception {

//Promote model attributes listed as @SessionAttributes to the session
modelFactory.updateModel(webRequest, mavContainer);
//If the request has been processed
if (mavContainer.isRequestHandled()) {
    return null;
//Get our saved data map from mavContainer
ModelMap model = mavContainer.getModel();
//Create a ModelAndView object from view name, modelmap, and status
ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model, mavContainer.getStatus());
if (!mavContainer.isViewReference()) {
    mav.setView((View) mavContainer.getView());
if (model instanceof RedirectAttributes) {
    Map<String, ?> flashAttributes = ((RedirectAttributes) model).getFlashAttributes();
    HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
    if (request != null) {
return mav;

The last thing returned is the ModelAndView object, which contains the logical name and the view of the model object.

Return value parsing is relatively simple:

Gets the corresponding return value parser based on the returned parameters.
Get the view name, mavContainer.setRedirectModelScenario(true) if redirect is required;
In other cases, simply set the ViewName view name property in the mvcContainer.
Finally, take out the model, status, viewName of mvcContainer and create mv object to return.

Both parameter parsing and return value parsing contain a large number of resolution strategies. The process of finding an appropriate parser is to first traverse the initialized parser table, then determine if asynchronous processing is required, determine if the return value type can be handled, and if possible, use the parser to parse. If not, traverse down until the table is overrunUntil you have a parser.

  1. View Resolution
    Copy private void process DispatchResult (HttpServletRequest request, HttpServletResponse response, @Nullable Handler ExecutionChain mappedHandler, @Nullable ModelAndView mv,

@Nullable Exception exception) throws Exception {

boolean errorView = false;
// Guarantee rendering once, cleared as tag
if (mv != null && !mv.wasCleared()) {
    //Rendering process!!!
    render(mv, request, response);
    if (errorView) {

render method of Dispatcher Servlet

Copy 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());

View view;
//Get View Name
String viewName = mv.getViewName();
if (viewName != null) {
    //Create a view object by processing the view name with the view resolver viewResolvers
    view = resolveViewName(viewName, mv.getModelInternal(), locale, request);
else {
    view = mv.getView();
if (mv.getStatus() != null) {
view.render(mv.getModelInternal(), request, response);   

Get the view parser and parse the view name:

Copy @Nullable
protected View resolveViewName(String viewName, @Nullable Map model,
Locale locale, HttpServletRequest request) throws Exception {

//Here we are registering InternalResourceViewResolver
if (this.viewResolvers != null) {
    for (ViewResolver viewResolver : this.viewResolvers) {
        View view = viewResolver.resolveViewName(viewName, locale);
        if (view != null) {
            return view;
return null;

createView method of UrlBasedViewResolver:

Copy @Override

protected View createView(String viewName, Locale locale) throws Exception {
    //If the parser cannot process the given view, return null and let the next parser see if it can execute
    if (!canHandle(viewName, locale)) {
        return null;
    // Check for special "redirect:" prefix.
    if (viewName.startsWith(REDIRECT_URL_PREFIX)) {
        //Determine if redirection is required
    // Check for special "forward:" prefix.
    if (viewName.startsWith(FORWARD_URL_PREFIX)) {
        //Determine whether forwarding is required
    //Call the loadView method of the parent class
    return super.createView(viewName, locale);

Last returned view object:

View resolver viewResolver -- instantiation - > View (stateless, no thread security issues)

render method of AbstractView

Copy @Override
public void render(@Nullable Map model, HttpServletRequest request,
HttpServletResponse response) throws Exception {

//Get the merged map, the map we have stored in the domain, the key value for PathVariable, and so on
Map<String, Object> mergedModel = createMergedOutputModel(model, request, response);
prepareResponse(request, response);
//Render internal resources based on a given model, such as setting the model to the property of request
renderMergedOutputModel(mergedModel, getRequestToExpose(request), response);

renderMergedOutputModel for InternalResourceView

Copy @Override
protected void renderMergedOutputModel(

Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {

//Set the value in the model to the request field
exposeModelAsRequestAttributes(model, request);

// Set helpers for request, if any

// Set target address in request
String dispatcherPath = prepareForRendering(request, response);

// Get RequestDispatcher for the target resource (usually JSP).
RequestDispatcher rd = getRequestDispatcher(request, dispatcherPath);

// If it already contains or the response has been submitted, then include is performed, otherwise forward.
if (useInclude(request, response)) {
    rd.include(request, response);
else {
    // Note: The forwarded resource should determine the content type itself.
    rd.forward(request, response);


Copy protected void exposeModelAsRequestAttributes(Map model,HttpServletRequest request) throws Exception {

//Traversing model
model.forEach((modelName, modelValue) -> {
    if (modelValue != null) {
        //Set value to request
        request.setAttribute(modelName, modelValue);
    else {
        //Remove the name if value is null

view resolver
View resolver (implements the ViewResolver interface): parses a logical view into a specific view object.

Each view parser implements the Ordered interface and opens the order attribute, with lower order being more preferred.

Resolve the logical view name in the view resolver's order of priority until the resolution succeeds and the view object is returned, or an exception is thrown.

View (implements the View interface): Renders model data and presents it to the user in some form.

The final view object is used to render the model data, the processor does not care, the processor cares about the production model data, and decouples.

Author: Tencho Bacha
Source: https://www.cnblogs.com/summerday152/

Tags: Spring xml Session JSP

Posted on Sun, 10 May 2020 01:20:44 -0400 by peyups