被@ResponseBoby注释的方法在拦截器的posthandle方法中设置cookie失效的问题

文章标题可能有点绕口。先来解释下遇到的问题。

我写了一个拦截器，希望能够实现保存特定方法的请求参数到cookie中。

public class SaveParamInterceptor extends HandlerInterceptorAdapter{
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
          throws Exception {
//         if(((HandlerMethod)handler).hasMethodAnnotation(SaveParam.class)){
//                saveParam(request, response);
//            }
        return super.preHandle(request, response, handler);
    }

     @Override
     public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
          ModelAndView modelAndView) throws Exception {
         if(((HandlerMethod)handler).hasMethodAnnotation(SaveParam.class)){
                saveParam(request, response);
            }
        super.postHandle(request, response, handler, modelAndView);
    }
     
     private void saveParam(HttpServletRequest request, HttpServletResponse response){
            Enumeration<String> enumeration = request.getParameterNames();
            while(enumeration.hasMoreElements()){
                String name = enumeration.nextElement();
                //过滤dataTables参数
                if(name.startsWith("columns") || name.startsWith("search") || name.startsWith("order")){
                    continue;
                }
                String value = request.getParameter(name);
                Cookie cookie = new Cookie(name, value);
                cookie.setMaxAge(3600);  
                cookie.setPath("/"); 
                response.addCookie(cookie);
                System.out.println("name:" + name + " value:" + value);
            }
        }
}

一开始我将saveParam方法放在postHandle中。发现虽然请求能被正常拦截，但是页面上取不到保存过的cookie。

然后我又试了下将saveParam移到preHandle中，结果就正常了。

而且这种情况只有在被@ResponseBody注释的方法上才会发生。

由于给response添加cookie的本质应该就是在reponse的header里写入一些信息。所以应该是某个流程后，再往response里写信息就无效了（之前看servlet的API里也有类似的情况，当response被提交过后，再对其进行一些操作会抛出异常）。

于是我猜想，这跟SpringMVC处理请求的流程有关。想起前些天Spring绑定请求参数的流程中，handler被invoke之后，有一个设置response的status的动作。

先随便找一个控制器试试：

@RequestMapping("test")
     @ResponseBody
     @SaveParam
     public JSONObject test(HttpServletResponse res) {
         res.addCookie(new Cookie("befroe", "1"));
         res.setStatus(200);
         res.addCookie(new Cookie("after", "1"));
      9          JSONObject object =  new JSONObject;
         return object;
     }

从浏览器中查看结果：

发现两个cookie都是正常的。看来真想并没有这么简单。

于是只好从Spring的流程在查一遍：

直接从ServletInvocableHandlerMethod的invokeAndHandle找起。

    public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
            Object... providedArgs) throws Exception {

        Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
        setResponseStatus(webRequest);

        if (returnValue == null) {
            if (isRequestNotModified(webRequest) || hasResponseStatus() || mavContainer.isRequestHandled()) {
                mavContainer.setRequestHandled(true);
                return;
            }
        }
        else if (StringUtils.hasText(this.responseReason)) {
            mavContainer.setRequestHandled(true);
            return;
        }

        mavContainer.setRequestHandled(false);
        try {
            this.returnValueHandlers.handleReturnValue(
                    returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
        }
        catch (Exception ex) {
            if (logger.isTraceEnabled()) {
                logger.trace(getReturnValueHandlingErrorMessage("Error handling return value", returnValue), ex);
            }
            throw ex;
        }
    }

进到handleReturnValue这个方法里：

public void handleReturnValue(Object returnValue, MethodParameter returnType,
            ModelAndViewContainer mavContainer, NativeWebRequest webRequest) throws Exception {

        HandlerMethodReturnValueHandler handler = selectHandler(returnValue, returnType);
        if (handler == null) {
            throw new IllegalArgumentException("Unknown return value type: " + returnType.getParameterType().getName());
        }
        handler.handleReturnValue(returnValue, returnType, mavContainer, webRequest);
    }

这是选择对应的处理器来处理返回值，继续往下：

因为是被@ResponseBoby注释的方法，所以我们进到了RequestResponseBodyMethodProcessor的实现里：

@Override
    public void handleReturnValue(Object returnValue, MethodParameter returnType,
            ModelAndViewContainer mavContainer, NativeWebRequest webRequest)
            throws IOException, HttpMediaTypeNotAcceptableException, HttpMessageNotWritableException {

        mavContainer.setRequestHandled(true);
        ServletServerHttpRequest inputMessage = createInputMessage(webRequest);
        ServletServerHttpResponse outputMessage = createOutputMessage(webRequest);

        // Try even with null return value. ResponseBodyAdvice could get involved.
        writeWithMessageConverters(returnValue, returnType, inputMessage, outputMessage);
    }

前两步几部是设置了状态，并将原生的request和response封装一下在返回。我们看writeWithMessageConverters里做了啥，

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) {
            outputValue = value.toString();
            valueType = String.class;
            declaredType = String.class;
        }
        else {
            outputValue = value;
            valueType = getReturnValueType(outputValue, returnType);
            declaredType = getGenericType(returnType);
        }

        HttpServletRequest request = inputMessage.getServletRequest();
        List<MediaType> requestedMediaTypes = getAcceptableMediaTypes(request);
        List<MediaType> producibleMediaTypes = getProducibleMediaTypes(request, valueType, declaredType);

        if (outputValue != null && producibleMediaTypes.isEmpty()) {
            throw new IllegalArgumentException("No converter found for return value of type: " + valueType);
        }

        Set<MediaType> compatibleMediaTypes = new LinkedHashSet<MediaType>();
        for (MediaType requestedType : requestedMediaTypes) {
            for (MediaType producibleType : producibleMediaTypes) {
                if (requestedType.isCompatibleWith(producibleType)) {
                    compatibleMediaTypes.add(getMostSpecificMediaType(requestedType, producibleType));
                }
            }
        }
        if (compatibleMediaTypes.isEmpty()) {
            if (outputValue != null) {
                throw new HttpMediaTypeNotAcceptableException(producibleMediaTypes);
            }
            return;
        }

        List<MediaType> mediaTypes = new ArrayList<MediaType>(compatibleMediaTypes);
        MediaType.sortBySpecificityAndQuality(mediaTypes);

        MediaType selectedMediaType = null;
        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;
                break;
            }
        }

        if (selectedMediaType != null) {
            selectedMediaType = selectedMediaType.removeQualityValue();
            for (HttpMessageConverter<?> messageConverter : this.messageConverters) {
                if (messageConverter instanceof GenericHttpMessageConverter) {
                    if (((GenericHttpMessageConverter) messageConverter).canWrite(
                            declaredType, valueType, selectedMediaType)) {
                        outputValue = (T) getAdvice().beforeBodyWrite(outputValue, returnType, selectedMediaType,
                                (Class<? extends HttpMessageConverter<?>>) messageConverter.getClass(),
                                inputMessage, outputMessage);
                        if (outputValue != null) {
                            addContentDispositionHeader(inputMessage, outputMessage);
                            ((GenericHttpMessageConverter) messageConverter).write(
                                    outputValue, declaredType, selectedMediaType, outputMessage);
                            if (logger.isDebugEnabled()) {
                                logger.debug("Written [" + outputValue + "] as "" + selectedMediaType +
                                        "" using [" + messageConverter + "]");
                            }
                        }
                        return;
                    }
                }
                else if (messageConverter.canWrite(valueType, selectedMediaType)) {
                    outputValue = (T) getAdvice().beforeBodyWrite(outputValue, returnType, selectedMediaType,
                            (Class<? extends HttpMessageConverter<?>>) messageConverter.getClass(),
                            inputMessage, outputMessage);
                    if (outputValue != null) {
                        addContentDispositionHeader(inputMessage, outputMessage);
                        ((HttpMessageConverter) messageConverter).write(outputValue, selectedMediaType, outputMessage);
                        if (logger.isDebugEnabled()) {
                            logger.debug("Written [" + outputValue + "] as "" + selectedMediaType +
                                    "" using [" + messageConverter + "]");
                        }
                    }
                    return;
                }
            }
        }

        if (outputValue != null) {
            throw new HttpMediaTypeNotAcceptableException(this.allSupportedMediaTypes);
        }
    }

虽然写了一大段，但是我们看到对outputMessage进行操作的只有在下面这个for循环里，我们就重点关注下这里操作了什么：

for (HttpMessageConverter<?> messageConverter : this.messageConverters) {
                if (messageConverter instanceof GenericHttpMessageConverter) {
                    if (((GenericHttpMessageConverter) messageConverter).canWrite(
                            declaredType, valueType, selectedMediaType)) {
                        outputValue = (T) getAdvice().beforeBodyWrite(outputValue, returnType, selectedMediaType,
                                (Class<? extends HttpMessageConverter<?>>) messageConverter.getClass(),
                                inputMessage, outputMessage);
                        if (outputValue != null) {
                            addContentDispositionHeader(inputMessage, outputMessage);
                            ((GenericHttpMessageConverter) messageConverter).write(
                                    outputValue, declaredType, selectedMediaType, outputMessage);
                            if (logger.isDebugEnabled()) {
                                logger.debug("Written [" + outputValue + "] as "" + selectedMediaType +
                                        "" using [" + messageConverter + "]");
                            }
                        }
                        return;
                    }
                }

重点应该是在write这个方法里，这里是Converter对内容进行转化。

由于我们用的conver是FastJsonHttpMessageConverter。

来看看具体实现：

public void write(Object t, //
                      Type type, //
                      MediaType contentType, //
                      HttpOutputMessage outputMessage //
    ) throws IOException, HttpMessageNotWritableException {

        HttpHeaders headers = outputMessage.getHeaders();
        if (headers.getContentType() == null) {
            if (contentType == null || contentType.isWildcardType() || contentType.isWildcardSubtype()) {
                contentType = getDefaultContentType(t);
            }
            if (contentType != null) {
                headers.setContentType(contentType);
            }
        }
        if (headers.getContentLength() == -1) {
            Long contentLength = getContentLength(t, headers.getContentType());
            if (contentLength != null) {
                headers.setContentLength(contentLength);
            }
        }
        writeInternal(t, outputMessage);
        outputMessage.getBody().flush();
    }

看看是不是flush动作导致了response状态改为已经被提交，所以导致设置cookie失效呢，再来试一试：

@RequestMapping("queryAuditList")
     @ResponseBody
     @SaveParam
     public JSONObject queryAuditList( HttpServletResponse res) {
         res.addCookie(new Cookie("befroe", "1"));
         try {
            res.getOutputStream().flush();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
         res.addCookie(new Cookie("after", "1"));
         return new JSONObject();
     }

看看结果：

果然是这样！

再看下servlet文档里的说法：

isCommitted

public boolean isCommitted()

Returns a boolean indicating if the response has been committed. A committed response has already had its status code and headers written.

 划重点：A committed response has already had its status and headers written.

所以flush操作是会导致response的commited状态被修改的，也就是说这时response的头信息已经被确定了！