@Override public Mono<Object> resolveArgument( MethodParameter parameter, BindingContext bindingContext, ServerWebExchange exchange) { Class<?> entityType = parameter.getParameterType(); return readBody(parameter.nested(), parameter, false, bindingContext, exchange) .map(body -> createEntity(body, entityType, exchange.getRequest())) .defaultIfEmpty(createEntity(null, entityType, exchange.getRequest())); }
@Override public boolean supportsParameter(MethodParameter parameter) { return checkParameterTypeNoReactiveWrapper(parameter, type -> HttpEntity.class.equals(type) || RequestEntity.class.equals(type)); }
private void testSupports(MethodParameter parameter) { assertTrue(this.resolver.supportsParameter(parameter)); }
result.add(new HttpEntityArgumentResolver(readers, reactiveRegistry));
@Override public Mono<Object> resolveArgument(MethodParameter param, BindingContext bindingContext, ServerWebExchange exchange) { ResolvableType entityType = ResolvableType.forMethodParameter(param); MethodParameter bodyParameter = new MethodParameter(param); bodyParameter.increaseNestingLevel(); return readBody(bodyParameter, false, bindingContext, exchange) .map(body -> createHttpEntity(body, entityType, exchange)) .defaultIfEmpty(createHttpEntity(null, entityType, exchange)); }
@SuppressWarnings("unchecked") private <T> T resolveValue(ServerWebExchange exchange, ResolvableType type) { MethodParameter param = this.testMethod.arg(type); Mono<Object> result = this.resolver.resolveArgument(param, new BindingContext(), exchange); Object value = result.block(Duration.ofSeconds(5)); assertNotNull(value); assertTrue("Unexpected return value type: " + value.getClass(), param.getParameterType().isAssignableFrom(value.getClass())); return (T) value; }
private HttpEntityArgumentResolver createResolver() { List<HttpMessageReader<?>> readers = new ArrayList<>(); readers.add(new DecoderHttpMessageReader<>(StringDecoder.allMimeTypes())); return new HttpEntityArgumentResolver(readers, ReactiveAdapterRegistry.getSharedInstance()); }
@SuppressWarnings("unchecked") private <T> HttpEntity<T> resolveValueWithEmptyBody(ResolvableType type) { ServerWebExchange exchange = MockServerWebExchange.from(post("/path")); MethodParameter param = this.testMethod.arg(type); Mono<Object> result = this.resolver.resolveArgument(param, new BindingContext(), exchange); HttpEntity<String> httpEntity = (HttpEntity<String>) result.block(Duration.ofSeconds(5)); assertEquals(exchange.getRequest().getHeaders(), httpEntity.getHeaders()); return (HttpEntity<T>) httpEntity; }
resolvers.add(new HttpEntityArgumentResolver(getMessageReaders(), getReactiveAdapterRegistry())); resolvers.add(new ModelArgumentResolver()); resolvers.add(new ErrorsMethodArgumentResolver(getReactiveAdapterRegistry()));
@Test public void doesNotSupport() throws Exception { assertFalse(this.resolver.supportsParameter(this.testMethod.arg(Mono.class, String.class))); assertFalse(this.resolver.supportsParameter(this.testMethod.arg(String.class))); try { this.resolver.supportsParameter(this.testMethod.arg(Mono.class, httpEntityType(String.class))); fail(); } catch (IllegalStateException ex) { assertTrue("Unexpected error message:\n" + ex.getMessage(), ex.getMessage().startsWith( "HttpEntityArgumentResolver doesn't support reactive type wrapper")); } }