springmvc默认解码方式

视图和视图解析器

• 请求处理方法执行完成后，最终返回一个 ModelAndView 对象。对于那些返回 String，View 或 ModeMap 等类型的处理方法，Spring MVC 也会在内部将它们装配成一个 ModelAndView 对象，它包含了逻辑名和模型对象的视图
• Spring MVC 借助视图解析器(ViewResolver)得到最终的视图对象(View)，最终的视图可以是 JSP ，也可能是 Excel、JFreeChart等各种表现形式的视图
• 对于最终究竟采取何种视图对象对模型数据进行渲染，处理器并不关心，处理器工作重点聚焦在生产模型数据的工作上，从而实现 MVC 的充分解耦

视图

视图的作用是渲染模型数据，将模型里的数据以某种形式呈现给客户。为了实现视图模型和具体实现技术的解耦，Spring 在 org.springframework.web.servlet 包中定义了一个高度抽象的 View 接口：

视图对象由视图解析器负责实例化。由于视图是无状态的，所以他们不会有线程安全的问题

常用的视图实现类

视图解析器

SpringMVC 为逻辑视图名的解析提供了不同的策略，可以在 Spring WEB 上下文中配置一种或多种解析策略，并指定他们之间的先后顺序。每一种映射策略对应一个具体的视图解析器实现类。

视图解析器的作用比较单一：将逻辑视图解析为一个具体的视图对象。

所有的视图解析器都必须实现 ViewResolver 接口：

程序员可以选择一种视图解析器或混用多种视图解析器。每个视图解析器都实现了 Ordered 接口并开放出一个 order 属性，可以通过 order 属性指定解析器的优先顺序，order 越小优先级越高。 SpringMVC 会按视图解析器顺序的优先顺序对逻辑视图名进行解析，直到解析成功并返回视图对象，否则将抛出 ServletException 异常。

JSP 是最常见的视图技术，可以使用 InternalResourceViewResolve作为视图解析器：

实验代码

请求转发

@RequestMapping("/hello1")
    public String hello1(){
        return "../../hello";
    }

    @RequestMapping("/hello2")
    public String hello2(){
        return "forward:/hello.jsp";
    }

    @RequestMapping("/hello3")
    public String hello3(){
        return "forward:/hello2";
    }

    @RequestMapping("/hello4")
    public String hello4(){
        return "redirect:/index.jsp";
    }

都可以跳到index.jsp

源码断点

1.任何的方法都会进入到doDispatch(request, response);中

2.在它的方法中mv = ha.handle(processedRequest, response, mappedHandler.getHandler());，有处理器适配器调用生成ModelAndView

3.调用handle方法，是由子类AnnotationMethodHandlerAdapter实现的，里面会调用invokeHandlerMethod(request, response, handler)方法。

最终会返回ModelAndView对象，view就是要跳转的页面，model里面就是数据。

4.方法继续放下走到processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);

private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
			HandlerExecutionChain mappedHandler, ModelAndView mv, 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.isDebugEnabled()) {
				logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + getServletName() +
						"': assuming HandlerAdapter completed request handling");
			}
		}

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

		if (mappedHandler != null) {
			mappedHandler.triggerAfterCompletion(request, response, null);
		}
	}

5.render(mv, request, response);

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.resolveLocale(request);
		response.setLocale(locale);

		View view;
		if (mv.isReference()) {
			// We need to resolve the view name.
			view = resolveViewName(mv.getViewName(), 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.isDebugEnabled()) {
			logger.debug("Rendering view [" + view + "] in DispatcherServlet with name '" + getServletName() + "'");
		}
		try {
			view.render(mv.getModelInternal(), request, response);
		}
		catch (Exception ex) {
			if (logger.isDebugEnabled()) {
				logger.debug("Error rendering view [" + view + "] in DispatcherServlet with name '"
						+ getServletName() + "'", ex);
			}
			throw ex;
		}
	}

其中有一个重要的方法resolveViewName(mv.getViewName(), mv.getModelInternal(), locale, request);，解析试图名，点进去看看。

试图解析器根据方法的返回值，得到一个view对象。要是不为空，说明能解析。

@Override
	public View resolveViewName(String viewName, Locale locale) throws Exception {
		if (!isCache()) {
			return createView(viewName, locale);
		}
		else {
			Object cacheKey = getCacheKey(viewName, locale);
			View view = this.viewAccessCache.get(cacheKey);
			if (view == null) {
				synchronized (this.viewCreationCache) {
					view = this.viewCreationCache.get(cacheKey);
					if (view == null) {
						// Ask the subclass to create the View object.
                        //根据方法的返回值创建view对象
						view = createView(viewName, locale);
						if (view == null && this.cacheUnresolved) {
							view = UNRESOLVED_VIEW;
						}
						if (view != null) {
							this.viewAccessCache.put(cacheKey, view);
							this.viewCreationCache.put(cacheKey, view);
							if (logger.isTraceEnabled()) {
								logger.trace("Cached view [" + cacheKey + "]");
							}
						}
					}
				}
			}
			return (view != UNRESOLVED_VIEW ? view : null);
		}
	}

view = createView(viewName, locale);这个方法，是真正的创建试图。

创建完成，会有一个view

视图解析器得到View对象的流程就是，所有配置的视图解析器都来尝试根据视图名(返回值)得到View(试图)对象；如果能得到就返回，得不到就换下一个试图解析器。

6.view进行渲染。

@Override
	protected void renderMergedOutputModel(
			Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {

		// Determine which request handle to expose to the RequestDispatcher.
		HttpServletRequest requestToExpose = getRequestToExpose(request);

		// Expose the model object as request attributes.
		exposeModelAsRequestAttributes(model, requestToExpose);

		// Expose helpers as request attributes, if any.
		exposeHelpers(requestToExpose);

		// Determine the path for the request dispatcher.
		String dispatcherPath = prepareForRendering(requestToExpose, response);

		// Obtain a RequestDispatcher for the target resource (typically a JSP).
		RequestDispatcher rd = getRequestDispatcher(requestToExpose, dispatcherPath);
		if (rd == null) {
			throw new ServletException("Could not get RequestDispatcher for [" + getUrl() +
					"]: Check that the corresponding file exists within your web application archive!");
		}

		// If already included or response already committed, perform include, else forward.
		if (useInclude(requestToExpose, response)) {
			response.setContentType(getContentType());
			if (logger.isDebugEnabled()) {
				logger.debug("Including resource [" + getUrl() + "] in InternalResourceView '" + getBeanName() + "'");
			}
			rd.include(requestToExpose, response);
		}

		else {
			// Note: The forwarded resource is supposed to determine the content type itself.
			if (logger.isDebugEnabled()) {
				logger.debug("Forwarding to resource [" + getUrl() + "] in InternalResourceView '" + getBeanName() + "'");
			}
			rd.forward(requestToExpose, response);
		}
	}

视图解析器只是为了得到试图对象；视图对象才能真正的转发(将模型数据全部放在请求域中)或者重定向到页面，视图对象才能渲染试图。

拓展

<!-- 直接配置响应的页面：无需经过控制器来执行结果 -->
      <mvc:view-controller path="/success" view-name="success"/>

但是请求别的接口的时候，都报错404。

配置mvc:view-controller会导致其他请求路径失效

解决办法：

<mvc:annotation-driven/>

自定义视图和视图解析器

/**
 * @author WGR
 * @create 2021/4/8 -- 0:06
 */
@Component
public class HelloView implements View {

    @Override
    public String getContentType() {
        return "text/html";
    }

    @Override
    public void render(Map<String, ?> model, HttpServletRequest request,
                       HttpServletResponse response) throws Exception {
        System.out.println(model);
        response.setContentType("text/html");
        response.getWriter().println("HelloView - time = " + new Date());
        response.getWriter().println(model.get("name"));
    }
}

/**
 * @author WGR
 * @create 2021/4/8 -- 0:04
 */
@Component
public class MyViewResolver implements ViewResolver, Ordered {
    @Override
    public View resolveViewName(String viewName, Locale locale) throws Exception {
       if(viewName.startsWith("wgr")){
           return new HelloView();
       }else {
           return null;
       }

    }

    @Override
    public int getOrder() {
        return 1;
    }
}

    @RequestMapping("/testView")
    public String testView(Model model){
        System.out.println("testView...");
        model.addAttribute("name","dalianpai");
        return "wgr:/helloView"; //与视图Bean 对象的id一致
    }