private boolean isAsyncVoidType(ResolvableType type, @Nullable ReactiveAdapter adapter) { return (adapter != null && (adapter.isNoValue() || type.resolveGeneric() == Void.class)); }
private void assertHasValues(ReactiveAdapter adapter, MethodParameter param) { if (adapter.isNoValue()) { throw new IllegalArgumentException( "No value reactive types not supported: " + param.getGenericParameterType()); } }
private static boolean isAsyncVoidReturnType(MethodParameter returnType, @Nullable ReactiveAdapter adapter) { if (adapter != null && adapter.supportsEmpty()) { if (adapter.isNoValue()) { return true; } Type parameterType = returnType.getGenericParameterType(); if (parameterType instanceof ParameterizedType) { ParameterizedType type = (ParameterizedType) parameterType; if (type.getActualTypeArguments().length == 1) { return Void.class.equals(type.getActualTypeArguments()[0]); } } } return false; }
@Override public boolean isAsyncReturnValue(Object returnValue, MethodParameter returnType) { ReactiveAdapter adapter = this.adapterRegistry.getAdapter(returnType.getParameterType(), returnValue); return (adapter != null && !adapter.isMultiValue() && !adapter.isNoValue()); }
private ResolvableType getElementType(ReactiveAdapter adapter, ResolvableType genericType) { if (adapter.isNoValue()) { return ResolvableType.forClass(Void.class); } else if (genericType != ResolvableType.NONE) { return genericType; } else { return ResolvableType.forClass(Object.class); } }
@Override public boolean supports(HandlerResult result) { if (hasModelAnnotation(result.getReturnTypeSource())) { return true; } Class<?> type = result.getReturnType().toClass(); ReactiveAdapter adapter = getAdapter(result); if (adapter != null) { if (adapter.isNoValue()) { return true; } type = result.getReturnType().getGeneric().toClass(); } return (CharSequence.class.isAssignableFrom(type) || Rendering.class.isAssignableFrom(type) || Model.class.isAssignableFrom(type) || Map.class.isAssignableFrom(type) || void.class.equals(type) || View.class.isAssignableFrom(type) || !BeanUtils.isSimpleProperty(type)); }
@Override public boolean supports(HandlerResult result) { Class<?> valueType = resolveReturnValueType(result); if (isSupportedType(valueType)) { return true; } ReactiveAdapter adapter = getAdapter(result); return adapter != null && !adapter.isNoValue() && isSupportedType(result.getReturnType().getGeneric().toClass()); }
Mono.from(adapter.toPublisher(result.getReturnValue())) : Mono.empty()); valueType = (adapter.isNoValue() ? ResolvableType.forClass(Void.class) : result.getReturnType().getGeneric());
@Override public boolean isAsyncReturnValue(Object returnValue, MethodParameter returnType) { ReactiveAdapter adapter = this.adapterRegistry.getAdapter(returnType.getParameterType(), returnValue); return (adapter != null && !adapter.isMultiValue() && !adapter.isNoValue()); }
private ResolvableType getElementType(ReactiveAdapter adapter, ResolvableType genericType) { if (adapter.isNoValue()) { return ResolvableType.forClass(Void.class); } else if (genericType != ResolvableType.NONE) { return genericType; } else { return ResolvableType.forClass(Object.class); } }
@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 boolean isHttpEntityType(HandlerResult result) { Class<?> rawClass = result.getReturnType().getRawClass(); if (HttpEntity.class.isAssignableFrom(rawClass)) { return true; } else { ReactiveAdapter adapter = getAdapterRegistry().getAdapter(rawClass, result.getReturnValue()); if (adapter != null && !adapter.isNoValue()) { ResolvableType genericType = result.getReturnType().getGeneric(0); if (HttpEntity.class.isAssignableFrom(genericType.getRawClass())) { return true; } } } return false; }
@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; }
.map(value -> Mono.from(adapter.toPublisher(value))) .orElse(Mono.empty()); elementType = !adapter.isNoValue() ? parameterType.getGeneric(0) : ResolvableType.forClass(Void.class);
@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; }
@Override public boolean supports(HandlerResult result) { Class<?> clazz = result.getReturnType().getRawClass(); if (hasModelAttributeAnnotation(result)) { return true; } Optional<Object> optional = result.getReturnValue(); ReactiveAdapter adapter = getAdapterRegistry().getAdapter(clazz, optional); if (adapter != null) { if (adapter.isNoValue()) { return true; } else { clazz = result.getReturnType().getGeneric(0).getRawClass(); return isSupportedType(clazz); } } else if (isSupportedType(clazz)) { return true; } return false; }
if (adapter != null) { publisher = adapter.toPublisher(body); elementType = adapter.isNoValue() ? ResolvableType.forClass(Void.class) : valueType.getGeneric(0);