被@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"));
                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的头信息已经被确定了！