root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 8 Packages Projects Releases Wiki Activity

Use List<T> instead of Supplier<Stream<T>> 

This commit changes all methods that return `Supplier<Stream<T>` to
return `List<T>` instead. This includes the HandlerStrategies, but also
BodyInserter.Context, BodyExtractor.Context, and ServerResponse.Context.

The reason for this change is that most of the strategies have some sort
of order, where more specific message readers - for instance - come
before generic ones. Such an ordering can only be enforced through a
List.

Issue: SPR-15578
This commit is contained in:
Arjen Poutsma 2017-05-24 13:48:03 +02:00
parent 01e3561db9
commit 31d1e26c95
28 changed files with 150 additions and 188 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
spring-webflux/src/main/java/org/springframework/web/reactive/function/BodyExtractor.java
View File

@ -16,10 +16,9 @@
package org.springframework.web.reactive.function;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Supplier;
import java.util.stream.Stream;
import org.springframework.http.ReactiveHttpInputMessage;
import org.springframework.http.codec.HttpMessageReader;
@ -52,11 +51,10 @@ public interface BodyExtractor<T, M extends ReactiveHttpInputMessage> {
interface Context {
/**
* Supply a {@linkplain Stream stream} of {@link HttpMessageReader}s
* to be used for body extraction.
* Return the {@link HttpMessageReader}s to be used for body extraction.
* @return the stream of message readers
*/
Supplier<Stream<HttpMessageReader<?>>> messageReaders();
List<HttpMessageReader<?>> messageReaders();
/**
* Optionally return the {@link ServerHttpResponse}, if present.

10
spring-webflux/src/main/java/org/springframework/web/reactive/function/BodyExtractors.java
View File

@ -19,9 +19,7 @@ package org.springframework.web.reactive.function;
import java.util.List;
import java.util.Optional;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.reactivestreams.Publisher;
import reactor.core.publisher.Flux;
@ -197,14 +195,14 @@ public abstract class BodyExtractors {
Function<HttpMessageReader<T>, S> readerFunction, Function<Throwable, S> unsupportedError) {
MediaType contentType = contentType(inputMessage);
Supplier<Stream<HttpMessageReader<?>>> messageReaders = context.messageReaders();
return messageReaders.get()
List<HttpMessageReader<?>> messageReaders = context.messageReaders();
return messageReaders.stream()
.filter(r -> r.canRead(elementType, contentType))
.findFirst()
.map(BodyExtractors::<T>cast)
.map(readerFunction)
.orElseGet(() -> {
List<MediaType> supportedMediaTypes = messageReaders.get()
List<MediaType> supportedMediaTypes = messageReaders.stream()
.flatMap(reader -> reader.getReadableMediaTypes().stream())
.collect(Collectors.toList());
UnsupportedMediaTypeException error =
@ -215,7 +213,7 @@ public abstract class BodyExtractors {
private static <T> HttpMessageReader<T> messageReader(ResolvableType elementType,
MediaType mediaType, BodyExtractor.Context context) {
return context.messageReaders().get()
return context.messageReaders().stream()
.filter(messageReader -> messageReader.canRead(elementType, mediaType))
.findFirst()
.map(BodyExtractors::<T>cast)

8
spring-webflux/src/main/java/org/springframework/web/reactive/function/BodyInserter.java
View File

@ -16,10 +16,9 @@
package org.springframework.web.reactive.function;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Supplier;
import java.util.stream.Stream;
import reactor.core.publisher.Mono;
@ -54,11 +53,10 @@ public interface BodyInserter<T, M extends ReactiveHttpOutputMessage> {
interface Context {
/**
* Supply a {@linkplain Stream stream} of {@link HttpMessageWriter}s
* to be used for response body conversion.
* Return the {@link HttpMessageWriter}s to be used for response body conversion.
* @return the stream of message writers
*/
Supplier<Stream<HttpMessageWriter<?>>> messageWriters();
List<HttpMessageWriter<?>> messageWriters();
/**
* Optionally return the {@link ServerHttpRequest}, if present.

12
spring-webflux/src/main/java/org/springframework/web/reactive/function/BodyInserters.java
View File

@ -18,9 +18,7 @@ package org.springframework.web.reactive.function;
import java.util.List;
import java.util.Optional;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.reactivestreams.Publisher;
import reactor.core.publisher.Mono;
@ -141,7 +139,7 @@ public abstract class BodyInserters {
}
private static HttpMessageWriter<Resource> resourceHttpMessageWriter(BodyInserter.Context context) {
return context.messageWriters().get()
return context.messageWriters().stream()
.filter(messageWriter -> messageWriter.canWrite(RESOURCE_TYPE, null))
.findFirst()
.map(BodyInserters::<Resource>cast)
@ -288,8 +286,8 @@ public abstract class BodyInserters {
return (outputMessage, context) -> {
MediaType contentType = outputMessage.getHeaders().getContentType();
Supplier<Stream<HttpMessageWriter<?>>> messageWriters = context.messageWriters();
return messageWriters.get()
List<HttpMessageWriter<?>> messageWriters = context.messageWriters();
return messageWriters.stream()
.filter(messageWriter -> messageWriter.canWrite(bodyType, contentType))
.findFirst()
.map(BodyInserters::cast)
@ -305,7 +303,7 @@ public abstract class BodyInserters {
}
})
.orElseGet(() -> {
List<MediaType> supportedMediaTypes = messageWriters.get()
List<MediaType> supportedMediaTypes = messageWriters.stream()
.flatMap(reader -> reader.getWritableMediaTypes().stream())
.collect(Collectors.toList());
UnsupportedMediaTypeException error =
@ -318,7 +316,7 @@ public abstract class BodyInserters {
private static <T> HttpMessageWriter<T> findMessageWriter(
BodyInserter.Context context, ResolvableType type, MediaType mediaType) {
return context.messageWriters().get()
return context.messageWriters().stream()
.filter(messageWriter -> messageWriter.canWrite(type, mediaType))
.findFirst()
.map(BodyInserters::<T>cast)

5
spring-webflux/src/main/java/org/springframework/web/reactive/function/client/DefaultClientRequestBuilder.java
View File

@ -18,10 +18,9 @@ package org.springframework.web.reactive.function.client;
import java.net.URI;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Supplier;
import java.util.stream.Stream;
import org.reactivestreams.Publisher;
import reactor.core.publisher.Mono;
@ -187,7 +186,7 @@ class DefaultClientRequestBuilder implements ClientRequest.Builder {
return this.inserter.insert(request, new BodyInserter.Context() {
@Override
public Supplier<Stream<HttpMessageWriter<?>>> messageWriters() {
public List<HttpMessageWriter<?>> messageWriters() {
return strategies.messageWriters();
}

4
spring-webflux/src/main/java/org/springframework/web/reactive/function/client/DefaultClientResponse.java
View File

@ -21,8 +21,6 @@ import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.OptionalLong;
import java.util.function.Supplier;
import java.util.stream.Stream;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
@ -79,7 +77,7 @@ class DefaultClientResponse implements ClientResponse {
public <T> T body(BodyExtractor<T, ? super ClientHttpResponse> extractor) {
return extractor.extract(this.response, new BodyExtractor.Context() {
@Override
public Supplier<Stream<HttpMessageReader<?>>> messageReaders() {
public List<HttpMessageReader<?>> messageReaders() {
return strategies.messageReaders();
}

10
spring-webflux/src/main/java/org/springframework/web/reactive/function/client/DefaultExchangeStrategiesBuilder.java
View File

@ -20,8 +20,6 @@ import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Supplier;
import java.util.stream.Stream;
import org.springframework.http.codec.ClientCodecConfigurer;
import org.springframework.http.codec.HttpMessageReader;
@ -88,13 +86,13 @@ class DefaultExchangeStrategiesBuilder implements ExchangeStrategies.Builder {
}
@Override
public Supplier<Stream<HttpMessageReader<?>>> messageReaders() {
return this.messageReaders::stream;
public List<HttpMessageReader<?>> messageReaders() {
return this.messageReaders;
}
@Override
public Supplier<Stream<HttpMessageWriter<?>>> messageWriters() {
return this.messageWriters::stream;
public List<HttpMessageWriter<?>> messageWriters() {
return this.messageWriters;
}
}

16
spring-webflux/src/main/java/org/springframework/web/reactive/function/client/ExchangeStrategies.java
View File

@ -16,9 +16,8 @@
package org.springframework.web.reactive.function.client;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Supplier;
import java.util.stream.Stream;
import org.springframework.http.codec.ClientCodecConfigurer;
import org.springframework.http.codec.HttpMessageReader;
@ -28,8 +27,7 @@ import org.springframework.http.codec.HttpMessageWriter;
* Defines the strategies for invoking {@link ExchangeFunction}s. An instance of
* this class is immutable; instances are typically created through the mutable {@link Builder}:
* either through {@link #builder()} to set up default strategies, or {@link #empty()} to start
* from scratch. Alternatively, {@code ExchangeStrategies} instances can be created through
* {@link #of(Supplier, Supplier)}.
* from scratch.
*
* @author Brian Clozel
* @author Arjen Poutsma
@ -40,18 +38,16 @@ public interface ExchangeStrategies {
// Instance methods
/**
* Supply a {@linkplain Stream stream} of {@link HttpMessageReader}s to be used for request
* body conversion.
* Return the {@link HttpMessageReader}s to be used for request body conversion.
* @return the stream of message readers
*/
Supplier<Stream<HttpMessageReader<?>>> messageReaders();
List<HttpMessageReader<?>> messageReaders();
/**
* Supply a {@linkplain Stream stream} of {@link HttpMessageWriter}s to be used for response
* body conversion.
* Return the {@link HttpMessageWriter}s to be used for response body conversion.
* @return the stream of message writers
*/
Supplier<Stream<HttpMessageWriter<?>>> messageWriters();
List<HttpMessageWriter<?>> messageWriters();
// Static methods

5
spring-webflux/src/main/java/org/springframework/web/reactive/function/server/DefaultEntityResponseBuilder.java
View File

@ -23,11 +23,10 @@ import java.time.format.DateTimeFormatter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.Supplier;
import java.util.stream.Stream;
import reactor.core.publisher.Mono;
@ -208,7 +207,7 @@ class DefaultEntityResponseBuilder<T> implements EntityResponse.Builder<T> {
writeStatusAndHeaders(response);
return inserter().insert(response, new BodyInserter.Context() {
@Override
public Supplier<Stream<HttpMessageWriter<?>>> messageWriters() {
public List<HttpMessageWriter<?>> messageWriters() {
return context.messageWriters();
}

22
spring-webflux/src/main/java/org/springframework/web/reactive/function/server/DefaultHandlerStrategiesBuilder.java
View File

@ -20,8 +20,6 @@ import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Supplier;
import java.util.stream.Stream;
import org.springframework.http.codec.CodecConfigurer;
import org.springframework.http.codec.HttpMessageReader;
@ -135,28 +133,28 @@ class DefaultHandlerStrategiesBuilder implements HandlerStrategies.Builder {
}
@Override
public Supplier<Stream<HttpMessageReader<?>>> messageReaders() {
return this.messageReaders::stream;
public List<HttpMessageReader<?>> messageReaders() {
return this.messageReaders;
}
@Override
public Supplier<Stream<HttpMessageWriter<?>>> messageWriters() {
return this.messageWriters::stream;
public List<HttpMessageWriter<?>> messageWriters() {
return this.messageWriters;
}
@Override
public Supplier<Stream<ViewResolver>> viewResolvers() {
return this.viewResolvers::stream;
public List<ViewResolver> viewResolvers() {
return this.viewResolvers;
}
@Override
public Supplier<Stream<WebFilter>> webFilters() {
return this.webFilters::stream;
public List<WebFilter> webFilters() {
return this.webFilters;
}
@Override
public Supplier<Stream<WebExceptionHandler>> exceptionHandlers() {
return this.exceptionHandlers::stream;
public List<WebExceptionHandler> exceptionHandlers() {
return this.exceptionHandlers;
}
}

2
spring-webflux/src/main/java/org/springframework/web/reactive/function/server/DefaultRenderingResponseBuilder.java
View File

@ -164,7 +164,7 @@ class DefaultRenderingResponseBuilder implements RenderingResponse.Builder {
writeStatusAndHeaders(response);
MediaType contentType = exchange.getResponse().getHeaders().getContentType();
Locale locale = resolveLocale(exchange);
Stream<ViewResolver> viewResolverStream = context.viewResolvers().get();
Stream<ViewResolver> viewResolverStream = context.viewResolvers().stream();
return Flux.fromStream(viewResolverStream)
.concatMap(viewResolver -> viewResolver.resolveViewName(name(), locale))

18
spring-webflux/src/main/java/org/springframework/web/reactive/function/server/DefaultServerRequest.java
View File

@ -20,6 +20,7 @@ import java.net.InetSocketAddress;
import java.net.URI;
import java.nio.charset.Charset;
import java.security.Principal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Locale;
@ -27,8 +28,6 @@ import java.util.Map;
import java.util.Optional;
import java.util.OptionalLong;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Stream;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
@ -66,15 +65,20 @@ class DefaultServerRequest implements ServerRequest {
private final Headers headers;
private final Supplier<Stream<HttpMessageReader<?>>> messageReaders;
private final List<HttpMessageReader<?>> messageReaders;
DefaultServerRequest(ServerWebExchange exchange, Supplier<Stream<HttpMessageReader<?>>> messageReaders) {
DefaultServerRequest(ServerWebExchange exchange, List<HttpMessageReader<?>> messageReaders) {
this.exchange = exchange;
this.messageReaders = messageReaders;
this.messageReaders = unmodifiableCopy(messageReaders);
this.headers = new DefaultHeaders();
}
private static <T> List<T> unmodifiableCopy(List<? extends T> list) {
return Collections.unmodifiableList(new ArrayList<>(list));
}
@Override
public HttpMethod method() {
@ -102,8 +106,8 @@ class DefaultServerRequest implements ServerRequest {
return extractor.extract(request(),
new BodyExtractor.Context() {
@Override
public Supplier<Stream<HttpMessageReader<?>>> messageReaders() {
return DefaultServerRequest.this.messageReaders;
public List<HttpMessageReader<?>> messageReaders() {
return messageReaders;
}
@Override
public Optional<ServerHttpResponse> serverResponse() {

5
spring-webflux/src/main/java/org/springframework/web/reactive/function/server/DefaultServerResponseBuilder.java
View File

@ -23,12 +23,11 @@ import java.time.format.DateTimeFormatter;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.function.Supplier;
import java.util.stream.Stream;
import org.reactivestreams.Publisher;
import reactor.core.publisher.Mono;
@ -314,7 +313,7 @@ class DefaultServerResponseBuilder implements ServerResponse.BodyBuilder {
writeStatusAndHeaders(response);
return this.inserter.insert(response, new BodyInserter.Context() {
@Override
public Supplier<Stream<HttpMessageWriter<?>>> messageWriters() {
public List<HttpMessageWriter<?>> messageWriters() {
return context.messageWriters();
}

38
spring-webflux/src/main/java/org/springframework/web/reactive/function/server/HandlerStrategies.java
View File

@ -16,9 +16,8 @@
package org.springframework.web.reactive.function.server;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Supplier;
import java.util.stream.Stream;
import org.springframework.http.codec.HttpMessageReader;
import org.springframework.http.codec.HttpMessageWriter;
@ -43,39 +42,34 @@ public interface HandlerStrategies {
// Instance methods
/**
* Supply a {@linkplain Stream stream} of {@link HttpMessageReader}s to be used for request
* body conversion.
* @return the stream of message readers
* Return the {@link HttpMessageReader}s to be used for request body conversion.
* @return the message readers
*/
Supplier<Stream<HttpMessageReader<?>>> messageReaders();
List<HttpMessageReader<?>> messageReaders();
/**
* Supply a {@linkplain Stream stream} of {@link HttpMessageWriter}s to be used for response
* body conversion.
* @return the stream of message writers
* Return the {@link HttpMessageWriter}s to be used for response body conversion.
* @return the message writers
*/
Supplier<Stream<HttpMessageWriter<?>>> messageWriters();
List<HttpMessageWriter<?>> messageWriters();
/**
* Supply a {@linkplain Stream stream} of {@link ViewResolver}s to be used for view name
* resolution.
* @return the stream of view resolvers
* Return the {@link ViewResolver}s to be used for view name resolution.
* @return the view resolvers
*/
Supplier<Stream<ViewResolver>> viewResolvers();
List<ViewResolver> viewResolvers();
/**
* Supply a {@linkplain Stream stream} of {@link WebFilter}s to be used for filtering the
* request and response.
* @return the stream of web filters
* Return the {@link WebFilter}s to be used for filtering the request and response.
* @return the web filters
*/
Supplier<Stream<WebFilter>> webFilters();
List<WebFilter> webFilters();
/**
* Supply a {@linkplain Stream stream} of {@link WebExceptionHandler}s to be used for handling
* exceptions.
* @return the stream of exception handlers
* Return the {@link WebExceptionHandler}s to be used for handling exceptions.
* @return the exception handlers
*/
Supplier<Stream<WebExceptionHandler>> exceptionHandlers();
List<WebExceptionHandler> exceptionHandlers();
// Static methods

49
spring-webflux/src/main/java/org/springframework/web/reactive/function/server/RouterFunctions.java
View File

@ -16,10 +16,10 @@
package org.springframework.web.reactive.function.server;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Stream;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
@ -45,9 +45,6 @@ import org.springframework.web.server.adapter.WebHttpHandlerBuilder;
* <p>Additionally, this class can {@linkplain #toHttpHandler(RouterFunction) transform} a
* {@code RouterFunction} into an {@code HttpHandler}, which can be run in Servlet 3.1+,
* Reactor, or Undertow.
* And it can {@linkplain #toHandlerMapping(RouterFunction, HandlerStrategies) transform} a
* {@code RouterFunction} into an {@code HandlerMapping}, which can be run in a
* {@code DispatcherHandler}.
*
* @author Arjen Poutsma
* @since 5.0
@ -199,10 +196,10 @@ public abstract class RouterFunctions {
Assert.notNull(strategies, "HandlerStrategies must not be null");
WebHandler webHandler = toWebHandler(routerFunction, strategies);
WebHttpHandlerBuilder handlerBuilder = WebHttpHandlerBuilder.webHandler(webHandler);
strategies.webFilters().get().forEach(handlerBuilder::filter);
strategies.exceptionHandlers().get().forEach(handlerBuilder::exceptionHandler);
return handlerBuilder.build();
return WebHttpHandlerBuilder.webHandler(webHandler)
.filters(strategies.webFilters())
.exceptionHandlers(strategies.exceptionHandlers())
.build();
}
/**
@ -222,7 +219,8 @@ public abstract class RouterFunctions {
return routerFunction.route(request)
.defaultIfEmpty(notFound())
.flatMap(handlerFunction -> wrapException(() -> handlerFunction.handle(request)))
.flatMap(response -> wrapException(() -> response.writeTo(exchange, toContext(strategies))));
.flatMap(response -> wrapException(() -> response.writeTo(exchange,
new HandlerStrategiesResponseContext(strategies))));
};
}
@ -235,20 +233,6 @@ public abstract class RouterFunctions {
}
}
private static ServerResponse.Context toContext(HandlerStrategies strategies) {
return new ServerResponse.Context() {
@Override
public Supplier<Stream<HttpMessageWriter<?>>> messageWriters() {
return strategies.messageWriters();
}
@Override
public Supplier<Stream<ViewResolver>> viewResolvers() {
return strategies.viewResolvers();
}
};
}
private static void addAttributes(ServerWebExchange exchange, ServerRequest request) {
Map<String, Object> attributes = exchange.getAttributes();
attributes.put(REQUEST_ATTRIBUTE, request);
@ -332,4 +316,23 @@ public abstract class RouterFunctions {
}
}
private static class HandlerStrategiesResponseContext implements ServerResponse.Context {
private final HandlerStrategies strategies;
public HandlerStrategiesResponseContext(HandlerStrategies strategies) {
this.strategies = strategies;
}
@Override
public List<HttpMessageWriter<?>> messageWriters() {
return this.strategies.messageWriters();
}
@Override
public List<ViewResolver> viewResolvers() {
return this.strategies.viewResolvers();
}
}
}

2
spring-webflux/src/main/java/org/springframework/web/reactive/function/server/ServerRequest.java
View File

@ -187,7 +187,7 @@ public interface ServerRequest {
static ServerRequest create(ServerWebExchange exchange,
List<HttpMessageReader<?>> messageReaders) {
return new DefaultServerRequest(exchange, messageReaders::stream);
return new DefaultServerRequest(exchange, messageReaders);
}
/**

13
spring-webflux/src/main/java/org/springframework/web/reactive/function/server/ServerResponse.java
View File

@ -19,11 +19,10 @@ package org.springframework.web.reactive.function.server;
import java.net.URI;
import java.time.ZonedDateTime;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.function.Supplier;
import java.util.stream.Stream;
import org.reactivestreams.Publisher;
import reactor.core.publisher.Mono;
@ -395,18 +394,16 @@ public interface ServerResponse {
interface Context {
/**
* Supply a {@linkplain Stream stream} of {@link HttpMessageWriter}s
* to be used for response body conversion.
* Return the {@link HttpMessageWriter}s to be used for response body conversion.
* @return the stream of message writers
*/
Supplier<Stream<HttpMessageWriter<?>>> messageWriters();
List<HttpMessageWriter<?>> messageWriters();
/**
* Supply a {@linkplain Stream stream} of {@link ViewResolver}s to be used for view name
* resolution.
* Return the {@link ViewResolver}s to be used for view name resolution.
* @return the stream of view resolvers
*/
Supplier<Stream<ViewResolver>> viewResolvers();
List<ViewResolver> viewResolvers();
}

10
spring-webflux/src/main/java/org/springframework/web/reactive/function/server/support/ServerResponseResultHandler.java
View File

@ -18,8 +18,6 @@ package org.springframework.web.reactive.function.server.support;
import java.util.Collections;
import java.util.List;
import java.util.function.Supplier;
import java.util.stream.Stream;
import reactor.core.publisher.Mono;
@ -99,13 +97,13 @@ public class ServerResponseResultHandler implements HandlerResultHandler, Initia
Assert.state(response != null, "No ServerResponse");
return response.writeTo(exchange, new ServerResponse.Context() {
@Override
public Supplier<Stream<HttpMessageWriter<?>>> messageWriters() {
return messageCodecConfigurer.getWriters()::stream;
public List<HttpMessageWriter<?>> messageWriters() {
return messageCodecConfigurer.getWriters();
}
@Override
public Supplier<Stream<ViewResolver>> viewResolvers() {
return viewResolvers::stream;
public List<ViewResolver> viewResolvers() {
return viewResolvers;
}
});
}

10
spring-webflux/src/test/java/org/springframework/web/reactive/function/BodyExtractorsTests.java
View File

@ -24,8 +24,6 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Supplier;
import java.util.stream.Stream;
import com.fasterxml.jackson.annotation.JsonView;
import org.junit.Before;
@ -86,8 +84,8 @@ public class BodyExtractorsTests {
this.context = new BodyExtractor.Context() {
@Override
public Supplier<Stream<HttpMessageReader<?>>> messageReaders() {
return messageReaders::stream;
public List<HttpMessageReader<?>> messageReaders() {
return messageReaders;
}
@Override
@ -209,8 +207,8 @@ public class BodyExtractorsTests {
BodyExtractor.Context emptyContext = new BodyExtractor.Context() {
@Override
public Supplier<Stream<HttpMessageReader<?>>> messageReaders() {
return Stream::empty;
public List<HttpMessageReader<?>> messageReaders() {
return Collections.emptyList();
}
@Override

10
spring-webflux/src/test/java/org/springframework/web/reactive/function/BodyInsertersTests.java
View File

@ -26,8 +26,6 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Supplier;
import java.util.stream.Stream;
import com.fasterxml.jackson.annotation.JsonView;
import org.junit.Before;
@ -93,8 +91,8 @@ public class BodyInsertersTests {
this.context = new BodyInserter.Context() {
@Override
public Supplier<Stream<HttpMessageWriter<?>>> messageWriters() {
return messageWriters::stream;
public List<HttpMessageWriter<?>> messageWriters() {
return messageWriters;
}
@Override
@ -207,8 +205,8 @@ public class BodyInsertersTests {
MockServerHttpResponse response = new MockServerHttpResponse();
Mono<Void> result = inserter.insert(response, new BodyInserter.Context() {
@Override
public Supplier<Stream<HttpMessageWriter<?>>> messageWriters() {
return Collections.<HttpMessageWriter<?>>singleton(new ResourceHttpMessageWriter())::stream;
public List<HttpMessageWriter<?>> messageWriters() {
return Collections.singletonList(new ResourceHttpMessageWriter());
}
@Override

8
spring-webflux/src/test/java/org/springframework/web/reactive/function/client/DefaultClientRequestBuilderTests.java
View File

@ -34,10 +34,12 @@ import org.springframework.http.codec.HttpMessageWriter;
import org.springframework.mock.http.client.reactive.test.MockClientHttpRequest;
import org.springframework.web.reactive.function.BodyInserter;
import static java.nio.charset.StandardCharsets.*;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
import static org.springframework.http.HttpMethod.*;
import static org.springframework.http.HttpMethod.DELETE;
import static org.springframework.http.HttpMethod.GET;
import static org.springframework.http.HttpMethod.POST;
/**
* @author Arjen Poutsma
@ -107,7 +109,7 @@ public class DefaultClientRequestBuilderTests {
messageWriters.add(new EncoderHttpMessageWriter<>(CharSequenceEncoder.allMimeTypes()));
ExchangeStrategies strategies = mock(ExchangeStrategies.class);
when(strategies.messageWriters()).thenReturn(messageWriters::stream);
when(strategies.messageWriters()).thenReturn(messageWriters);
MockClientHttpRequest request = new MockClientHttpRequest(GET, "/");
result.writeTo(request, strategies).block();

19
spring-webflux/src/test/java/org/springframework/web/reactive/function/client/DefaultClientResponseTests.java
View File

@ -23,7 +23,6 @@ import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.OptionalLong;
import java.util.Set;
import org.junit.Before;
import org.junit.Test;
@ -121,9 +120,9 @@ public class DefaultClientResponseTests {
when(mockResponse.getHeaders()).thenReturn(httpHeaders);
when(mockResponse.getBody()).thenReturn(body);
Set<HttpMessageReader<?>> messageReaders = Collections
.singleton(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes(true)));
when(mockExchangeStrategies.messageReaders()).thenReturn(messageReaders::stream);
List<HttpMessageReader<?>> messageReaders = Collections
.singletonList(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes(true)));
when(mockExchangeStrategies.messageReaders()).thenReturn(messageReaders);
Mono<String> resultMono = defaultClientResponse.body(toMono(String.class));
assertEquals("foo", resultMono.block());
@ -142,9 +141,9 @@ public class DefaultClientResponseTests {
when(mockResponse.getStatusCode()).thenReturn(HttpStatus.OK);
when(mockResponse.getBody()).thenReturn(body);
Set<HttpMessageReader<?>> messageReaders = Collections
.singleton(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes(true)));
when(mockExchangeStrategies.messageReaders()).thenReturn(messageReaders::stream);
List<HttpMessageReader<?>> messageReaders = Collections
.singletonList(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes(true)));
when(mockExchangeStrategies.messageReaders()).thenReturn(messageReaders);
Mono<String> resultMono = defaultClientResponse.bodyToMono(String.class);
assertEquals("foo", resultMono.block());
@ -163,9 +162,9 @@ public class DefaultClientResponseTests {
when(mockResponse.getStatusCode()).thenReturn(HttpStatus.OK);
when(mockResponse.getBody()).thenReturn(body);
Set<HttpMessageReader<?>> messageReaders = Collections
.singleton(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes(true)));
when(mockExchangeStrategies.messageReaders()).thenReturn(messageReaders::stream);
List<HttpMessageReader<?>> messageReaders = Collections
.singletonList(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes(true)));
when(mockExchangeStrategies.messageReaders()).thenReturn(messageReaders);
Flux<String> resultFlux = defaultClientResponse.bodyToFlux(String.class);
Mono<List<String>> result = resultFlux.collectList();

10
spring-webflux/src/test/java/org/springframework/web/reactive/function/client/ExchangeStrategiesTests.java
View File

@ -16,8 +16,6 @@
package org.springframework.web.reactive.function.client;
import java.util.Optional;
import org.junit.Test;
import static org.junit.Assert.*;
@ -30,15 +28,15 @@ public class ExchangeStrategiesTests {
@Test
public void empty() {
ExchangeStrategies strategies = ExchangeStrategies.empty().build();
assertEquals(Optional.empty(), strategies.messageReaders().get().findFirst());
assertEquals(Optional.empty(), strategies.messageWriters().get().findFirst());
assertTrue(strategies.messageReaders().isEmpty());
assertTrue(strategies.messageWriters().isEmpty());
}
@Test
public void withDefaults() {
ExchangeStrategies strategies = ExchangeStrategies.withDefaults();
assertNotEquals(Optional.empty(), strategies.messageReaders().get().findFirst());
assertNotEquals(Optional.empty(), strategies.messageWriters().get().findFirst());
assertFalse(strategies.messageReaders().isEmpty());
assertFalse(strategies.messageWriters().isEmpty());
}
}

10
spring-webflux/src/test/java/org/springframework/web/reactive/function/server/DefaultEntityResponseBuilderTests.java
View File

@ -23,8 +23,6 @@ import java.util.EnumSet;
import java.util.List;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.function.Supplier;
import java.util.stream.Stream;
import org.junit.Test;
import org.reactivestreams.Publisher;
@ -196,13 +194,13 @@ public class DefaultEntityResponseBuilderTests {
ServerResponse.Context context = new ServerResponse.Context() {
@Override
public Supplier<Stream<HttpMessageWriter<?>>> messageWriters() {
return Collections.<HttpMessageWriter<?>>singletonList(new EncoderHttpMessageWriter<>(CharSequenceEncoder.allMimeTypes()))::stream;
public List<HttpMessageWriter<?>> messageWriters() {
return Collections.<HttpMessageWriter<?>>singletonList(new EncoderHttpMessageWriter<>(CharSequenceEncoder.allMimeTypes()));
}
@Override
public Supplier<Stream<ViewResolver>> viewResolvers() {
return Collections.<ViewResolver>emptyList()::stream;
public List<ViewResolver> viewResolvers() {
return Collections.<ViewResolver>emptyList();
}
};
HandlerStrategies strategies = HandlerStrategies.empty()

5
spring-webflux/src/test/java/org/springframework/web/reactive/function/server/DefaultRenderingResponseTests.java
View File

@ -33,8 +33,7 @@ import org.springframework.mock.http.server.reactive.test.MockServerWebExchange;
import org.springframework.web.reactive.result.view.View;
import org.springframework.web.reactive.result.view.ViewResolver;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.*;
/**
* @author Arjen Poutsma
@ -119,7 +118,7 @@ public class DefaultRenderingResponseTests {
viewResolvers.add(viewResolver);
HandlerStrategies mockConfig = mock(HandlerStrategies.class);
when(mockConfig.viewResolvers()).thenReturn(viewResolvers::stream);
when(mockConfig.viewResolvers()).thenReturn(viewResolvers);
StepVerifier.create(result)
.expectNextMatches(response -> "view".equals(response.name()) &&

8
spring-webflux/src/test/java/org/springframework/web/reactive/function/server/DefaultServerRequestTests.java
View File

@ -26,8 +26,6 @@ import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.OptionalLong;
import java.util.function.Supplier;
import java.util.stream.Stream;
import org.junit.Before;
import org.junit.Test;
@ -66,7 +64,7 @@ public class DefaultServerRequestTests {
private ServerWebExchange mockExchange;
Supplier<Stream<HttpMessageReader<?>>> messageReaders;
List<HttpMessageReader<?>> messageReaders;
private DefaultServerRequest defaultRequest;
@ -80,7 +78,7 @@ public class DefaultServerRequestTests {
when(mockExchange.getRequest()).thenReturn(mockRequest);
when(mockExchange.getResponse()).thenReturn(mockResponse);
this.messageReaders = Collections.<HttpMessageReader<?>>singleton(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes(true)))::stream;
this.messageReaders = Collections.<HttpMessageReader<?>>singletonList(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes(true)));
defaultRequest = new DefaultServerRequest(mockExchange, messageReaders);
}
@ -238,7 +236,7 @@ public class DefaultServerRequestTests {
when(mockRequest.getHeaders()).thenReturn(httpHeaders);
when(mockRequest.getBody()).thenReturn(body);
this.messageReaders = Collections.<HttpMessageReader<?>>emptySet()::stream;
this.messageReaders = Collections.emptyList();
this.defaultRequest = new DefaultServerRequest(mockExchange, messageReaders);
Flux<String> resultFlux = defaultRequest.bodyToFlux(String.class);

14
spring-webflux/src/test/java/org/springframework/web/reactive/function/server/HandlerStrategiesTests.java
View File

@ -16,8 +16,6 @@
package org.springframework.web.reactive.function.server;
import java.util.Optional;
import org.junit.Test;
import static org.junit.Assert.*;
@ -30,17 +28,17 @@ public class HandlerStrategiesTests {
@Test
public void empty() {
HandlerStrategies strategies = HandlerStrategies.empty().build();
assertEquals(Optional.empty(), strategies.messageReaders().get().findFirst());
assertEquals(Optional.empty(), strategies.messageWriters().get().findFirst());
assertEquals(Optional.empty(), strategies.viewResolvers().get().findFirst());
assertTrue(strategies.messageReaders().isEmpty());
assertTrue(strategies.messageWriters().isEmpty());
assertTrue(strategies.viewResolvers().isEmpty());
}
@Test
public void withDefaults() {
HandlerStrategies strategies = HandlerStrategies.withDefaults();
assertNotEquals(Optional.empty(), strategies.messageReaders().get().findFirst());
assertNotEquals(Optional.empty(), strategies.messageWriters().get().findFirst());
assertEquals(Optional.empty(), strategies.viewResolvers().get().findFirst());
assertFalse(strategies.messageReaders().isEmpty());
assertFalse(strategies.messageWriters().isEmpty());
assertTrue(strategies.viewResolvers().isEmpty());
}
}

7
spring-webflux/src/test/java/org/springframework/web/reactive/function/server/ResourceHandlerFunctionTests.java
View File

@ -19,8 +19,7 @@ package org.springframework.web.reactive.function.server;
import java.io.IOException;
import java.nio.file.Files;
import java.util.EnumSet;
import java.util.function.Supplier;
import java.util.stream.Stream;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
@ -56,12 +55,12 @@ public class ResourceHandlerFunctionTests {
HandlerStrategies strategies = HandlerStrategies.withDefaults();
context = new ServerResponse.Context() {
@Override
public Supplier<Stream<HttpMessageWriter<?>>> messageWriters() {
public List<HttpMessageWriter<?>> messageWriters() {
return strategies.messageWriters();
}
@Override
public Supplier<Stream<ViewResolver>> viewResolvers() {
public List<ViewResolver> viewResolvers() {
return strategies.viewResolvers();
}
};