DATACMNS-836 - Encapsulate reactive type conversion in ReactiveWrapperConverters.

Reactive type conversion now happens fully inside of ReactiveWrapperConverters and does not require an external ConversionService. This change allows changes to reactive type conversion without changing the API since all details are encapsulated by ReactiveWrapperConverters.

Author: mp911de

src/main/java/org/springframework/data/repository/core/support/QueryExecutionResultHandler.java

@@ -44,14 +44,13 @@ public QueryExecutionResultHandler() {
 
 		GenericConversionService conversionService = new DefaultConversionService();
 		QueryExecutionConverters.registerConvertersIn(conversionService);
-		ReactiveWrapperConverters.registerConvertersIn(conversionService);
 
 		this.conversionService = conversionService;
 	}
 
 	/**
 	 * Post-processes the given result of a query invocation to the given type.
-	 * 
+	 *
 	 * @param result can be {@literal null}.
 	 * @param returnTypeDescriptor can be {@literal null}, if so, no conversion is performed.
 	 * @return
@@ -87,6 +86,11 @@ public Object postProcessInvocationResult(Object result, TypeDescriptor returnTy
 		}
 
 		if (result != null) {
+
+			if (ReactiveWrapperConverters.supports(expectedReturnType)) {
+				return ReactiveWrapperConverters.toWrapper(result, expectedReturnType);
+			}
+
 			return conversionService.canConvert(result.getClass(), expectedReturnType)
 					? conversionService.convert(result, expectedReturnType) : result;
 		}

src/main/java/org/springframework/data/repository/core/support/ReactiveRepositoryInformation.java

@@ -27,11 +27,11 @@
 
 import org.springframework.core.MethodParameter;
 import org.springframework.core.convert.ConversionService;
-import org.springframework.core.convert.support.DefaultConversionService;
 import org.springframework.data.repository.core.RepositoryInformation;
 import org.springframework.data.repository.core.RepositoryMetadata;
 import org.springframework.data.repository.util.QueryExecutionConverters;
 import org.springframework.data.repository.util.ReactiveWrapperConverters;
+import org.springframework.data.repository.util.ReactiveWrappers;
 import org.springframework.util.Assert;
 
 /**
@@ -110,7 +110,7 @@ static boolean isNonUnwrappingWrapper(Class<?> parameterType) {
 
 	/**
 	 * Returns whether the given {@link Method} uses a reactive wrapper type as parameter.
-	 * 
+	 *
 	 * @param method must not be {@literal null}.
 	 * @return
 	 */
@@ -125,7 +125,7 @@ private static boolean usesParametersWithReactiveWrappers(Method method) {
 	/**
 	 * Returns a candidate method from the base class for the given one or the method given in the first place if none one
 	 * the base class matches.
-	 * 
+	 *
 	 * @param method must not be {@literal null}.
 	 * @param baseClass must not be {@literal null}.
 	 * @param predicate must not be {@literal null}.
@@ -189,8 +189,6 @@ private static boolean parametersMatch(Method method, Method baseClassMethod,
 	@RequiredArgsConstructor(staticName = "of")
 	static class WrapperConversionMatch implements BiPredicate<Class<?>, Integer> {
 
-		private static final ConversionService CONVERSION_SERVICE = ReactiveWrapperConverters
-				.registerConvertersIn(new DefaultConversionService());
 		private final Class<?>[] declaredParameterTypes;
 
 		/*
@@ -208,7 +206,8 @@ public boolean test(Class<?> candidateParameterType, Integer index) {
 				return false;
 			}
 
-			return CONVERSION_SERVICE.canConvert(declaredParameterTypes[index], candidateParameterType);
+			return ReactiveWrappers.isAvailable()
+					&& ReactiveWrapperConverters.canConvert(declaredParameterTypes[index], candidateParameterType);
 		}
 	}
 
@@ -244,7 +243,7 @@ public boolean test(Class<?> candidateParameterType, Integer index) {
 	/**
 	 * {@link BiPredicate} to check parameter assignability between a parameters in which the declared parameter may be
 	 * wrapped but supports unwrapping. Usually types like {@link java.util.Optional} or {@link java.util.stream.Stream}.
-	 * 
+	 *
 	 * @see QueryExecutionConverters
 	 */
 	@RequiredArgsConstructor(access = AccessLevel.PRIVATE)

src/main/java/org/springframework/data/repository/core/support/RepositoryFactorySupport.java

@@ -35,9 +35,7 @@
 import org.springframework.beans.factory.BeanFactoryAware;
 import org.springframework.core.GenericTypeResolver;
 import org.springframework.core.MethodParameter;
-import org.springframework.core.convert.ConversionService;
 import org.springframework.core.convert.TypeDescriptor;
-import org.springframework.core.convert.support.DefaultConversionService;
 import org.springframework.data.projection.DefaultMethodInvokingMethodInterceptor;
 import org.springframework.data.projection.SpelAwareProxyProjectionFactory;
 import org.springframework.data.repository.Repository;
@@ -53,6 +51,7 @@
 import org.springframework.data.repository.query.RepositoryQuery;
 import org.springframework.data.repository.util.ClassUtils;
 import org.springframework.data.repository.util.ReactiveWrapperConverters;
+import org.springframework.data.repository.util.ReactiveWrappers;
 import org.springframework.data.util.ReflectionUtils;
 import org.springframework.util.Assert;
 import org.springframework.util.ObjectUtils;
@@ -482,7 +481,7 @@ private Object doInvoke(MethodInvocation invocation) throws Throwable {
 
 		/**
 		 * Returns whether we know of a query to execute for the given {@link Method};
-		 * 
+		 *
 		 * @param method
 		 * @return
 		 */
@@ -583,9 +582,6 @@ private boolean isCustomMethodInvocation(MethodInvocation invocation) {
 	 */
 	public class ConvertingImplementationMethodExecutionInterceptor extends ImplementationMethodExecutionInterceptor {
 
-		private final ConversionService conversionService = ReactiveWrapperConverters
-				.registerConvertersIn(new DefaultConversionService());
-
 		/**
 		 * @param repositoryInformation
 		 * @param customImplementation
@@ -624,15 +620,12 @@ private Object[] convertParameters(Class<?>[] parameterTypes, Object[] parameter
 					continue;
 				}
 
-				if (parameterTypes[i].isAssignableFrom(parameters[i].getClass())
-						|| !conversionService.canConvert(parameters[i].getClass(), parameterTypes[i])) {
-
-					result[i] = parameters[i];
-
+				if (!parameterTypes[i].isAssignableFrom(parameters[i].getClass()) && ReactiveWrappers.isAvailable()
+						&& ReactiveWrapperConverters.canConvert(parameters[i].getClass(), parameterTypes[i])) {
+					result[i] = ReactiveWrapperConverters.toWrapper(parameters[i], parameterTypes[i]);
 				} else {
-					result[i] = conversionService.convert(parameters[i], parameterTypes[i]);
+					result[i] = parameters[i];
 				}
-
 			}
 
 			return result;