@Override
 public JSONEntity read(Class<? extends JSONEntity> clazz, HttpInputMessage inputMessage)
     throws IOException, HttpMessageNotReadableException {
   // First read the string
   String jsonString =
       JSONEntityHttpMessageConverter.readToString(
           inputMessage.getBody(), inputMessage.getHeaders().getContentType().getCharSet());
   try {
     return EntityFactory.createEntityFromJSONString(jsonString, clazz);
   } catch (JSONObjectAdapterException e) {
     // Try to convert entity type to a concrete type and try again. See PLFM-2079.
     try {
       JSONObject jsonObject = new JSONObject(jsonString);
       if (jsonObject.has(ENTITY_TYPE)) {
         // get the entity type so we can replace it with concrete type
         String type = jsonObject.getString(ENTITY_TYPE);
         jsonObject.remove(ENTITY_TYPE);
         jsonObject.put(CONCRETE_TYPE, type);
         jsonString = jsonObject.toString();
         // try again
         return EntityFactory.createEntityFromJSONString(jsonString, clazz);
       } else {
         // Something else went wrong
         throw new HttpMessageNotReadableException(e.getMessage(), e);
       }
     } catch (JSONException e1) {
       throw new HttpMessageNotReadableException(e1.getMessage(), e);
     } catch (JSONObjectAdapterException e2) {
       throw new HttpMessageNotReadableException(e2.getMessage(), e);
     }
   }
 }
  /** Resolves the given {@link RequestBody @RequestBody} annotation. */
  @SuppressWarnings("unchecked")
  protected Object resolveRequestBody(
      MethodParameter methodParam, NativeWebRequest webRequest, Object handler) throws Exception {

    HttpInputMessage inputMessage = createHttpInputMessage(webRequest);
    Class paramType = methodParam.getParameterType();
    MediaType contentType = inputMessage.getHeaders().getContentType();
    if (contentType == null) {
      StringBuilder builder =
          new StringBuilder(ClassUtils.getShortName(methodParam.getParameterType()));
      String paramName = methodParam.getParameterName();
      if (paramName != null) {
        builder.append(' ');
        builder.append(paramName);
      }
      throw new HttpMediaTypeNotSupportedException(
          "Cannot extract @RequestBody parameter ("
              + builder.toString()
              + "): no Content-Type found");
    }
    List<MediaType> allSupportedMediaTypes = new ArrayList<MediaType>();
    if (this.messageConverters != null) {
      for (HttpMessageConverter<?> messageConverter : this.messageConverters) {
        allSupportedMediaTypes.addAll(messageConverter.getSupportedMediaTypes());
        if (messageConverter.canRead(paramType, contentType)) {
          return messageConverter.read(paramType, inputMessage);
        }
      }
    }
    throw new HttpMediaTypeNotSupportedException(contentType, allSupportedMediaTypes);
  }
 @SuppressWarnings({"unchecked", "rawtypes"})
 private ModelAndView handleResponseError(
     ModelAndView exception, HttpServletRequest request, HttpServletResponse response)
     throws ServletException, IOException {
   HttpInputMessage inputMessage = new ServletServerHttpRequest(request);
   List<MediaType> acceptedMediaTypes = inputMessage.getHeaders().getAccept();
   if (acceptedMediaTypes.isEmpty()) {
     acceptedMediaTypes = Collections.singletonList(MediaType.ALL);
   }
   MediaType.sortByQualityValue(acceptedMediaTypes);
   HttpOutputMessage outputMessage = new ServletServerHttpResponse(response);
   Class<?> returnValueType = exception.getClass();
   List<HttpMessageConverter<?>> messageConverters = super.getMessageConverters();
   if (messageConverters != null) {
     for (MediaType acceptedMediaType : acceptedMediaTypes) {
       for (HttpMessageConverter messageConverter : messageConverters) {
         if (messageConverter.canWrite(returnValueType, acceptedMediaType)) {
           messageConverter.write(exception, acceptedMediaType, outputMessage);
           return new ModelAndView();
         }
       }
     }
   }
   if (logger.isWarnEnabled()) {
     logger.warn(
         "Could not find HttpMessageConverter that supports return type ["
             + returnValueType
             + "] and "
             + acceptedMediaTypes);
   }
   return null;
 }
 @Override
 protected String readInternal(Class<? extends String> clazz, HttpInputMessage inputMessage)
     throws IOException, HttpMessageNotReadableException {
   MediaType contentType = inputMessage.getHeaders().getContentType();
   Charset charset = contentType.getCharSet() != null ? contentType.getCharSet() : DEFAULT_CHARSET;
   return FileCopyUtils.copyToString(new InputStreamReader(inputMessage.getBody(), charset));
 }
  @Override
  public BufferedImage read(Class<? extends BufferedImage> clazz, HttpInputMessage inputMessage)
      throws IOException, HttpMessageNotReadableException {

    ImageInputStream imageInputStream = null;
    ImageReader imageReader = null;
    try {
      imageInputStream = createImageInputStream(inputMessage.getBody());
      MediaType contentType = inputMessage.getHeaders().getContentType();
      Iterator<ImageReader> imageReaders =
          ImageIO.getImageReadersByMIMEType(contentType.toString());
      if (imageReaders.hasNext()) {
        imageReader = imageReaders.next();
        ImageReadParam irp = imageReader.getDefaultReadParam();
        process(irp);
        imageReader.setInput(imageInputStream, true);
        return imageReader.read(0, irp);
      } else {
        throw new HttpMessageNotReadableException(
            "Could not find javax.imageio.ImageReader for Content-Type [" + contentType + "]");
      }
    } finally {
      if (imageReader != null) {
        imageReader.dispose();
      }
      if (imageInputStream != null) {
        try {
          imageInputStream.close();
        } catch (IOException ex) {
          // ignore
        }
      }
    }
  }
  private HttpEntity<?> resolveHttpEntityRequest(
      MethodParameter methodParam, NativeWebRequest webRequest) throws Exception {

    HttpInputMessage inputMessage = createHttpInputMessage(webRequest);
    Class<?> paramType = getHttpEntityType(methodParam);
    Object body = readWithMessageConverters(methodParam, inputMessage, paramType);
    return new HttpEntity<Object>(body, inputMessage.getHeaders());
  }
示例#7
0
  public Object resolveArgument(
      MethodParameter parameter,
      ModelAndViewContainer mavContainer,
      NativeWebRequest webRequest,
      WebDataBinderFactory binderFactory)
      throws IOException, HttpMediaTypeNotSupportedException {

    HttpInputMessage inputMessage = createInputMessage(webRequest);
    Class<?> paramType = getHttpEntityType(parameter);

    Object body = readWithMessageConverters(webRequest, parameter, paramType);
    return new HttpEntity<Object>(body, inputMessage.getHeaders());
  }
 @Override
 public Object read(Type type, Class<?> contextClass, HttpInputMessage inputMessage)
     throws IOException, HttpMessageNotReadableException {
   try {
     TumblrResponse tumblrResponse =
         objectMapper.readValue(inputMessage.getBody(), TumblrResponse.class);
     checkResponse(tumblrResponse);
     Object result;
     if (TumblrResponse.class.equals(type)) {
       // don't parse the response json, callee is going to process is manually
       result = tumblrResponse;
     } else {
       // parse the response json into an instance of the given class
       JavaType javaType = getJavaType(type, contextClass);
       String response = tumblrResponse.getResponseJson();
       result = objectMapper.readValue(response, javaType);
     }
     return result;
   } catch (JsonParseException ex) {
     throw new HttpMessageNotReadableException("Could not read JSON: " + ex.getMessage(), ex);
   } catch (EOFException ex) {
     throw new HttpMessageNotReadableException("Could not read JSON: " + ex.getMessage(), ex);
   } catch (Exception e) {
     e.printStackTrace();
     throw new IOException(e);
   }
 }
 private Object readJavaType(JavaType javaType, HttpInputMessage inputMessage) {
   try {
     if (inputMessage instanceof MappingJacksonInputMessage) {
       Class<?> deserializationView =
           ((MappingJacksonInputMessage) inputMessage).getDeserializationView();
       if (deserializationView != null) {
         return this.objectMapper
             .readerWithView(deserializationView)
             .forType(javaType)
             .readValue(inputMessage.getBody());
       }
     }
     return this.objectMapper.readValue(inputMessage.getBody(), javaType);
   } catch (IOException ex) {
     throw new HttpMessageNotReadableException("Could not read document: " + ex.getMessage(), ex);
   }
 }
 @Override
 protected OAuth2AccessToken readInternal(
     Class<? extends OAuth2AccessToken> clazz, HttpInputMessage response)
     throws IOException, HttpMessageNotReadableException {
   MediaType contentType = response.getHeaders().getContentType();
   if (contentType != null && JSON_MEDIA_TYPE.includes(contentType)) {
     try {
       return getSerializationService().deserializeJsonAccessToken(response.getBody());
     } catch (SerializationException e) {
       throw new OAuth2Exception(
           "Error getting the access token, and unable to read the details of the error in the JSON response.",
           e);
     }
   } else {
     // the spec currently says json is required, but facebook, for example, still returns
     // form-encoded.
     MultiValueMap<String, String> map = FORM_MESSAGE_CONVERTER.read(null, response);
     return getSerializationService().deserializeAccessToken(map.toSingleValueMap());
   }
 }
  /**
   * Creates the method argument value of the expected parameter type by reading from the given
   * HttpInputMessage.
   *
   * @param <T> the expected type of the argument value to be created
   * @param inputMessage the HTTP input message representing the current request
   * @param methodParam the method argument
   * @param paramType the type of the argument value to be created
   * @return the created method argument value
   * @throws IOException if the reading from the request fails
   * @throws HttpMediaTypeNotSupportedException if no suitable message converter is found
   */
  @SuppressWarnings("unchecked")
  protected <T> Object readWithMessageConverters(
      HttpInputMessage inputMessage, MethodParameter methodParam, Type paramType)
      throws IOException, HttpMediaTypeNotSupportedException {

    MediaType contentType = inputMessage.getHeaders().getContentType();
    if (contentType == null) {
      contentType = MediaType.APPLICATION_OCTET_STREAM;
    }

    Class<T> paramClass = (paramType instanceof Class) ? (Class) paramType : null;

    for (HttpMessageConverter<?> messageConverter : this.messageConverters) {
      if (messageConverter instanceof GenericHttpMessageConverter) {
        GenericHttpMessageConverter genericMessageConverter =
            (GenericHttpMessageConverter) messageConverter;
        if (genericMessageConverter.canRead(paramType, contentType)) {
          if (logger.isDebugEnabled()) {
            logger.debug(
                "Reading ["
                    + paramType
                    + "] as \""
                    + contentType
                    + "\" using ["
                    + messageConverter
                    + "]");
          }
          return (T) genericMessageConverter.read(paramType, inputMessage);
        }
      }
      if (paramClass != null) {
        if (messageConverter.canRead(paramClass, contentType)) {
          if (logger.isDebugEnabled()) {
            logger.debug(
                "Reading ["
                    + paramClass.getName()
                    + "] as \""
                    + contentType
                    + "\" using ["
                    + messageConverter
                    + "]");
          }
          return ((HttpMessageConverter<T>) messageConverter).read(paramClass, inputMessage);
        }
      }
    }

    throw new HttpMediaTypeNotSupportedException(contentType, allSupportedMediaTypes);
  }
  private Object success(Class<?> clazz, HttpInputMessage inputMessage)
      throws JsonParseException, IOException {

    // Note, parsing code used from ektorp project
    JsonParser jp = objectMapper.getJsonFactory().createJsonParser(inputMessage.getBody());
    if (jp.nextToken() != JsonToken.START_OBJECT) {
      throw new RuntimeException("Expected data to start with an Object");
    }
    Map<String, Integer> fields = readHeaderFields(jp);

    List result;
    if (fields.containsKey(TOTAL_ROWS_FIELD_NAME)) {
      int totalRows = fields.get(TOTAL_ROWS_FIELD_NAME);
      if (totalRows == 0) {
        return Collections.emptyList();
      }
      result = new ArrayList(totalRows);
    } else {
      result = new ArrayList();
    }

    ParseState state = new ParseState();

    Object first = parseFirstRow(jp, state, clazz);
    if (first == null) {
      return Collections.emptyList();
    } else {
      result.add(first);
    }

    while (jp.getCurrentToken() != null) {
      skipToField(jp, state.docFieldName, state);
      if (atEndOfRows(jp)) {
        return result;
      }
      result.add(jp.readValueAs(clazz));
      endRow(jp, state);
    }
    return result;
  }
  @SuppressWarnings({"unchecked", "rawtypes"})
  private Object readWithMessageConverters(
      MethodParameter methodParam, HttpInputMessage inputMessage, Class<?> paramType)
      throws Exception {

    MediaType contentType = inputMessage.getHeaders().getContentType();
    if (contentType == null) {
      StringBuilder builder =
          new StringBuilder(ClassUtils.getShortName(methodParam.getParameterType()));
      String paramName = methodParam.getParameterName();
      if (paramName != null) {
        builder.append(' ');
        builder.append(paramName);
      }
      throw new HttpMediaTypeNotSupportedException(
          "Cannot extract parameter (" + builder.toString() + "): no Content-Type found");
    }

    List<MediaType> allSupportedMediaTypes = new ArrayList<MediaType>();
    if (this.messageConverters != null) {
      for (HttpMessageConverter<?> messageConverter : this.messageConverters) {
        allSupportedMediaTypes.addAll(messageConverter.getSupportedMediaTypes());
        if (messageConverter.canRead(paramType, contentType)) {
          if (logger.isDebugEnabled()) {
            logger.debug(
                "Reading ["
                    + paramType.getName()
                    + "] as \""
                    + contentType
                    + "\" using ["
                    + messageConverter
                    + "]");
          }
          return messageConverter.read((Class) paramType, inputMessage);
        }
      }
    }
    throw new HttpMediaTypeNotSupportedException(contentType, allSupportedMediaTypes);
  }