/**     * Do we need view name translation?     */    private void applyDefaultViewName(HttpServletRequest request, ModelAndView mv) throws Exception {        if (mv != null && !mv.hasView()) {            mv.setViewName(getDefaultViewName(request));        }    }

    /**     * Translate the supplied request into a default view name.     * @param request current HTTP servlet request     * @return the view name (or {@code null} if no default found)     * @throws Exception if view name translation failed     */    protected String getDefaultViewName(HttpServletRequest request) throws Exception {        return this.viewNameTranslator.getViewName(request);    }

    /**     * Initialize the strategy objects that this servlet uses.     * <p>May be overridden in subclasses in order to initialize further strategy objects.     */    protected void initStrategies(ApplicationContext context) {        initMultipartResolver(context);        initLocaleResolver(context);        initThemeResolver(context);        initHandlerMappings(context);        initHandlerAdapters(context);        initHandlerExceptionResolvers(context);        initRequestToViewNameTranslator(context);        initViewResolvers(context);        initFlashMapManager(context);    }     * Initialize the RequestToViewNameTranslator used by this servlet instance.     * <p>If no implementation is configured then we default to DefaultRequestToViewNameTranslator.     */    private void initRequestToViewNameTranslator(ApplicationContext context) {        try {            this.viewNameTranslator =                    context.getBean(REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME, RequestToViewNameTranslator.class);            if (logger.isDebugEnabled()) {                logger.debug("Using RequestToViewNameTranslator [" + this.viewNameTranslator + "]");            }        }        catch (NoSuchBeanDefinitionException ex) {            // We need to use the default.            this.viewNameTranslator = getDefaultStrategy(context, RequestToViewNameTranslator.class);            if (logger.isDebugEnabled()) {                logger.debug("Unable to locate RequestToViewNameTranslator with name ‘" +                        REQUEST_TO_VIEW_NAME_TRANSLATOR_BEAN_NAME + "‘: using default [" + this.viewNameTranslator +                        "]");            }        }    }

/**     * Translates the request URI of the incoming {@link HttpServletRequest}     * into the view name based on the configured parameters.     * @see org.springframework.web.util.UrlPathHelper#getLookupPathForRequest     * @see #transformPath     */    @Override    public String getViewName(HttpServletRequest request) {        String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);        return (this.prefix + transformPath(lookupPath) + this.suffix);    }    /**     * Transform the request URI (in the context of the webapp) stripping     * slashes and extensions, and replacing the separator as required.     * @param lookupPath the lookup path for the current request,     * as determined by the UrlPathHelper     * @return the transformed path, with slashes and extensions stripped     * if desired     */    protected String transformPath(String lookupPath) {        String path = lookupPath;        if (this.stripLeadingSlash && path.startsWith(SLASH)) {            path = path.substring(1);        }        if (this.stripTrailingSlash && path.endsWith(SLASH)) {            path = path.substring(0, path.length() - 1);        }        if (this.stripExtension) {            path = StringUtils.stripFilenameExtension(path);        }        if (!SLASH.equals(this.separator)) {            path = StringUtils.replace(path, SLASH, this.separator);        }        return path;    }

/**     * Return the mapping lookup path for the given request, within the current     * servlet mapping if applicable, else within the web application.     * <p>Detects include request URL if called within a RequestDispatcher include.     * @param request current HTTP request     * @return the lookup path     * @see #getPathWithinApplication     * @see #getPathWithinServletMapping     */    public String getLookupPathForRequest(HttpServletRequest request) {        // Always use full path within current servlet context?        if (this.alwaysUseFullPath) {            return getPathWithinApplication(request);        }        // Else, use path within current servlet mapping if applicable        String rest = getPathWithinServletMapping(request);        if (!"".equals(rest)) {            return rest;        }        else {            return getPathWithinApplication(request);        }    }    /**     * Return the path within the servlet mapping for the given request,     * i.e. the part of the request‘s URL beyond the part that called the servlet,     * or "" if the whole URL has been used to identify the servlet.     * <p>Detects include request URL if called within a RequestDispatcher include.     * <p>E.g.: servlet mapping = "/test/*"; request URI = "/test/a" -> "/a".     * <p>E.g.: servlet mapping = "/test"; request URI = "/test" -> "".     * <p>E.g.: servlet mapping = "/*.test"; request URI = "/a.test" -> "".     * @param request current HTTP request     * @return the path within the servlet mapping, or ""     */    public String getPathWithinServletMapping(HttpServletRequest request) {        String pathWithinApp = getPathWithinApplication(request);        String servletPath = getServletPath(request);        String path = getRemainingPath(pathWithinApp, servletPath, false);        if (path != null) {            // Normal case: URI contains servlet path.            return path;        }        else {            // Special case: URI is different from servlet path.            String pathInfo = request.getPathInfo();            if (pathInfo != null) {                // Use path info if available. Indicates index page within a servlet mapping?                // e.g. with index page: URI="/", servletPath="/index.html"                return pathInfo;            }            if (!this.urlDecode) {                // No path info... (not mapped by prefix, nor by extension, nor "/*")                // For the default servlet mapping (i.e. "/"), urlDecode=false can                // cause issues since getServletPath() returns a decoded path.                // If decoding pathWithinApp yields a match just use pathWithinApp.                path = getRemainingPath(decodeInternal(request, pathWithinApp), servletPath, false);                if (path != null) {                    return pathWithinApp;                }            }            // Otherwise, use the full servlet path.            return servletPath;        }    }    /**     * Return the path within the web application for the given request.     * <p>Detects include request URL if called within a RequestDispatcher include.     * @param request current HTTP request     * @return the path within the web application     */    public String getPathWithinApplication(HttpServletRequest request) {        String contextPath = getContextPath(request);        String requestUri = getRequestUri(request);        String path = getRemainingPath(requestUri, contextPath, true);        if (path != null) {            // Normal case: URI contains context path.            return (StringUtils.hasText(path) ? path : "/");        }        else {            return requestUri;        }    }    /**     * Match the given "mapping" to the start of the "requestUri" and if there     * is a match return the extra part. This method is needed because the     * context path and the servlet path returned by the HttpServletRequest are     * stripped of semicolon content unlike the requesUri.     */    private String getRemainingPath(String requestUri, String mapping, boolean ignoreCase) {        int index1 = 0;        int index2 = 0;        for (; (index1 < requestUri.length()) && (index2 < mapping.length()); index1++, index2++) {            char c1 = requestUri.charAt(index1);            char c2 = mapping.charAt(index2);            if (c1 == ‘;‘) {                index1 = requestUri.indexOf(‘/‘, index1);                if (index1 == -1) {                    return null;                }                c1 = requestUri.charAt(index1);            }            if (c1 == c2) {                continue;            }            if (ignoreCase && (Character.toLowerCase(c1) == Character.toLowerCase(c2))) {                continue;            }            return null;        }        if (index2 != mapping.length()) {            return null;        }        if (index1 == requestUri.length()) {            return "";        }        else if (requestUri.charAt(index1) == ‘;‘) {            index1 = requestUri.indexOf(‘/‘, index1);        }        return (index1 != -1 ? requestUri.substring(index1) : "");    }

    /**     * Resolve the given view name into a View object (to be rendered).     * <p>The default implementations asks all ViewResolvers of this dispatcher.     * Can be overridden for custom resolution strategies, potentially based on     * specific model attributes or request parameters.     * @param viewName the name of the view to resolve     * @param model the model to be passed to the view     * @param locale the current locale     * @param request current HTTP servlet request     * @return the View object, or {@code null} if none found     * @throws Exception if the view cannot be resolved     * (typically in case of problems creating an actual View object)     * @see ViewResolver#resolveViewName     */    protected View resolveViewName(String viewName, Map<String, Object> model, Locale locale,            HttpServletRequest request) throws Exception {        for (ViewResolver viewResolver : this.viewResolvers) {            View view = viewResolver.resolveViewName(viewName, locale);            if (view != null) {                return view;            }        }        return null;    }

    @Override    protected AbstractUrlBasedView buildView(String viewName) throws Exception {        InternalResourceView view = (InternalResourceView) super.buildView(viewName);        if (this.alwaysInclude != null) {            view.setAlwaysInclude(this.alwaysInclude);        }        if (this.exposeContextBeansAsAttributes != null) {            view.setExposeContextBeansAsAttributes(this.exposeContextBeansAsAttributes);        }        if (this.exposedContextBeanNames != null) {            view.setExposedContextBeanNames(this.exposedContextBeanNames);        }        view.setPreventDispatchLoop(true);        return view;    }

/**
* Creates a new View instance of the specified view class and configures it.
* Does <i>not</i> perform any lookup for pre-defined View instances.
* <p>Spring lifecycle methods as defined by the bean container do not have to
* be called here; those will be applied by the {@code loadView} method
* after this method returns.
* <p>Subclasses will typically call {@code super.buildView(viewName)}
* first, before setting further properties themselves. {@code loadView}
* will then apply Spring lifecycle methods at the end of this process.
* @param viewName the name of the view to build
* @return the View instance
* @throws Exception if the view couldn‘t be resolved
* @see #loadView(String, java.util.Locale)
*/
protected AbstractUrlBasedView buildView(String viewName) throws Exception {
AbstractUrlBasedView view = (AbstractUrlBasedView) BeanUtils.instantiateClass(getViewClass());
view.setUrl(getPrefix() + viewName + getSuffix());

String contentType = getContentType();
if (contentType != null) {
view.setContentType(contentType);
}

view.setRequestContextAttribute(getRequestContextAttribute());
view.setAttributesMap(getAttributesMap());

Boolean exposePathVariables = getExposePathVariables();
if (exposePathVariables != null) {
view.setExposePathVariables(exposePathVariables);
}

return view;
}

            // No need to lookup: the ModelAndView object contains the actual View object.            view = mv.getView();