<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
 <property name="prefix" value="/WEB-INF/view/"/>
 <property name="suffix" value=".jsp"/>
</bean>

public interface ViewResolver {
 // 通過邏輯視圖名和用戶地區(qū)信息生成View對象
 View resolveViewName(String viewName, Locale locale) throws Exception;
}

public interface View {
 // 獲取返回值的contentType
 default String getContentType() {
 return null;
 }

 // 通過用戶提供的模型數(shù)據(jù)與視圖信息渲染視圖
 void render(@Nullable Map<String, ?> model, HttpServletRequest request, 
  HttpServletResponse response) throws Exception;
}

@Override
@Nullable
public View resolveViewName(String viewName, Locale locale) throws Exception {
 // 判斷當前ViewResolver是否設(shè)置了需要對需要解析的視圖進行緩存，如果不需要緩存，
 // 則每次請求時都會重新解析生成視圖對象
 if (!isCache()) {
  // 根據(jù)視圖名稱和用戶地區(qū)信息創(chuàng)建View對象
  return createView(viewName, locale);
 } else {
  // 如果可以對視圖進行緩存，則首先獲取緩存使用的key，然后從緩存中獲取該key，如果沒有取到，
  // 則對其進行加鎖，再次獲取，如果還是沒有取到，則創(chuàng)建一個新的View，并且對其進行緩存。
  // 這里使用的是雙檢查法來判斷緩存中是否存在對應(yīng)的邏輯視圖。
  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是
     // 一個沒有任何內(nèi)容的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);
 }
}

@Override
protected View loadView(String viewName, Locale locale) throws Exception {
 // 使用邏輯視圖名按照指定規(guī)則生成View對象
 AbstractUrlBasedView view = buildView(viewName);
 // 應(yīng)用聲明周期函數(shù)，也就是調(diào)用View對象的初始化函數(shù)和Spring用于切入bean創(chuàng)建的
 // Processor和Aware函數(shù)
 View result = applyLifecycleMethods(viewName, view);
 // 檢查view的準確性，這里默認始終返回true
 return (view.checkResource(locale) ? result : null);
}

// 這里buildView()方法主要是根據(jù)邏輯視圖名生成一個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());

 // 設(shè)置View的contentType屬性
 String contentType = getContentType();
 if (contentType != null) {
  view.setContentType(contentType);
 }

 // 設(shè)置contextAttribute和attributeMap等屬性
 view.setRequestContextAttribute(getRequestContextAttribute());
 view.setAttributesMap(getAttributesMap());

 // 這了pathVariables表示request請求url中的屬性，這里主要是設(shè)置是否將這些屬性暴露到視圖中
 Boolean exposePathVariables = getExposePathVariables();
 if (exposePathVariables != null) {
  view.setExposePathVariables(exposePathVariables);
 }
 
 // 這里設(shè)置的是是否將Spring的bean暴露在視圖中，以供給前端調(diào)用
 Boolean exposeContextBeansAsAttributes = getExposeContextBeansAsAttributes();
 if (exposeContextBeansAsAttributes != null) {
  view.setExposeContextBeansAsAttributes(exposeContextBeansAsAttributes);
 }
 
 // 設(shè)置需要暴露給前端頁面的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對象應(yīng)用初始化方法，主要包括InitializingBean.afterProperties()和一些
  // Processor，Aware方法
  Object initialized = context.getAutowireCapableBeanFactory()
   .initializeBean(view, viewName);
  if (initialized instanceof View) {
   return (View) initialized;
  }
 }
 return view;
}

@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對象的類型是否為文件下載類型，如果是文件下載類型，則設(shè)置response的
 // Pragma和Cache-Control等屬性值
 prepareResponse(request, response);
 // 通過合并的model數(shù)據(jù)以及視圖地址進行視圖的渲染
 renderMergedOutputModel(mergedModel, getRequestToExpose(request), response);
}

@Override
protected void renderMergedOutputModel(Map<String, Object> model, 
  HttpServletRequest request, HttpServletResponse response) throws Exception {
 // 這里主要是對model進行遍歷，將其key和value設(shè)置到request中，當做request的
 // 一個屬性供給頁面調(diào)用
 exposeModelAsRequestAttributes(model, request);
 // 提供的一個hook方法，默認是空實現(xiàn)，用于用戶進行request屬性的自定義使用
 exposeHelpers(request);

 // 檢查當前是否存在循環(huán)類型的視圖名稱解析，主要是根據(jù)相對路徑進行判斷視圖名是無法解析的
 String dispatcherPath = prepareForRendering(request, response);
 
 // 獲取當前request的RequestDispatcher對象，該對象有兩個方法：include()和forward()，
 // 用于對當前的request進行轉(zhuǎn)發(fā)，其實也就是將當前的request轉(zhuǎn)發(fā)到另一個url，這里的另一個
 // url就是要解析的視圖地址，也就是說進行視圖解析的時候請求的對于文件的解析實際上相當于
 // 構(gòu)造了另一個（文件）請求，在該請求中對文件內(nèi)容進行渲染，從而得到最終的文件。這里的
 // include()方法表示將目標文件引入到當前文件中，與jsp中的include標簽作用相同；
 // forward()請求則表示將當前請求轉(zhuǎn)發(fā)到另一個請求中，也就是目標文件路徑，這種轉(zhuǎn)發(fā)并不會
 // 改變用戶瀏覽器地址欄的請求地址。
 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請求，如果是，則調(diào)用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請求將當前請求轉(zhuǎn)發(fā)到目標文件路徑中，
  // 從而渲染該視圖
  rd.forward(request, response);
 }
}