Spring 源码解析

文章15 |   阅读 8473 |   点赞0

来源：https://github.com/senntyou/blogs

Spring 源码解析七：异常处理与视图解析

x33g5p2x  于2022-02-11 发布在 Spring  
字(21.2k)|赞(0)|评价(0)|浏览(543)

接着上一篇，讲一下剩下的几个策略

另外，View.render 视图渲染也在这里讲一下

1. ExceptionHandlerExceptionResolver

ExceptionHandlerExceptionResolver
的主要功能是解析处理器调用产生的异常

继承关系如下

  1. - AbstractHandlerExceptionResolver
  2.   - AbstractHandlerMethodExceptionResolver
  3.     - ExceptionHandlerExceptionResolver

1.1. AbstractHandlerExceptionResolver

AbstractHandlerExceptionResolver
的主要功能是可以设置异常处理器

  1. public abstract class AbstractHandlerExceptionResolver implements HandlerExceptionResolver, Ordered {
  2.     // 设置自定义处理器
  3.     public void setMappedHandlers(Set<?> mappedHandlers) {
  4.         this.mappedHandlers = mappedHandlers;
  5.     }
  6.     // 设置自定义处理器类
  7.     public void setMappedHandlerClasses(Class<?>... mappedHandlerClasses) {
  8.         this.mappedHandlerClasses = mappedHandlerClasses;
  9.     }
  11.     // 解析异常
  12.     public ModelAndView resolveException(
  13.             HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {
  14.         // 检查是否可应用处理器
  15.         if (shouldApplyTo(request, handler)) {
  16.             // 解析异常，调用处理器处理
  17.             ModelAndView result = doResolveException(request, response, handler, ex);
  19.             // ... 代码省略
  21.             return result;
  22.         }
  23.         else {
  24.             return null;
  25.         }
  26.     }
  27. }
  1. public abstract class AbstractHandlerExceptionResolver implements HandlerExceptionResolver, Ordered {
  2.     // 检查是否可应用处理器
  3.     protected boolean shouldApplyTo(HttpServletRequest request, @Nullable Object handler) {
  4.         if (handler != null) {
  5.             // 如果包含在mappedHandlers中，可以处理
  6.             if (this.mappedHandlers != null && this.mappedHandlers.contains(handler)) {
  7.                 return true;
  8.             }
  9.             // 如果包含在mappedHandlerClasses中，可以处理
  10.             if (this.mappedHandlerClasses != null) {
  11.                 for (Class<?> handlerClass : this.mappedHandlerClasses) {
  12.                     if (handlerClass.isInstance(handler)) {
  13.                         return true;
  14.                     }
  15.                 }
  16.             }
  17.         }
  18.         // 如果没有mappedHandlers与mappedHandlerClasses，默认可以使用
  19.         return !hasHandlerMappings();
  20.     }
  22.     // 解析异常，调用处理器处理，子类实现
  23.     protected abstract ModelAndView doResolveException(
  24.             HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex);
  25. }

1.2. AbstractHandlerMethodExceptionResolver

AbstractHandlerMethodExceptionResolver
的主要功能是可以通过异常类型来处理

  1. public abstract class AbstractHandlerMethodExceptionResolver extends AbstractHandlerExceptionResolver {
  2.     // 检查是否可应用处理器
  3.     @Override
  4.     protected boolean shouldApplyTo(HttpServletRequest request, @Nullable Object handler) {
  5.         if (handler == null) {
  6.             return super.shouldApplyTo(request, null);
  7.         }
  8.         // 如果是，获取HandlerMethod内部的handler，继续判断
  9.         else if (handler instanceof HandlerMethod) {
  10.             HandlerMethod handlerMethod = (HandlerMethod) handler;
  11.             handler = handlerMethod.getBean();
  12.             return super.shouldApplyTo(request, handler);
  13.         }
  14.         // 如果有全局的异常处理器或自定义异常处理器，继续判断
  15.         else if (hasGlobalExceptionHandlers() && hasHandlerMappings()) {
  16.             return super.shouldApplyTo(request, handler);
  17.         }
  18.         // 否则就不能处理了
  19.         else {
  20.             return false;
  21.         }
  22.     }
  24.     // 解析异常，调用处理器处理
  25.     @Override
  26.     protected final ModelAndView doResolveException(
  27.             HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {
  28.         // 只能是HandlerMethod才能用于处理异常
  29.         HandlerMethod handlerMethod = (handler instanceof HandlerMethod ? (HandlerMethod) handler : null);
  30.         // 实际处理
  31.         return doResolveHandlerMethodException(request, response, handlerMethod, ex);
  32.     }
  34.     // 实际处理，由子类实现
  35.     protected abstract ModelAndView doResolveHandlerMethodException(
  36.             HttpServletRequest request, HttpServletResponse response, @Nullable HandlerMethod handlerMethod, Exception ex);
  38. }

1.3. ExceptionHandlerExceptionResolver

ExceptionHandlerExceptionResolver
的主要功能是可以通过注解@ExceptionHandler来处理异常

1.3.1. ExceptionHandlerExceptionResolver.afterPropertiesSet

  1. public class ExceptionHandlerExceptionResolver extends AbstractHandlerMethodExceptionResolver
  2.         implements ApplicationContextAware, InitializingBean {
  3.     // 当属性都注入后，由上下文环境调用此方法初始化
  4.     @Override
  5.     public void afterPropertiesSet() {
  6.         // 初始化`@ControllerAdvice`注解标注的组件
  7.         initExceptionHandlerAdviceCache();
  9.         if (this.argumentResolvers == null) {
  10.             // 获取默认的参数解析器
  11.             List<HandlerMethodArgumentResolver> resolvers = getDefaultArgumentResolvers();
  12.             this.argumentResolvers = new HandlerMethodArgumentResolverComposite().addResolvers(resolvers);
  13.         }
  14.         if (this.returnValueHandlers == null) {
  15.             // 获取默认的响应值处理器
  16.             List<HandlerMethodReturnValueHandler> handlers = getDefaultReturnValueHandlers();
  17.             this.returnValueHandlers = new HandlerMethodReturnValueHandlerComposite().addHandlers(handlers);
  18.         }
  19.     }
  21.     // 初始化`@ControllerAdvice`注解标注的组件
  22.     private void initExceptionHandlerAdviceCache() {
  23.         // ... 代码省略
  25.         // 获取有`@ControllerAdvice`注解的bean
  26.         List<ControllerAdviceBean> adviceBeans = ControllerAdviceBean.findAnnotatedBeans(getApplicationContext());
  27.         // 进行遍历
  28.         for (ControllerAdviceBean adviceBean : adviceBeans) {
  29.             Class<?> beanType = adviceBean.getBeanType();
  30.             if (beanType == null) {
  31.                 // 没有类型，报错
  32.             }
  33.             // @ExceptionHandler注解解析器
  34.             ExceptionHandlerMethodResolver resolver = new ExceptionHandlerMethodResolver(beanType);
  35.             // 有异常处理方法
  36.             if (resolver.hasExceptionMappings()) {
  37.                 // 加入全局异常处理器缓存容器
  38.                 this.exceptionHandlerAdviceCache.put(adviceBean, resolver);
  39.             }
  40.             // 是ResponseBodyAdvice的子类
  41.             if (ResponseBodyAdvice.class.isAssignableFrom(beanType)) {
  42.                 // 加入容器
  43.                 this.responseBodyAdvice.add(adviceBean);
  44.             }
  45.         }
  47.         // ... 代码省略
  48.     }
  49. }
  1. public class ExceptionHandlerExceptionResolver extends AbstractHandlerMethodExceptionResolver
  2.         implements ApplicationContextAware, InitializingBean {
  3.     // 获取默认的参数解析器
  4.     protected List<HandlerMethodArgumentResolver> getDefaultArgumentResolvers() {
  5.         List<HandlerMethodArgumentResolver> resolvers = new ArrayList<>();
  7.         // @SessionAttribute 解析
  8.         resolvers.add(new SessionAttributeMethodArgumentResolver());
  9.         // @RequestAttribute 解析
  10.         resolvers.add(new RequestAttributeMethodArgumentResolver());
  12.         // 从原生 ServletRequest 对象的输入流中解析请求头、请求体等
  13.         resolvers.add(new ServletRequestMethodArgumentResolver());
  14.         // 把处理器最终的数据写入到原生 ServletResponse 对象的输出流中，包括响应头、响应体等
  15.         resolvers.add(new ServletResponseMethodArgumentResolver());
  16.         // 重定向处理
  17.         resolvers.add(new RedirectAttributesMethodArgumentResolver());
  18.         // Model 处理
  19.         resolvers.add(new ModelMethodProcessor());
  21.         // ... 代码省略
  22.     }
  24.     // 获取默认的响应值处理器
  25.     protected List<HandlerMethodReturnValueHandler> getDefaultReturnValueHandlers() {
  26.         List<HandlerMethodReturnValueHandler> handlers = new ArrayList<>();
  28.         // ModelAndView 处理
  29.         handlers.add(new ModelAndViewMethodReturnValueHandler());
  30.         // Model 处理
  31.         handlers.add(new ModelMethodProcessor());
  32.         // View 处理
  33.         handlers.add(new ViewMethodReturnValueHandler());
  34.         // HttpEntity 处理
  35.         handlers.add(new HttpEntityMethodProcessor(
  36.                 getMessageConverters(), this.contentNegotiationManager, this.responseBodyAdvice));
  38.         // 数据绑定解析
  39.         handlers.add(new ServletModelAttributeMethodProcessor(false));
  40.         // @RequestBody @ResponseBody 解析
  41.         handlers.add(new RequestResponseBodyMethodProcessor(
  42.                 getMessageConverters(), this.contentNegotiationManager, this.responseBodyAdvice));
  44.         // 视图名字处理
  45.         handlers.add(new ViewNameMethodReturnValueHandler());
  46.         // Map 处理
  47.         handlers.add(new MapMethodProcessor());
  49.         // ... 代码省略
  51.         return handlers;
  52.     }
  53. }

1.3.2. ExceptionHandlerExceptionResolver.doResolveHandlerMethodException

  1. public class ExceptionHandlerExceptionResolver extends AbstractHandlerMethodExceptionResolver
  2.         implements ApplicationContextAware, InitializingBean {
  3.     // 实际处理异常
  4.     @Override
  5.     protected ModelAndView doResolveHandlerMethodException(HttpServletRequest request,
  6.             HttpServletResponse response, @Nullable HandlerMethod handlerMethod, Exception exception) {
  7.         // 获取异常处理的方法对象
  8.         ServletInvocableHandlerMethod exceptionHandlerMethod = getExceptionHandlerMethod(handlerMethod, exception);
  9.         // 如果没有，返回null
  10.         if (exceptionHandlerMethod == null) {
  11.             return null;
  12.         }
  14.         if (this.argumentResolvers != null) {
  15.             // 注入参数解析器argumentResolvers
  16.             exceptionHandlerMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
  17.         }
  18.         if (this.returnValueHandlers != null) {
  19.             // 注入响应处理returnValueHandlers
  20.             exceptionHandlerMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
  21.         }
  23.         ServletWebRequest webRequest = new ServletWebRequest(request, response);
  24.         // 响应容器
  25.         ModelAndViewContainer mavContainer = new ModelAndViewContainer();
  27.         ArrayList<Throwable> exceptions = new ArrayList<>();
  28.         try {
  29.             // 遍历内部的异常
  30.             Throwable exToExpose = exception;
  31.             while (exToExpose != null) {
  32.                 exceptions.add(exToExpose);
  33.                 Throwable cause = exToExpose.getCause();
  34.                 exToExpose = (cause != exToExpose ? cause : null);
  35.             }
  36.             Object[] arguments = new Object[exceptions.size() + 1];
  37.             exceptions.toArray(arguments);
  38.             arguments[arguments.length - 1] = handlerMethod;
  40.             // 调用处理器，获取处理结果，应用响应处理returnValueHandlers
  41.             exceptionHandlerMethod.invokeAndHandle(webRequest, mavContainer, arguments);
  42.         }
  43.         catch (Throwable invocationEx) {
  44.             // ... 代码省略
  45.         }
  47.         // 如果是已经处理过了，返回空ModelAndView
  48.         if (mavContainer.isRequestHandled()) {
  49.             return new ModelAndView();
  50.         }
  51.         else {
  52.             // 获取模型对象
  53.             ModelMap model = mavContainer.getModel();
  54.             // 生成ModelAndView
  55.             ModelAndView mav = new ModelAndView(mavContainer.getViewName(), model, mavContainer.getStatus());
  57.             // ... 代码省略
  59.             // 处理重定向
  60.             if (model instanceof RedirectAttributes) {
  61.                 // ... 代码省略
  62.             }
  63.             return mav;
  64.         }
  65.     }
  67.     // 获取异常处理的方法对象
  68.     protected ServletInvocableHandlerMethod getExceptionHandlerMethod(
  69.             @Nullable HandlerMethod handlerMethod, Exception exception) {
  71.         Class<?> handlerType = null;
  73.         if (handlerMethod != null) {
  74.             // 获取bean类型
  75.             handlerType = handlerMethod.getBeanType();
  76.             // 获取缓存的处理器
  77.             ExceptionHandlerMethodResolver resolver = this.exceptionHandlerCache.get(handlerType);
  78.             // 如果没有，就生成，并缓存
  79.             if (resolver == null) {
  80.                 resolver = new ExceptionHandlerMethodResolver(handlerType);
  81.                 this.exceptionHandlerCache.put(handlerType, resolver);
  82.             }
  83.             // 解析处理exception的方法
  84.             Method method = resolver.resolveMethod(exception);
  85.             // 有了就返回一个封装对象
  86.             if (method != null) {
  87.                 return new ServletInvocableHandlerMethod(handlerMethod.getBean(), method);
  88.             }
  90.             // ... 代码省略
  91.         }
  93.         // 没有自定义的，就使用全局的异常处理器
  94.         for (Map.Entry<ControllerAdviceBean, ExceptionHandlerMethodResolver> entry : this.exceptionHandlerAdviceCache.entrySet()) {
  95.             ControllerAdviceBean advice = entry.getKey();
  96.             if (advice.isApplicableToBeanType(handlerType)) {
  97.                 ExceptionHandlerMethodResolver resolver = entry.getValue();
  98.                 // 解析处理exception的方法
  99.                 Method method = resolver.resolveMethod(exception);
  100.                 // 有了就返回一个封装对象
  101.                 if (method != null) {
  102.                     return new ServletInvocableHandlerMethod(advice.resolveBean(), method);
  103.                 }
  104.             }
  105.         }
  107.         return null;
  108.     }
  109. }

2. ResponseStatusExceptionResolver

ResponseStatusExceptionResolver
的主要功能是支持@ResponseStatus注解映射状态码

  1. public class ResponseStatusExceptionResolver extends AbstractHandlerExceptionResolver implements MessageSourceAware {
  2.     // 解析异常，调用处理器处理
  3.     @Override
  4.     protected ModelAndView doResolveException(
  5.             HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {
  7.         try {
  8.             // 如果ResponseStatusException，把ResponseStatusException内部的responseHeaders设置到响应中
  9.             // 并设置响应码和响应原因
  10.             if (ex instanceof ResponseStatusException) {
  11.                 return resolveResponseStatusException((ResponseStatusException) ex, request, response, handler);
  12.             }
  14.             // 不然，查看异常类的`@ResponseStatus`注解，如果有，设置响应码和响应原因
  15.             ResponseStatus status = AnnotatedElementUtils.findMergedAnnotation(ex.getClass(), ResponseStatus.class);
  16.             if (status != null) {
  17.                 return resolveResponseStatus(status, request, response, handler, ex);
  18.             }
  20.             // 如果有内部异常，循环遍历处理
  21.             if (ex.getCause() instanceof Exception) {
  22.                 return doResolveException(request, response, handler, (Exception) ex.getCause());
  23.             }
  24.         }
  25.         catch (Exception resolveEx) {
  26.             // ... 代码省略
  27.         }
  28.         return null;
  29.     }
  30. }

3. DefaultHandlerExceptionResolver

DefaultHandlerExceptionResolver
的主要功能是把标准 SpringMVC 异常映射状态码

  1. public class DefaultHandlerExceptionResolver extends AbstractHandlerExceptionResolver {
  2.     // 解析异常，调用处理器处理
  3.     @Override
  4.     protected ModelAndView doResolveException(
  5.             HttpServletRequest request, HttpServletResponse response, @Nullable Object handler, Exception ex) {
  6.         try {
  7.             // 405
  8.             if (ex instanceof HttpRequestMethodNotSupportedException) {
  9.                 return handleHttpRequestMethodNotSupported(
  10.                         (HttpRequestMethodNotSupportedException) ex, request, response, handler);
  11.             }
  12.             // 415
  13.             else if (ex instanceof HttpMediaTypeNotSupportedException) {
  14.                 return handleHttpMediaTypeNotSupported(
  15.                         (HttpMediaTypeNotSupportedException) ex, request, response, handler);
  16.             }
  17.             // 406
  18.             else if (ex instanceof HttpMediaTypeNotAcceptableException) {
  19.                 return handleHttpMediaTypeNotAcceptable(
  20.                         (HttpMediaTypeNotAcceptableException) ex, request, response, handler);
  21.             }
  22.             // 500
  23.             else if (ex instanceof MissingPathVariableException) {
  24.                 return handleMissingPathVariable(
  25.                         (MissingPathVariableException) ex, request, response, handler);
  26.             }
  27.             // 400
  28.             else if (ex instanceof MissingServletRequestParameterException) {
  29.                 return handleMissingServletRequestParameter(
  30.                         (MissingServletRequestParameterException) ex, request, response, handler);
  31.             }
  32.             // 400
  33.             else if (ex instanceof ServletRequestBindingException) {
  34.                 return handleServletRequestBindingException(
  35.                         (ServletRequestBindingException) ex, request, response, handler);
  36.             }
  37.             // 500
  38.             else if (ex instanceof ConversionNotSupportedException) {
  39.                 return handleConversionNotSupported(
  40.                         (ConversionNotSupportedException) ex, request, response, handler);
  41.             }
  42.             // 400
  43.             else if (ex instanceof TypeMismatchException) {
  44.                 return handleTypeMismatch(
  45.                         (TypeMismatchException) ex, request, response, handler);
  46.             }
  47.             // 400
  48.             else if (ex instanceof HttpMessageNotReadableException) {
  49.                 return handleHttpMessageNotReadable(
  50.                         (HttpMessageNotReadableException) ex, request, response, handler);
  51.             }
  52.             // 500
  53.             else if (ex instanceof HttpMessageNotWritableException) {
  54.                 return handleHttpMessageNotWritable(
  55.                         (HttpMessageNotWritableException) ex, request, response, handler);
  56.             }
  57.             // 400
  58.             else if (ex instanceof MethodArgumentNotValidException) {
  59.                 return handleMethodArgumentNotValidException(
  60.                         (MethodArgumentNotValidException) ex, request, response, handler);
  61.             }
  62.             // 400
  63.             else if (ex instanceof MissingServletRequestPartException) {
  64.                 return handleMissingServletRequestPartException(
  65.                         (MissingServletRequestPartException) ex, request, response, handler);
  66.             }
  67.             // 400
  68.             else if (ex instanceof BindException) {
  69.                 return handleBindException((BindException) ex, request, response, handler);
  70.             }
  71.             // 404
  72.             else if (ex instanceof NoHandlerFoundException) {
  73.                 return handleNoHandlerFoundException(
  74.                         (NoHandlerFoundException) ex, request, response, handler);
  75.             }
  76.             // 503
  77.             else if (ex instanceof AsyncRequestTimeoutException) {
  78.                 return handleAsyncRequestTimeoutException(
  79.                         (AsyncRequestTimeoutException) ex, request, response, handler);
  80.             }
  81.         }
  82.         catch (Exception handlerEx) {
  83.             // ... 代码省略
  84.         }
  85.         return null;
  86.     }
  87. }

4. DefaultRequestToViewNameTranslator

DefaultRequestToViewNameTranslator
的主要功能是把 URI 映射视图名字

  1. public class DefaultRequestToViewNameTranslator implements RequestToViewNameTranslator {
  2.     // 根据请求获取视图名字
  3.     @Override
  4.     public String getViewName(HttpServletRequest request) {
  5.         // 获取URI的path部分
  6.         String path = ServletRequestPathUtils.getCachedPathValue(request);
  7.         // 加上前缀与后缀
  8.         return (this.prefix + transformPath(path) + this.suffix);
  9.     }
  11.     // 转换path
  12.     protected String transformPath(String lookupPath) {
  13.         String path = lookupPath;
  14.         // 去掉开头的/
  15.         if (this.stripLeadingSlash && path.startsWith(SLASH)) {
  16.             path = path.substring(1);
  17.         }
  18.         // 去掉结尾的/
  19.         if (this.stripTrailingSlash && path.endsWith(SLASH)) {
  20.             path = path.substring(0, path.length() - 1);
  21.         }
  22.         // 去掉扩展名
  23.         if (this.stripExtension) {
  24.             path = StringUtils.stripFilenameExtension(path);
  25.         }
  26.         // 确保分隔符为/
  27.         if (!SLASH.equals(this.separator)) {
  28.             path = StringUtils.replace(path, SLASH, this.separator);
  29.         }
  30.         return path;
  31.     }
  32. }

5. InternalResourceViewResolver

InternalResourceViewResolver
的主要功能是把视图名字解析成视图对象

继承关系如下

  1. - AbstractCachingViewResolver
  2.   - UrlBasedViewResolver
  3.     - InternalResourceViewResolver

5.1. AbstractCachingViewResolver

AbstractCachingViewResolver
的主要功能是把视图名字解析成视图对象

  1. public abstract class AbstractCachingViewResolver extends WebApplicationObjectSupport implements ViewResolver {
  2.     // 把视图名字解析成视图对象
  3.     @Override
  4.     public View resolveViewName(String viewName, Locale locale) throws Exception {
  5.         // 如果不使用缓存，则每次都加载一次视图文件
  6.         if (!isCache()) {
  7.             return createView(viewName, locale);
  8.         }
  9.         else {
  10.             // 获取缓存键
  11.             Object cacheKey = getCacheKey(viewName, locale);
  12.             // 获取缓存
  13.             View view = this.viewAccessCache.get(cacheKey);
  14.             if (view == null) {
  15.                 synchronized (this.viewCreationCache) {
  16.                     view = this.viewCreationCache.get(cacheKey);
  17.                     if (view == null) {
  18.                         // 缓存中不存在，加载创建视图对象，并加入缓存
  19.                         view = createView(viewName, locale);
  21.                         // ... 代码省略
  23.                         if (view != null) {
  24.                             this.viewAccessCache.put(cacheKey, view);
  25.                             this.viewCreationCache.put(cacheKey, view);
  26.                         }
  27.                     }
  28.                 }
  29.             }
  30.             return (view != UNRESOLVED_VIEW ? view : null);
  31.         }
  32.     }
  34.     protected View createView(String viewName, Locale locale) throws Exception {
  35.         return loadView(viewName, locale);
  36.     }
  38.     // 加载视图，子类实现
  39.     protected abstract View loadView(String viewName, Locale locale) throws Exception;
  40. }

5.2. UrlBasedViewResolver

UrlBasedViewResolver
的主要功能是支持把直接视图名字映射为 url

  1. public class UrlBasedViewResolver extends AbstractCachingViewResolver implements Ordered {
  2.     @Override
  3.     protected View createView(String viewName, Locale locale) throws Exception {
  4.         // ... 代码省略
  6.         // 以"redirect:"开头的重定向，可以跳到其他视图
  7.         if (viewName.startsWith(REDIRECT_URL_PREFIX)) {
  8.             String redirectUrl = viewName.substring(REDIRECT_URL_PREFIX.length());
  9.             RedirectView view = new RedirectView(redirectUrl,
  10.                     isRedirectContextRelative(), isRedirectHttp10Compatible());
  12.             // ... 代码省略
  14.             return view;
  15.         }
  17.         // 以"forward:"开头的重定向，可以转发到其他视图
  18.         if (viewName.startsWith(FORWARD_URL_PREFIX)) {
  19.             String forwardUrl = viewName.substring(FORWARD_URL_PREFIX.length());
  20.             InternalResourceView view = new InternalResourceView(forwardUrl);
  21.             return view;
  22.         }
  24.         // 其他保持父类行为
  25.         return super.createView(viewName, locale);
  26.     }
  27. }
  1. public class UrlBasedViewResolver extends AbstractCachingViewResolver implements Ordered {
  2.     // 加载视图
  3.     @Override
  4.     protected View loadView(String viewName, Locale locale) throws Exception {
  5.         // 构建视图
  6.         AbstractUrlBasedView view = buildView(viewName);
  8.         // ... 代码省略
  10.         return view;
  11.     }
  13.     // 构建视图
  14.     protected AbstractUrlBasedView buildView(String viewName) throws Exception {
  15.         // 初始化视图类
  16.         AbstractUrlBasedView view = instantiateView();
  17.         // 设置路径
  18.         view.setUrl(getPrefix() + viewName + getSuffix());
  19.         // 设置解析数据
  20.         view.setAttributesMap(getAttributesMap());
  22.         // ... 代码省略
  24.         return view;
  25.     }
  26. }

5.3. InternalResourceViewResolver

InternalResourceViewResolver
的主要功能是支持 InternalResourceView 和 JstlView

  1. public class InternalResourceViewResolver extends UrlBasedViewResolver {
  2.     @Override
  3.     protected AbstractUrlBasedView instantiateView() {
  4.         return (getViewClass() == InternalResourceView.class ? new InternalResourceView() :
  5.                 (getViewClass() == JstlView.class ? new JstlView() : super.instantiateView()));
  6.     }
  7. }

6. 视图渲染

6.1. View

View
是所有扩展视图组件的基础接口，主要就是 render 方法

  1. public interface View {
  2.     void render(@Nullable Map<String, ?> model, HttpServletRequest request, HttpServletResponse response)
  3.             throws Exception;
  4. }

6.2. AbstractView

AbstractView
的主要功能是支持 Spring 对视图组件以 bean 形式来管理

  1. public abstract class AbstractView extends WebApplicationObjectSupport implements View, BeanNameAware {
  2.     // 渲染视图
  3.     @Override
  4.     public void render(@Nullable Map<String, ?> model, HttpServletRequest request,
  5.             HttpServletResponse response) throws Exception {
  6.         // 合并其他数据到模型中
  7.         Map<String, Object> mergedModel = createMergedOutputModel(model, request, response);
  8.         // 渲染合并的模型数据
  9.         renderMergedOutputModel(mergedModel, getRequestToExpose(request), response);
  10.     }
  12.     // 合并其他数据到模型中
  13.     protected Map<String, Object> createMergedOutputModel(@Nullable Map<String, ?> model,
  14.             HttpServletRequest request, HttpServletResponse response) {
  15.         // 路径变量
  16.         Map<String, Object> pathVars = (this.exposePathVariables ?
  17.                 (Map<String, Object>) request.getAttribute(View.PATH_VARIABLES) : null);
  19.         // 注入的静态属性
  20.         int size = this.staticAttributes.size();
  21.         size += (model != null ? model.size() : 0);
  22.         size += (pathVars != null ? pathVars.size() : 0);
  24.         // 合并路径变量与静态属性到模型中
  25.         Map<String, Object> mergedModel = CollectionUtils.newLinkedHashMap(size);
  26.         mergedModel.putAll(this.staticAttributes);
  27.         if (pathVars != null) {
  28.             mergedModel.putAll(pathVars);
  29.         }
  30.         if (model != null) {
  31.             mergedModel.putAll(model);
  32.         }
  34.         // ... 代码省略
  36.         return mergedModel;
  37.     }
  39.     // 渲染合并的模型数据，子类实现
  40.     protected abstract void renderMergedOutputModel(
  41.             Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception;
  42. }

6.3. AbstractUrlBasedView

AbstractUrlBasedView
的主要功能是要求有一个 url 数据，其他没有什么功能

6.4. AbstractTemplateView

AbstractTemplateView
的主要功能是实现模板渲染，纯接口数据(不需要模板渲染的)，直接继承 AbstractView 就可以了

  1. public abstract class AbstractTemplateView extends AbstractUrlBasedView {
  2.     // 渲染合并的模型数据
  3.     @Override
  4.     protected final void renderMergedOutputModel(
  5.             Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
  7.         // ... 代码省略，载入请求属性、session属性、spring宏属性到模型数据中
  9.         // 渲染合并的模型数据到模板
  10.         renderMergedTemplateModel(model, request, response);
  11.     }
  13.     // 渲染合并的模型数据到模板，子类实现
  14.     protected abstract void renderMergedTemplateModel(
  15.             Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception;
  16. }

6.5. FreeMarkerView

FreeMarkerView
的主要功能是用 FreeMarker 渲染视图

  1. public class FreeMarkerView extends AbstractTemplateView {
  2.     // 渲染合并的模型数据到模板
  3.     @Override
  4.     protected void renderMergedTemplateModel(
  5.             Map<String, Object> model, HttpServletRequest request, HttpServletResponse response) throws Exception {
  6.         doRender(model, request, response);
  7.     }
  9.     protected void doRender(Map<String, Object> model, HttpServletRequest request,
  10.             HttpServletResponse response) throws Exception {
  12.         // ... 代码省略
  14.         // 构建FreeMarker模板对象
  15.         SimpleHash fmModel = buildTemplateModel(model, request, response);
  17.         // ... 代码省略
  19.         // 获取模板文件，渲染模板到response
  20.         processTemplate(getTemplate(locale), fmModel, response);
  21.     }
  23.     // 渲染模板到response
  24.     protected void processTemplate(Template template, SimpleHash model, HttpServletResponse response)
  25.             throws IOException, TemplateException {
  26.         // 输入模板渲染结果到response writer
  27.         template.process(model, response.getWriter());
  28.     }
  29. }

6.6. MappingJackson2JsonView

MappingJackson2JsonView
的主要功能是用 jackson 来序列化输出接口数据，直接继承 AbstractView

  1. public class MappingJackson2JsonView extends AbstractView {
  2.     // 渲染合并的模型数据
  3.     @Override
  4.     protected void renderMergedOutputModel(Map<String, Object> model, HttpServletRequest request,
  5.             HttpServletResponse response) throws Exception {
  6.         // 字节数组输出流
  7.         ByteArrayOutputStream temporaryStream = null;
  8.         // 输出流
  9.         OutputStream stream;
  11.         // 需要更新'Content-Length'头
  12.         if (this.updateContentLength) {
  13.             // 创建一个新的临时输出流
  14.             temporaryStream = createTemporaryOutputStream();
  15.             stream = temporaryStream;
  16.         }
  17.         else {
  18.             // 不然使用response的输出流
  19.             stream = response.getOutputStream();
  20.         }
  22.         // 把一些不需要的对象过滤掉，包装成可序列化的对象
  23.         Object value = filterAndWrapModel(model, request);
  24.         // 把结果写入输出流中
  25.         writeContent(stream, value);
  27.         if (temporaryStream != null) {
  28.             // 如果有新的临时输出流，把这个新的流写入到response对象中
  29.             writeToResponse(response, temporaryStream);
  30.         }
  31.     }
  33.     // 把结果写入输出流中
  34.     protected void writeContent(OutputStream stream, Object object) throws IOException {
  35.         // 生成一个JsonGenerator
  36.         try (JsonGenerator generator = this.objectMapper.getFactory().createGenerator(stream, this.encoding)) {
  37.             // ... 代码省略
  39.             Object value = object;
  40.             Class<?> serializationView = null;
  41.             FilterProvider filters = null;
  43.             // 获取序列化视图和过滤器
  44.             if (value instanceof MappingJacksonValue) {
  45.                 MappingJacksonValue container = (MappingJacksonValue) value;
  46.                 value = container.getValue();
  47.                 serializationView = container.getSerializationView();
  48.                 filters = container.getFilters();
  49.             }
  51.             // 给writer加入序列化视图
  52.             ObjectWriter objectWriter = (serializationView != null ?
  53.                     this.objectMapper.writerWithView(serializationView) : this.objectMapper.writer());
  54.             // 给writer加入过滤器，如字段过滤
  55.             if (filters != null) {
  56.                 objectWriter = objectWriter.with(filters);
  57.             }
  58.             objectWriter.writeValue(generator, value);
  60.             // ... 代码省略
  62.             // 刷新数据
  63.             generator.flush();
  64.         }
  65.     }
  66. }

后续

更多博客，查看 https://github.com/senntyou/blogs

作者：深予之 (@senntyou)

版权声明：自由转载-非商用-非衍生-保持署名（创意共享 3.0 许可证）

内容来源于网络，如有侵权，请联系作者删除！

相关文章

    查看更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com