/** * Specify the target type of this bean definition, if known in advance. * @since 3.2.2 */ public void setTargetType(@Nullable Class<?> targetType) { this.targetType = (targetType != null ? ResolvableType.forClass(targetType) : null); }
/** * Constructor with a fully initialized {@link HttpMessageWriter}. */ public HttpMessageWriterView(HttpMessageWriter<?> writer) { Assert.notNull(writer, "HttpMessageWriter is required"); this.writer = writer; this.canWriteMap = writer.canWrite(ResolvableType.forClass(Map.class), null); }
@Override public void writer(HttpMessageWriter<?> writer) { boolean canWriteObject = writer.canWrite(ResolvableType.forClass(Object.class), null); (canWriteObject ? this.objectWriters : this.typedWriters).add(writer); }
@Nullable static ResolvableType resolveDeclaredEventType(Class<?> listenerType) { ResolvableType eventType = eventTypeCache.get(listenerType); if (eventType == null) { eventType = ResolvableType.forClass(listenerType).as(ApplicationListener.class).getGeneric(); eventTypeCache.put(listenerType, eventType); } return (eventType != ResolvableType.NONE ? eventType : null); }
@Test public void listenerWithPayloadTypeErasure() { // Always accept such event when the type is unknown Method method = ReflectionUtils.findMethod(SampleEvents.class, "handleString", String.class); supportsEventType(true, method, ResolvableType.forClass(PayloadApplicationEvent.class)); }
@Test public void listenerWithSubTypeSeveralGenerics() { Method method = ReflectionUtils.findMethod(SampleEvents.class, "handleString", String.class); supportsEventType(true, method, ResolvableType.forClass(PayloadTestEvent.class)); }
@Override @Test public void canDecode() { assertTrue(decoder.canDecode(forClass(Pojo.class), SMILE_MIME_TYPE)); assertTrue(decoder.canDecode(forClass(Pojo.class), STREAM_SMILE_MIME_TYPE)); assertTrue(decoder.canDecode(forClass(Pojo.class), null)); assertFalse(decoder.canDecode(forClass(String.class), null)); assertFalse(decoder.canDecode(forClass(Pojo.class), APPLICATION_JSON)); }
@Override @Test public void canDecode() { assertTrue(this.decoder.canDecode(forClass(Msg.class), null)); assertTrue(this.decoder.canDecode(forClass(Msg.class), PROTOBUF_MIME_TYPE)); assertTrue(this.decoder.canDecode(forClass(Msg.class), MediaType.APPLICATION_OCTET_STREAM)); assertFalse(this.decoder.canDecode(forClass(Msg.class), MediaType.APPLICATION_JSON)); assertFalse(this.decoder.canDecode(forClass(Object.class), PROTOBUF_MIME_TYPE)); }
@Override @Test public void canDecode() { assertTrue(this.decoder.canDecode(ResolvableType.forClass(byte[].class), MimeTypeUtils.TEXT_PLAIN)); assertFalse(this.decoder.canDecode(ResolvableType.forClass(Integer.class), MimeTypeUtils.TEXT_PLAIN)); assertTrue(this.decoder.canDecode(ResolvableType.forClass(byte[].class), MimeTypeUtils.APPLICATION_JSON)); }
@Test public void canNotEncode() { assertFalse(this.encoder.canEncode(ResolvableType.forClass(String.class), null)); assertFalse(this.encoder.canEncode(ResolvableType.forClass(Pojo.class), APPLICATION_XML)); ResolvableType sseType = ResolvableType.forClass(ServerSentEvent.class); assertFalse(this.encoder.canEncode(sseType, APPLICATION_JSON)); }
@SuppressWarnings("unchecked") private void assertStringDecoder(Decoder<?> decoder, boolean textOnly) { assertEquals(StringDecoder.class, decoder.getClass()); assertTrue(decoder.canDecode(forClass(String.class), MimeTypeUtils.TEXT_PLAIN)); assertEquals(!textOnly, decoder.canDecode(forClass(String.class), MediaType.TEXT_EVENT_STREAM)); Flux<String> flux = (Flux<String>) decoder.decode( Flux.just(new DefaultDataBufferFactory().wrap("line1\nline2".getBytes(StandardCharsets.UTF_8))), ResolvableType.forClass(String.class), MimeTypeUtils.TEXT_PLAIN, Collections.emptyMap()); assertEquals(Arrays.asList("line1", "line2"), flux.collectList().block(Duration.ZERO)); }
@Test public void customMessageConverterConfig() throws Exception { ApplicationContext context = loadConfig(CustomMessageConverterConfig.class); String name = "requestMappingHandlerAdapter"; RequestMappingHandlerAdapter adapter = context.getBean(name, RequestMappingHandlerAdapter.class); assertNotNull(adapter); List<HttpMessageReader<?>> messageReaders = adapter.getMessageReaders(); assertEquals(2, messageReaders.size()); assertHasMessageReader(messageReaders, forClass(String.class), TEXT_PLAIN); assertHasMessageReader(messageReaders, forClass(TestBean.class), APPLICATION_XML); }
@Test // SPR-15331 public void decodeFullContentAsString() { String body = "data:foo\ndata:bar\n\ndata:baz\n\n"; MockServerHttpRequest request = MockServerHttpRequest.post("/") .body(Mono.just(stringBuffer(body))); String actual = messageReader .readMono(ResolvableType.forClass(String.class), request, Collections.emptyMap()) .cast(String.class) .block(Duration.ZERO); assertEquals(body, actual); }
@Test public void resolveTypeVaraibleFromSimpleCollectionSuperclassType() { ResolvableType type = ResolvableType.forClass( MyCollectionSuperclassType.class).as(MySuperclassType.class); assertThat(type.resolveGeneric(), equalTo((Class) Collection.class)); assertThat(type.resolveGeneric(0, 0), equalTo((Class) String.class)); }
@Override @Test public void decode() { String u = "ü"; String e = "é"; String o = "ø"; String s = String.format("%s\n%s\n%s", u, e, o); Flux<DataBuffer> input = toDataBuffers(s, 1, UTF_8); testDecodeAll(input, ResolvableType.forClass(String.class), step -> step .expectNext(u, e, o) .verifyComplete(), null, null); }
@Test public void useNegotiatedMediaTypeCharset() { MediaType negotiatedMediaType = new MediaType("text", "html", ISO_8859_1); HttpMessageWriter<String> writer = getWriter(TEXT_PLAIN_UTF_8, TEXT_HTML); writer.write(Mono.just("body"), forClass(String.class), negotiatedMediaType, this.response, NO_HINTS); assertEquals(negotiatedMediaType, this.response.getHeaders().getContentType()); assertEquals(negotiatedMediaType, this.mediaTypeCaptor.getValue()); }
@Test public void getSuperType() throws Exception { ResolvableType type = ResolvableType.forClass(ExtendsList.class).getSuperType(); assertThat(type.resolve(), equalTo((Class) ArrayList.class)); type = type.getSuperType(); assertThat(type.resolve(), equalTo((Class) AbstractList.class)); type = type.getSuperType(); assertThat(type.resolve(), equalTo((Class) AbstractCollection.class)); type = type.getSuperType(); assertThat(type.resolve(), equalTo((Class) Object.class)); }
@Test public void decodeMultipleXmlRootElement() throws Exception { Mono<DataBuffer> source = stringBuffer(POJO_CHILD); Flux<Object> output = this.decoder.decode(source, ResolvableType.forClass(Pojo.class), null, Collections.emptyMap()); StepVerifier.create(output) .expectNext(new Pojo("foo", "bar")) .expectNext(new Pojo("foofoo", "barbar")) .expectComplete() .verify(); }