springmvc--12--jsp视图解析响应原理

男娘i 2022-11-07 13:30 187阅读 0赞

# springmvc–`jsp`视图解析响应原理 #

### 文章目录 ###

*  springmvc--\`jsp\`视图解析响应原理
 *  1 前言
 *  2 \`jsp\`视图解析器
 *   *  2.1 \`AbstractCachingViewResolver\`
     *   *  2.1.1 是否使用缓存
         *  2.1.2 根据视图名构建缓存的\`key\`
         *  2.1.3 根据视图名创建视图对象
     *  2.2 \`UrlBasedViewResolver\`
     *   *  2.2.1 \`createView(viewName,locale)\`方法,添加对转发和重定向支持
         *   *  2.2.1.1 判断该视图解析器是否支持处理该视图名
             *  2.2.1.2 给定\`URL\`是否解释为根路径开始的\`URL\`
             *  2.2.1.3 是否应该与\`HTTP1.0\`客户端兼容
             *  2.2.1.4 获取重定向的主机地址
             *  2.2.1.5 视图对象应用\`spring\`生命周期初始化阶段方法
         *  2.2.2 \`loadView(String viewName, Locale locale)\`方法，创建视图对象
         *   *  2.2.2.1 获取视图的\`clazz\`对象
             *  2.2.2.2 获取静态属性
             *  2.2.2.3 获取视图的内容类型
             *  2.2.2.4 获取用户定义的请求上下文对象的名字
             *  2.2.2.5 是否将模板变量添加到模型中
             *  2.2.2.6 是否将上下文\`bean\`作为属性放入视图中
             *  2.2.2.7 获取上下文\`bean\`的\`beanName\`
         *  2.2.3 \`InternalResourceViewResolver\`
         *   *  2.2.3.1 构造方法
             *  2.2.3.2 \`buildView(viewName)\`方法
 *  3 \`jsp\`视图
 *   *  3.1 \`AbstractView\`
     *   *  3.1.1 \`getContentType()\`方法
         *  3.1.2 \`render(model, request,response)\`方法
         *   *  3.1.2.1 创建一个包含动态值和静态值的组合\`Map\`
             *  3.1.2.2 渲染视图的准备工作
             *  3.1.2.3 渲染视图
     *  3.2 \`AbstractUrlBasedView\`
     *  3.3 \` InternalResourceView\`
     *   *  3.3.1 将模型中所有数据保存到请求域中
         *  3.3.2 暴露请求域属性的帮助者
         *  3.3.3 渲染前的准备工作
         *  3.3.4 获取请求转发器
         *  3.3.5 是否请求包含
     *  3.4 \`JstlView\`

# 1 前言 #

虽然`jsp`已经被淘汰了，但是毕竟我们接触`web`编程最开始接触的就是`jsp`，所以我觉得还是有必要了解一下这项过时的技术。这篇文章会完整的介绍`springmvc`是如何将一个`String`字符串解析为`jsp`视图对象，最后又是如何响应给客户端浏览器的？

# 2 `jsp`视图解析器 #

> `InternalResourceViewResolver` 负责创建一个`jsp`视图
> 
> 我们先来看看它的继承关系

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMDEyOTgx_size_16_color_FFFFFF_t_70_pic_center]

我们只看`ViewResolver`的实现类

## 2.1 `AbstractCachingViewResolver` ##

根据继承关系，我们先看`AbstractCachingViewResolver`类，这个抽象的视图解析器提供了缓存的功能，解析一次之后，将视图名和视图对象缓存到一个`Map`集合中。

/** Default maximum number of entries for the view cache: 1024. */
 public static final int DEFAULT_CACHE_LIMIT = 1024;
 
 
 //可缓存1024个映射关系
 private final Map<Object, View> viewAccessCache = new ConcurrentHashMap<>(DEFAULT_CACHE_LIMIT);
 
 //另一个缓存
 private final Map<Object, View> viewCreationCache =
 new LinkedHashMap<Object, View>(DEFAULT_CACHE_LIMIT, 0.75f, true) { 
 @Override
 protected boolean removeEldestEntry(Map.Entry<Object, View> eldest) { 
 //缓存大于1024之后，就删除之前缓存的所有映射关系
 if (size() > getCacheLimit()) { 
 viewAccessCache.remove(eldest.getKey());
 return true;
 }
 else { 
 return false;
 }
 }
 };
 
 //一个空视图，它什么也不做
 private static final View UNRESOLVED_VIEW = new View() { 
 @Override
 @Nullable
 public String getContentType() { 
 return null;
 }
 @Override
 public void render(@Nullable Map<String, ?> model, HttpServletRequest request, HttpServletResponse response) { 
 }
 };
 
 @Override
 @Nullable
 public View resolveViewName(String viewName, Locale locale) throws Exception { 
 //不使用缓存，见3.1.1
 if (!isCache()) { 
 //根据视图名创建视图，见2.1.3
 return createView(viewName, locale);
 }
 //使用缓存
 else { 
 //根据视图名构建缓存的key，见2.1.2
 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.
 //根据视图名创建视图，见2.1.3
 view = createView(viewName, locale);
 if (view == null && this.cacheUnresolved) { 
 //无法创建视图就返回一个空视图对象
 view = UNRESOLVED_VIEW;
 }
 if (view != null && this.cacheFilter.filter(view, viewName, locale)) { 
 //添加缓存，两个缓存
 this.viewAccessCache.put(cacheKey, view);
 this.viewCreationCache.put(cacheKey, view);
 }
 }
 }
 }
 else { 
 if (logger.isTraceEnabled()) { 
 logger.trace(formatKey(cacheKey) + "served from cache");
 }
 }
 return (view != UNRESOLVED_VIEW ? view : null);
 }
 }

> 典型的模板方法模式，定义了解析视图的流程
> 
> 1.  首先判断是否使用缓存，不使用缓存则直接调用`createView(viewName, locale)`方法创建视图对象
> 2.  使用缓存，则首先尝试从第一个缓存`viewAccessCache`中获取视图，若能获取，则直接使用这个视图
> 3.  第一个缓存`viewAccessCache`中获取不到，则尝试从第二个缓存`viewCreationCache`中获取，若能获取，则直接使用这个视图
> 4.  否则调用调用`createView(viewName, locale)`方法创建视图对象并缓存到两个缓存集合中

### 2.1.1 是否使用缓存 ###

/** Default maximum number of entries for the view cache: 1024. */
    public static final int DEFAULT_CACHE_LIMIT = 1024;
    
    //在构造缓存map集合时也用到了DEFAULT_CACHE_LIMIT
    private volatile int cacheLimit = DEFAULT_CACHE_LIMIT;
    
    
    /** * Return if caching is enabled. */
    public boolean isCache() { 
        return (this.cacheLimit > 0);
    }

> 最多只能缓存`1024`个视图映射关系
> 
>  *  `>0`表示使用缓存
>  *  `=0`表示不使用缓存

### 2.1.2 根据视图名构建缓存的`key` ###

/** * Return the cache key for the given view name and the given locale. * Default is a String consisting of view name and locale suffix. * Can be overridden in subclasses. * Needs to respect the locale in general, as a different locale can * lead to a different view resource. */
 protected Object getCacheKey(String viewName, Locale locale) { 
 return viewName + '_' + locale;
 }

> 该方法会被子类重写，定义自己的缓存的`key`的规则
> 
>  *  `UrlBasedViewResolver`：直接使用视图名
>  *  `XmlViewResolver`：直接使用视图名
>  *  `GroovyMarkupViewResolver`：`viewName + '_' + locale`

### 2.1.3 根据视图名创建视图对象 ###

/** * Create the actual View object. * The default implementation delegates to {@link #loadView}. * This can be overridden to resolve certain view names in a special fashion, * before delegating to the actual {@code loadView} implementation * provided by the subclass. * @param viewName the name of the view to retrieve * @param locale the Locale to retrieve the view for * @return the View instance, or {@code null} if not found * (optional, to allow for ViewResolver chaining) * @throws Exception if the view couldn't be resolved * @see #loadView */
 @Nullable
 protected View createView(String viewName, Locale locale) throws Exception { 
 return loadView(viewName, locale);
 }
 
 
 //这是一个抽象方法，由子类实现，完成具体的创建过程
 @Nullable
 protected abstract View loadView(String viewName, Locale locale) throws Exception;

>  *  子类可以重写创建视图的方法`createView(viewName, locale)`，添加转发视图和重定向视图的支持。
>  *  子类可以重写创建视图的方法`loadView(viewName, locale)`，自定义视图创建逻辑。

## 2.2 `UrlBasedViewResolver` ##

> 这是一个很重要的视图解析器，它添加了对处理器方法返回`redirect:`和`forward:`开头的字符串的支持，也就是说它支持解析重定向视图`RedirectView`和转发视图`InternalResourceView`。

### 2.2.1 `createView(viewName,locale)`方法,添加对转发和重定向支持 ###

该类重写了它父类`AbstractCachingViewResolver`的`createView(viewName,locale)`方法

public static final String REDIRECT_URL_PREFIX = "redirect:";
 public static final String FORWARD_URL_PREFIX = "forward:";
 
 /** * Overridden to implement check for "redirect:" prefix. * Not possible in {@code loadView}, since overridden * {@code loadView} versions in subclasses might rely on the * superclass always creating instances of the required view class. * @see #loadView * @see #requiredViewClass */
 @Override
 protected View createView(String viewName, Locale locale) throws Exception { 
 // If this resolver is not supposed to handle the given view,
 // return null to pass on to the next resolver in the chain.
 //判断该视图解析器是否支持处理该视图名，见2.2.1.1
 if (!canHandle(viewName, locale)) { 
 return null;
 }
 
 // Check for special "redirect:" prefix.
 //视图名以redirect:开头
 if (viewName.startsWith(REDIRECT_URL_PREFIX)) { 
 //去掉前缀得到真实的视图名
 String redirectUrl = viewName.substring(REDIRECT_URL_PREFIX.length());
 /** * 创建一个重定向视图 * isRedirectContextRelative()方法， 判断给定URL是否解释为根路径开始的URL，见2.2.1.2 * isRedirectHttp10Compatible()方法， 判断是否应该与HTTP1.0客户端兼容，见2.2.1.3 */
 RedirectView view = new RedirectView(redirectUrl,
 isRedirectContextRelative(), isRedirectHttp10Compatible());
 //获取重定向的主机地址，见2.2.1.4
 String[] hosts = getRedirectHosts();
 if (hosts != null) { 
 view.setHosts(hosts);
 }
 //视图对象应用spring生命周期初始化阶段方法，见2.2.1.5
 return applyLifecycleMethods(REDIRECT_URL_PREFIX, view);
 }
 
 // Check for special "forward:" prefix.
 //视图名以forward:开头
 if (viewName.startsWith(FORWARD_URL_PREFIX)) { 
 //去掉前缀得到真实的视图名
 String forwardUrl = viewName.substring(FORWARD_URL_PREFIX.length());
 /** * 创建一个jsp视图 * 转发视图，因为jsp就是一个Servlet，就是将请求由DispatcherServlet * 转发给视图名对应的Servlet处理 */
 InternalResourceView view = new InternalResourceView(forwardUrl);
 //视图对象应用spring生命周期初始化阶段方法，见2.2.1.5
 return applyLifecycleMethods(FORWARD_URL_PREFIX, view);
 }
 
 // Else fall back to superclass implementation: calling loadView.
 //非转发和重定向视图则由父类方法进行视图创建
 return super.createView(viewName, locale);
 }

> 该类重写这个方法添加对转发和重定向支持

#### 2.2.1.1 判断该视图解析器是否支持处理该视图名 ####

//该视图解析器支持处理的视图名
    @Nullable
    private String[] viewNames;
    
    /** * Indicates whether or not this {@link org.springframework.web.servlet.ViewResolver} can * handle the supplied view name. If not, {@link #createView(String, java.util.Locale)} will * return {@code null}. The default implementation checks against the configured * {@link #setViewNames view names}. * @param viewName the name of the view to retrieve * @param locale the Locale to retrieve the view for * @return whether this resolver applies to the specified view * @see org.springframework.util.PatternMatchUtils#simpleMatch(String, String) */
    protected boolean canHandle(String viewName, Locale locale) { 
        //获取支持处理的视图名
        String[] viewNames = getViewNames();
        /** * 空表示支持处理所有的视图名 * 否则判断视图名是否匹配，viewNames可以为*xxx*、xxx*yyy，模糊匹配 */
        return (viewNames == null || PatternMatchUtils.simpleMatch(viewNames, viewName));
    }
    
    
    /** * Return the view names (or name patterns) that can be handled by this * {@link org.springframework.web.servlet.ViewResolver}. */
    @Nullable
    protected String[] getViewNames() { 
        return this.viewNames;
    }

>  *  用户可在创建视图解析器的时候指定该视图解析器支持的视图名，只需要设置`viewNames`字段的值即可
>  *  `viewNames`字段为`null`，表示支持处理所有的视图名，否则进行视图名匹配
>  *  `viewNames`字段可以写`*xxx*`、`xxx*yyy`这种，系统会进行模糊匹配

#### 2.2.1.2 给定`URL`是否解释为根路径开始的`URL` ####

private boolean redirectContextRelative = true;
    
    
    /** * Return whether to interpret a given redirect URL that starts with a * slash ("/") as relative to the current ServletContext, i.e. as * relative to the web application root. */
    protected boolean isRedirectContextRelative() { 
        return this.redirectContextRelative;
    }

> 默认为`true`，会将所有`URL`作为从根路径开始的`URL`

#### 2.2.1.3 是否应该与`HTTP1.0`客户端兼容 ####

private boolean redirectHttp10Compatible = true;
    
    
    /** * Return whether redirects should stay compatible with HTTP 1.0 clients. */
    protected boolean isRedirectHttp10Compatible() { 
        return this.redirectHttp10Compatible;
    }

> 默认是兼容的

#### 2.2.1.4 获取重定向的主机地址 ####

@Nullable
    private String[] redirectHosts;
    
    
    /** * Return the configured application hosts for redirect purposes. * @since 4.3 */
    @Nullable
    public String[] getRedirectHosts() { 
        return this.redirectHosts;
    }

> 用户在创建`UrlBasedViewResolver`视图解析器的时候指定所有重定向视图的主机地址

#### 2.2.1.5 视图对象应用`spring`生命周期初始化阶段方法 ####

/** * Apply the containing {@link ApplicationContext}'s lifecycle methods * to the given {@link View} instance, if such a context is available. * @param viewName the name of the view * @param view the freshly created View instance, pre-configured with * {@link AbstractUrlBasedView}'s properties * @return the {@link View} instance to use (either the original one * or a decorated variant) * @since 5.0 * @see #getApplicationContext() * @see ApplicationContext#getAutowireCapableBeanFactory() * @see org.springframework.beans.factory.config.AutowireCapableBeanFactory#initializeBean */
    protected View applyLifecycleMethods(String viewName, AbstractUrlBasedView view) { 
        //获取当前上下文对象
        ApplicationContext context = getApplicationContext();
        if (context != null) { 
            //将视图对象作为一个spring的bean进行初始化
            Object initialized = context.getAutowireCapableBeanFactory().initializeBean(view, viewName);
            if (initialized instanceof View) { 
                return (View) initialized;
            }
        }
        return view;
    }

> `initializeBean(view, viewName)`方法做的事情：
> 
>  *  回调视图对象实现的`Aware`接口
>  *  回调所有`BeanPostProcessor`的`before()`和`after()`方法
>  *  回调`InitializingBean`接口的`afterPropertiesSet()`方法

### 2.2.2 `loadView(String viewName, Locale locale)`方法，创建视图对象 ###

该类还重写了它父类`AbstractCachingViewResolver`的`loadView(viewName,locale)`方法

/** * Delegates to {@code buildView} for creating a new instance of the * specified view class. Applies the following Spring lifecycle methods * (as supported by the generic Spring bean factory): * <ul> * <li>ApplicationContextAware's {@code setApplicationContext} * <li>InitializingBean's {@code afterPropertiesSet} * </ul> * @param viewName the name of the view to retrieve * @return the View instance * @throws Exception if the view couldn't be resolved * @see #buildView(String) * @see org.springframework.context.ApplicationContextAware#setApplicationContext * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet */
 @Override
 protected View loadView(String viewName, Locale locale) throws Exception { 
 //视图对象创建过程委派给buildView()方法
 AbstractUrlBasedView view = buildView(viewName);
 //视图对象应用spring生命周期初始化阶段方法，见2.2.1.5
 View result = applyLifecycleMethods(viewName, view);
 return (view.checkResource(locale) ? result : null);
 }

视图对象创建过程委派给`buildView()`方法

//前缀
 private String prefix = "";
 //后缀
 private String suffix = "";
 
 /** * Creates a new View instance of the specified view class and configures it. * Does not perform any lookup for pre-defined View instances. * 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. * 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 { 
 //获取视图的clazz对象，这个对象需要用户指定，见2.2.2.1
 Class<?> viewClass = getViewClass();
 Assert.state(viewClass != null, "No view class");
 
 //反射实例化，得到对应的视图对象
 AbstractUrlBasedView view = (AbstractUrlBasedView) BeanUtils.instantiateClass(viewClass);
 
 /**************************初始化视图**********************************/
 /** * 设置视图位置 * 通过前缀后缀的拼接，得到真正响应内容的位置 */
 view.setUrl(getPrefix() + viewName + getSuffix());
 //设置静态属性，见2.2.2.2
 view.setAttributesMap(getAttributesMap());
 
 //获取视图的内容类型，见2.2.2.3
 String contentType = getContentType();
 if (contentType != null) { 
 view.setContentType(contentType);
 }
 
 //获取用户定义的请求上下文对象的名字，见2.2.2.4
 String requestContextAttribute = getRequestContextAttribute();
 if (requestContextAttribute != null) { 
 view.setRequestContextAttribute(requestContextAttribute);
 }
 
 //是否将模板变量添加到模型中，见2.2.2.5
 Boolean exposePathVariables = getExposePathVariables();
 if (exposePathVariables != null) { 
 view.setExposePathVariables(exposePathVariables);
 }
 //是否将上下文bean作为属性放入视图中，见2.2.2.6
 Boolean exposeContextBeansAsAttributes = getExposeContextBeansAsAttributes();
 if (exposeContextBeansAsAttributes != null) { 
 view.setExposeContextBeansAsAttributes(exposeContextBeansAsAttributes);
 }
 //获取上下文bean的beanName，见2.2.2.7
 String[] exposedContextBeanNames = getExposedContextBeanNames();
 if (exposedContextBeanNames != null) { 
 view.setExposedContextBeanNames(exposedContextBeanNames);
 }
 
 return view;
 }

> 使用反射实例化一个视图对象，然后初始化视图

#### 2.2.2.1 获取视图的`clazz`对象 ####

@Nullable
 private Class<?> viewClass;
 
 
 /** * Return the view class to be used to create views. */
 @Nullable
 protected Class<?> getViewClass() { 
 return this.viewClass;
 }

> `viewClass`字段就是视图的`clazz`对象，`UrlBasedViewResolver`会通过反射来创建对应的视图对象，用户必须指定该字段值

#### 2.2.2.2 获取静态属性 ####

private final Map<String, Object> staticAttributes = new HashMap<>();
 
 
 /** * Allow Map access to the static attributes for views returned by * this resolver, with the option to add or override specific entries. * Useful for specifying entries directly, for example via * "attributesMap[myKey]". This is particularly useful for * adding or overriding entries in child view definitions. */
 public Map<String, Object> getAttributesMap() { 
 return this.staticAttributes;
 }

> 用户可以在创建`UrlBasedViewResolver`视图解析器的时候指定`staticAttributes`字段值，然后所有通过该视图解析器创建的视图对象都会携带这些值。需要注意的是，视图对象持有的是集合的引用，所有你修改集合的值，其他视图对象的这些值也会跟着变化，就像静态属性一样。

#### 2.2.2.3 获取视图的内容类型 ####

@Nullable
    private String contentType;
    
    
    /** * Return the content type for all views, if any. */
    @Nullable
    protected String getContentType() { 
        return this.contentType;
    }

> 用户可以在创建`UrlBasedViewResolver`视图解析器的时候指定`contentType`字段值，也就是视图响应的内容类型，然后所有通过该视图解析器创建的视图对象都会应用这个内容类型。

#### 2.2.2.4 获取用户定义的请求上下文对象的名字 ####

@Nullable
    private String requestContextAttribute;
    
    
    /** * Return the name of the RequestContext attribute for all views, if any. */
    @Nullable
    protected String getRequestContextAttribute() { 
        return this.requestContextAttribute;
    }

> 用户可以在创建`UrlBasedViewResolver`视图解析器的时候指定`requestContextAttribute`字段值，也就是请求上下文`RequestContext`对象的名字，如果指定了这个字段值，那么通过该视图解析器创建的视图对象都会创建一个`RequestContext`，并以这个字段值作为名字，保存到模型中，见`3.1.2.1`

#### 2.2.2.5 是否将模板变量添加到模型中 ####

@Nullable
    private Boolean exposePathVariables;
    
    
    /** * Return whether views resolved by this resolver should add path variables to the model or not. */
    @Nullable
    protected Boolean getExposePathVariables() { 
        return this.exposePathVariables;
    }

> 用户可以在创建`UrlBasedViewResolver`视图解析器的时候指定`exposePathVariables`字段值，`true`表示将模板变量添加到模型中，`false`不添加

#### 2.2.2.6 是否将上下文`bean`作为属性放入视图中 ####

@Nullable
    private Boolean exposeContextBeansAsAttributes;
    
    
    @Nullable
    protected Boolean getExposeContextBeansAsAttributes() { 
        return this.exposeContextBeansAsAttributes;
    }

#### 2.2.2.7 获取上下文`bean`的`beanName` ####

@Nullable
    private String[] exposedContextBeanNames;
    
    
    @Nullable
    protected String[] getExposedContextBeanNames() { 
        return this.exposedContextBeanNames;
    }

> 用户可以在创建`UrlBasedViewResolver`视图解析器的时候指定`exposedContextBeanNames`字段值，然后视图对象会自动从`spring`容器中加载到`beanName`对应的`bean`对象，加载到对象之后把它作为视图的属性。

### 2.2.3 `InternalResourceViewResolver` ###

> 该类继承了`2.2`章节中`UrlBasedViewResolver`类，表示一个`jsp`视图解析器，它可以生成两种类型的视图
> 
>  *  生成`InternalResourceView` `jsp`视图
>  *  生成`JstlView` 使用了`jstl`表达式的`jsp`视图

#### 2.2.3.1 构造方法 ####

//是否导入了jstl相关包
 private static final boolean jstlPresent = ClassUtils.isPresent(
 "javax.servlet.jsp.jstl.core.Config", InternalResourceViewResolver.class.getClassLoader());
 
 
 /** * Sets the default {@link #setViewClass view class} to {@link #requiredViewClass}: * by default {@link InternalResourceView}, or {@link JstlView} if the JSTL API * is present. */
 public InternalResourceViewResolver() { 
 //创建的视图为InternalResourceView
 Class<?> viewClass = requiredViewClass();
 //若果导入了jstl包，则创建JstlView视图
 if (InternalResourceView.class == viewClass && jstlPresent) { 
 viewClass = JstlView.class;
 }
 setViewClass(viewClass);
 }
 
 
 /** * This resolver requires {@link InternalResourceView}. */
 @Override
 protected Class<?> requiredViewClass() { 
 return InternalResourceView.class;
 }

> 在构造方法中已经初始化了创建视图的类型
> 
>  *  导入了`jstl`包，生成`JstlView`
>  *  否则生成`InternalResourceView`

#### 2.2.3.2 `buildView(viewName)`方法 ####

> 这个类很简单，它重写了`buildView(viewName)`方法，完成具体的视图创建过程

//是否总是包含视图，而不是转发视图
    @Nullable
    private Boolean alwaysInclude;
    
    
    @Override
    protected AbstractUrlBasedView buildView(String viewName) throws Exception { 
        //调用父类的buildView()方法创建jsp视图对象，见2.2.2
        InternalResourceView view = (InternalResourceView) super.buildView(viewName);
        if (this.alwaysInclude != null) { 
            view.setAlwaysInclude(this.alwaysInclude);
        }
        view.setPreventDispatchLoop(true);
        return view;
    }

> 调用父类的`buildView(viewName)`方法完成视图创建，并添加额外的初始化参数

# 3 `jsp`视图 #

> `JstlView`代表一个使用了`jstl`标签的`jsp`视图
> 
> 我们先来看看它的继承关系

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMDEyOTgx_size_16_color_FFFFFF_t_70_pic_center 1]

我们只看`View`的实现类

## 3.1 `AbstractView` ##

根据继承关系，我们先看`AbstractView`类，所有的视图对象都继承了该类

该类实现了`View`接口的两个方法

### 3.1.1 `getContentType()`方法 ###

public static final String DEFAULT_CONTENT_TYPE = "text/html;charset=ISO-8859-1";
    @Nullable
    private String contentType = DEFAULT_CONTENT_TYPE;
    
    
    /** * Return the content type for this view. */
    @Override
    @Nullable
    public String getContentType() { 
        return this.contentType;
    }

> 很容易发现：视图对象默认响应一个`ISO-8859-1`编码格式的`html`页面给浏览器

### 3.1.2 `render(model, request,response)`方法 ###

/** * 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(@Nullable Map<String, ?> model, HttpServletRequest request,
 HttpServletResponse response) throws Exception { 
 
 if (logger.isDebugEnabled()) { 
 logger.debug("View " + formatViewName() +
 ", model " + (model != null ? model : Collections.emptyMap()) +
 (this.staticAttributes.isEmpty() ? "" : ", static attributes " + this.staticAttributes));
 }
 
 //创建一个包含动态值和静态值的组合Map，见3.1.2.1
 Map<String, Object> mergedModel = createMergedOutputModel(model, request, response);
 //响应的准备工作，见3.1.2.2
 prepareResponse(request, response);
 //渲染视图，见3.1.2.3
 renderMergedOutputModel(mergedModel, getRequestToExpose(request), response);
 }

> 模板方法模式，定义了渲染视图的流程
> 
> 1.  合并动态模型数据和静态模型数据
> 2.  准备渲染视图
> 3.  渲染视图

#### 3.1.2.1 创建一个包含动态值和静态值的组合`Map` ####

//是否需要将模板变量保存到模型中，见2.2.2.5
 private boolean exposePathVariables = true;
 //静态属性，这个集合所有视图对象共享，见2.2.2.2
 private final Map<String, Object> staticAttributes = new LinkedHashMap<>();
 //请求上下文对象名，见2.2.2.4
 @Nullable
 private String requestContextAttribute;
 
 /** * Creates a combined output Map (never {@code null}) that includes dynamic values and static attributes. * Dynamic values take precedence over static attributes. */
 protected Map<String, Object> createMergedOutputModel(@Nullable Map<String, ?> model,
 HttpServletRequest request, HttpServletResponse response) { 
 
 @SuppressWarnings("unchecked")
 /** * 取出请求域中保存的模板变量 * 在使用PathVariableMethodArgumentResolver参数解析器解析模板变量参数的时候 * 会将解析成功的模板变量放入请求域中 */
 Map<String, Object> pathVars = (this.exposePathVariables ?
 (Map<String, Object>) request.getAttribute(View.PATH_VARIABLES) : null);
 
 // Consolidate static and dynamic model attributes.
 //统计模型中最终存在的数据数量
 int size = this.staticAttributes.size();
 size += (model != null ? model.size() : 0);
 size += (pathVars != null ? pathVars.size() : 0);
 
 //这个集合用来合并动态值和静态值
 Map<String, Object> mergedModel = new LinkedHashMap<>(size);
 //放入所有的静态属性
 mergedModel.putAll(this.staticAttributes);
 //放入所有的模板变量
 if (pathVars != null) { 
 mergedModel.putAll(pathVars);
 }
 //放入所有的模型数据
 if (model != null) { 
 mergedModel.putAll(model);
 }
 
 // Expose RequestContext?
 /** * 如果用户指定了请求上下文对象的名字，见2.2.2.4 * 那么就会创建一个RequestContext对象，并以这个名字作为key保存在这个组合Map中 */
 if (this.requestContextAttribute != null) { 
 mergedModel.put(this.requestContextAttribute, createRequestContext(request, response, mergedModel));
 }
 
 return mergedModel;
 }

> 该方法会重新构建一个`Map`，并将用户指定的静态属性，模板变量和模型数据都放入这个集合中

/** * Create a RequestContext to expose under the specified attribute name. * The default implementation creates a standard RequestContext instance for the * given request and model. Can be overridden in subclasses for custom instances. * @param request current HTTP request * @param model combined output Map (never {@code null}), * with dynamic values taking precedence over static attributes * @return the RequestContext instance * @see #setRequestContextAttribute * @see org.springframework.web.servlet.support.RequestContext */
 protected RequestContext createRequestContext(
 HttpServletRequest request, HttpServletResponse response, Map<String, Object> model) { 
 
 return new RequestContext(request, response, getServletContext(), model);
 }

> 就是简单的`new`一个`RequestContext`对象

#### 3.1.2.2 渲染视图的准备工作 ####

/** * Prepare the given response for rendering. * The default implementation applies a workaround for an IE bug * when sending download content via HTTPS. * @param request current HTTP request * @param response current HTTP response */
 protected void prepareResponse(HttpServletRequest request, HttpServletResponse response) { 
 //该视图是否生成一个下载内容
 if (generatesDownloadContent()) { 
 //设置下载相关的请求头
 response.setHeader("Pragma", "private");
 response.setHeader("Cache-Control", "private, must-revalidate");
 }
 }
 
 
 
 /** * Return whether this view generates download content * (typically binary content like PDF or Excel files). * The default implementation returns {@code false}. Subclasses are * encouraged to return {@code true} here if they know that they are * generating download content that requires temporary caching on the * client side, typically via the response OutputStream. * @see #prepareResponse * @see javax.servlet.http.HttpServletResponse#getOutputStream() */
 protected boolean generatesDownloadContent() { 
 return false;
 }

>  *  这个方法简单的判断一下视图是否生成一个下载内容，是则设置下载相关的请求头，否则不做任何处理，这里永远不会生成下载内容。
>  *  该方法会被子类重写，不同的视图有不同的准备工作

#### 3.1.2.3 渲染视图 ####

/** * Subclasses must implement this method to actually render the view. * The first step will be preparing the request: In the JSP case, * this would mean setting model objects as request attributes. * The second step will be the actual rendering of the view, * for example including the JSP via a RequestDispatcher. * @param model combined output Map (never {@code null}), * with dynamic values taking precedence over static attributes * @param request current HTTP request * @param response current HTTP response * @throws Exception if rendering failed */
 protected abstract void renderMergedOutputModel(
 Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception;

> 模板方法设计模式
> 
> 这是一个抽象方法，具体的渲染过程由对应的视图实现

## 3.2 `AbstractUrlBasedView` ##

> 在原来的基础上添加`URL`支持，保存转发路径

public abstract class AbstractUrlBasedView extends AbstractView implements InitializingBean { 
 
 /** * 视图实例化完成后，视图解析器就会进行拼接得到转发路径 * prefix+viewName+stuff，拼接完成之后类似于/WEB-INF/jsp/index.jsp * 然后保存到url字段中，见2.2.2 */
 @Nullable
 private String url;
 
 
 /** * Constructor for use as a bean. */
 protected AbstractUrlBasedView() { 
 }
 
 /** * Create a new AbstractUrlBasedView with the given URL. * @param url the URL to forward to */
 protected AbstractUrlBasedView(String url) { 
 this.url = url;
 }
 
 
 /** * Set the URL of the resource that this view wraps. * The URL must be appropriate for the concrete View implementation. */
 public void setUrl(@Nullable String url) { 
 this.url = url;
 }
 
 /** * Return the URL of the resource that this view wraps. */
 @Nullable
 public String getUrl() { 
 return this.url;
 }
 
 /** * 这个初始化方法只是验证url是否必须 */
 @Override
 public void afterPropertiesSet() throws Exception { 
 if (isUrlRequired() && getUrl() == null) { 
 throw new IllegalArgumentException("Property 'url' is required");
 }
 }
 
 /** * Return whether the 'url' property is required. * The default implementation returns {@code true}. * This can be overridden in subclasses. */
 protected boolean isUrlRequired() { 
 return true;
 }
 
 /** * Check whether the underlying resource that the configured URL points to * actually exists. * @param locale the desired Locale that we're looking for * @return {@code true} if the resource exists (or is assumed to exist); * {@code false} if we know that it does not exist * @throws Exception if the resource exists but is invalid (e.g. could not be parsed) */
 public boolean checkResource(Locale locale) throws Exception { 
 return true;
 }
 
 @Override
 public String toString() { 
 return super.toString() + "; URL [" + getUrl() + "]";
 }
 
 }

> 该类的方法都很简单，唯一需要注意的是它实现了`InitializingBean`接口，那么视图对象创建完成之后就会自动回调这个接口的`afterPropertiesSet()`方法，校验`url`字段是否必须指定值

## 3.3 `InternalResourceView` ##

> 该类继承了`AbstractUrlBasedView`，并重写了`renderMergedOutputModel()`方法–渲染视图，见`3.1.2.3`

/** * Render the internal resource given the specified model. * This includes setting the model as request attributes. */
 @Override
 protected void renderMergedOutputModel(
 Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception { 
 
 // Expose the model object as request attributes.
 //将模型中所有数据保存到请求域中，见3.3.1
 exposeModelAsRequestAttributes(model, request);
 
 // Expose helpers as request attributes, if any.
 //暴露请求域属性的帮助者，见3.3.2
 exposeHelpers(request);
 
 // Determine the path for the request dispatcher.
 //渲染前的准备工作，见3.3.3
 String dispatcherPath = prepareForRendering(request, response);
 
 // Obtain a RequestDispatcher for the target resource (typically a JSP).
 //获取请求转发器，见3.3.4
 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!");
 }
 
 // If already included or response already committed, perform include, else forward.
 //请求包含，见3.3.5
 if (useInclude(request, response)) { 
 response.setContentType(getContentType());
 if (logger.isDebugEnabled()) { 
 logger.debug("Including [" + getUrl() + "]");
 }
 rd.include(request, response);
 }
 
 //否则请求转发
 else { 
 // Note: The forwarded resource is supposed to determine the content type itself.
 if (logger.isDebugEnabled()) { 
 logger.debug("Forwarding to [" + getUrl() + "]");
 }
 rd.forward(request, response);
 }
 }

> 总结起来，这个方法主要做了两件事
> 
> 1.  将模型数据保存到请求域中
> 2.  使用`Servlet`原生的方法转发请求，将本次请求交给对应的`Servlet`（实际上就是`jsp`翻译后的`Servlet`）处理

### 3.3.1 将模型中所有数据保存到请求域中 ###

/** * Expose the model objects in the given map as request attributes. * Names will be taken from the model Map. * This method is suitable for all resources reachable by {@link javax.servlet.RequestDispatcher}. * @param model a Map of model objects to expose * @param request current HTTP request */
 protected void exposeModelAsRequestAttributes(Map<String, Object> model,
 HttpServletRequest request) throws Exception { 
 
 model.forEach((name, value) -> { 
 if (value != null) { 
 request.setAttribute(name, value);
 }
 else { 
 request.removeAttribute(name);
 }
 });
 }

> 就是将模型中的数据保存到请求域中

### 3.3.2 暴露请求域属性的帮助者 ###

/** * Expose helpers unique to each rendering operation. This is necessary so that * different rendering operations can't overwrite each other's contexts etc. * Called by {@link #renderMergedOutputModel(Map, HttpServletRequest, HttpServletResponse)}. * The default implementation is empty. This method can be overridden to add * custom helpers as request attributes. * @param request current HTTP request * @throws Exception if there's a fatal error while we're adding attributes * @see #renderMergedOutputModel * @see JstlView#exposeHelpers */
 protected void exposeHelpers(HttpServletRequest request) throws Exception { 
 }

> 空方法，留给子类`JstlView`重写

### 3.3.3 渲染前的准备工作 ###

//是否开启校验循环转发的功能
 private boolean preventDispatchLoop = false;
 
 /** * Prepare for rendering, and determine the request dispatcher path * to forward to (or to include). * This implementation simply returns the configured URL. * Subclasses can override this to determine a resource to render, * typically interpreting the URL in a different manner. * @param request current HTTP request * @param response current HTTP response * @return the request dispatcher path to use * @throws Exception if preparations failed * @see #getUrl() */
 protected String prepareForRendering(HttpServletRequest request, HttpServletResponse response)
 throws Exception { 
 
 /** * 视图实例化完成后，视图解析器就会进行拼接得到转发路径 * prefix+viewName+stuff，拼接完成之后类似于/WEB-INF/jsp/index.jsp * 然后保存到url字段中，此处取出这个字段值 */
 String path = getUrl();
 Assert.state(path != null, "'url' not set");
 
 //校验循环转发
 if (this.preventDispatchLoop) { 
 //原始的uri路径
 String uri = request.getRequestURI();
 //转发路径和当前请求路径相同，产生了循环转发问题，抛出异常
 if (path.startsWith("/") ? uri.equals(path) : uri.equals(StringUtils.applyRelativePath(uri, path))) { 
 throw new ServletException("Circular view path [" + path + "]: would dispatch back " +
 "to the current handler URL [" + uri + "] again. Check your ViewResolver setup! " +
 "(Hint: This may be the result of an unspecified view, due to default view name generation.)");
 }
 }
 return path;
 }

> 校验两个方面
> 
>  *  是否设置了`jsp`视图的真实位置
>  *  校验是否循环转发，该功能默认是关闭的

### 3.3.4 获取请求转发器 ###

/** * Obtain the RequestDispatcher to use for the forward/include. * The default implementation simply calls * {@link HttpServletRequest#getRequestDispatcher(String)}. * Can be overridden in subclasses. * @param request current HTTP request * @param path the target URL (as returned from {@link #prepareForRendering}) * @return a corresponding RequestDispatcher */
 @Nullable
 protected RequestDispatcher getRequestDispatcher(HttpServletRequest request, String path) { 
 return request.getRequestDispatcher(path);
 }

> 使用`Servlet`原生的转发方法，获取路径对应的请求转发器，后面通过这个请求转发器将请求准发给别的`Servlet`处理

### 3.3.5 是否请求包含 ###

//默认为fasle
 private boolean alwaysInclude = false;
 
 /** * Determine whether to use RequestDispatcher's {@code include} or * {@code forward} method. * Performs a check whether an include URI attribute is found in the request, * indicating an include request, and whether the response has already been committed. * In both cases, an include will be performed, as a forward is not possible anymore. * @param request current HTTP request * @param response current HTTP response * @return {@code true} for include, {@code false} for forward * @see javax.servlet.RequestDispatcher#forward * @see javax.servlet.RequestDispatcher#include * @see javax.servlet.ServletResponse#isCommitted * @see org.springframework.web.util.WebUtils#isIncludeRequest */
 protected boolean useInclude(HttpServletRequest request, HttpServletResponse response) { 
 return (this.alwaysInclude || WebUtils.isIncludeRequest(request) || response.isCommitted());
 }

> 请求转发器根据该方法的返回值执行对应的操作
> 
>  *  `true`：请求转发器执行`inclue()`方法，**请求包含**
>  *  `false`：请求转发器执行`forward()`方法，**请求转发**

## 3.4 `JstlView` ##

> 该类继承了`InternalResourceView`，并重写了`exposeHelpers(request)`方法，见`3.3.2`

@Nullable
    private MessageSource messageSource;
    
    
    /** * Exposes a JSTL LocalizationContext for Spring's locale and MessageSource. * @see JstlUtils#exposeLocalizationContext */
    @Override
    protected void exposeHelpers(HttpServletRequest request) throws Exception { 
        if (this.messageSource != null) { 
            JstlUtils.exposeLocalizationContext(request, this.messageSource);
        }
        else { 
            JstlUtils.exposeLocalizationContext(new RequestContext(request, getServletContext()));
        }
    }

> 这些配置略过吧，不用深究

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMDEyOTgx_size_16_color_FFFFFF_t_70_pic_center]: /images/20221023/8431096a5d1a45a9b5ef0542f3e76d9b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMzMDEyOTgx_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221023/f19ce01c1b0b4d13a890ac109b567fa8.png