diff --git a/src/main/java/org/springframework/data/repository/config/RepositoryConfigurationExtensionSupport.java b/src/main/java/org/springframework/data/repository/config/RepositoryConfigurationExtensionSupport.java index 6e1806908..aab9a0717 100644 --- a/src/main/java/org/springframework/data/repository/config/RepositoryConfigurationExtensionSupport.java +++ b/src/main/java/org/springframework/data/repository/config/RepositoryConfigurationExtensionSupport.java @@ -301,9 +301,7 @@ public abstract class RepositoryConfigurationExtensionSupport implements Reposit try { return org.springframework.util.ClassUtils.forName(repositoryInterface, classLoader); - } catch (ClassNotFoundException e) { - LOGGER.warn(String.format(CLASS_LOADING_ERROR, getModuleName(), repositoryInterface, classLoader), e); - } catch (LinkageError e) { + } catch (ClassNotFoundException | LinkageError e) { LOGGER.warn(String.format(CLASS_LOADING_ERROR, getModuleName(), repositoryInterface, classLoader), e); } diff --git a/src/main/java/org/springframework/data/repository/core/support/ReactiveRepositoryInformation.java b/src/main/java/org/springframework/data/repository/core/support/ReactiveRepositoryInformation.java index da8a5bc0f..da387019f 100644 --- a/src/main/java/org/springframework/data/repository/core/support/ReactiveRepositoryInformation.java +++ b/src/main/java/org/springframework/data/repository/core/support/ReactiveRepositoryInformation.java @@ -31,7 +31,7 @@ import org.springframework.util.Assert; /** * This {@link RepositoryInformation} uses a {@link ConversionService} to check whether method arguments can be * converted for invocation of implementation methods. - * + * * @author Mark Paluch * @since 2.0 */ @@ -42,7 +42,7 @@ public class ReactiveRepositoryInformation extends DefaultRepositoryInformation /** * Creates a new {@link ReactiveRepositoryInformation} for the given repository interface and repository base class * using a {@link ConversionService}. - * + * * @param metadata must not be {@literal null}. * @param repositoryBaseClass must not be {@literal null}. * @param customImplementationClass @@ -67,15 +67,15 @@ public class ReactiveRepositoryInformation extends DefaultRepositoryInformation * @param baseClass * @return */ + @Override Method getTargetClassMethod(Method method, Class baseClass) { if (baseClass == null) { return method; } - boolean wantsWrappers = wantsMethodUsingReactiveWrapperParameters(method); + if (usesParametersWithReactiveWrappers(method)) { - if (wantsWrappers) { Method candidate = getMethodCandidate(method, baseClass, new AssignableWrapperMatch(method)); if (candidate != null) { @@ -99,12 +99,13 @@ public class ReactiveRepositoryInformation extends DefaultRepositoryInformation return method; } - private boolean wantsMethodUsingReactiveWrapperParameters(Method method) { + private boolean usesParametersWithReactiveWrappers(Method method) { boolean wantsWrappers = false; for (Class parameterType : method.getParameterTypes()) { - if (isNonunwrappingWrapper(parameterType)) { + + if (isNonUnwrappingWrapper(parameterType)) { wantsWrappers = true; break; } @@ -167,13 +168,13 @@ public class ReactiveRepositoryInformation extends DefaultRepositoryInformation * @param parameterType * @return */ - static boolean isNonunwrappingWrapper(Class parameterType) { + static boolean isNonUnwrappingWrapper(Class parameterType) { return QueryExecutionConverters.supports(parameterType) && !QueryExecutionConverters.supportsUnwrapping(parameterType); } /** - * {@link BiPredicate} to check whether a method parameter is a {@link #isNonunwrappingWrapper(Class)} and can be + * {@link BiPredicate} 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. */ @@ -193,7 +194,7 @@ public class ReactiveRepositoryInformation extends DefaultRepositoryInformation @Override public boolean test(Class candidateParameterType, Integer index) { - if (isNonunwrappingWrapper(candidateParameterType) && isNonunwrappingWrapper(declaredParameterTypes[index])) { + if (isNonUnwrappingWrapper(candidateParameterType) && isNonUnwrappingWrapper(declaredParameterTypes[index])) { if (conversionService.canConvert(declaredParameterTypes[index], candidateParameterType)) { return true; @@ -205,7 +206,7 @@ public class ReactiveRepositoryInformation extends DefaultRepositoryInformation } /** - * {@link BiPredicate} to check parameter assignability between a {@link #isNonunwrappingWrapper(Class)} parameter and + * {@link BiPredicate} to check parameter assignability between a {@link #isNonUnwrappingWrapper(Class)} parameter and * a declared parameter. Usually {@link reactor.core.publisher.Flux} vs. {@link org.reactivestreams.Publisher} * conversion. */ @@ -223,7 +224,7 @@ public class ReactiveRepositoryInformation extends DefaultRepositoryInformation @Override public boolean test(Class candidateParameterType, Integer index) { - if (isNonunwrappingWrapper(candidateParameterType) && isNonunwrappingWrapper(declaredParameterTypes[index])) { + if (isNonUnwrappingWrapper(candidateParameterType) && isNonUnwrappingWrapper(declaredParameterTypes[index])) { if (declaredParameterTypes[index].isAssignableFrom(candidateParameterType)) { return true; diff --git a/src/main/java/org/springframework/data/repository/query/ResultProcessor.java b/src/main/java/org/springframework/data/repository/query/ResultProcessor.java index 0dfb32d19..f5ba30731 100644 --- a/src/main/java/org/springframework/data/repository/query/ResultProcessor.java +++ b/src/main/java/org/springframework/data/repository/query/ResultProcessor.java @@ -159,7 +159,7 @@ public class ResultProcessor { } if(ReactiveWrapperConverters.supports(source.getClass())){ - return (T) ReactiveWrapperConverters.map(source, o -> type.isInstance(o) ? o : converter.convert(o)); + return (T) ReactiveWrapperConverters.map(source, converter::convert); } return (T) converter.convert(source); diff --git a/src/main/java/org/springframework/data/repository/util/ReactiveWrapperConverters.java b/src/main/java/org/springframework/data/repository/util/ReactiveWrapperConverters.java index 57cb445fe..47647d73e 100644 --- a/src/main/java/org/springframework/data/repository/util/ReactiveWrapperConverters.java +++ b/src/main/java/org/springframework/data/repository/util/ReactiveWrapperConverters.java @@ -19,6 +19,7 @@ import static org.springframework.data.repository.util.ReactiveWrapperConverters import java.util.ArrayList; import java.util.List; +import java.util.function.Function; import org.reactivestreams.Publisher; import org.springframework.core.ReactiveAdapterRegistry; @@ -54,7 +55,7 @@ import rx.Single; @UtilityClass public class ReactiveWrapperConverters { - private static final List> REACTIVE_WRAPPERS = new ArrayList<>(); + private static final List> REACTIVE_WRAPPERS = new ArrayList<>(); private static final GenericConversionService GENERIC_CONVERSION_SERVICE = new GenericConversionService(); static { @@ -194,12 +195,12 @@ public class ReactiveWrapperConverters { * @return */ @SuppressWarnings("unchecked") - public static T map(Object stream, Converter converter) { + public static T map(Object stream, Function converter) { Assert.notNull(stream, "Stream must not be null!"); Assert.notNull(converter, "Converter must not be null!"); - for (AbstractReactiveWrapper reactiveWrapper : REACTIVE_WRAPPERS) { + for (ReactiveTypeWrapper reactiveWrapper : REACTIVE_WRAPPERS) { if (ClassUtils.isAssignable(reactiveWrapper.getWrapperClass(), stream.getClass())) { return (T) reactiveWrapper.map(stream, converter); @@ -214,11 +215,12 @@ public class ReactiveWrapperConverters { // ------------------------------------------------------------------------- /** - * Wrapper descriptor that can apply a {@link Converter} to map (convert) items inside its stream. + * Wrapper descriptor that can apply a {@link Function} to map items inside its stream. * * @author Mark Paluch + * @author Christoph Strobl */ - private interface AbstractReactiveWrapper { + private interface ReactiveTypeWrapper { /** * @return the wrapper class. @@ -226,19 +228,19 @@ public class ReactiveWrapperConverters { Class getWrapperClass(); /** - * Apply a {@link Converter} to a reactive type. + * Apply a {@link Function} to a reactive type. * * @param wrapper the reactive type, must not be {@literal null}. - * @param converter the converter, must not be {@literal null}. + * @param function the converter, must not be {@literal null}. * @return the reactive type applying conversion. */ - Object map(Object wrapper, Converter converter); + Object map(Object wrapper, Function function); } /** * Wrapper for Project Reactor's {@link Mono}. */ - private enum MonoWrapper implements AbstractReactiveWrapper> { + private enum MonoWrapper implements ReactiveTypeWrapper> { INSTANCE; @@ -248,15 +250,15 @@ public class ReactiveWrapperConverters { } @Override - public Mono map(Object wrapper, Converter converter) { - return ((Mono) wrapper).map(converter::convert); + public Mono map(Object wrapper, Function function) { + return ((Mono) wrapper).map(function::apply); } } /** * Wrapper for Project Reactor's {@link Flux}. */ - private enum FluxWrapper implements AbstractReactiveWrapper> { + private enum FluxWrapper implements ReactiveTypeWrapper> { INSTANCE; @@ -265,15 +267,15 @@ public class ReactiveWrapperConverters { return Flux.class; } - public Flux map(Object wrapper, Converter converter) { - return ((Flux) wrapper).map(converter::convert); + public Flux map(Object wrapper, Function function) { + return ((Flux) wrapper).map(function::apply); } } /** * Wrapper for Reactive Stream's {@link Publisher}. */ - private enum PublisherWrapper implements AbstractReactiveWrapper> { + private enum PublisherWrapper implements ReactiveTypeWrapper> { INSTANCE; @@ -283,24 +285,24 @@ public class ReactiveWrapperConverters { } @Override - public Publisher map(Object wrapper, Converter converter) { + public Publisher map(Object wrapper, Function function) { if (wrapper instanceof Mono) { - return MonoWrapper.INSTANCE.map(wrapper, converter); + return MonoWrapper.INSTANCE.map(wrapper, function); } if (wrapper instanceof Flux) { - return FluxWrapper.INSTANCE.map(wrapper, converter); + return FluxWrapper.INSTANCE.map(wrapper, function); } - return FluxWrapper.INSTANCE.map(Flux.from((Publisher) wrapper), converter); + return FluxWrapper.INSTANCE.map(Flux.from((Publisher) wrapper), function); } } /** * Wrapper for RxJava 1's {@link Single}. */ - private enum RxJava1SingleWrapper implements AbstractReactiveWrapper> { + private enum RxJava1SingleWrapper implements ReactiveTypeWrapper> { INSTANCE; @@ -310,15 +312,15 @@ public class ReactiveWrapperConverters { } @Override - public Single map(Object wrapper, Converter converter) { - return ((Single) wrapper).map(converter::convert); + public Single map(Object wrapper, Function function) { + return ((Single) wrapper).map(function::apply); } } /** * Wrapper for RxJava 1's {@link Observable}. */ - private enum RxJava1ObservableWrapper implements AbstractReactiveWrapper> { + private enum RxJava1ObservableWrapper implements ReactiveTypeWrapper> { INSTANCE; @@ -328,15 +330,15 @@ public class ReactiveWrapperConverters { } @Override - public Observable map(Object wrapper, Converter converter) { - return ((Observable) wrapper).map(converter::convert); + public Observable map(Object wrapper, Function function) { + return ((Observable) wrapper).map(function::apply); } } /** * Wrapper for RxJava 2's {@link io.reactivex.Single}. */ - private enum RxJava2SingleWrapper implements AbstractReactiveWrapper> { + private enum RxJava2SingleWrapper implements ReactiveTypeWrapper> { INSTANCE; @@ -346,15 +348,15 @@ public class ReactiveWrapperConverters { } @Override - public io.reactivex.Single map(Object wrapper, Converter converter) { - return ((io.reactivex.Single) wrapper).map(converter::convert); + public io.reactivex.Single map(Object wrapper, Function function) { + return ((io.reactivex.Single) wrapper).map(function::apply); } } /** * Wrapper for RxJava 2's {@link io.reactivex.Maybe}. */ - private enum RxJava2MaybeWrapper implements AbstractReactiveWrapper> { + private enum RxJava2MaybeWrapper implements ReactiveTypeWrapper> { INSTANCE; @@ -364,15 +366,15 @@ public class ReactiveWrapperConverters { } @Override - public io.reactivex.Maybe map(Object wrapper, Converter converter) { - return ((io.reactivex.Maybe) wrapper).map(converter::convert); + public io.reactivex.Maybe map(Object wrapper, Function function) { + return ((io.reactivex.Maybe) wrapper).map(function::apply); } } /** * Wrapper for RxJava 2's {@link io.reactivex.Observable}. */ - private enum RxJava2ObservableWrapper implements AbstractReactiveWrapper> { + private enum RxJava2ObservableWrapper implements ReactiveTypeWrapper> { INSTANCE; @@ -382,15 +384,15 @@ public class ReactiveWrapperConverters { } @Override - public io.reactivex.Observable map(Object wrapper, Converter converter) { - return ((io.reactivex.Observable) wrapper).map(converter::convert); + public io.reactivex.Observable map(Object wrapper, Function function) { + return ((io.reactivex.Observable) wrapper).map(function::apply); } } /** * Wrapper for RxJava 2's {@link io.reactivex.Flowable}. */ - private enum RxJava2FlowableWrapper implements AbstractReactiveWrapper> { + private enum RxJava2FlowableWrapper implements ReactiveTypeWrapper> { INSTANCE; @@ -400,8 +402,8 @@ public class ReactiveWrapperConverters { } @Override - public io.reactivex.Flowable map(Object wrapper, Converter converter) { - return ((io.reactivex.Flowable) wrapper).map(converter::convert); + public io.reactivex.Flowable map(Object wrapper, Function function) { + return ((io.reactivex.Flowable) wrapper).map(function::apply); } } diff --git a/src/main/java/org/springframework/data/repository/util/ReactiveWrappers.java b/src/main/java/org/springframework/data/repository/util/ReactiveWrappers.java index 91d144d07..fa888d031 100644 --- a/src/main/java/org/springframework/data/repository/util/ReactiveWrappers.java +++ b/src/main/java/org/springframework/data/repository/util/ReactiveWrappers.java @@ -43,6 +43,7 @@ import rx.Single; * multiplicity and whether a reactive wrapper type is acceptable for a specific operation. * * @author Mark Paluch + * @author Christoph Strobl * @since 2.0 * @see org.reactivestreams.Publisher * @see rx.Single @@ -72,7 +73,7 @@ public class ReactiveWrappers { static { - Map, Descriptor> reactiveWrappers = new LinkedHashMap<>(3); + Map, Descriptor> reactiveWrappers = new LinkedHashMap<>(5); if (RXJAVA1_PRESENT) { @@ -140,6 +141,10 @@ public class ReactiveWrappers { * @return {@literal true} if the {@code type} is a supported reactive wrapper type. */ public static boolean supports(Class type) { + return isWrapper(ClassUtils.getUserClass(type)); + } + + private static boolean isWrapper(Class type) { return isNoValueType(type) || isSingleValueType(type) || isMultiValueType(type); }