DATACMNS-836 - Cleanups.

Convert single-instance classes to enums. Consolidate single/multi type checking into ReactiveWrappers class. Guard QueryExecutionConverters.registerConvertersIn against NPE in case of absence of AsyncResult.

Author: mp911de

src/main/java/org/springframework/data/repository/query/ReactiveWrapperConverters.java

@@ -29,6 +29,7 @@
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 
+import io.reactivex.Flowable;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import rx.Observable;
@@ -76,7 +77,7 @@ private ReactiveWrapperConverters() {
 	 * Returns whether the given type is a supported wrapper type.
 	 * 
 	 * @param type must not be {@literal null}.
-	 * @return
+	 * @return {@literal true} if the {@code type} is a supported reactive wrapper type.
 	 */
 	public static boolean supports(Class<?> type) {
 		return assignableStream(type).isPresent();
@@ -86,25 +87,28 @@ public static boolean supports(Class<?> type) {
 	 * Returns whether the type is a single-like wrapper.
 	 * 
 	 * @param type must not be {@literal null}.
-	 * @return
-	 * @see Single
+	 * @return {@literal true} if the {@code type} is a single-like reactive wrapper type.
+	 * @see rx.Single
+	 * @see io.reactivex.Single
 	 * @see Mono
 	 */
 	public static boolean isSingleLike(Class<?> type) {
-		return assignableStream(type).map(wrapper -> wrapper.getMultiplicity() == Multiplicity.ONE).orElse(false);
+		return ReactiveWrappers.isSingleType(type);
 	}
 
 	/**
 	 * Returns whether the type is a collection/multi-element-like wrapper.
 	 * 
 	 * @param type must not be {@literal null}.
-	 * @return
-	 * @see Observable
+	 * @return {@literal true} if the {@code type} is a collection/multi-element-like reactive wrapper type.
+	 * @see rx.Observable
+	 * @see io.reactivex.Observable
+	 * @see io.reactivex.Flowable
 	 * @see Flux
 	 * @see Publisher
 	 */
 	public static boolean isCollectionLike(Class<?> type) {
-		return assignableStream(type).map(wrapper -> wrapper.getMultiplicity() == Multiplicity.MANY).orElse(false);
+		return ReactiveWrappers.isMultiType(type);
 	}
 
 	/**
@@ -114,6 +118,7 @@ public static boolean isCollectionLike(Class<?> type) {
 	 * @param expectedWrapperType must not be {@literal null}.
 	 * @return
 	 */
+	@SuppressWarnings("unchecked")
 	public static <T> T toWrapper(Object stream, Class<? extends T> expectedWrapperType) {
 
 		Assert.notNull(stream, "Stream must not be null!");
@@ -162,59 +167,49 @@ private static Optional<AbstractReactiveWrapper<?>> findWrapper(
 		return REACTIVE_WRAPPERS.stream().filter(predicate).findFirst();
 	}
 
-	private abstract static class AbstractReactiveWrapper<T> {
-
-		private final Class<? super T> wrapperClass;
-		private final Multiplicity multiplicity;
+	private interface AbstractReactiveWrapper<T> {
 
-		public AbstractReactiveWrapper(Class<? super T> wrapperClass, Multiplicity multiplicity) {
-			this.wrapperClass = wrapperClass;
-			this.multiplicity = multiplicity;
-		}
+		Class<? super T> getWrapperClass();
 
-		public Class<? super T> getWrapperClass() {
-			return wrapperClass;
-		}
-
-		public Multiplicity getMultiplicity() {
-			return multiplicity;
-		}
-
-		public abstract Object map(Object wrapper, Converter<Object, Object> converter);
+		Object map(Object wrapper, Converter<Object, Object> converter);
 	}
 
-	private static class MonoWrapper extends AbstractReactiveWrapper<Mono<?>> {
+	private enum MonoWrapper implements AbstractReactiveWrapper<Mono<?>> {
 
-		static final MonoWrapper INSTANCE = new MonoWrapper();
+		INSTANCE;
 
-		private MonoWrapper() {
-			super(Mono.class, Multiplicity.ONE);
+		@Override
+		public Class<? super Mono<?>> getWrapperClass() {
+			return Mono.class;
 		}
 
+		@Override
 		public Mono<?> map(Object wrapper, Converter<Object, Object> converter) {
 			return ((Mono<?>) wrapper).map(converter::convert);
 		}
 	}
 
-	private static class FluxWrapper extends AbstractReactiveWrapper<Flux<?>> {
+	private enum FluxWrapper implements AbstractReactiveWrapper<Flux<?>> {
 
-		static final FluxWrapper INSTANCE = new FluxWrapper();
+		INSTANCE;
 
-		private FluxWrapper() {
-			super(Flux.class, Multiplicity.MANY);
+		@Override
+		public Class<? super Flux<?>> getWrapperClass() {
+			return Flux.class;
 		}
 
 		public Flux<?> map(Object wrapper, Converter<Object, Object> converter) {
 			return ((Flux<?>) wrapper).map(converter::convert);
 		}
 	}
 
-	private static class PublisherWrapper extends AbstractReactiveWrapper<Publisher<?>> {
+	private enum PublisherWrapper implements AbstractReactiveWrapper<Publisher<?>> {
 
-		static final PublisherWrapper INSTANCE = new PublisherWrapper();
+		INSTANCE;
 
-		public PublisherWrapper() {
-			super(Publisher.class, Multiplicity.MANY);
+		@Override
+		public Class<? super Publisher<?>> getWrapperClass() {
+			return Publisher.class;
 		}
 
 		@Override
@@ -232,12 +227,13 @@ public Publisher<?> map(Object wrapper, Converter<Object, Object> converter) {
 		}
 	}
 
-	private static class RxJava1SingleWrapper extends AbstractReactiveWrapper<Single<?>> {
+	private enum RxJava1SingleWrapper implements AbstractReactiveWrapper<Single<?>> {
 
-		static final RxJava1SingleWrapper INSTANCE = new RxJava1SingleWrapper();
+		INSTANCE;
 
-		private RxJava1SingleWrapper() {
-			super(Single.class, Multiplicity.ONE);
+		@Override
+		public Class<? super Single<?>> getWrapperClass() {
+			return Single.class;
 		}
 
 		@Override
@@ -246,12 +242,13 @@ public Single<?> map(Object wrapper, Converter<Object, Object> converter) {
 		}
 	}
 
-	private static class RxJava1ObservableWrapper extends AbstractReactiveWrapper<Observable<?>> {
+	private enum RxJava1ObservableWrapper implements AbstractReactiveWrapper<Observable<?>> {
 
-		static final RxJava1ObservableWrapper INSTANCE = new RxJava1ObservableWrapper();
+		INSTANCE;
 
-		private RxJava1ObservableWrapper() {
-			super(Observable.class, Multiplicity.MANY);
+		@Override
+		public Class<? super Observable<?>> getWrapperClass() {
+			return Observable.class;
 		}
 
 		@Override
@@ -260,12 +257,13 @@ public Observable<?> map(Object wrapper, Converter<Object, Object> converter) {
 		}
 	}
 
-	private static class RxJava2SingleWrapper extends AbstractReactiveWrapper<io.reactivex.Single<?>> {
+	private enum RxJava2SingleWrapper implements AbstractReactiveWrapper<io.reactivex.Single<?>> {
 
-		static final RxJava2SingleWrapper INSTANCE = new RxJava2SingleWrapper();
+		INSTANCE;
 
-		private RxJava2SingleWrapper() {
-			super(io.reactivex.Single.class, Multiplicity.ONE);
+		@Override
+		public Class<? super io.reactivex.Single<?>> getWrapperClass() {
+			return io.reactivex.Single.class;
 		}
 
 		@Override
@@ -274,12 +272,13 @@ public io.reactivex.Single<?> map(Object wrapper, Converter<Object, Object> conv
 		}
 	}
 
-	private static class RxJava2MaybeWrapper extends AbstractReactiveWrapper<io.reactivex.Maybe<?>> {
+	private enum RxJava2MaybeWrapper implements AbstractReactiveWrapper<io.reactivex.Maybe<?>> {
 
-		static final RxJava2MaybeWrapper INSTANCE = new RxJava2MaybeWrapper();
+		INSTANCE;
 
-		private RxJava2MaybeWrapper() {
-			super(io.reactivex.Maybe.class, Multiplicity.MANY);
+		@Override
+		public Class<? super io.reactivex.Maybe<?>> getWrapperClass() {
+			return io.reactivex.Maybe.class;
 		}
 
 		@Override
@@ -288,12 +287,13 @@ public io.reactivex.Maybe<?> map(Object wrapper, Converter<Object, Object> conve
 		}
 	}
 
-	private static class RxJava2ObservableWrapper extends AbstractReactiveWrapper<io.reactivex.Observable<?>> {
+	private enum RxJava2ObservableWrapper implements AbstractReactiveWrapper<io.reactivex.Observable<?>> {
 
-		static final RxJava2ObservableWrapper INSTANCE = new RxJava2ObservableWrapper();
+		INSTANCE;
 
-		private RxJava2ObservableWrapper() {
-			super(io.reactivex.Observable.class, Multiplicity.MANY);
+		@Override
+		public Class<? super io.reactivex.Observable<?>> getWrapperClass() {
+			return io.reactivex.Observable.class;
 		}
 
 		@Override
@@ -302,12 +302,13 @@ public io.reactivex.Observable<?> map(Object wrapper, Converter<Object, Object>
 		}
 	}
 
-	private static class RxJava2FlowableWrapper extends AbstractReactiveWrapper<io.reactivex.Flowable<?>> {
+	private enum RxJava2FlowableWrapper implements AbstractReactiveWrapper<io.reactivex.Flowable<?>> {
 
-		static final RxJava2FlowableWrapper INSTANCE = new RxJava2FlowableWrapper();
+		INSTANCE;
 
-		private RxJava2FlowableWrapper() {
-			super(io.reactivex.Flowable.class, Multiplicity.MANY);
+		@Override
+		public Class<? super Flowable<?>> getWrapperClass() {
+			return io.reactivex.Flowable.class;
 		}
 
 		@Override
@@ -316,8 +317,4 @@ public io.reactivex.Flowable<?> map(Object wrapper, Converter<Object, Object> co
 		}
 	}
 
-	private enum Multiplicity {
-		ONE, MANY,
-	}
-
 }

src/main/java/org/springframework/data/repository/query/ReactiveWrappers.java

@@ -17,9 +17,10 @@
 package org.springframework.data.repository.query;
 
 import java.util.Collections;
-import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.Set;
 
+import org.reactivestreams.Publisher;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 
@@ -35,14 +36,24 @@
  *
  * @author Mark Paluch
  * @since 2.0
- * @see Single
- * @see Observable
+ * @see org.reactivestreams.Publisher
+ * @see rx.Single
+ * @see rx.Observable
+ * @see rx.Completable
+ * @see io.reactivex.Single
+ * @see io.reactivex.Maybe
+ * @see io.reactivex.Observable
+ * @see io.reactivex.Completable
+ * @see io.reactivex.Flowable
  * @see Mono
  * @see Flux
  */
 @UtilityClass
 public class ReactiveWrappers {
 
+	public static final boolean PUBLISHER_PRESENT = ClassUtils.isPresent("org.reactivestreams.Publisher",
+			ReactiveWrappers.class.getClassLoader());
+
 	public static final boolean PROJECT_REACTOR_PRESENT = ClassUtils.isPresent("reactor.core.publisher.Flux",
 			ReactiveWrappers.class.getClassLoader());
 
@@ -57,8 +68,8 @@ public class ReactiveWrappers {
 
 	static {
 
-		Set<Class<?>> singleTypes = new HashSet<>();
-		Set<Class<?>> multiTypes = new HashSet<>();
+		Set<Class<?>> singleTypes = new LinkedHashSet<>();
+		Set<Class<?>> multiTypes = new LinkedHashSet<>();
 
 		if (RXJAVA1_PRESENT) {
 			singleTypes.add(getRxJava1SingleClass());
@@ -77,6 +88,10 @@ public class ReactiveWrappers {
 			multiTypes.add(getReactorFluxClass());
 		}
 
+		if (PUBLISHER_PRESENT) {
+			multiTypes.add(getReactorPublisherClass());
+		}
+
 		SINGLE_TYPES = Collections.unmodifiableSet(singleTypes);
 		MULTI_TYPES = Collections.unmodifiableSet(multiTypes);
 	}
@@ -106,6 +121,12 @@ public static boolean isMultiType(Class<?> theClass) {
 
 		Assert.notNull(theClass, "Class type must not be null!");
 
+		// Prevent single-types with a multi-hierarchy supertype to be reported as multi type
+		// See Mono implements Publisher
+		if (isSingleType(theClass)) {
+			return false;
+		}
+
 		return isAssignable(MULTI_TYPES, theClass);
 	}
 
@@ -151,4 +172,8 @@ private static Class<?> getReactorMonoClass() {
 	private static Class<?> getReactorFluxClass() {
 		return Flux.class;
 	}
+
+	private static Class<?> getReactorPublisherClass() {
+		return Publisher.class;
+	}
 }

src/main/java/org/springframework/data/repository/util/QueryExecutionConverters.java

@@ -75,6 +75,9 @@ public abstract class QueryExecutionConverters {
 			"org.springframework.core.annotation.AnnotationConfigurationException",
 			QueryExecutionConverters.class.getClassLoader());
 
+	private static final boolean ASYNC_RESULT_PRESENT = ClassUtils.isPresent(
+			"org.springframework.scheduling.annotation.AsyncResult", QueryExecutionConverters.class.getClassLoader());
+
 	private static final boolean GUAVA_PRESENT = ClassUtils.isPresent("com.google.common.base.Optional",
 			QueryExecutionConverters.class.getClassLoader());
 	private static final boolean JDK_8_PRESENT = ClassUtils.isPresent("java.util.Optional",
@@ -206,7 +209,9 @@ public static void registerConvertersIn(ConfigurableConversionService conversion
 			conversionService.addConverter(new NullableWrapperToScalaOptionConverter(conversionService));
 		}
 
-		conversionService.addConverter(new NullableWrapperToFutureConverter(conversionService));
+		if (ASYNC_RESULT_PRESENT) {
+			conversionService.addConverter(new NullableWrapperToFutureConverter(conversionService));
+		}
 
 		if (PROJECT_REACTOR_PRESENT) {