前言
在requestmappinghandleradapter对request进行了适配，并且调用了目标handler之后，其会返回一个modelandview对象，该对象中主要封装了两个属性：view和model。其中view可以是字符串类型也可以是view类型，如果是字符串类型，则表示逻辑视图名，如果是view类型，则其即为我们要转换的目标view；这里model是一个map类型的对象，其保存了渲染视图所需要的属性。本文主要讲解spring是如何通过用户配置的viewresolver来对视图进行解析，并且声称页面进行渲染的。
首先我们来看一个比较典型的viewresolver配置：
|
1
2
3
4
|
<bean class="org.springframework.web.servlet.view.internalresourceviewresolver">
<property name="prefix" value="/web-inf/view/"/>
<property name="suffix" value=".jsp"/>
</bean>
|
这里配置的viewresolver是internalresourceviewresolver，其主要有两个属性：prefix和suffix。在进行视图解析时，如果modelandview中的view是字符串类型的，那么要解析的视图存储位置就通过“prefix + (string)view + suffix”的格式生成要解析的文件路径，并且将其封装为一个view对象，最后通过view对象来渲染具体的视图。前面讲到，modelandview中view也可以是view类型的，如果其是view类型的，那么这里就可以跳过第一步，直接使用其提供的view对象进行视图解析了。
由上面的讲解可以看出，对于视图的解析可以分为两个步骤：①解析逻辑视图名；②渲染视图。对应于这两步，spring也抽象了两个接口：viewresolver和view，这两个接口的声明分别如下：
|
1
2
3
4
|
public interface viewresolver {
// 通过逻辑视图名和用户地区信息生成view对象
view resolveviewname(string viewname, locale locale) throws exception;
}
|
|
1
2
3
4
5
6
7
8
9
10
|
public interface view {
// 获取返回值的contenttype
default string getcontenttype() {
return null;
}
// 通过用户提供的模型数据与视图信息渲染视图
void render(@nullable map<string, ?> model, httpservletrequest request,
httpservletresponse response) throws exception;
}
|
从上面两个接口的声明可以看出，viewresolver的作用主要在于通过用户提供的逻辑视图名根据一定的策略生成一个view对象，而view接口则负责根据视图信息和需要填充的模型数据进行视图的渲染。这里我们首先看internalresourceviewresolver是如何解析视图名的，如下是其具体实现方式：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
|
@override
@nullable
public view resolveviewname(string viewname, locale locale) throws exception {
// 判断当前viewresolver是否设置了需要对需要解析的视图进行缓存，如果不需要缓存，
// 则每次请求时都会重新解析生成视图对象
if (!iscache()) {
// 根据视图名称和用户地区信息创建view对象
return createview(viewname, locale);
} else {
// 如果可以对视图进行缓存，则首先获取缓存使用的key，然后从缓存中获取该key，如果没有取到，
// 则对其进行加锁，再次获取，如果还是没有取到，则创建一个新的view，并且对其进行缓存。
// 这里使用的是双检查法来判断缓存中是否存在对应的逻辑视图。
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) {
view = createview(viewname, locale);
// 这里cacheunresolved指的是是否缓存默认的空视图，unresolved_view是
// 一个没有任何内容的view
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);
}
}
|
上面代码中，internalresourceviewresolver主要是判断了当前是否配置了需要缓存生成的view对象，如果需要缓存，则从缓存中取，如果没有配置，则每次请求时都会重新生成新的view对象。这里我们继续看其是如何创建视图的：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
|
@override
protected view loadview(string viewname, locale locale) throws exception {
// 使用逻辑视图名按照指定规则生成view对象
abstracturlbasedview view = buildview(viewname);
// 应用声明周期函数，也就是调用view对象的初始化函数和spring用于切入bean创建的
// processor和aware函数
view result = applylifecyclemethods(viewname, view);
// 检查view的准确性，这里默认始终返回true
return (view.checkresource(locale) ? result : null);
}
// 这里buildview()方法主要是根据逻辑视图名生成一个view对象
protected abstracturlbasedview buildview(string viewname) throws exception {
// 对于internalresourceviewresolver而言，其返回的view对象的
// 具体类型是internalresourceview
class<?> viewclass = getviewclass();
assert.state(viewclass != null, "no view class");
// 使用反射生成internalresourceview对象实例
abstracturlbasedview view = (abstracturlbasedview)
beanutils.instantiateclass(viewclass);
// 这里可以看出，internalresourceviewresolver获取目标视图的方式就是将用户返回的
// viewname与prefix和suffix进行拼接，以供view对象直接读取
view.seturl(getprefix() + viewname + getsuffix());
// 设置view的contenttype属性
string contenttype = getcontenttype();
if (contenttype != null) {
view.setcontenttype(contenttype);
}
// 设置contextattribute和attributemap等属性
view.setrequestcontextattribute(getrequestcontextattribute());
view.setattributesmap(getattributesmap());
// 这了pathvariables表示request请求url中的属性，这里主要是设置是否将这些属性暴露到视图中
boolean exposepathvariables = getexposepathvariables();
if (exposepathvariables != null) {
view.setexposepathvariables(exposepathvariables);
}
// 这里设置的是是否将spring的bean暴露在视图中，以供给前端调用
boolean exposecontextbeansasattributes = getexposecontextbeansasattributes();
if (exposecontextbeansasattributes != null) {
view.setexposecontextbeansasattributes(exposecontextbeansasattributes);
}
// 设置需要暴露给前端页面的bean名称
string[] exposedcontextbeannames = getexposedcontextbeannames();
if (exposedcontextbeannames != null) {
view.setexposedcontextbeannames(exposedcontextbeannames);
}
return view;
}
protected view applylifecyclemethods(string viewname, abstracturlbasedview view) {
applicationcontext context = getapplicationcontext();
if (context != null) {
// 对生成的view对象应用初始化方法，主要包括initializingbean.afterproperties()和一些
// processor，aware方法
object initialized = context.getautowirecapablebeanfactory()
.initializebean(view, viewname);
if (initialized instanceof view) {
return (view) initialized;
}
}
return view;
}
|
从上面对于视图名称的解析，可以看出，其主要做了四部分工作：①实例化view对象；②设置目标视图地址；③初始化视图的一些基本属性，如需要暴露的bean对象；④调用view对象的初始化方法对其进行初始化。从这里的生成view对象的过程也可以看出，viewresolver生成的view对象只是保存了目标view的地址，而对其加载和渲染的过程主要是委托给了view对象进行的。下面我们就来看一下internalresourceview是如何结合具体的model来渲染视图的：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
@override
public void render(@nullable 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);
}
// 这里主要是将request中pathvariable，staticattribute与用户返回的model属性
// 合并为一个map对象，以供给后面对视图的渲染使用
map<string, object> mergedmodel = createmergedoutputmodel(model, request, response);
// 判断当前view对象的类型是否为文件下载类型，如果是文件下载类型，则设置response的
// pragma和cache-control等属性值
prepareresponse(request, response);
// 通过合并的model数据以及视图地址进行视图的渲染
rendermergedoutputmodel(mergedmodel, getrequesttoexpose(request), response);
}
|
这里对于视图的渲染主要分为了三步：①合并用户返回的model数据和request中的pathvariable与staticattribute等数据；②判断当前是否为文件下载类型的视图解析，如果是，则设置pragma和cache-control等header；③通过合并的模型数据和request请求对视图进行渲染。这里我们主要看一下rendermergedoutputmodel()方法是如何对视图进行渲染的：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
|
@override
protected void rendermergedoutputmodel(map<string, object> model,
httpservletrequest request, httpservletresponse response) throws exception {
// 这里主要是对model进行遍历，将其key和value设置到request中，当做request的
// 一个属性供给页面调用
exposemodelasrequestattributes(model, request);
// 提供的一个hook方法，默认是空实现，用于用户进行request属性的自定义使用
exposehelpers(request);
// 检查当前是否存在循环类型的视图名称解析，主要是根据相对路径进行判断视图名是无法解析的
string dispatcherpath = prepareforrendering(request, response);
// 获取当前request的requestdispatcher对象，该对象有两个方法：include()和forward()，
// 用于对当前的request进行转发，其实也就是将当前的request转发到另一个url，这里的另一个
// url就是要解析的视图地址，也就是说进行视图解析的时候请求的对于文件的解析实际上相当于
// 构造了另一个（文件）请求，在该请求中对文件内容进行渲染，从而得到最终的文件。这里的
// include()方法表示将目标文件引入到当前文件中，与jsp中的include标签作用相同；
// forward()请求则表示将当前请求转发到另一个请求中，也就是目标文件路径，这种转发并不会
// 改变用户浏览器地址栏的请求地址。
requestdispatcher rd = getrequestdispatcher(request, dispatcherpath);
if (rd == null) {
throw new servletexception("could not get requestdispatcher for [" + geturl()
+ "]: check that the corresponding file exists within your web "
+ "application archive!");
}
// 判断当前是否为include请求，如果是，则调用requestdispatcher.include()方法进行文件引入
if (useinclude(request, response)) {
response.setcontenttype(getcontenttype());
if (logger.isdebugenabled()) {
logger.debug("including resource [" + geturl() + "] in internalresourceview '"
+ getbeanname() + "'");
}
rd.include(request, response);
} else {
if (logger.isdebugenabled()) {
logger.debug("forwarding to resource [" + geturl()
+ "] in internalresourceview '" + getbeanname() + "'");
}
// 如果当前不是include()请求，则直接使用forward请求将当前请求转发到目标文件路径中，
// 从而渲染该视图
rd.forward(request, response);
}
}
|
上述代码就是进行视图渲染的核心逻辑，上述逻辑主要分为两个步骤：①将需要在页面渲染使用的model数据设置到request中；②按照当前请求的方式（include或forward）来将当前请求转发到目标文件中，从而达到目标文件的渲染。从这里可以看出，实际上对于spring而言，其对页面的渲染并不是在其原始的request中完成的。
本文首先讲解了spring进行视图渲染所需要的两大组件viewresolver和view的关系，然后以internalresourceviewresolver和internalresourceview为例讲解spring底层是如何解析一个view，并且渲染该view的。
总结
以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对服务器之家的支持。
原文链接：https://my.oschina.net/zhangxufeng/blog/2222523