Java Code Examples for org.springframework.http.MediaType#valueOf()

@Test
public void parseTest() {
    MediaType mediaType = MediaType.valueOf("image/gif");

    assertNotNull(mediaType);
    assertThat(mediaType, equalTo(MediaType.IMAGE_GIF));
}
 

@Test
public void includesTest() {
    MediaType mediaType = MediaType.valueOf("image/*");
    boolean isInclude = mediaType.includes(MediaType.IMAGE_GIF);
    assertTrue(isInclude);

    isInclude = mediaType.includes(MediaType.IMAGE_JPEG);
    assertTrue(isInclude);

    isInclude = mediaType.includes(MediaType.IMAGE_PNG);
    assertTrue(isInclude);

    isInclude = mediaType.includes(MediaType.TEXT_HTML);
    assertFalse(isInclude);
}
 

private MediaType contentType(ResponseDefinition response) {
	String value = null;
	if (response.getHeaders() != null) {
		HttpHeader header = response.getHeaders().getHeader("Content-Type");
		if (header != null && header.isPresent()) {
			value = header.firstValue();
		}
	}
	return value == null ? MediaType.TEXT_PLAIN : MediaType.valueOf(value);
}
 

public static MediaType getAcceptAsMediaType(HttpServletRequest request){
	String accept = request.getHeader("Accept");
	try {
		MediaType mtype = MediaType.valueOf(accept);
		return mtype;
	} catch (Exception e) {
		logger.error("parse [{}] as MediaType error: " + e.getMessage(), accept);
		return null;
	}
}
 

@Test
public void test(){
	MediaType mtype = MediaType.valueOf("application/json");
	MediaType jsonUtf8 = MediaType.valueOf("application/json;charset=UTF-8");
	Assert.assertTrue(jsonUtf8.isCompatibleWith(mtype));
	Assert.assertTrue(mtype.isCompatibleWith(jsonUtf8));
}
 

protected MediaType getRequestContentType(RequestTemplate request){
	Collection<String> contentTypes = request.headers().get("Content-Type");

	MediaType requestContentType = null;
	if (contentTypes != null && !contentTypes.isEmpty()) {
		String type = contentTypes.iterator().next();
		requestContentType = MediaType.valueOf(type);
	}
	return requestContentType;
}
 

@Override
public <T> T convert(Class<T> aClass, Object o) {
    return (T) MediaType.valueOf(String.valueOf(o));
}
 

private MediaType buildMediaType(final ServerWebExchange exchange) {
    return MediaType.valueOf(Optional.ofNullable(exchange
            .getRequest()
            .getHeaders().getFirst(HttpHeaders.CONTENT_TYPE))
            .orElse(MediaType.APPLICATION_JSON_VALUE));
}
 

@Override
public void encode(Object requestBody, Type bodyType, RequestTemplate request)
		throws EncodeException {
	// template.body(conversionService.convert(object, String.class));
	if (requestBody != null) {
		Collection<String> contentTypes = request.headers()
				.get(HttpEncoding.CONTENT_TYPE);

		MediaType requestContentType = null;
		if (contentTypes != null && !contentTypes.isEmpty()) {
			String type = contentTypes.iterator().next();
			requestContentType = MediaType.valueOf(type);
		}

		if (Objects.equals(requestContentType, MediaType.MULTIPART_FORM_DATA)) {
			this.springFormEncoder.encode(requestBody, bodyType, request);
			return;
		}
		else {
			if (bodyType == MultipartFile.class) {
				log.warn(
						"For MultipartFile to be handled correctly, the 'consumes' parameter of @RequestMapping "
								+ "should be specified as MediaType.MULTIPART_FORM_DATA_VALUE");
			}
		}

		for (HttpMessageConverter messageConverter : this.messageConverters
				.getObject().getConverters()) {
			FeignOutputMessage outputMessage;
			try {
				if (messageConverter instanceof GenericHttpMessageConverter) {
					outputMessage = checkAndWrite(requestBody, bodyType,
							requestContentType,
							(GenericHttpMessageConverter) messageConverter, request);
				}
				else {
					outputMessage = checkAndWrite(requestBody, requestContentType,
							messageConverter, request);
				}
			}
			catch (IOException | HttpMessageConversionException ex) {
				throw new EncodeException("Error converting request body", ex);
			}
			if (outputMessage != null) {
				// clear headers
				request.headers(null);
				// converters can modify headers, so update the request
				// with the modified headers
				request.headers(getHeaders(outputMessage.getHeaders()));

				// do not use charset for binary data and protobuf
				Charset charset;
				if (messageConverter instanceof ByteArrayHttpMessageConverter) {
					charset = null;
				}
				else if (messageConverter instanceof ProtobufHttpMessageConverter
						&& ProtobufHttpMessageConverter.PROTOBUF.isCompatibleWith(
								outputMessage.getHeaders().getContentType())) {
					charset = null;
				}
				else {
					charset = StandardCharsets.UTF_8;
				}
				request.body(Request.Body.encoded(
						outputMessage.getOutputStream().toByteArray(), charset));
				return;
			}
		}
		String message = "Could not write request: no suitable HttpMessageConverter "
				+ "found for request type [" + requestBody.getClass().getName() + "]";
		if (requestContentType != null) {
			message += " and content type [" + requestContentType + "]";
		}
		throw new EncodeException(message);
	}
}
 

public BladeMediaType(String version) {
	this.version = version;
	this.mediaType = MediaType.valueOf(String.format(MEDIA_TYPE_TEMP, appName, version));
}
 

@Override
protected MediaType getContentType(MvcResult result) {
	return MediaType.valueOf(result.getRequest().getContentType());
}
 

public CatnapMessageConverter(final T view) {
    super(MediaType.valueOf(view.getContentType()));
    this.view = view;
}
 

public CatnapMessageConverter(final T view) {
    super(MediaType.valueOf(view.getContentType()));
    this.view = view;
}
 

@Override
public void setAsText(String text) {

    MediaType mediaType = MediaType.valueOf(text);

    setValue(mediaType);

}
 

/**
 * Add a mapping from a key, extracted from a path extension or a query
 * parameter, to a MediaType. This is required in order for the parameter
 * strategy to work. Any extensions explicitly registered here are also
 * whitelisted for the purpose of Reflected File Download attack detection
 * (see Spring Framework reference documentation for more details on RFD
 * attack protection).
 * <p>The path extension strategy will also try to use
 * {@link ServletContext#getMimeType} and JAF (if present) to resolve path
 * extensions. To change this behavior see the {@link #useJaf} property.
 * @param mediaTypes media type mappings
 * @see #addMediaType(String, MediaType)
 * @see #addMediaTypes(Map)
 */
public void setMediaTypes(Properties mediaTypes) {
	if (!CollectionUtils.isEmpty(mediaTypes)) {
		for (Entry<Object, Object> entry : mediaTypes.entrySet()) {
			String extension = ((String)entry.getKey()).toLowerCase(Locale.ENGLISH);
			MediaType mediaType = MediaType.valueOf((String) entry.getValue());
			this.mediaTypes.put(extension, mediaType);
		}
	}
}
 

/**
 * Add a mapping from a key, extracted from a path extension or a query
 * parameter, to a MediaType. This is required in order for the parameter
 * strategy to work. Any extensions explicitly registered here are also
 * whitelisted for the purpose of Reflected File Download attack detection
 * (see Spring Framework reference documentation for more details on RFD
 * attack protection).
 * <p>The path extension strategy will also try to use
 * {@link ServletContext#getMimeType} and JAF (if present) to resolve path
 * extensions. To change this behavior see the {@link #useJaf} property.
 * @param mediaTypes media type mappings
 * @see #addMediaType(String, MediaType)
 * @see #addMediaTypes(Map)
 */
public void setMediaTypes(Properties mediaTypes) {
	if (!CollectionUtils.isEmpty(mediaTypes)) {
		for (Entry<Object, Object> entry : mediaTypes.entrySet()) {
			String extension = ((String)entry.getKey()).toLowerCase(Locale.ENGLISH);
			MediaType mediaType = MediaType.valueOf((String) entry.getValue());
			this.mediaTypes.put(extension, mediaType);
		}
	}
}