/** * Return a new {@code HandlerStrategies} with default initialization. * @return the new {@code HandlerStrategies} */ static HandlerStrategies withDefaults() { return builder().build(); }
@Test public void withDefaults() { HandlerStrategies strategies = HandlerStrategies.withDefaults(); assertFalse(strategies.messageReaders().isEmpty()); assertFalse(strategies.messageWriters().isEmpty()); assertTrue(strategies.viewResolvers().isEmpty()); }
@Test public void empty() { HandlerStrategies strategies = HandlerStrategies.empty().build(); assertTrue(strategies.messageReaders().isEmpty()); assertTrue(strategies.messageWriters().isEmpty()); assertTrue(strategies.viewResolvers().isEmpty()); }
public DefaultServerRequest(ServerWebExchange exchange) { this(exchange, HandlerStrategies.withDefaults().messageReaders()); }
@Override protected WebHttpHandlerBuilder initHttpHandlerBuilder() { WebHandler webHandler = RouterFunctions.toWebHandler(this.routerFunction, this.handlerStrategies); return WebHttpHandlerBuilder.webHandler(webHandler) .filters(filters -> filters.addAll(this.handlerStrategies.webFilters())) .exceptionHandlers(handlers -> handlers.addAll(this.handlerStrategies.exceptionHandlers())) .localeContextResolver(this.handlerStrategies.localeContextResolver()); }
/** * Convert the given {@linkplain RouterFunction router function} into a {@link WebHandler}. * This conversion uses {@linkplain HandlerStrategies#builder() default strategies}. * @param routerFunction the router function to convert * @return a web handler that handles web request using the given router function */ public static WebHandler toWebHandler(RouterFunction<?> routerFunction) { return toWebHandler(routerFunction, HandlerStrategies.withDefaults()); }
@Override public List<ViewResolver> viewResolvers() { return this.strategies.viewResolvers(); } }
@Override public List<HttpMessageWriter<?>> messageWriters() { return this.strategies.messageWriters(); }
/** * Convert the given {@linkplain RouterFunction router function} into a {@link WebHandler}, * using the given strategies. * @param routerFunction the router function to convert * @param strategies the strategies to use * @return a web handler that handles web request using the given router function */ public static WebHandler toWebHandler(RouterFunction<?> routerFunction, HandlerStrategies strategies) { Assert.notNull(routerFunction, "RouterFunction must not be null"); Assert.notNull(strategies, "HandlerStrategies must not be null"); return exchange -> { ServerRequest request = new DefaultServerRequest(exchange, strategies.messageReaders()); addAttributes(exchange, request); return routerFunction.route(request) .defaultIfEmpty(notFound()) .flatMap(handlerFunction -> wrapException(() -> handlerFunction.handle(request))) .flatMap(response -> wrapException(() -> response.writeTo(exchange, new HandlerStrategiesResponseContext(strategies)))); }; }
private HttpWebHandlerAdapter httpHandler(GenericApplicationContext context) { return (HttpWebHandlerAdapter) RouterFunctions.toHttpHandler( context.getBean(RouterFunction.class), HandlerStrategies.empty() .exceptionHandler(context.getBean(WebExceptionHandler.class)) .codecs(config -> config.registerDefaults(true)).build()); }
public ModifyRequestBodyGatewayFilterFactory() { super(Config.class); this.messageReaders = HandlerStrategies.withDefaults().messageReaders(); }
/** * Convert the given {@linkplain RouterFunction router function} into a {@link HttpHandler}, * using the given strategies. * <p>The returned {@code HttpHandler} can be adapted to run in * <ul> * <li>Servlet 3.1+ using the * {@link org.springframework.http.server.reactive.ServletHttpHandlerAdapter},</li> * <li>Reactor using the * {@link org.springframework.http.server.reactive.ReactorHttpHandlerAdapter},</li> * <li>Undertow using the * {@link org.springframework.http.server.reactive.UndertowHttpHandlerAdapter}.</li> * </ul> * @param routerFunction the router function to convert * @param strategies the strategies to use * @return an http handler that handles HTTP request using the given router function */ public static HttpHandler toHttpHandler(RouterFunction<?> routerFunction, HandlerStrategies strategies) { WebHandler webHandler = toWebHandler(routerFunction, strategies); return WebHttpHandlerBuilder.webHandler(webHandler) .filters(filters -> filters.addAll(strategies.webFilters())) .exceptionHandlers(handlers -> handlers.addAll(strategies.exceptionHandlers())) .localeContextResolver(strategies.localeContextResolver()) .build(); }
protected HandlerStrategies handlerStrategies() { return HandlerStrategies.withDefaults(); }
@Override public List<ViewResolver> viewResolvers() { return this.strategies.viewResolvers(); } }
@Override public List<HttpMessageWriter<?>> messageWriters() { return this.strategies.messageWriters(); }
@Override public Supplier<Stream<HttpMessageReader<?>>> messageReaders() { return DefaultServerRequest.this.strategies.messageReaders(); } @Override
private HttpHandler httpHandler(GenericApplicationContext context) { return RouterFunctions.toHttpHandler(context.getBean(RouterFunction.class), HandlerStrategies.empty() .exceptionHandler(context.getBean(WebExceptionHandler.class)) .codecs(config -> config.registerDefaults(true)).build()); }
@Test public void options() { MockServerWebExchange exchange = MockServerWebExchange.from(MockServerHttpRequest.options("http://localhost")); MockServerHttpResponse mockResponse = exchange.getResponse(); ServerRequest request = new DefaultServerRequest(exchange, HandlerStrategies.withDefaults().messageReaders()); Mono<ServerResponse> responseMono = this.handlerFunction.handle(request); Mono<Void> result = responseMono.flatMap(response -> { assertEquals(HttpStatus.OK, response.statusCode()); assertEquals(EnumSet.of(HttpMethod.GET, HttpMethod.HEAD, HttpMethod.OPTIONS), response.headers().getAllow()); return response.writeTo(exchange, context); }); StepVerifier.create(result) .expectComplete() .verify(); assertEquals(HttpStatus.OK, mockResponse.getStatusCode()); assertEquals(EnumSet.of(HttpMethod.GET, HttpMethod.HEAD, HttpMethod.OPTIONS), mockResponse.getHeaders().getAllow()); StepVerifier.create(mockResponse.getBody()).expectComplete().verify(); }
@Override protected HandlerStrategies handlerStrategies() { return HandlerStrategies.builder() .viewResolver(new DummyViewResolver()) .build(); }
@Override protected WebHttpHandlerBuilder initHttpHandlerBuilder() { WebHandler webHandler = RouterFunctions.toWebHandler(this.routerFunction, this.handlerStrategies); return WebHttpHandlerBuilder.webHandler(webHandler) .filters(filters -> filters.addAll(this.handlerStrategies.webFilters())) .exceptionHandlers(handlers -> handlers.addAll(this.handlerStrategies.exceptionHandlers())) .localeContextResolver(this.handlerStrategies.localeContextResolver()); }