@Override
 protected void writeInternal(String t, HttpOutputMessage outputMessage)
     throws IOException, HttpMessageNotWritableException {
   MediaType contentType = outputMessage.getHeaders().getContentType();
   Charset charset = contentType.getCharSet() != null ? contentType.getCharSet() : DEFAULT_CHARSET;
   FileCopyUtils.copy(t, new OutputStreamWriter(outputMessage.getBody(), charset));
 }
  @Test
  public void headers() throws URISyntaxException {
    MediaType accept = MediaType.TEXT_PLAIN;
    Charset charset = Charset.forName("UTF-8");
    long ifModifiedSince = 12345L;
    String ifNoneMatch = "\"foo\"";
    long contentLength = 67890;
    MediaType contentType = MediaType.TEXT_PLAIN;

    RequestEntity<Void> responseEntity =
        RequestEntity.post(new URI("http://example.com"))
            .accept(accept)
            .acceptCharset(charset)
            .ifModifiedSince(ifModifiedSince)
            .ifNoneMatch(ifNoneMatch)
            .contentLength(contentLength)
            .contentType(contentType)
            .build();

    assertNotNull(responseEntity);
    assertEquals(HttpMethod.POST, responseEntity.getMethod());
    assertEquals(new URI("http://example.com"), responseEntity.getUrl());
    HttpHeaders responseHeaders = responseEntity.getHeaders();

    assertEquals("text/plain", responseHeaders.getFirst("Accept"));
    assertEquals("utf-8", responseHeaders.getFirst("Accept-Charset"));
    assertEquals("Thu, 01 Jan 1970 00:00:12 GMT", responseHeaders.getFirst("If-Modified-Since"));
    assertEquals(ifNoneMatch, responseHeaders.getFirst("If-None-Match"));
    assertEquals(String.valueOf(contentLength), responseHeaders.getFirst("Content-Length"));
    assertEquals(contentType.toString(), responseHeaders.getFirst("Content-Type"));

    assertNull(responseEntity.getBody());
  }
 @Override
 public void write(JSONEntity entity, MediaType contentType, HttpOutputMessage outputMessage)
     throws IOException, HttpMessageNotWritableException {
   // First write the entity to a JSON string
   try {
     HttpHeaders headers = outputMessage.getHeaders();
     if (headers.getContentType() == null) {
       if (contentType == null
           || contentType.isWildcardType()
           || contentType.isWildcardSubtype()) {
         contentType = MediaType.APPLICATION_JSON;
       }
       if (contentType != null) {
         headers.setContentType(contentType);
       }
     }
     String jsonString = EntityFactory.createJSONStringForEntity(entity);
     long length =
         JSONEntityHttpMessageConverter.writeToStream(
             jsonString, outputMessage.getBody(), contentType.getCharSet());
     if (headers.getContentLength() == -1) {
       headers.setContentLength(length);
     }
   } catch (JSONObjectAdapterException e) {
     throw new HttpMessageNotWritableException(e.getMessage());
   }
 }
 @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));
 }
  @Test
  public void putTest() throws RestClientException, URISyntaxException {
    String url = dirFrontEnd + "/empresa/nifPrueba";
    String acceptHeaderValue = "application/json";

    HttpHeaders requestHeaders = new HttpHeaders();
    List<MediaType> mediaTypes = new ArrayList<MediaType>();
    mediaTypes.add(MediaType.valueOf(acceptHeaderValue));
    requestHeaders.setAccept(mediaTypes);
    requestHeaders.setContentType(MediaType.valueOf(acceptHeaderValue));
    HttpMethod put = HttpMethod.PUT;

    String body = "{\"nombre\":\"nombrePruebaModificado\"}";
    HttpEntity<String> entity = new HttpEntity<String>(body, requestHeaders);

    ResponseEntity<String> response = restTemplate.exchange(url, put, entity, String.class);
    assertTrue(response.getStatusCode().equals(HttpStatus.NO_CONTENT));
    String nombreEmpresa =
        (String)
            jdbcTemplate.queryForObject(
                "SELECT NOMBRE FROM EMPRESA WHERE NIF= ?",
                new Object[] {"nifPrueba"},
                String.class);
    assertTrue(nombreEmpresa.equals("nombrePruebaModificado"));
  }
  @Test
  public void postTest() throws RestClientException, URISyntaxException {
    String url = dirFrontEnd + "/empresa/";
    String acceptHeaderValue = "application/json";

    HttpHeaders requestHeaders = new HttpHeaders();
    List<MediaType> mediaTypes = new ArrayList<MediaType>();
    mediaTypes.add(MediaType.valueOf(acceptHeaderValue));
    requestHeaders.setAccept(mediaTypes);
    requestHeaders.setContentType(MediaType.valueOf(acceptHeaderValue));
    HttpMethod post = HttpMethod.POST;

    String body =
        "{\"nif\":\"nifPrueba\",\"nombre\":\"nombrePrueba\",\"direccionFiscal\":\"DirPrueba\",\"fechaInicioActividades\":\"2014-01-10\",\"version\":\"0\"}";
    HttpEntity<String> entity = new HttpEntity<String>(body, requestHeaders);

    ResponseEntity<String> response = restTemplate.exchange(url, post, entity, String.class);
    assertTrue(response.getStatusCode().equals(HttpStatus.CREATED));
    String nombreEmpresa =
        (String)
            jdbcTemplate.queryForObject(
                "SELECT NOMBRE FROM EMPRESA WHERE NIF= ?",
                new Object[] {"nifPrueba"},
                String.class);
    assertTrue(nombreEmpresa.equals("nombrePrueba"));
  }
  @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
        }
      }
    }
  }
Пример #8
0
 @SuppressWarnings("unchecked")
 public void doWithRequest(ClientHttpRequest request) throws IOException {
   if (responseType != null) {
     List<MediaType> allSupportedMediaTypes = new ArrayList<MediaType>();
     for (HttpMessageConverter<?> messageConverter : getMessageConverters()) {
       if (messageConverter.canRead(responseType, null)) {
         List<MediaType> supportedMediaTypes = messageConverter.getSupportedMediaTypes();
         for (MediaType supportedMediaType : supportedMediaTypes) {
           if (supportedMediaType.getCharSet() != null) {
             supportedMediaType =
                 new MediaType(supportedMediaType.getType(), supportedMediaType.getSubtype());
           }
           allSupportedMediaTypes.add(supportedMediaType);
         }
       }
     }
     if (!allSupportedMediaTypes.isEmpty()) {
       MediaType.sortBySpecificity(allSupportedMediaTypes);
       if (logger.isDebugEnabled()) {
         logger.debug("Setting request Accept header to " + allSupportedMediaTypes);
       }
       request.getHeaders().setAccept(allSupportedMediaTypes);
     }
   }
 }
 private View getBestView(List<View> candidateViews, List<MediaType> requestedMediaTypes) {
   for (View candidateView : candidateViews) {
     if (candidateView instanceof SmartView) {
       SmartView smartView = (SmartView) candidateView;
       if (smartView.isRedirectView()) {
         if (logger.isDebugEnabled()) {
           logger.debug("Returning redirect view [" + candidateView + "]");
         }
         return candidateView;
       }
     }
   }
   for (MediaType mediaType : requestedMediaTypes) {
     for (View candidateView : candidateViews) {
       if (StringUtils.hasText(candidateView.getContentType())) {
         MediaType candidateContentType = MediaType.parseMediaType(candidateView.getContentType());
         if (mediaType.includes(candidateContentType)) {
           if (logger.isDebugEnabled()) {
             logger.debug(
                 "Returning ["
                     + candidateView
                     + "] based on requested media type '"
                     + mediaType
                     + "'");
           }
           return candidateView;
         }
       }
     }
   }
   return null;
 }
public class PersonControllerTest {

  private static final MediaType FORM_URL =
      MediaType.parseMediaType("application/x-www-form-urlencoded");
  private static final MediaType JSON_UTF8 =
      MediaType.parseMediaType("application/json;charset=UTF-8");

  private MockMvc mockMvc;

  @Before
  public void setup() {
    this.mockMvc = MockMvcBuilders.standaloneSetup(new PersonController()).build();
  }

  @Test
  public void testPostAndGet() throws Exception {
    mockMvc
        .perform(
            post("/")
                .contentType(FORM_URL)
                .param("forename", "Buzz")
                .param("surname", "Aldrin")
                .param("age", "85"))
        .andDo(MockMvcResultHandlers.print())
        .andExpect(status().isCreated());

    mockMvc
        .perform(get("/").contentType(JSON_UTF8))
        .andDo(MockMvcResultHandlers.print())
        .andExpect(jsonPath("$.forename", is("Buzz")))
        .andExpect(jsonPath("$.surname", is("Aldrin")))
        .andExpect(jsonPath("$.age", is(85)));
  }
}
  @Test
  @SuppressWarnings("unchecked")
  public void Can_create_a_user_for_a_specific_content_type() {

    final MediaType contentTypeOne = APPLICATION_FORM_URLENCODED;
    final MediaType contentTypeTwo = APPLICATION_JSON;
    final UserFactory<HttpServletRequest> userFactoryOne = mock(UserFactory.class);
    final UserFactory<HttpServletRequest> userFactoryTwo = mock(UserFactory.class);
    final Map<MediaType, UserFactory<HttpServletRequest>> factories =
        new HashMap<MediaType, UserFactory<HttpServletRequest>>() {
          {
            put(contentTypeOne, userFactoryOne);
            put(contentTypeTwo, userFactoryTwo);
          }
        };

    final HttpServletRequest request = mock(HttpServletRequest.class);

    final User expected = mock(PersistedUser.class);

    // Given
    given(request.getContentType()).willReturn(contentTypeTwo.toString());
    given(userFactoryTwo.create(request)).willReturn(expected);

    // When
    final User actual = new ContentTypeUserFactory(factories).create(request);

    // Then
    assertThat(actual, equalTo(expected));
  }
Пример #12
0
  /**
   * Indicate whether this {@code MediaType} is compatible with the given media type.
   *
   * <p>For instance, {@code text/*} is compatible with {@code text/plain}, {@code text/html}, and
   * vice versa. In effect, this method is similar to {@link #includes(MediaType)}, except that it
   * <b>is</b> symmetric.
   *
   * @param other the reference media type with which to compare
   * @return <code>true</code> if this media type is compatible with the given media type; <code>
   *     false</code> otherwise
   */
  public boolean isCompatibleWith(MediaType other) {
    if (other == null) {
      return false;
    }
    if (isWildcardType() || other.isWildcardType()) {
      return true;
    } else if (this.type.equals(other.type)) {
      if (this.subtype.equals(other.subtype)
          || this.isWildcardSubtype()
          || other.isWildcardSubtype()) {
        return true;
      }
      // application/*+xml is compatible with application/soap+xml, and vice-versa
      int thisPlusIdx = this.subtype.indexOf('+');
      int otherPlusIdx = other.subtype.indexOf('+');
      if (thisPlusIdx != -1 && otherPlusIdx != -1) {
        String thisSubtypeNoSuffix = this.subtype.substring(0, thisPlusIdx);
        String otherSubtypeNoSuffix = other.subtype.substring(0, otherPlusIdx);

        String thisSubtypeSuffix = this.subtype.substring(thisPlusIdx + 1);
        String otherSubtypeSuffix = other.subtype.substring(otherPlusIdx + 1);

        if (thisSubtypeSuffix.equals(otherSubtypeSuffix)
            && (WILDCARD_TYPE.equals(thisSubtypeNoSuffix)
                || WILDCARD_TYPE.equals(otherSubtypeNoSuffix))) {
          return true;
        }
      }
    }
    return false;
  }
 private String determineEncoding(String contentTypeHeader, String defaultEncoding) {
   if (!StringUtils.hasText(contentTypeHeader)) {
     return defaultEncoding;
   }
   MediaType contentType = MediaType.parseMediaType(contentTypeHeader);
   Charset charset = contentType.getCharSet();
   return (charset != null ? charset.name() : defaultEncoding);
 }
Пример #14
0
 @Test
 public void parseQuotedCharset() {
   String s = "application/xml;charset=\"utf-8\"";
   MediaType mediaType = MediaType.parseMediaType(s);
   assertEquals("Invalid type", "application", mediaType.getType());
   assertEquals("Invalid subtype", "xml", mediaType.getSubtype());
   assertEquals("Invalid charset", Charset.forName("UTF-8"), mediaType.getCharSet());
 }
Пример #15
0
 @Test
 public void parseCharset() throws Exception {
   String s = "text/html; charset=iso-8859-1";
   MediaType mediaType = MediaType.parseMediaType(s);
   assertEquals("Invalid type", "text", mediaType.getType());
   assertEquals("Invalid subtype", "html", mediaType.getSubtype());
   assertEquals("Invalid charset", Charset.forName("ISO-8859-1"), mediaType.getCharSet());
 }
Пример #16
0
 @Test
 public void parseURLConnectionMediaType() throws Exception {
   String s = "*; q=.2";
   MediaType mediaType = MediaType.parseMediaType(s);
   assertEquals("Invalid type", "*", mediaType.getType());
   assertEquals("Invalid subtype", "*", mediaType.getSubtype());
   assertEquals("Invalid quality factor", 0.2D, mediaType.getQualityValue(), 0D);
 }
 public static boolean isJSONType(MediaType type) {
   if (type == null) return false;
   if (type.getType() == null) return false;
   if (type.getSubtype() == null) return false;
   if (!"application".equals(type.getType().toLowerCase())) return false;
   if (!"json".equals(type.getSubtype().toLowerCase())) return false;
   return true;
 }
 private int indexOfEqualMediaType(MediaType mediaType) {
   for (int i = 0; i < getExpressionsToCompare().size(); i++) {
     MediaType currentMediaType = getExpressionsToCompare().get(i).getMediaType();
     if (mediaType.getType().equalsIgnoreCase(currentMediaType.getType())
         && mediaType.getSubtype().equalsIgnoreCase(currentMediaType.getSubtype())) {
       return i;
     }
   }
   return -1;
 }
Пример #19
0
 /**
  * Return a string representation of the given list of {@code MediaType} objects.
  *
  * <p>This method can be used to for an {@code Accept} or {@code Content-Type} header.
  *
  * @param mediaTypes the string to parse
  * @return the list of media types
  * @throws IllegalArgumentException if the String cannot be parsed
  */
 public static String toString(Collection<MediaType> mediaTypes) {
   StringBuilder builder = new StringBuilder();
   for (Iterator<MediaType> iterator = mediaTypes.iterator(); iterator.hasNext(); ) {
     MediaType mediaType = iterator.next();
     mediaType.appendTo(builder);
     if (iterator.hasNext()) {
       builder.append(", ");
     }
   }
   return builder.toString();
 }
 /**
  * Returns {@code true} if the given media type includes any of the {@linkplain
  * #setSupportedMediaTypes(List) supported media types}.
  *
  * @param mediaType the media type to write, can be {@code null} if not specified. Typically the
  *     value of an {@code Accept} header.
  * @return {@code true} if the supported media types are compatible with the media type, or if the
  *     media type is {@code null}
  */
 protected boolean canWrite(MediaType mediaType) {
   if (mediaType == null || MediaType.ALL.equals(mediaType)) {
     return true;
   }
   for (MediaType supportedMediaType : getSupportedMediaTypes()) {
     if (supportedMediaType.isCompatibleWith(mediaType)) {
       return true;
     }
   }
   return false;
 }
 /**
  * Returns true if any of the {@linkplain #setSupportedMediaTypes(List) supported} media types
  * {@link MediaType#includes(MediaType) include} the given media type.
  *
  * @param mediaType the media type to read, can be {@code null} if not specified. Typically the
  *     value of a {@code Content-Type} header.
  * @return {@code true} if the supported media types include the media type, or if the media type
  *     is {@code null}
  */
 protected boolean canRead(MediaType mediaType) {
   if (mediaType == null) {
     return true;
   }
   for (MediaType supportedMediaType : getSupportedMediaTypes()) {
     if (supportedMediaType.includes(mediaType)) {
       return true;
     }
   }
   return false;
 }
 /**
  * Determine the JSON encoding to use for the given content type.
  *
  * @param contentType the media type as requested by the caller
  * @return the JSON encoding to use (never {@code null})
  */
 protected JsonEncoding getJsonEncoding(MediaType contentType) {
   if (contentType != null && contentType.getCharset() != null) {
     Charset charset = contentType.getCharset();
     for (JsonEncoding encoding : JsonEncoding.values()) {
       if (charset.name().equals(encoding.getJavaName())) {
         return encoding;
       }
     }
   }
   return JsonEncoding.UTF8;
 }
Пример #23
0
  @Test
  public void parseMediaTypes() throws Exception {
    String s = "text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c";
    List<MediaType> mediaTypes = MediaType.parseMediaTypes(s);
    assertNotNull("No media types returned", mediaTypes);
    assertEquals("Invalid amount of media types", 4, mediaTypes.size());

    mediaTypes = MediaType.parseMediaTypes(null);
    assertNotNull("No media types returned", mediaTypes);
    assertEquals("Invalid amount of media types", 0, mediaTypes.size());
  }
  @Test(expected = HttpMediaTypeNotSupportedException.class)
  public void resolveArgumentNotReadable() throws Exception {
    MediaType contentType = MediaType.TEXT_PLAIN;
    servletRequest.addHeader("Content-Type", contentType.toString());

    expect(messageConverter.canRead(String.class, contentType)).andReturn(false);
    replay(messageConverter);

    processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, null);

    fail("Expected exception");
  }
 @Override
 protected Long getContentLength(String s, MediaType contentType) {
   if (contentType != null && contentType.getCharSet() != null) {
     Charset charset = contentType.getCharSet();
     try {
       return (long) s.getBytes(charset.name()).length;
     } catch (UnsupportedEncodingException ex) {
       throw new InternalError(ex.getMessage());
     }
   } else {
     return null;
   }
 }
 @Override
 protected View createView(String viewName, Locale locale) throws Exception {
   View view = super.createView(viewName, locale);
   if (viewName.startsWith(FORWARD_URL_PREFIX) || viewName.startsWith(REDIRECT_URL_PREFIX)) {
     if (view instanceof AbstractView) {
       MediaType requestedMediaType = getRequestedMediaType();
       if (requestedMediaType != null) {
         ((AbstractView) view).setContentType(requestedMediaType.toString());
       }
     }
   }
   return view;
 }
 public boolean canWrite(Class<?> clazz, MediaType mediaType) {
   if (!Map.class.isAssignableFrom(clazz)) {
     return false;
   }
   if (mediaType == null || MediaType.ALL.equals(mediaType)) {
     return true;
   }
   for (MediaType supportedMediaType : getSupportedMediaTypes()) {
     if (supportedMediaType.isCompatibleWith(mediaType)) {
       return true;
     }
   }
   return false;
 }
Пример #28
0
  @Test
  public void compareToConsistentWithEquals() {
    MediaType m1 = MediaType.parseMediaType("text/html; q=0.7; charset=iso-8859-1");
    MediaType m2 = MediaType.parseMediaType("text/html; charset=iso-8859-1; q=0.7");

    assertEquals("Media types not equal", m1, m2);
    assertEquals("compareTo() not consistent with equals", 0, m1.compareTo(m2));
    assertEquals("compareTo() not consistent with equals", 0, m2.compareTo(m1));

    m1 = MediaType.parseMediaType("text/html; q=0.7; charset=iso-8859-1");
    m2 = MediaType.parseMediaType("text/html; Q=0.7; charset=iso-8859-1");
    assertEquals("Media types not equal", m1, m2);
    assertEquals("compareTo() not consistent with equals", 0, m1.compareTo(m2));
    assertEquals("compareTo() not consistent with equals", 0, m2.compareTo(m1));
  }
  @Test(expected = HttpMediaTypeNotAcceptableException.class)
  public void handleReturnValueNotAcceptableProduces() throws Exception {
    MediaType accepted = MediaType.TEXT_PLAIN;
    servletRequest.addHeader("Accept", accepted.toString());

    expect(messageConverter.canWrite(String.class, null)).andReturn(true);
    expect(messageConverter.getSupportedMediaTypes())
        .andReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
    expect(messageConverter.canWrite(String.class, accepted)).andReturn(false);
    replay(messageConverter);

    processor.handleReturnValue("Foo", returnTypeStringProduces, mavContainer, webRequest);

    fail("Expected exception");
  }
 /**
  * Determines the {@link MediaType} for the given filename.
  *
  * <p>The default implementation will check the {@linkplain #setMediaTypes(Map) media types}
  * property first for a defined mapping. If not present, and if the Java Activation Framework can
  * be found on the classpath, it will call {@link FileTypeMap#getContentType(String)}
  *
  * <p>This method can be overridden to provide a different algorithm.
  *
  * @param filename the current request file name (i.e. {@code hotels.html})
  * @return the media type, if any
  */
 protected MediaType getMediaTypeFromFilename(String filename) {
   String extension = StringUtils.getFilenameExtension(filename);
   if (!StringUtils.hasText(extension)) {
     return null;
   }
   extension = extension.toLowerCase(Locale.ENGLISH);
   MediaType mediaType = this.mediaTypes.get(extension);
   if (mediaType == null) {
     String mimeType = getServletContext().getMimeType(filename);
     if (StringUtils.hasText(mimeType)) {
       mediaType = MediaType.parseMediaType(mimeType);
     }
     if (this.useJaf
         && (mediaType == null || MediaType.APPLICATION_OCTET_STREAM.equals(mediaType))) {
       MediaType jafMediaType = ActivationMediaTypeFactory.getMediaType(filename);
       if (jafMediaType != null && !MediaType.APPLICATION_OCTET_STREAM.equals(jafMediaType)) {
         mediaType = jafMediaType;
       }
     }
     if (mediaType != null) {
       this.mediaTypes.putIfAbsent(extension, mediaType);
     }
   }
   return mediaType;
 }