DeferredResultSubscriber(DeferredResult<Object> result, ReactiveAdapter adapter, ResolvableType elementType) { this.result = result; this.multiValueSource = adapter.isMultiValue(); this.values = new CollectedValuesList(elementType); }
@Override public boolean isAsyncReturnValue(Object returnValue, MethodParameter returnType) { ReactiveAdapter adapter = this.adapterRegistry.getAdapter(returnType.getParameterType(), returnValue); return (adapter != null && !adapter.isMultiValue() && !adapter.isNoValue()); }
DeferredResultSubscriber(DeferredResult<Object> result, ReactiveAdapter adapter, ResolvableType elementType) { this.result = result; this.multiValueSource = adapter.isMultiValue(); this.values = new CollectedValuesList(elementType); }
if (adapter != null) { names.add(entry.getKey()); if (adapter.isMultiValue()) { Flux<Object> fluxValue = Flux.from(adapter.toPublisher(value)); valueMonos.add(fluxValue.collectList().defaultIfEmpty(Collections.emptyList()));
Optional<MediaType> mediaType = mediaTypes.stream().filter(MimeType::isConcrete).findFirst(); if (adapter.isMultiValue()) { if (mediaTypes.stream().anyMatch(MediaType.TEXT_EVENT_STREAM::includes) || ServerSentEvent.class.isAssignableFrom(elementClass)) {
private Mono<?> prepareAttributeMono(String attributeName, ResolvableType attributeType, BindingContext context, ServerWebExchange exchange) { Object attribute = context.getModel().asMap().get(attributeName); if (attribute == null) { attribute = findAndRemoveReactiveAttribute(context.getModel(), attributeName); } if (attribute == null) { return createAttribute(attributeName, attributeType.toClass(), context, exchange); } ReactiveAdapter adapterFrom = getAdapterRegistry().getAdapter(null, attribute); if (adapterFrom != null) { Assert.isTrue(!adapterFrom.isMultiValue(), "Data binding only supports single-value async types"); return Mono.from(adapterFrom.toPublisher(attribute)); } else { return Mono.justOrEmpty(attribute); } }
parts = (adapter.isMultiValue() ? parts : parts.take(1)); return Mono.just(adapter.fromPublisher(parts)); if (adapter.isMultiValue()) { return Mono.just(decodePartValues(parts, elementType, bindingContext, exchange, isRequired));
ResolvableType valueType = (adapter != null ? type.getGeneric() : type); Assert.state(adapter == null || !adapter.isMultiValue(), () -> getClass().getSimpleName() + " does not support multi-value reactive type wrapper: " + parameter.getGenericParameterType());
Assert.isTrue(!adapter.isMultiValue(), "Only a single ResponseEntity supported"); returnValueMono = Mono.from(adapter.toPublisher(result.getReturnValue())); bodyParameter = actualParameter.nested().nested();
Optional<MediaType> mediaType = mediaTypes.stream().filter(MimeType::isConcrete).findFirst(); if (adapter.isMultiValue()) { if (mediaTypes.stream().anyMatch(MediaType.TEXT_EVENT_STREAM::includes) || ServerSentEvent.class.isAssignableFrom(elementClass)) {
if (adapter.isMultiValue()) { throw new IllegalArgumentException( "Multi-value reactive types not supported in view resolution: " + result.getReturnType());
if (reader.canRead(elementType, mediaType)) { Map<String, Object> readHints = Hints.from(Hints.LOG_PREFIX_HINT, exchange.getLogPrefix()); if (adapter != null && adapter.isMultiValue()) { if (logger.isDebugEnabled()) { logger.debug(exchange.getLogPrefix() + "0..N [" + elementType + "]");
@Override public boolean isAsyncReturnValue(Object returnValue, MethodParameter returnType) { ReactiveAdapter adapter = this.adapterRegistry.getAdapter(returnType.getParameterType(), returnValue); return (adapter != null && !adapter.isMultiValue() && !adapter.isNoValue()); }
if (adapter != null && adapter.isMultiValue()) { Flux<?> flux = httpMessageReader.read(bodyType, elementType, request, response, readHints); return Mono.just(adapter.fromPublisher(flux));
DeferredResultSubscriber(DeferredResult<Object> result, ReactiveAdapter adapter, ResolvableType elementType) { this.result = result; this.multiValueSource = adapter.isMultiValue(); this.values = new CollectedValuesList(elementType); }
@Override public boolean isAsyncReturnValue(Object returnValue, MethodParameter returnType) { ReactiveAdapter adapter = this.adapterRegistry.getAdapter(returnType.getParameterType(), returnValue); return (adapter != null && !adapter.isMultiValue() && !adapter.isNoValue()); }
@Override public boolean isAsyncReturnValue(Object returnValue, MethodParameter returnType) { ReactiveAdapter adapter = this.adapterRegistry.getAdapter(returnType.getParameterType(), returnValue); return (adapter != null && !adapter.isMultiValue() && !adapter.isNoValue()); }
private Mono<?> getAttributeMono(String attributeName, Class<?> attributeType, MethodParameter param, BindingContext context, ServerWebExchange exchange) { Object attribute = context.getModel().asMap().get(attributeName); if (attribute == null) { attribute = createAttribute(attributeName, attributeType, param, context, exchange); } if (attribute != null) { ReactiveAdapter adapterFrom = getAdapterRegistry().getAdapter(null, attribute); if (adapterFrom != null) { Assert.isTrue(!adapterFrom.isMultiValue(), "Data binding supports single-value async types."); return Mono.from(adapterFrom.toPublisher(attribute)); } } return Mono.justOrEmpty(attribute); }
@Override public boolean supportsParameter(MethodParameter parameter) { if (parameter.hasParameterAnnotation(ModelAttribute.class)) { return true; } if (this.useDefaultResolution) { Class<?> clazz = parameter.getParameterType(); ReactiveAdapter adapter = getAdapterRegistry().getAdapter(clazz); if (adapter != null) { if (adapter.isNoValue() || adapter.isMultiValue()) { return false; } clazz = ResolvableType.forMethodParameter(parameter).getGeneric(0).getRawClass(); } return !BeanUtils.isSimpleProperty(clazz); } return false; }
@Override public boolean supports(HandlerResult result) { Class<?> returnType = result.getReturnType().getRawClass(); if (isSupportedType(returnType)) { return true; } else { ReactiveAdapter adapter = getAdapterRegistry().getAdapter(returnType, result.getReturnValue()); if (adapter != null && !adapter.isMultiValue() && !adapter.isNoValue()) { ResolvableType genericType = result.getReturnType().getGeneric(0); return isSupportedType(genericType.getRawClass()); } } return false; }