学习SpringMVC——说说视图解析器

  各位前排的,后排的,都不要走,咱趁热打铁,就这一股劲我们今天来说说spring mvc的视图解析器(不要抢,都有位子~~~)

  相信大家在昨天那篇如何获取请求参数篇中都已经领略到了spring mvc注解的魅力和套路了。搭上@RequestMapping的便车,我们可以去到我们想去的地方(方法)去,借助@RequestParam、@PathVariable等我们可以得到请求中想要的参数值,最终还能够通过神奇的“return SUCCESS”到达我们的目的地。今天主要就来说说在达到目的地的路上,我们都经历了些什么!

在此之前

  我们顺便说说@RequestHeader、请求参数类型为POJO(也就是Java对象类型)的情况以及ModelAndView

  1. @RequestHeader

  这个无需多说,还是原来的配方,还是一样的套路,只要举个例子,你就都明白了。

  在SpringMVCTest中添加测试方法

@RequestMapping(value="/testRequestHeader")
public String testRequestHeader(@RequestHeader(value="Accept-Language") String language){
	System.out.println("testRequestHeader Accept-Languge:" + language);
	return SUCCESS;
}

  我们知道一个请求如get请求或post都有请求头和响应头,这里我们想获取的是请求头中“Accept-Language”的具体信息,所以就用上了@RequestHeader注解来获取。

  index.jsp中

<a href="springmvc/testRequestHeader">testRequestHeader</a><br/><br/>

  启动服务器,点击超链接,我们得到了

testRequestHeader Accept-Languge:zh-CN

  2. 请求参数为POJO

  前面两篇,我们看到的请求类型都是一些字符串也就是某一个字段。那么如果现在有一个form表单,说夸张点,表单中有10个字段需要提交,行吧,还用原来的匹配的方式,你要用10个参数来接收,累不累?累!有没有办法?有!我们可以把这些要提交的字段封装在一个对象中,从而请求类型就是一个POJO。

  这里我们新建一个类User

package com.jackie.springmvc.entities;

public class User {

	private Integer id;

	private String username;
	private String password;
	private String email;
	private int age;
	private Address address;

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getUsername() {
		return username;
	}

	public void setUsername(String username) {
		this.username = username;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}

	public String getEmail() {
		return email;
	}

	public void setEmail(String email) {
		this.email = email;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public Address getAddress() {
		return address;
	}

	public void setAddress(Address address) {
		this.address = address;
	}

	public User(String username, String password, String email, int age) {
		super();
		this.username = username;
		this.password = password;
		this.email = email;
		this.age = age;
	}

	public User(Integer id, String username, String password, String email, int age) {
		super();
		this.id = id;
		this.username = username;
		this.password = password;
		this.email = email;
		this.age = age;
	}

	@Override
	public String toString() {
		return "User [id=" + id + ", username=" + username + ", password=" + password + ", email=" + email + ", age="
				+ age + "]";
	}

	public User() {

	}
}

  还有一个Address类

package com.jackie.springmvc.entities;

public class Address {

	private String province;
	private String city;

	public String getProvince() {
		return province;
	}

	public void setProvince(String province) {
		this.province = province;
	}

	public String getCity() {
		return city;
	}

	public void setCity(String city) {
		this.city = city;
	}

	@Override
	public String toString() {
		return "Address [province=" + province + ", city=" + city + "]";
	}
}

  同时我们还需要在SpringMVCTest中写一个testPojo的测试方法

@RequestMapping(value="/testPojo")
public String testPojo(User user){
	System.out.println("testPojo: " + user);
	return SUCCESS;
}

  好了,这样,我们就可以在前台jsp页面上构造这样的表单数据了

<form action="springmvc/testPojo" method="post">
	username: <input type="text" name="username"><br>
	password: <input type="password" name="password"><br>
	email: <input type="text" name="email"><br>
	age: <input type="text" name="age"><br>
	city: <input type="text" name="address.city"><br>
	province: <input type="text" name="address.province"><br>
	<input type="submit" value="submit">
</form><br/><br/>

  至此,我们启动tomcat服务器,就可以发送一个POJO类型的参数了,并且我们成功了读取了这个请求参数

  3. ModelAndView

  ModelAndView是什么鬼?其实它是我们经常写在SpringMVCTest里测试方法的返回值类型,在方法体内我们可以通过ModelAndView对象来是像请求域中添加模型数据的,抽象?那就看例子吧~~~

  SpringMVCTest中添加方法

@RequestMapping(value="/testModelAndView")
public ModelAndView testModelAndView(){
	String viewname = SUCCESS;
	ModelAndView modelAndView = new ModelAndView(viewname);
	modelAndView.addObject("time", new Date());
	return modelAndView;
}

  index.jsp中还是添加一个超链接

<a href="springmvc/testModelAndView">testModelAndView</a><br/><br/>

  注意我们需要在结果页面中拿到这个放入请求域中的键值对,所以在success.jsp页面中添加

time: ${requestScope.time}<br><br>

  最终的效果图是这样的

  没错,我们将当前时间信息写进了请求域,并通过视图展示出来。

  有了前面的小铺垫,现在我们来唠唠这视图解析器的事儿

视图解析器

  这里主要通过调试源代码看看spring mvc的handler是如何利用视图解析器找到并返回实际的物理视图的,别眨眼

 1. 如何看源码

  说到调试源码,我们就要有源码才行,那么如何看源码,相信这个页面大家已经看腻了吧

  没错,这是因为你没有导入源码的jar包,程序没办法给你呈现源代码,还好,这个问题难不倒我们,在第一篇中我们有关于springframework所需要的功能jar包,javadoc以及源码包,那么来导入一波

  选中前面提示的spring-context的source jar包,我们就可以一睹这个java文件的庐山真面目了

                                            484很开心~~~

  2. 代码调试

  为此我们写一个测试方法

@RequestMapping("/testViewAndViewResolver")
public String testViewAndViewResolver(){
	System.out.println("testViewAndViewResolver");
	return SUCCESS;
}

  index.jsp加个链接

<a href="springmvc/testViewAndViewResolver">testViewAndViewResolver</a><br/><br/>

  给testViewAndView方法体一个断点,我们进入调试状态,

  程序停在断点处,在调试的上下文中,我们找到DispatcherServlet.doDispaatch方法,以此为入口,来看看视图解析器

  (1) 进入DispatcherServlet.doDispaatch

  定位到

mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

  可以看到这里有个mv对象,实际上就是ModelAndView,通过调试我们发现这里的mv中包括了model和view,view的指向就是success,而model这里之所以有值是因为在SpringMVCTest中有一个getUser方法,且加上了@ModelAttribute注解,从而初始化了model。

(2)执行processDispatchResult方法

  在doDispatch中继续执行,直到

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

  这里我们着重看下render方法,然后得到视图的名字,即运行到view = resolveViewName(mv.getViewName(), mv.getModelInternal(), locale, request);进入到该方法后,我们可以看到整个方法如下:

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

  这里用到了视图解析器即this.viewResolvers。而真正的渲染视图在DispatcherServlet的view.render(mv.getModelInternal(), request, response);点击进入这里的render方法,我们选择AbstractView这个抽象类中的该方法

/**
	 * Prepares the view given the specified model, merging it with static
	 * attributes and a RequestContext attribute, if necessary.
	 * Delegates to renderMergedOutputModel for the actual rendering.
	 * @see #renderMergedOutputModel
	 */
	@Override
	public void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
		if (logger.isTraceEnabled()) {
			logger.trace("Rendering view with name '" + this.beanName + "' with model " + model +
				" and static attributes " + this.staticAttributes);
		}

		Map<String, Object> mergedModel = createMergedOutputModel(model, request, response);
		prepareResponse(request, response);
		renderMergedOutputModel(mergedModel, request, response);
	}

  该方法负责针对具体的Model呈现具体的view,这时候再进入到renderMergedOutputMode的具体实现类

  点击后,我们发现对此方法多个类都有实现,那么到底是哪个呢,实际上是InternalResourceView这个类,为什么定位到这个类,笔者是根据之前在springmvc.xml中配置的视图解析器的线索找到的,当时我们配的是InternalResourceViewResolver这个解析器,所以相应的,这里应该是InternalResourceView类,同时通过加断点,更加验证了这一想法~~~

  此外在调试DispatcherServlet的resolveViewName方法时,发现,这里的viewResolver正是我们配置的视图解析器InternalResourceViewResolver

  同时发现这里返回的view就是/WEB-INF/views/success.jsp

  至此,我们就完成了ModelAndView的逻辑路径向这里"/WEB-INF/views/success.jsp"的物理路径的转化,大致了了解了视图解析器的工作机制(感觉还是没有说清楚--!)。

  好了,本篇我们主要学习了

  1. @Request的用法
  2. 请求参数为POJO的用法
  3. ModelAndView的用法
  4. 如何看源代码
  5. spring mvc如何通过视图解析器得到真正的物理视图页面

  如果您觉得阅读本文对您有帮助,请点一下“推荐”按钮,您的“推荐”将是我最大的写作动力!如果您想持续关注我的文章,请扫描二维码,关注JackieZheng的微信公众号,我会将我的文章推送给您,并和您一起分享我日常阅读过的优质文章。(点赞不迷路,博主带你上高速~~~)

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏你不就像风一样

[转]Spring基础知识汇总 Java开发必看

Spring框架由Rod Johnson开发,2004年发布了Spring框架的第一版。Spring是一个从实际开发中抽取出来的框架,因此它完成了大量开发中的通...

1293
来自专栏程序猿DD

【译】Spring 官方教程:创建批处理服务

原文:Creating a Batch Service 译者:Mr.lzc 校对:lexburner 本指南将引导你完成创建基本的批处理驱动解决方案的过程。 你...

5217
来自专栏机器学习从入门到成神

临界区、互斥量、信号量

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/sinat_35512245/articl...

1662
来自专栏coderhuo

虚拟内存探究 -- 第三篇:一步一步画虚拟内存图

这是虚拟内存系列文章的第三篇。 前面我们提到在进程的虚拟内存中可以找到哪些东西,以及在哪里去找。 本文我们将通过打印程序中不同元素内存地址的方式,一步一步细...

2044
来自专栏黑泽君的专栏

day63_SpringMVC学习笔记_01

(1)使用eclipse,创建一个动态的web工程   其中Dynamic web module version版本选择 2.5,这样兼容性好一些;   Def...

861
来自专栏SpringSpace.cn

使用 Postman 与 Kotlin 交互REST API接口数据 顶

在前面2篇文章使用 Kotlin 和Spring Boot 2.0快速开发REST API接口和使用 Kotlin 和Spring Boot 2.0快速开发RE...

1423
来自专栏Java后端技术

SpringBoot一站式启动流程源码分析

  由上篇文章我们得知,SpringBoot启动时,就是有很简单的一行代码。那我们可以很清楚的看到这行代码的主角便是SpringApplication了,本文我...

912
来自专栏美团技术团队

这个Spring高危漏洞,你修补了吗?

前言 2009年9月Spring 3.0 RC1发布后,Spring就引入了SpEL(Spring Expression Language)。对于开发者而言,引...

1.1K11
来自专栏Kirito的技术分享

解析Spring中的ResponseBody和RequestBody

spring,restful,前后端分离这些关键词都是大家耳熟能详的关键词了,一般spring常常需要与前端、第三方使用JSON,XML等形式进行交互,你也一定...

2.8K17
来自专栏CodeSheep的技术分享

初探Kotlin+SpringBoot联合编程

Kotlin是一门最近比较流行的静态类型编程语言,而且和Groovy、Scala一样同属Java系。Kotlin具有的很多静态语言特性诸如:类型判断、多范式、扩...

75014

扫码关注云+社区