DATACMNS-1615 - Allow deferred converter configuration.

Add a Supplier variant for constructing new CustomConversions. This allows store implementations to hook into the actual configuration based on user code. Required for messing with store specific simple type registration based on user decisions.

Author: christophstrobl

Diff for: src/main/java/org/springframework/data/convert/CustomConversions.java

@@ -22,9 +22,19 @@
 import lombok.Value;
 import lombok.extern.slf4j.Slf4j;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Function;
+import java.util.function.Supplier;
 import java.util.stream.Collectors;
 
 import org.springframework.core.GenericTypeResolver;
@@ -84,6 +94,8 @@ public class CustomConversions {
 	private final ConversionTargetsCache customReadTargetTypes = new ConversionTargetsCache();
 	private final ConversionTargetsCache customWriteTargetTypes = new ConversionTargetsCache();
 
+	private final ConverterConfiguration converterConfiguration;
+
 	private final Function<ConvertiblePair, Class<?>> getReadTarget = convertiblePair -> getCustomTarget(
 			convertiblePair.getSourceType(), convertiblePair.getTargetType(), readingPairs);
 
@@ -93,6 +105,41 @@ public class CustomConversions {
 	private Function<ConvertiblePair, Class<?>> getRawWriteTarget = convertiblePair -> getCustomTarget(
 			convertiblePair.getSourceType(), null, writingPairs);
 
+	/**
+	 * Deferred initialization allowing store implementations use a callback/consumer driven configuration of the actual
+	 * {@link CustomConversions}.
+	 *
+	 * @param converterConfiguration the {@link Supplier} providing a {@link ConverterConfiguration}.
+	 * @since 2.3
+	 */
+	protected CustomConversions(Supplier<ConverterConfiguration> converterConfiguration) {
+		this(converterConfiguration.get());
+	}
+
+	/**
+	 * @param converterConfiguration the {@link ConverterConfiguration} to apply.
+	 * @since 2.3
+	 */
+	protected CustomConversions(ConverterConfiguration converterConfiguration) {
+
+		this.converterConfiguration = converterConfiguration;
+
+		List<Object> registeredConverters = collectPotentialConverterRegistrations(
+				converterConfiguration.getStoreConversions(), converterConfiguration.getUserConverters()).stream() //
+						.filter(this::isSupportedConverter) //
+						.filter(it -> !skip(it)) //
+						.map(ConverterRegistrationIntent::getConverterRegistration) //
+						.map(this::register) //
+						.distinct() //
+						.collect(Collectors.toList());
+
+		Collections.reverse(registeredConverters);
+
+		this.converters = Collections.unmodifiableList(registeredConverters);
+		this.simpleTypeHolder = new SimpleTypeHolder(customSimpleTypes,
+				converterConfiguration.getStoreConversions().getStoreTypeHolder());
+	}
+
 	/**
 	 * Creates a new {@link CustomConversions} instance registering all given user defined converters and selecting
 	 * {@link Converter converters} from {@link StoreConversions} depending on
@@ -103,47 +150,34 @@ public class CustomConversions {
 	 * @param converters must not be {@literal null}.
 	 */
 	public CustomConversions(StoreConversions storeConversions, Collection<?> converters) {
-
-		Assert.notNull(storeConversions, "StoreConversions must not be null!");
-		Assert.notNull(converters, "List of converters must not be null!");
-
-		List<Object> registeredConverters = collectPotentialConverterRegistrations(storeConversions, converters).stream() //
-				.filter(this::isSupportedConverter) //
-				.map(ConverterRegistrationIntent::getConverterRegistration) //
-				.map(this::register) //
-				.distinct() //
-				.collect(Collectors.toList());
-
-		Collections.reverse(registeredConverters);
-
-		this.converters = Collections.unmodifiableList(registeredConverters);
-		this.simpleTypeHolder = new SimpleTypeHolder(customSimpleTypes, storeConversions.getStoreTypeHolder());
+		this(new ConverterConfiguration(storeConversions, new ArrayList<>(converters)));
 	}
 
 	/**
 	 * Validate a given {@link ConverterRegistration} in a specific setup. <br />
 	 * Non {@link ReadingConverter reading} and user defined {@link Converter converters} are only considered supported if
 	 * the {@link ConverterRegistrationIntent#isSimpleTargetType() target type} is considered to be a store simple type.
 	 * 
-	 * @param registration
-	 * @return
+	 * @param registrationIntent
+	 * @return {@literal true} if supported.
 	 * @since 2.3
 	 */
-	protected boolean isSupportedConverter(ConverterRegistrationIntent registration) {
+	protected boolean isSupportedConverter(ConverterRegistrationIntent registrationIntent) {
 
-		boolean register = registration.isUserConverter() || (registration.isReading() && registration.isSimpleSourceType())
-				|| (registration.isWriting() && registration.isSimpleTargetType());
+		boolean register = registrationIntent.isUserConverter()
+				|| (registrationIntent.isReading() && registrationIntent.isSimpleSourceType())
+				|| (registrationIntent.isWriting() && registrationIntent.isSimpleTargetType());
 
 		if (LOG.isDebugEnabled()) {
 
 			if (register) {
-				LOG.debug(String.format(ADD_CONVERTER, registration.isUserConverter() ? "user defined " : "",
-						registration.getSourceType(), registration.getTargetType(),
-						registration.isReading() ? "reading" : "writing"));
+				LOG.debug(String.format(ADD_CONVERTER, registrationIntent.isUserConverter() ? "user defined " : "",
+						registrationIntent.getSourceType(), registrationIntent.getTargetType(),
+						registrationIntent.isReading() ? "reading" : "writing"));
 			} else {
-				LOG.debug(String.format(SKIP_CONVERTER, registration.getSourceType(), registration.getTargetType(),
-						registration.isReading() ? "reading" : "writing",
-						registration.isReading() ? registration.getSourceType() : registration.getTargetType()));
+				LOG.debug(String.format(SKIP_CONVERTER, registrationIntent.getSourceType(), registrationIntent.getTargetType(),
+						registrationIntent.isReading() ? "reading" : "writing",
+						registrationIntent.isReading() ? registrationIntent.getSourceType() : registrationIntent.getTargetType()));
 			}
 		}
 
@@ -285,6 +319,17 @@ private Object register(ConverterRegistration converterRegistration) {
 		return converterRegistration.getConverter();
 	}
 
+	/**
+	 * @param intent must not be {@literal null}.
+	 * @return {@literal true} if the given {@link ConverterRegistration} shall be skipped.
+	 * @since 2.3
+	 */
+	private boolean skip(ConverterRegistrationIntent intent) {
+
+		return intent.isDefaultConveter()
+				&& converterConfiguration.getSkipFor().contains(intent.getConverterRegistration().getConvertiblePair());
+	}
+
 	/**
 	 * Returns the target type to convert to in case we have a custom conversion registered to convert the given source
 	 * type into a Mongo native one.
@@ -765,4 +810,42 @@ private boolean isStoreSimpleType(Class<?> type) {
 			return storeTypeHolder.isSimpleType(type);
 		}
 	}
+
+	/**
+	 * Value object holding the actual {@link StoreConversions} and custom {@link Converter converters} configured for
+	 * registration.
+	 * 
+	 * @author Christoph Strobl
+	 * @since 2.3
+	 */
+	protected static class ConverterConfiguration {
+
+		private final StoreConversions storeConversions;
+		private final List<?> userConverters;
+		private final Set<ConvertiblePair> skipFor;
+
+		public ConverterConfiguration(StoreConversions storeConversions, List<?> userConverters) {
+			this(storeConversions, userConverters, Collections.emptySet());
+		}
+
+		public ConverterConfiguration(StoreConversions storeConversions, List<?> userConverters,
+				Collection<ConvertiblePair> skipFor) {
+
+			this.storeConversions = storeConversions;
+			this.userConverters = new ArrayList<>(userConverters);
+			this.skipFor = new HashSet<>(skipFor);
+		}
+
+		StoreConversions getStoreConversions() {
+			return storeConversions;
+		}
+
+		List<?> getUserConverters() {
+			return userConverters;
+		}
+
+		Set<ConvertiblePair> getSkipFor() {
+			return skipFor;
+		}
+	}
 }