SpringMVC 4.3 源码分析之 HandlerMethodReturnValueHandler

1. HandlerMethodReturnValueHandler 概述

HandlerMethodReturnValueHandler = HandlerMethod(@RequestMapping的处理器) + returnValue(返回值) + Handler(处理器), 其实就是 HandlerMethod 返沪值的处理器, 将返回值以特定的格式输出到client端, 或将 View 相关的信息设置到 ModelAndViewContainer 里面, 以便于视图的渲染, 其接口如下:

//  HandlerMethod 的返回值处理器
public interface HandlerMethodReturnValueHandler {

    // 判断当前处理器是否支持 返回值
    boolean supportsReturnType(MethodParameter returnType);

    // 处理 HandlerMethod 的返回值
    void handleReturnValue(Object returnValue, MethodParameter returnType, ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception;
}

基于这个接口实现的处理器主要是如下几类:

1. 返回值通常是View类型或 ViewName 或 Map 类型, 通常都是设置到 ModelAndViewContainer 里面
2. 支持返回值是 DeferredResult, ListenableFuture, CompletionStage 类型, 最后转为对应的适配器, 交给WebAsyncManager 进行运行
3. 根据 ContentType 的类型将数据通过 HttpMessageConverter 转换成对应的数据格式, 最后输出到远端

2. 处理 View 或 String 类型的HandlerMethodReturnValueHandler

1. ViewMethodReturnValueHandler
    针对 View 及其子类的返回值处理器, 主要还是将 View 设置到 ModelAndViewContainer
2. ViewNameMethodReturnValueHandler
    支持返回值为 CharSequence 类型, 设置 ModelAndViewContainer.setViewName
3. StreamingResponseBodyReturnValueHandler
    支持 StreamingResponseBody 类型的返回值, 最后将请求包装成 Callable, 通过 Spring 的异步处理器 SimpleAsyncTaskExecutor 执行 StreamingResponseBody 将数据流写到远端
4. ModelMethodProcessor
    针对 Model 及其子类的返回值处理器, 主要还是将 ModelAndView 中的 model 设置到 ModelAndViewContainer
5. ModelAttributeMethodProcessor
    针对被 @ModelAttribute 修饰的返回值, 最后将数据写入到 ModelAndViewContainer 中 
6. ModelAndViewResolverMethodReturnValueHandler
    通过 ModelAndViewResolver 将数据解析成 View, Model, 最后设置到 ModelAndViewContainer 里面
7. ModelAndViewMethodReturnValueHandler
    针对 ModelAndView 及其子类的返回值处理器, 主要还是将 ModelAndView 中的 status, model 设置到 ModelAndViewContainer
8. MapMethodProcessor
    支持返回值为 Map, 并将结果设置到 ModelAndViewContainer
9. HttpHeadersReturnValueHandler
    针对 HttpHeaders 类型的返回值, 最后设置到 Response 的 Header 中, 输出到远端

上面几个 ReturnValueHandler 基本上就是将数据设置到 ModelAndViewContainer 里面

3. 处理异步返回值的 HandlerMethodReturnValueHandler

这一类接口都是 AsyncHandlerMethodReturnValueHandler 的子类, 主要如下:

1. AsyncTaskMethodReturnValueHandler
    支持返回值是 WebAsyncTask 类型, 并通过 WebAsyncManager 中的 SimpleAsyncTaskExecutor 来进行处理
2. CallableMethodReturnValueHandler
    支持返回值是 Callable 类型, 并通过 WebAsyncManager 中的 SimpleAsyncTaskExecutor 来进行处理
3. CompletionStageReturnValueHandler
    支持返回值是 CompletionStage 类型, 并通过 WebAsyncManager 中的 SimpleAsyncTaskExecutor 来进行处理
4. DeferredResultMethodReturnValueHandler
    这个类适配 DeferredResult, ListenableFuture, CompletionStage 类型的返回值, 最后通过 WebAsyncManager 来完成任务的调用
5. ListenableFutureReturnValueHandler
    支持返回值是 ListenableFuture 类型, 并通过 WebAsyncManager 中的 SimpleAsyncTaskExecutor 来进行处理

4. 支持格式转换的 HandlerMethodReturnValueHandler

这些 ReturnValueHandler 都是AbstractMessageConverterMethodProcessor的子类, 对应实现的主逻辑也在 AbstractMessageConverterMethodProcessor 中

1. 获取 request 对应的 MediaType(PS: ContentNegotiationManager 进行获取 Request 所能支持的 MediaType)
2. 返回 HttpMessageConverter 所支持的 MediaType
3. 若 producibleMediaType 是空 且 返回值有数据, 直接抛出异常
4. 找出 producibleMediaType 与 AcceptMediaType 都兼容的 MediaType
5. 循环遍历 HttpMessageConverter, 进行返回值的转换处理 下面进行选择 converter 时, 加入 MediaType 作为考虑
6. 通过 ResponseBodyAdvice 在将数据写入输出流之前进行一些增强操作
7. 对 Http 请求中的 header 进行一些配置信息进行处理
8. HttpMessageConverter 进行处理, 将数据写入 outputStream, 并且写到远端

主流程的代码如下:

protected <T> void writeWithMessageConverters(T value, MethodParameter returnType, ServletServerHttpRequest inputMessage, ServletServerHttpResponse outputMessage) throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {
    Object outputValue;                         // 返回值内容
    Class<?> valueType;                         // 返回值类型
    Type declaredType;
    if (value instanceof CharSequence) {        // 若 value 是 Char
        outputValue = value.toString();         // 设置 outputValue
        valueType = String.class;               // 设置 返回值的类型
        declaredType = String.class;
    } else {
        outputValue = value;                    // 设置返回值
        valueType = getReturnValueType(outputValue, returnType); // 获取 返回值的类型
        declaredType = getGenericType(returnType); // 返回值类型
    }
    HttpServletRequest request = inputMessage.getServletRequest();
    // 获取 request 对应的 MediaType(PS: ContentNegotiationManager 进行获取 Request 所能支持的 MediaType)
    List<MediaType> requestedMediaTypes = getAcceptableMediaTypes(request);
    // 返回 HttpMessageConverter 所支持的 MediaType
    List<MediaType> producibleMediaTypes = getProducibleMediaTypes(request, valueType, declaredType);
    // 若 producibleMediaType 是空 且 返回值有数据, 直接抛出异常
    if (outputValue != null && producibleMediaTypes.isEmpty()) throw new IllegalArgumentException("No converter found for return value of type: " + valueType);

    Set<MediaType> compatibleMediaTypes = new LinkedHashSet<MediaType>();
    // 找出两端都兼容的 MediaType
    for (MediaType requestedType : requestedMediaTypes) {
        // getMostSpecificMediaType 找出 两个 MediaType 中更加适合 producible
        for (MediaType producibleType : producibleMediaTypes) if (requestedType.isCompatibleWith(producibleType)) compatibleMediaTypes.add(getMostSpecificMediaType(requestedType, producibleType));
    }
    if (compatibleMediaTypes.isEmpty()) {
        // 未出现两者都兼容的 MediaType, 则直接抛出异常
        if (outputValue != null) throw new HttpMediaTypeNotAcceptableException(producibleMediaTypes);
        return;
    }

    List<MediaType> mediaTypes = new ArrayList<MediaType>(compatibleMediaTypes);
    // 将所有的 MediaType 进行排序
    MediaType.sortBySpecificityAndQuality(mediaTypes);
    MediaType selectedMediaType = null;
    // 筛选出其中一个 mediaType
    for (MediaType mediaType : mediaTypes) {
        if (mediaType.isConcrete()) {
            selectedMediaType = mediaType;
            break;
        } else if (mediaType.equals(MediaType.ALL) || mediaType.equals(MEDIA_TYPE_APPLICATION)) {
            selectedMediaType = MediaType.APPLICATION_OCTET_STREAM; // 设置 application/octet-stream
            break;
        }
    }
    if (selectedMediaType != null) {
        selectedMediaType = selectedMediaType.removeQualityValue();
        // 循环遍历 HttpMessageConverter, 进行返回值的转换处理 下面进行选择 converter 时, 加入 MediaType 作为考虑
        for (HttpMessageConverter<?> messageConverter : this.messageConverters) {
            // 下面分类 HttpMessageConverter 进行分开处理 <-- 先是支持 Type 的 HttpMessageConverter
            if (messageConverter instanceof GenericHttpMessageConverter) {
                if (((GenericHttpMessageConverter) messageConverter).canWrite(declaredType, valueType, selectedMediaType)) {
                    // 通过 ResponseBodyAdvice 在将数据写入输出流之前进行一些增强操作
                    outputValue = (T) getAdvice().beforeBodyWrite(outputValue, returnType, selectedMediaType, (Class<? extends HttpMessageConverter<?>>) messageConverter.getClass(), inputMessage, outputMessage);
                    if (outputValue != null) {
                        // 对 Http 请求中的 header 进行一些处理
                        addContentDispositionHeader(inputMessage, outputMessage);
                        // HttpMessageConverter 进行处理, 将数据写入 outputStream, 并且写到远端
                        ((GenericHttpMessageConverter) messageConverter).write(outputValue, declaredType, selectedMediaType, outputMessage);
                        logger.info("Written [" + outputValue + "] as \"" + selectedMediaType + "\" using [" + messageConverter + "]");
                    }
                    return;
                }
            }
            // 普通 HttpMessageConverter 处理
            else if (messageConverter.canWrite(valueType, selectedMediaType)) {
                // 通过 ResponseBodyAdvice 在将数据写入输出流之前进行一些增强操作
                outputValue = (T) getAdvice().beforeBodyWrite(outputValue, returnType, selectedMediaType, (Class<? extends HttpMessageConverter<?>>) messageConverter.getClass(), inputMessage, outputMessage);
                if (outputValue != null) {
                    // 对 Http 请求中的 header 进行一些处理
                    addContentDispositionHeader(inputMessage, outputMessage);
                    // HttpMessageConverter 进行处理, 将数据写入 outputStream, 并且写到远端
                    ((HttpMessageConverter) messageConverter).write(outputValue, selectedMediaType, outputMessage);
                    logger.info("Written [" + outputValue + "] as \"" + selectedMediaType + "\" using [" + messageConverter + "]");
                }
                return;
            }
        }
    }
    if (outputValue != null) throw new HttpMediaTypeNotAcceptableException(this.allSupportedMediaTypes);
}

而子类 HttpEntityMethodProcessor, RequestResponseBodyMethodProcessor, 先准备数据, 然后使用父类的writeWithMessageConverters 方法, 将数据写入数据流中, 最后在刷到远端!

5. HandlerMethodReturnValueHandler 总结

总体上 HandlerMethodReturnValueHandler 的设计体系和HandlerMethodArgumentResolver 差不多, 设计上夹杂着策略, 模版, 适配器等等, 而我们常用的 @ResponseBody 就是通过RequestResponseBodyMethodProcessor 来解决的(PS: 根据 Http中的 acceptMedia 与 HttpMessageConverter 来进行数据的转换操作)！