public ReactiveMongoParameterAccessor(MongoQueryMethod method, Object[] values) { super(method, values); this.values = values; this.subscriptions = new ArrayList<>(values.length); for (int i = 0; i < values.length; i++) { Object value = values[i]; if (value == null || !ReactiveWrappers.supports(value.getClass())) { subscriptions.add(null); continue; } if (ReactiveWrappers.isSingleValueType(value.getClass())) { subscriptions.add(ReactiveWrapperConverters.toWrapper(value, Mono.class).toProcessor()); } else { subscriptions.add(ReactiveWrapperConverters.toWrapper(value, Flux.class).collectList().toProcessor()); } } }
/** * Check if the given {@link org.springframework.data.repository.query.QueryMethod} receives a reactive parameter * wrapper as one of its parameters. * * @return */ public boolean hasReactiveWrapperParameter() { for (ElasticsearchParameter param : getParameters()) { if (ReactiveWrapperConverters.supports(param.getType())) { return true; } } return false; }
/** * {@link Predicate} to check whether a method parameter is a {@link #isNonUnwrappingWrapper(Class)} and can be * converted into a different wrapper. Usually {@link rx.Observable} to {@link org.reactivestreams.Publisher} * conversion. * * @return */ private static Predicate<ParameterOverrideCriteria> wrapperConversionMatch() { return (parameterCriteria) -> isNonUnwrappingWrapper(parameterCriteria.getBaseType()) // && isNonUnwrappingWrapper(parameterCriteria.getDeclaredType()) // && ReactiveWrapperConverters.canConvert(parameterCriteria.getDeclaredType(), parameterCriteria.getBaseType()); }
/** * {@link Predicate} to check whether a method parameter is a {@link #isNonUnwrappingWrapper(Class)} and can be * converted into a different wrapper. Usually {@link rx.Observable} to {@link org.reactivestreams.Publisher} * conversion. * * @return */ private static Predicate<ParameterOverrideCriteria> wrapperConversionMatch() { return (parameterCriteria) -> isNonUnwrappingWrapper(parameterCriteria.getBaseType()) // && isNonUnwrappingWrapper(parameterCriteria.getDeclaredType()) // && ReactiveWrapperConverters.canConvert(parameterCriteria.getDeclaredType(), parameterCriteria.getBaseType()); }
/** * Creates a new {@link ElasticsearchParametersParameterAccessor}. * * @param method must not be {@literal null}. * @param values must not be {@literal null}. */ ReactiveElasticsearchParametersParameterAccessor(ReactiveElasticsearchQueryMethod method, Object[] values) { super(method, values); this.subscriptions = new ArrayList<>(values.length); for (int i = 0; i < values.length; i++) { Object value = values[i]; if (value == null || !ReactiveWrappers.supports(value.getClass())) { subscriptions.add(null); continue; } if (ReactiveWrappers.isSingleValueType(value.getClass())) { subscriptions.add(ReactiveWrapperConverters.toWrapper(value, Mono.class).toProcessor()); } else { subscriptions.add(ReactiveWrapperConverters.toWrapper(value, Flux.class).collectList().toProcessor()); } } }
/** * Check if the given {@link org.springframework.data.repository.query.QueryMethod} receives a reactive parameter * wrapper as one of its parameters. * * @return */ public boolean hasReactiveWrapperParameter() { for (MongoParameter mongoParameter : getParameters()) { if (ReactiveWrapperConverters.supports(mongoParameter.getType())) { return true; } } return false; }
/** * {@link Predicate} to check whether a method parameter is a {@link #isNonUnwrappingWrapper(Class)} and can be * converted into a different wrapper. Usually {@link rx.Observable} to {@link org.reactivestreams.Publisher} * conversion. * * @return */ private static Predicate<ParameterOverrideCriteria> wrapperConversionMatch() { return (parameterCriteria) -> isNonUnwrappingWrapper(parameterCriteria.getBaseType()) // && isNonUnwrappingWrapper(parameterCriteria.getDeclaredType()) // && ReactiveWrapperConverters.canConvert(parameterCriteria.getDeclaredType(), parameterCriteria.getBaseType()); }
public ReactiveMongoParameterAccessor(MongoQueryMethod method, Object[] values) { super(method, values); this.values = values; this.subscriptions = new ArrayList<>(values.length); for (int i = 0; i < values.length; i++) { Object value = values[i]; if (value == null || !ReactiveWrappers.supports(value.getClass())) { subscriptions.add(null); continue; } if (ReactiveWrappers.isSingleValueType(value.getClass())) { subscriptions.add(ReactiveWrapperConverters.toWrapper(value, Mono.class).toProcessor()); } else { subscriptions.add(ReactiveWrapperConverters.toWrapper(value, Flux.class).collectList().toProcessor()); } } }
/** * Check if the given {@link org.springframework.data.repository.query.QueryMethod} receives a reactive parameter * wrapper as one of its parameters. * * @return */ public boolean hasReactiveWrapperParameter() { for (MongoParameter mongoParameter : getParameters()) { if (ReactiveWrapperConverters.supports(mongoParameter.getType())) { return true; } } return false; }
/** * {@link Predicate} to check whether a method parameter is a {@link #isNonUnwrappingWrapper(Class)} and can be * converted into a different wrapper. Usually {@link rx.Observable} to {@link org.reactivestreams.Publisher} * conversion. * * @return */ private static Predicate<ParameterOverrideCriteria> wrapperConversionMatch() { return (parameterCriteria) -> isNonUnwrappingWrapper(parameterCriteria.getBaseType()) // && isNonUnwrappingWrapper(parameterCriteria.getDeclaredType()) // && ReactiveWrapperConverters.canConvert(parameterCriteria.getDeclaredType(), parameterCriteria.getBaseType()); }
protected Mono mapMono(Single single) { return ReactiveWrapperConverters.toWrapper(single , Mono.class); }
/** * Reactive MongoDB support requires reactive wrapper support. If return type/parameters are reactive wrapper types, * then it's required to be able to convert these. * * @param method the method to validate. */ private static void validate(Method method) { if (ReactiveWrappers.supports(method.getReturnType()) && !ClassUtils.isAssignable(Publisher.class, method.getReturnType()) && !ReactiveWrapperConverters.supports(method.getReturnType())) { throw new InvalidDataAccessApiUsageException( String.format("No reactive type converter found for type %s used in %s, method %s.", method.getReturnType().getName(), method.getDeclaringClass().getName(), method)); } Arrays.stream(method.getParameterTypes()) // .filter(ReactiveWrappers::supports) // .filter(parameterType -> !ClassUtils.isAssignable(Publisher.class, parameterType)) // .filter(parameterType -> !ReactiveWrapperConverters.supports(parameterType)) // .forEach(parameterType -> { throw new InvalidDataAccessApiUsageException( String.format("No reactive type converter found for type %s used in %s, method %s.", parameterType.getName(), method.getDeclaringClass().getName(), method)); }); } }
/** * {@link Predicate} to check whether a method parameter is a {@link #isNonUnwrappingWrapper(Class)} and can be * converted into a different wrapper. Usually {@link rx.Observable} to {@link org.reactivestreams.Publisher} * conversion. * * @return */ private static Predicate<ParameterOverrideCriteria> wrapperConversionMatch() { return (parameterCriteria) -> isNonUnwrappingWrapper(parameterCriteria.getBaseType()) // && isNonUnwrappingWrapper(parameterCriteria.getDeclaredType()) // && ReactiveWrapperConverters.canConvert(parameterCriteria.getDeclaredType(), parameterCriteria.getBaseType()); }
protected Flux mapFlux(Observable observable) { return ReactiveWrapperConverters.toWrapper(observable, Flux.class); }
/** * Check if the given {@link org.springframework.data.repository.query.QueryMethod} receives a reactive parameter * wrapper as one of its parameters. * * @return {@literal true} if the given {@link org.springframework.data.repository.query.QueryMethod} receives a * reactive parameter wrapper as one of its parameters. */ public boolean hasReactiveWrapperParameter() { for (Parameter parameter : getParameters()) { if (ReactiveWrapperConverters.supports(parameter.getType())) { return true; } } return false; }
/** * {@link Predicate} to check whether a method parameter is a {@link #isNonUnwrappingWrapper(Class)} and can be * converted into a different wrapper. Usually {@link rx.Observable} to {@link org.reactivestreams.Publisher} * conversion. * * @return */ private static Predicate<ParameterOverrideCriteria> wrapperConversionMatch() { return (parameterCriteria) -> isNonUnwrappingWrapper(parameterCriteria.getBaseType()) // && isNonUnwrappingWrapper(parameterCriteria.getDeclaredType()) // && ReactiveWrapperConverters.canConvert(parameterCriteria.getDeclaredType(), parameterCriteria.getBaseType()); }
protected Mono mapMono(Single single) { return ReactiveWrapperConverters.toWrapper(single , Mono.class); }
/** * Check if the given {@link org.springframework.data.repository.query.QueryMethod} receives a reactive parameter * wrapper as one of its parameters. * * @return {@literal true} if the given {@link org.springframework.data.repository.query.QueryMethod} receives a * reactive parameter wrapper as one of its parameters. */ public boolean hasReactiveWrapperParameter() { for (Parameter parameter : getParameters()) { if (ReactiveWrapperConverters.supports(parameter.getType())) { return true; } } return false; }