/** * Provide the TaskScheduler to use for SockJS endpoints for which a task * scheduler has not been explicitly registered. This method must be called * prior to {@link #getHandlerMapping()}. */ protected void setTaskScheduler(TaskScheduler scheduler) { this.registrations.stream() .map(ServletWebSocketHandlerRegistration::getSockJsServiceRegistration) .filter(Objects::nonNull) .filter(r -> r.getTaskScheduler() == null) .forEach(registration -> registration.setTaskScheduler(scheduler)); }
private static <T> HttpMessageWriter<T> findWriter( BodyInserter.Context context, ResolvableType elementType, @Nullable MediaType mediaType) { return context.messageWriters().stream() .filter(messageWriter -> messageWriter.canWrite(elementType, mediaType)) .findFirst() .map(BodyInserters::<T>cast) .orElseThrow(() -> new IllegalStateException( "No HttpMessageWriter for \"" + mediaType + "\" and \"" + elementType + "\"")); }
@Test public void convertFromStreamToRawList() throws NoSuchFieldException { Stream<Integer> stream = Arrays.asList(1, 2, 3).stream(); TypeDescriptor listOfStrings = new TypeDescriptor(Types.class.getField("rawList")); Object result = this.conversionService.convert(stream, listOfStrings); assertNotNull("Converted object must not be null", result); assertTrue("Converted object must be a list", result instanceof List); @SuppressWarnings("unchecked") List<Object> content = (List<Object>) result; assertEquals(1, content.get(0)); assertEquals(2, content.get(1)); assertEquals(3, content.get(2)); assertEquals("Wrong number of elements", 3, content.size()); }
@Test public void testEntries() { map.set("foo", Arrays.<String>asList("foo_value_1", "foo_value_2")); List<Map.Entry<String, String>> entries = map.entries(); assertEquals(entries.size(), 1); assertEquals("foo", entries.get(0).getKey()); assertEquals("foo_value_1", entries.get(0).getValue()); map.set("bar", "bar_value"); Map<String, String> collected = map.entries().stream().collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); assertEquals("foo_value_1", collected.get("foo")); assertEquals("bar_value", collected.get("bar")); }
/** * Return declared "consumable" types but only among those that also * match the "methods" condition. */ public Set<MediaType> getConsumableMediaTypes() { return this.partialMatches.stream().filter(PartialMatch::hasMethodsMatch). flatMap(m -> m.getInfo().getConsumesCondition().getConsumableMediaTypes().stream()). collect(Collectors.toCollection(LinkedHashSet::new)); }
@Test public void convertFromStreamToList() throws NoSuchFieldException { this.conversionService.addConverter(Number.class, String.class, new ObjectToStringConverter()); Stream<Integer> stream = Arrays.asList(1, 2, 3).stream(); TypeDescriptor listOfStrings = new TypeDescriptor(Types.class.getField("listOfStrings")); Object result = this.conversionService.convert(stream, listOfStrings); assertNotNull("Converted object must not be null", result); assertTrue("Converted object must be a list", result instanceof List); @SuppressWarnings("unchecked") List<String> content = (List<String>) result; assertEquals("1", content.get(0)); assertEquals("2", content.get(1)); assertEquals("3", content.get(2)); assertEquals("Wrong number of elements", 3, content.size()); }
private void assertDecoderInstance(Decoder<?> decoder) { assertSame(decoder, this.configurer.getReaders().stream() .filter(writer -> writer instanceof DecoderHttpMessageReader) .map(writer -> ((DecoderHttpMessageReader<?>) writer).getDecoder()) .filter(e -> decoder.getClass().equals(e.getClass())) .findFirst() .filter(e -> e == decoder).orElse(null)); }
/** * Return declared "producible" types but only among those that also * match the "methods" and "consumes" conditions. */ public Set<MediaType> getProducibleMediaTypes() { return this.partialMatches.stream().filter(PartialMatch::hasConsumesMatch). flatMap(m -> m.getInfo().getProducesCondition().getProducibleMediaTypes().stream()). collect(Collectors.toCollection(LinkedHashSet::new)); }
private static <T> HttpMessageReader<T> findReader( ResolvableType elementType, MediaType mediaType, BodyExtractor.Context context) { return context.messageReaders().stream() .filter(messageReader -> messageReader.canRead(elementType, mediaType)) .findFirst() .map(BodyExtractors::<T>cast) .orElseThrow(() -> new IllegalStateException( "No HttpMessageReader for \"" + mediaType + "\" and \"" + elementType + "\"")); }
@Test public void conditionalConversionForAllTypes() { MyConditionalGenericConverter converter = new MyConditionalGenericConverter(); conversionService.addConverter(converter); assertEquals((Integer) 3, conversionService.convert(3, Integer.class)); assertThat(converter.getSourceTypes().size(), greaterThan(2)); assertTrue(converter.getSourceTypes().stream().allMatch(td -> Integer.class.equals(td.getType()))); }
private void assertEncoderInstance(Encoder<?> encoder) { assertSame(encoder, this.configurer.getWriters().stream() .filter(writer -> writer instanceof EncoderHttpMessageWriter) .map(writer -> ((EncoderHttpMessageWriter<?>) writer).getEncoder()) .filter(e -> encoder.getClass().equals(e.getClass())) .findFirst() .filter(e -> e == encoder).orElse(null)); }
public DefaultExchangeFunction(ClientHttpConnector connector, ExchangeStrategies strategies) { Assert.notNull(connector, "ClientHttpConnector must not be null"); Assert.notNull(strategies, "ExchangeStrategies must not be null"); this.connector = connector; this.strategies = strategies; strategies.messageWriters().stream() .filter(LoggingCodecSupport.class::isInstance) .forEach(reader -> { if (((LoggingCodecSupport) reader).isEnableLoggingRequestDetails()) { this.enableLoggingRequestDetails = true; } }); }
@Override protected WebExchangeDataBinder initDataBinder(WebExchangeDataBinder dataBinder, ServerWebExchange exchange) { this.binderMethods.stream() .filter(binderMethod -> { InitBinder ann = binderMethod.getMethodAnnotation(InitBinder.class); Assert.state(ann != null, "No InitBinder annotation"); String[] names = ann.value(); return (ObjectUtils.isEmpty(names) || ObjectUtils.containsElement(names, dataBinder.getObjectName())); }) .forEach(method -> invokeBinderMethod(dataBinder, exchange, method)); return dataBinder; }
@Test public void jackson2EncoderOverride() { Jackson2JsonEncoder encoder = new Jackson2JsonEncoder(); this.configurer.defaultCodecs().jackson2JsonEncoder(encoder); assertSame(encoder, this.configurer.getWriters().stream() .filter(writer -> ServerSentEventHttpMessageWriter.class.equals(writer.getClass())) .map(writer -> (ServerSentEventHttpMessageWriter) writer) .findFirst() .map(ServerSentEventHttpMessageWriter::getEncoder) .filter(e -> e == encoder).orElse(null)); }