DATACMNS-836 - Refactoring.

Move ReactiveWrappers and ReactiveWrapperConverters to util package. Provide reactive type details in ReactiveWrappers.

Author: mp911de

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

@@ -32,6 +32,7 @@
 import org.springframework.core.convert.support.DefaultConversionService;
 import org.springframework.data.domain.Slice;
 import org.springframework.data.projection.ProjectionFactory;
+import org.springframework.data.repository.util.ReactiveWrapperConverters;
 import org.springframework.data.util.ReflectionUtils;
 import org.springframework.util.Assert;
 

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

@@ -57,17 +57,13 @@
  * <li>{@code java.util.concurrent.Future}</li>
  * <li>{@code java.util.concurrent.CompletableFuture}</li>
  * <li>{@code org.springframework.util.concurrent.ListenableFuture<}</li>
- * <li>{@code rx.Single}</li>
- * <li>{@code rx.Observable}</li>
- * <li>{@code rx.Completable}</li>
- * <li>{@code reactor.core.publisher.Mono}</li>
- * <li>{@code reactor.core.publisher.Flux}</li>
- * <li>{@code org.reactivestreams.Publisher}</li>
+ * <li>Reactive wrappers supported by {@link ReactiveWrappers}</li>
  * </ul>
  * 
  * @author Oliver Gierke
  * @author Mark Paluch
  * @since 1.8
+ * @see ReactiveWrappers
  */
 public abstract class QueryExecutionConverters {
 
@@ -85,13 +81,6 @@ public abstract class QueryExecutionConverters {
 	private static final boolean SCALA_PRESENT = ClassUtils.isPresent("scala.Option",
 			QueryExecutionConverters.class.getClassLoader());
 
-	private static final boolean PROJECT_REACTOR_PRESENT = ClassUtils.isPresent("reactor.core.publisher.Mono",
-			QueryExecutionConverters.class.getClassLoader());
-	private static final boolean RXJAVA1_PRESENT = ClassUtils.isPresent("rx.Completable",
-			QueryExecutionConverters.class.getClassLoader());
-	private static final boolean RXJAVA2_PRESENT = ClassUtils.isPresent("io.reactivex.Flowable",
-			QueryExecutionConverters.class.getClassLoader());
-
 	private static final Set<Class<?>> WRAPPER_TYPES = new HashSet<Class<?>>();
 	private static final Set<Class<?>> UNWRAPPER_TYPES = new HashSet<Class<?>>();
 	private static final Set<Converter<Object, Object>> UNWRAPPERS = new HashSet<Converter<Object, Object>>();
@@ -127,25 +116,9 @@ public abstract class QueryExecutionConverters {
 			UNWRAPPERS.add(ScalOptionUnwrapper.INSTANCE);
 		}
 
-		if (PROJECT_REACTOR_PRESENT) {
-			WRAPPER_TYPES.add(Publisher.class);
-			WRAPPER_TYPES.add(Mono.class);
-			WRAPPER_TYPES.add(Flux.class);
-		}
-
-		if (RXJAVA1_PRESENT) {
-			WRAPPER_TYPES.add(Single.class);
-			WRAPPER_TYPES.add(Completable.class);
-			WRAPPER_TYPES.add(Observable.class);
-		}
-
-		if (RXJAVA2_PRESENT) {
-			WRAPPER_TYPES.add(io.reactivex.Single.class);
-			WRAPPER_TYPES.add(io.reactivex.Maybe.class);
-			WRAPPER_TYPES.add(io.reactivex.Completable.class);
-			WRAPPER_TYPES.add(io.reactivex.Observable.class);
-			WRAPPER_TYPES.add(io.reactivex.Flowable.class);
-		}
+		WRAPPER_TYPES.addAll(ReactiveWrappers.getNoValueTypes());
+		WRAPPER_TYPES.addAll(ReactiveWrappers.getSingleValueTypes());
+		WRAPPER_TYPES.addAll(ReactiveWrappers.getMultiValueTypes());
 	}
 
 	private QueryExecutionConverters() {}
@@ -214,9 +187,9 @@ public static void registerConvertersIn(ConfigurableConversionService conversion
 			conversionService.addConverter(new NullableWrapperToFutureConverter(conversionService));
 		}
 
-		if (PROJECT_REACTOR_PRESENT) {
+		if (ReactiveWrappers.isAvailable()) {
 
-			if (RXJAVA1_PRESENT) {
+			if (ReactiveWrappers.RXJAVA1_PRESENT) {
 
 				conversionService.addConverter(PublisherToRxJava1CompletableConverter.INSTANCE);
 				conversionService.addConverter(RxJava1CompletableToPublisherConverter.INSTANCE);
@@ -233,7 +206,7 @@ public static void registerConvertersIn(ConfigurableConversionService conversion
 				conversionService.addConverter(RxJava1ObservableToFluxConverter.INSTANCE);
 			}
 
-			if (RXJAVA2_PRESENT) {
+			if (ReactiveWrappers.RXJAVA2_PRESENT) {
 
 				conversionService.addConverter(PublisherToRxJava2CompletableConverter.INSTANCE);
 				conversionService.addConverter(RxJava2CompletableToPublisherConverter.INSTANCE);
@@ -258,18 +231,20 @@ public static void registerConvertersIn(ConfigurableConversionService conversion
 				conversionService.addConverter(RxJava2MaybeToFluxConverter.INSTANCE);
 			}
 
-			conversionService.addConverter(PublisherToMonoConverter.INSTANCE);
-			conversionService.addConverter(PublisherToFluxConverter.INSTANCE);
-		}
+			if (ReactiveWrappers.PROJECT_REACTOR_PRESENT) {
+				conversionService.addConverter(PublisherToMonoConverter.INSTANCE);
+				conversionService.addConverter(PublisherToFluxConverter.INSTANCE);
+			}
 
-		if (RXJAVA1_PRESENT) {
-			conversionService.addConverter(RxJava1SingleToObservableConverter.INSTANCE);
-			conversionService.addConverter(RxJava1ObservableToSingleConverter.INSTANCE);
-		}
+			if (ReactiveWrappers.RXJAVA1_PRESENT) {
+				conversionService.addConverter(RxJava1SingleToObservableConverter.INSTANCE);
+				conversionService.addConverter(RxJava1ObservableToSingleConverter.INSTANCE);
+			}
 
-		if (RXJAVA2_PRESENT) {
-			conversionService.addConverter(RxJava2SingleToObservableConverter.INSTANCE);
-			conversionService.addConverter(RxJava2ObservableToSingleConverter.INSTANCE);
+			if (ReactiveWrappers.RXJAVA2_PRESENT) {
+				conversionService.addConverter(RxJava2SingleToObservableConverter.INSTANCE);
+				conversionService.addConverter(RxJava2ObservableToSingleConverter.INSTANCE);
+			}
 		}
 	}
 

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

@@ -13,56 +13,61 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.springframework.data.repository.query;
-
-import static org.springframework.data.repository.query.ReactiveWrappers.*;
+package org.springframework.data.repository.util;
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
-import java.util.function.Predicate;
 
 import org.reactivestreams.Publisher;
 import org.springframework.core.ReactiveAdapterRegistry;
 import org.springframework.core.convert.converter.Converter;
 import org.springframework.core.convert.support.GenericConversionService;
-import org.springframework.data.repository.util.QueryExecutionConverters;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 
 import io.reactivex.Flowable;
+import lombok.experimental.UtilityClass;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 import rx.Observable;
 import rx.Single;
 
 /**
- * Conversion support for reactive wrapper types.
+ * Conversion support for reactive wrapper types. This class is a logical extension to {@link QueryExecutionConverters}.
+ * <p>
+ * This class discovers reactive wrapper availability and their conversion support based on the class path. Reactive
+ * wrapper types might be supported/on the class path but conversion may require additional dependencies.
  * 
  * @author Mark Paluch
  * @since 2.0
+ * @see ReactiveWrappers
+ * @see ReactiveAdapterRegistry
  */
-public abstract class ReactiveWrapperConverters {
+@UtilityClass
+public class ReactiveWrapperConverters {
 
 	private static final List<AbstractReactiveWrapper<?>> REACTIVE_WRAPPERS = new ArrayList<>();
 	private static final GenericConversionService GENERIC_CONVERSION_SERVICE = new GenericConversionService();
 	private static final ReactiveAdapterRegistry REACTIVE_ADAPTER_REGISTRY = new ReactiveAdapterRegistry();
 
 	static {
 
-		if (RXJAVA1_PRESENT) {
+		if (ReactiveWrappers.RXJAVA1_PRESENT) {
+
 			REACTIVE_WRAPPERS.add(RxJava1SingleWrapper.INSTANCE);
 			REACTIVE_WRAPPERS.add(RxJava1ObservableWrapper.INSTANCE);
 		}
 
-		if (RXJAVA2_PRESENT) {
+		if (ReactiveWrappers.RXJAVA2_PRESENT) {
+
 			REACTIVE_WRAPPERS.add(RxJava2SingleWrapper.INSTANCE);
 			REACTIVE_WRAPPERS.add(RxJava2MaybeWrapper.INSTANCE);
 			REACTIVE_WRAPPERS.add(RxJava2ObservableWrapper.INSTANCE);
 			REACTIVE_WRAPPERS.add(RxJava2FlowableWrapper.INSTANCE);
 		}
 
-		if (PROJECT_REACTOR_PRESENT) {
+		if (ReactiveWrappers.PROJECT_REACTOR_PRESENT) {
+
 			REACTIVE_WRAPPERS.add(FluxWrapper.INSTANCE);
 			REACTIVE_WRAPPERS.add(MonoWrapper.INSTANCE);
 			REACTIVE_WRAPPERS.add(PublisherWrapper.INSTANCE);
@@ -71,11 +76,12 @@ public abstract class ReactiveWrapperConverters {
 		QueryExecutionConverters.registerConvertersIn(GENERIC_CONVERSION_SERVICE);
 	}
 
-	private ReactiveWrapperConverters() {
-	}
-
 	/**
-	 * Returns whether the given type is a supported wrapper type.
+	 * Returns whether the given type is supported for wrapper type conversion.
+	 * <p>
+	 * NOTE: A reactive wrapper type might be supported in general by {@link ReactiveWrappers#supports(Class)} but not
+	 * necessarily for conversion using this method.
+	 * </p>
 	 * 
 	 * @param type must not be {@literal null}.
 	 * @return {@literal true} if the {@code type} is a supported reactive wrapper type.
@@ -84,34 +90,6 @@ public static boolean supports(Class<?> type) {
 		return REACTIVE_ADAPTER_REGISTRY.getAdapterFrom(type) != null;
 	}
 
-	/**
-	 * Returns whether the type is a single-like wrapper.
-	 * 
-	 * @param type must not be {@literal null}.
-	 * @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 ReactiveWrappers.isSingleType(type);
-	}
-
-	/**
-	 * Returns whether the type is a collection/multi-element-like wrapper.
-	 * 
-	 * @param type must not be {@literal null}.
-	 * @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 ReactiveWrappers.isMultiType(type);
-	}
-
 	/**
 	 * Casts or converts the given wrapper type into a different wrapper type.
 	 *