@Nullable public MimeType getContentType() { Object value = getHeader(MessageHeaders.CONTENT_TYPE); if (value == null) { return null; } return (value instanceof MimeType ? (MimeType) value : MimeType.valueOf(value.toString())); }
@Override @Nullable public MimeType resolve(@Nullable MessageHeaders headers) { if (headers == null || headers.get(MessageHeaders.CONTENT_TYPE) == null) { return this.defaultMimeType; } Object value = headers.get(MessageHeaders.CONTENT_TYPE); if (value == null) { return null; } else if (value instanceof MimeType) { return (MimeType) value; } else if (value instanceof String) { return MimeType.valueOf((String) value); } else { throw new IllegalArgumentException( "Unknown type for contentType header value: " + value.getClass()); } }
protected boolean isJsonContentType(Request request) { String mime = request.headers("Content-Type"); if (isBlank(mime)) { return false; } try { MimeType mimeType = MimeType.valueOf(mime); return "application".equals(mimeType.getType()) && "json".equals(mimeType.getSubtype()); } catch (InvalidMimeTypeException e) { return false; } }
@Test(expected = InvalidMimeTypeException.class) public void valueOfIllegalType() { MimeType.valueOf("audio(/basic"); }
@Test(expected = InvalidMimeTypeException.class) public void valueOfIllegalCharset() { MimeType.valueOf("text/html; charset=foo-bar"); }
public SELF hasContentType(String mimeType) { String contentType = actual.getHeader("content-type"); try { if (!(isNotBlank(contentType) && MimeType.valueOf(contentType).isCompatibleWith(MimeType.valueOf(mimeType)))) { failWithMessage("Expected content type <%s> but was <%s>", mimeType, contentType); } } catch (InvalidMimeTypeException e) { failWithMessage("Actual content type <%s> could not be parsed", contentType); } return myself; }
@Test(expected = InvalidMimeTypeException.class) public void valueOfNoSubtypeSlash() { MimeType.valueOf("audio/"); }
@Test(expected = InvalidMimeTypeException.class) public void valueOfNoSubtype() { MimeType.valueOf("audio"); }
@Test(expected = InvalidMimeTypeException.class) public void valueOfIllegalSubtype() { MimeType.valueOf("audio/basic)"); }
@Test public void toNativeHeadersContentType() { SimpMessageHeaderAccessor simpHeaderAccessor = SimpMessageHeaderAccessor.create(); simpHeaderAccessor.setContentType(MimeType.valueOf("application/atom+xml")); Message<byte[]> message = MessageBuilder.createMessage(new byte[0], simpHeaderAccessor.getMessageHeaders()); StompHeaderAccessor stompHeaderAccessor = StompHeaderAccessor.wrap(message); Map<String, List<String>> map = stompHeaderAccessor.toNativeHeaderMap(); assertEquals("application/atom+xml", map.get(StompHeaderAccessor.STOMP_CONTENT_TYPE_HEADER).get(0)); }
@Test public void withConversionService() { ConversionService conversionService = new DefaultConversionService(); assertTrue(conversionService.canConvert(String.class, MimeType.class)); MimeType mimeType = MimeType.valueOf("application/xml"); assertEquals(mimeType, conversionService.convert("application/xml", MimeType.class)); }
@Test public void parseQuotedCharset() { String s = "application/xml;charset=\"utf-8\""; MimeType mimeType = MimeType.valueOf(s); assertEquals("Invalid type", "application", mimeType.getType()); assertEquals("Invalid subtype", "xml", mimeType.getSubtype()); assertEquals("Invalid charset", StandardCharsets.UTF_8, mimeType.getCharset()); }
@Test public void parseCharset() { String s = "text/html; charset=iso-8859-1"; MimeType mimeType = MimeType.valueOf(s); assertEquals("Invalid type", "text", mimeType.getType()); assertEquals("Invalid subtype", "html", mimeType.getSubtype()); assertEquals("Invalid charset", StandardCharsets.ISO_8859_1, mimeType.getCharset()); }
@Test public void nonExisting() { Resource resource = new ClassPathResource("ResourceRegionEncoderTests.txt", getClass()); Resource nonExisting = new ClassPathResource("does not exist", getClass()); Flux<ResourceRegion> regions = Flux.just( new ResourceRegion(resource, 0, 6), new ResourceRegion(nonExisting, 0, 6)); String boundary = MimeTypeUtils.generateMultipartBoundaryString(); Flux<DataBuffer> result = this.encoder.encode(regions, this.bufferFactory, ResolvableType.forClass(ResourceRegion.class), MimeType.valueOf("text/plain"), Collections.singletonMap(ResourceRegionEncoder.BOUNDARY_STRING_HINT, boundary)); StepVerifier.create(result) .consumeNextWith(stringConsumer("\r\n--" + boundary + "\r\n")) .consumeNextWith(stringConsumer("Content-Type: text/plain\r\n")) .consumeNextWith(stringConsumer("Content-Range: bytes 0-5/39\r\n\r\n")) .consumeNextWith(stringConsumer("Spring")) .expectError(EncodingException.class) .verify(); }
@Test public void parseQuotedSeparator() { String s = "application/xop+xml;charset=utf-8;type=\"application/soap+xml;action=\\\"http://x.y.z\\\"\""; MimeType mimeType = MimeType.valueOf(s); assertEquals("Invalid type", "application", mimeType.getType()); assertEquals("Invalid subtype", "xop+xml", mimeType.getSubtype()); assertEquals("Invalid charset", StandardCharsets.UTF_8, mimeType.getCharset()); assertEquals("\"application/soap+xml;action=\\\"http://x.y.z\\\"\"", mimeType.getParameter("type")); }
@Test public void canEncode() { ResolvableType resourceRegion = ResolvableType.forClass(ResourceRegion.class); MimeType allMimeType = MimeType.valueOf("*/*"); assertFalse(this.encoder.canEncode(ResolvableType.forClass(Resource.class), MimeTypeUtils.APPLICATION_OCTET_STREAM)); assertFalse(this.encoder.canEncode(ResolvableType.forClass(Resource.class), allMimeType)); assertTrue(this.encoder.canEncode(resourceRegion, MimeTypeUtils.APPLICATION_OCTET_STREAM)); assertTrue(this.encoder.canEncode(resourceRegion, allMimeType)); // SPR-15464 assertFalse(this.encoder.canEncode(ResolvableType.NONE, null)); }
@Nullable public static MimeType getContentType(Message<?> message) { Object value = message.getHeaders().get(MessageHeaders.CONTENT_TYPE); if (value == null) { return null; } return (value instanceof MimeType ? (MimeType) value : MimeType.valueOf(value.toString())); }
@Nullable public MimeType getContentType() { Object value = getHeader(MessageHeaders.CONTENT_TYPE); if (value == null) { return null; } return (value instanceof MimeType ? (MimeType) value : MimeType.valueOf(value.toString())); }
MimeType.valueOf("text/plain"), Collections.singletonMap(ResourceRegionEncoder.BOUNDARY_STRING_HINT, boundary) );
@Test public void fromHeadersWithContentTypeAsMimeType() { DefaultAmqpHeaderMapper headerMapper = DefaultAmqpHeaderMapper.inboundMapper(); Map<String, Object> headerMap = new HashMap<String, Object>(); MimeType contentType = MimeType.valueOf("text/html"); headerMap.put(AmqpHeaders.CONTENT_TYPE, contentType); MessageHeaders integrationHeaders = new MessageHeaders(headerMap); MessageProperties amqpProperties = new MessageProperties(); headerMapper.fromHeadersToRequest(integrationHeaders, amqpProperties); assertEquals("text/html", amqpProperties.getContentType()); }