Polishing.

Increase visibility of converter builders.

Refine generics naming towards DV/SV instead of A/B to easier identify store-native values and domains-specific values in the API. Refactor PropertyValueConversions.hasValueConverter into a non-default method.

Tweak documentation.

See #1484
Original pull request: #2566.

Author: mp911de

src/main/java/org/springframework/data/convert/CustomConversions.java

@@ -55,7 +55,7 @@
  * Value object to capture custom conversion. That is essentially a {@link List} of converters and some additional logic
  * around them. The converters build up two sets of types which store-specific basic types can be converted into and
  * from. These types will be considered simple ones (which means they neither need deeper inspection nor nested
- * conversion. Thus the {@link CustomConversions} also act as factory for {@link SimpleTypeHolder} .
+ * conversion. Thus, the {@link CustomConversions} also act as factory for {@link SimpleTypeHolder} .
  *
  * @author Oliver Gierke
  * @author Thomas Darimont
@@ -195,22 +195,23 @@ public void registerConvertersIn(ConverterRegistry conversionService) {
 	 * @since 2.7
 	 */
 	public boolean hasPropertyValueConverter(PersistentProperty<?> property) {
-		return propertyValueConversions != null ? propertyValueConversions.hasValueConverter(property) : false;
+		return propertyValueConversions != null && propertyValueConversions.hasValueConverter(property);
 	}
 
 	/**
 	 * Delegate to obtain the {@link PropertyValueConverter} for the given {@literal property} from
 	 * {@link PropertyValueConversions}.
 	 *
-	 * @param property must not be {@literal null}. param <A> domain specific type
-	 * @param <B> store native type
+	 * @param property must not be {@literal null}.
+	 * @param <DV> domain-specific type
+	 * @param <SV> store-native type
 	 * @param <C> conversion context type
 	 * @return the suitable {@link PropertyValueConverter} or {@literal null} if none available.
 	 * @see PropertyValueConversions#getValueConverter(PersistentProperty)
 	 * @since 2.7
 	 */
 	@Nullable
-	public <A, B, C extends PersistentProperty<C>, D extends ValueConversionContext<C>> PropertyValueConverter<A, B, D> getPropertyValueConverter(
+	public <DV, SV, C extends PersistentProperty<C>, VCC extends ValueConversionContext<C>> PropertyValueConverter<DV, SV, VCC> getPropertyValueConverter(
 			C property) {
 		return propertyValueConversions != null ? propertyValueConversions.getValueConverter(property) : null;
 	}

src/main/java/org/springframework/data/convert/PropertyValueConversions.java

@@ -18,7 +18,6 @@
 import java.util.function.Consumer;
 
 import org.springframework.data.mapping.PersistentProperty;
-import org.springframework.lang.Nullable;
 
 /**
  * {@link PropertyValueConversions} provides access to {@link PropertyValueConverter converters} that may only be
@@ -38,26 +37,25 @@ public interface PropertyValueConversions {
 	 * @param property must not be {@literal null}.
 	 * @return {@literal true} if a specific {@link PropertyValueConverter} is available.
 	 */
-	default boolean hasValueConverter(PersistentProperty<?> property) {
-		return getValueConverter((PersistentProperty) property) != null;
-	}
+	boolean hasValueConverter(PersistentProperty<?> property);
 
 	/**
-	 * Get the {@link PropertyValueConverter} for the given {@literal property} if present.
+	 * Get the {@link PropertyValueConverter} for the given {@literal property}.
 	 *
-	 * @param property must not be {@literal null}. param <A> domain specific type
-	 * @param <B> store native type
+	 * @param property must not be {@literal null}.
+	 * @param <DV> domain-specific type
+	 * @param <SV> store-native type
 	 * @param <C> conversion context type
-	 * @return the suitable {@link PropertyValueConverter} or {@literal null} if none available.
+	 * @return the suitable {@link PropertyValueConverter}.
 	 */
-	@Nullable
-	<A, B, C extends PersistentProperty<C>, D extends ValueConversionContext<C>> PropertyValueConverter<A, B, D> getValueConverter(
+	<DV, SV, C extends PersistentProperty<C>, VCC extends ValueConversionContext<C>> PropertyValueConverter<DV, SV, VCC> getValueConverter(
 			C property);
 
 	/**
 	 * Helper that allows to create {@link PropertyValueConversions} instance with the configured
 	 * {@link PropertyValueConverter converters} provided via the given callback.
 	 */
+	@SuppressWarnings({ "rawtypes", "unchecked" })
 	static <P extends PersistentProperty<P>> PropertyValueConversions simple(
 			Consumer<PropertyValueConverterRegistrar<P>> config) {
 

src/main/java/org/springframework/data/convert/PropertyValueConverter.java

@@ -21,44 +21,44 @@
 import org.springframework.lang.Nullable;
 
 /**
- * {@link PropertyValueConverter} provides a symmetric way of converting certain properties from domain to store
- * specific values.
+ * {@link PropertyValueConverter} provides a symmetric way of converting certain properties from domain to
+ * store-specific values.
  * <p>
  * A {@link PropertyValueConverter} is, other than a {@link ReadingConverter} or {@link WritingConverter}, only applied
- * to special annotated fields which allows a fine grained conversion of certain values within a specific context.
+ * to special annotated fields which allows a fine-grained conversion of certain values within a specific context.
  *
  * @author Christoph Strobl
- * @param <A> domain specific type.
- * @param <B> store native type.
+ * @param <DV> domain-specific type.
+ * @param <SV> store-native type.
  * @param <C> the store specific {@link ValueConversionContext conversion context}.
  * @since 2.7
  */
-public interface PropertyValueConverter<A, B, C extends ValueConversionContext<? extends PersistentProperty<?>>> {
+public interface PropertyValueConverter<DV, SV, C extends ValueConversionContext<? extends PersistentProperty<?>>> {
 
 	/**
-	 * Convert the given store specific value into it's domain value representation. Typically a {@literal read}
+	 * Convert the given store specific value into it's domain value representation. Typically, a {@literal read}
 	 * operation.
 	 *
 	 * @param value can be {@literal null}.
 	 * @param context never {@literal null}.
 	 * @return the converted value. Can be {@literal null}.
 	 */
 	@Nullable
-	A read(@Nullable B value, C context);
+	DV read(@Nullable SV value, C context);
 
 	/**
-	 * Convert the given domain specific value into it's native store representation. Typically a {@literal write}
+	 * Convert the given domain-specific value into it's native store representation. Typically, a {@literal write}
 	 * operation.
 	 *
 	 * @param value can be {@literal null}.
 	 * @param context never {@literal null}.
 	 * @return the converted value. Can be {@literal null}.
 	 */
 	@Nullable
-	B write(@Nullable A value, C context);
+	SV write(@Nullable DV value, C context);
 
 	/**
-	 * NoOp {@link PropertyValueConverter} implementation.
+	 * No-op {@link PropertyValueConverter} implementation.
 	 *
 	 * @author Christoph Strobl
 	 */
@@ -67,13 +67,15 @@ enum ObjectToObjectPropertyValueConverter implements PropertyValueConverter {
 
 		INSTANCE;
 
+		@Nullable
 		@Override
-		public Object read(Object value, ValueConversionContext context) {
+		public Object read(@Nullable Object value, ValueConversionContext context) {
 			return value;
 		}
 
+		@Nullable
 		@Override
-		public Object write(Object value, ValueConversionContext context) {
+		public Object write(@Nullable Object value, ValueConversionContext context) {
 			return value;
 		}
 	}
@@ -83,26 +85,28 @@ public Object write(Object value, ValueConversionContext context) {
 	 *
 	 * @author Oliver Drotbohm
 	 */
-	class FunctionPropertyValueConverter<A, B, P extends PersistentProperty<P>>
-			implements PropertyValueConverter<A, B, ValueConversionContext<P>> {
+	class FunctionPropertyValueConverter<DV, SV, P extends PersistentProperty<P>>
+			implements PropertyValueConverter<DV, SV, ValueConversionContext<P>> {
 
-		private final BiFunction<A, ValueConversionContext<P>, B> writer;
-		private final BiFunction<B, ValueConversionContext<P>, A> reader;
+		private final BiFunction<DV, ValueConversionContext<P>, SV> writer;
+		private final BiFunction<SV, ValueConversionContext<P>, DV> reader;
 
-		public FunctionPropertyValueConverter(BiFunction<A, ValueConversionContext<P>, B> writer,
-				BiFunction<B, ValueConversionContext<P>, A> reader) {
+		public FunctionPropertyValueConverter(BiFunction<DV, ValueConversionContext<P>, SV> writer,
+				BiFunction<SV, ValueConversionContext<P>, DV> reader) {
 
 			this.writer = writer;
 			this.reader = reader;
 		}
 
+		@Nullable
 		@Override
-		public B write(A value, ValueConversionContext<P> context) {
+		public SV write(@Nullable DV value, ValueConversionContext<P> context) {
 			return writer.apply(value, context);
 		}
 
+		@Nullable
 		@Override
-		public A read(B value, ValueConversionContext<P> context) {
+		public DV read(@Nullable SV value, ValueConversionContext<P> context) {
 			return reader.apply(value, context);
 		}
 	}

src/main/java/org/springframework/data/convert/PropertyValueConverterFactories.java

@@ -18,15 +18,14 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.EnumSet;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
 
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.BeanFactory;
-import org.springframework.beans.factory.NoSuchBeanDefinitionException;
 import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
 import org.springframework.data.mapping.PersistentProperty;
 import org.springframework.lang.Nullable;
@@ -120,29 +119,26 @@ static class BeanFactoryAwarePropertyValueConverterFactory implements PropertyVa
 		}
 
 		@Override
-		public <S, T, C extends ValueConversionContext<?>> PropertyValueConverter<S, T, C> getConverter(
-				Class<? extends PropertyValueConverter<S, T, C>> converterType) {
+		public <DV, SV, C extends ValueConversionContext<?>> PropertyValueConverter<DV, SV, C> getConverter(
+				Class<? extends PropertyValueConverter<DV, SV, C>> converterType) {
 
-			Assert.state(beanFactory != null, "BeanFactory must not be null. Did you forget to set it!");
 			Assert.notNull(converterType, "ConverterType must not be null!");
 
-			try {
-				return beanFactory.getBean(converterType);
-			} catch (NoSuchBeanDefinitionException exception) {
+			PropertyValueConverter<DV, SV, C> converter = beanFactory.getBeanProvider(converterType).getIfAvailable();
 
-				if (beanFactory instanceof AutowireCapableBeanFactory) {
-					return (PropertyValueConverter<S, T, C>) ((AutowireCapableBeanFactory) beanFactory).createBean(converterType,
-							AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR, false);
-				}
+			if (converter == null && beanFactory instanceof AutowireCapableBeanFactory) {
+				return (PropertyValueConverter<DV, SV, C>) ((AutowireCapableBeanFactory) beanFactory).createBean(converterType,
+						AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR, false);
 			}
-			return null;
+
+			return converter;
 		}
 	}
 
 	/**
 	 * {@link PropertyValueConverterFactory} implementation that serves {@link PropertyValueConverter} from a given
 	 * {@link ValueConverterRegistry registry}.
-	 * 
+	 *
 	 * @author Christoph Strobl
 	 * @since 2.7
 	 */
@@ -158,9 +154,9 @@ static class ConfiguredInstanceServingValueConverterFactory implements PropertyV
 
 		@Nullable
 		@Override
-		public <A, B, C extends ValueConversionContext<?>> PropertyValueConverter<A, B, C> getConverter(
+		public <DV, SV, C extends ValueConversionContext<?>> PropertyValueConverter<DV, SV, C> getConverter(
 				PersistentProperty<?> property) {
-			return (PropertyValueConverter<A, B, C>) converterRegistry.getConverter(property.getOwner().getType(),
+			return (PropertyValueConverter<DV, SV, C>) converterRegistry.getConverter(property.getOwner().getType(),
 					property.getName());
 		}
 
@@ -174,7 +170,7 @@ public <S, T, C extends ValueConversionContext<?>> PropertyValueConverter<S, T,
 	/**
 	 * {@link PropertyValueConverterFactory} implementation that caches converters provided by an underlying
 	 * {@link PropertyValueConverterFactory factory}.
-	 * 
+	 *
 	 * @author Christoph Strobl
 	 * @since 2.7
 	 */
@@ -191,7 +187,7 @@ static class CachingPropertyValueConverterFactory implements PropertyValueConver
 
 		@Nullable
 		@Override
-		public <S, T, C extends ValueConversionContext<?>> PropertyValueConverter<S, T, C> getConverter(
+		public <DV, SV, C extends ValueConversionContext<?>> PropertyValueConverter<DV, SV, C> getConverter(
 				PersistentProperty<?> property) {
 
 			Optional<PropertyValueConverter<?, ?, ? extends ValueConversionContext<?>>> converter = cache.get(property);
@@ -201,8 +197,8 @@ public <S, T, C extends ValueConversionContext<?>> PropertyValueConverter<S, T,
 		}
 
 		@Override
-		public <S, T, C extends ValueConversionContext<?>> PropertyValueConverter<S, T, C> getConverter(
-				Class<? extends PropertyValueConverter<S, T, C>> converterType) {
+		public <DV, SV, C extends ValueConversionContext<?>> PropertyValueConverter<DV, SV, C> getConverter(
+				Class<? extends PropertyValueConverter<DV, SV, C>> converterType) {
 
 			Optional<PropertyValueConverter<?, ?, ? extends ValueConversionContext<?>>> converter = cache.get(converterType);
 
@@ -212,8 +208,8 @@ public <S, T, C extends ValueConversionContext<?>> PropertyValueConverter<S, T,
 
 		static class Cache {
 
-			Map<PersistentProperty<?>, Optional<PropertyValueConverter<?, ?, ? extends ValueConversionContext<?>>>> perPropertyCache = new HashMap<>();
-			Map<Class<?>, Optional<PropertyValueConverter<?, ?, ? extends ValueConversionContext<?>>>> typeCache = new HashMap<>();
+			Map<PersistentProperty<?>, Optional<PropertyValueConverter<?, ?, ? extends ValueConversionContext<?>>>> perPropertyCache = new ConcurrentHashMap<>();
+			Map<Class<?>, Optional<PropertyValueConverter<?, ?, ? extends ValueConversionContext<?>>>> typeCache = new ConcurrentHashMap<>();
 
 			Optional<PropertyValueConverter<?, ?, ? extends ValueConversionContext<?>>> get(PersistentProperty<?> property) {
 				return perPropertyCache.get(property);
@@ -226,7 +222,12 @@ static class Cache {
 			<S, T, C extends ValueConversionContext<?>> PropertyValueConverter<S, T, C> cache(PersistentProperty<?> property,
 					@Nullable PropertyValueConverter<S, T, C> converter) {
 				perPropertyCache.putIfAbsent(property, Optional.ofNullable(converter));
-				cache(property.getValueConverterType(), converter);
+
+				Class<? extends PropertyValueConverter<?, ?, ? extends ValueConversionContext<? extends PersistentProperty<?>>>> valueConverterType = property
+						.getValueConverterType();
+				if (valueConverterType != null) {
+					cache(valueConverterType, converter);
+				}
 				return converter;
 			}
 

src/main/java/org/springframework/data/convert/PropertyValueConverterFactory.java

@@ -44,35 +44,35 @@ public interface PropertyValueConverterFactory {
 	 * Get the {@link PropertyValueConverter} applicable for the given {@link PersistentProperty}.
 	 *
 	 * @param property must not be {@literal null}.
-	 * @param <A> domain specific type.
-	 * @param <B> store native type.
+	 * @param <DV> domain-specific type.
+	 * @param <SV> store-native type.
 	 * @param <C> value conversion context to use.
 	 * @return can be {@literal null}.
 	 */
-	@Nullable
 	@SuppressWarnings("unchecked")
-	default <A, B, C extends ValueConversionContext<?>> PropertyValueConverter<A, B, C> getConverter(
+	@Nullable
+	default <DV, SV, C extends ValueConversionContext<?>> PropertyValueConverter<DV, SV, C> getConverter(
 			PersistentProperty<?> property) {
 
 		if (!property.hasValueConverter()) {
 			return null;
 		}
 
-		return getConverter((Class<PropertyValueConverter<A, B, C>>) property.getValueConverterType());
+		return getConverter((Class<PropertyValueConverter<DV, SV, C>>) property.getValueConverterType());
 	}
 
 	/**
 	 * Get the converter by its type.
 	 *
 	 * @param converterType must not be {@literal null}.
-	 * @param <A> domain specific type.
-	 * @param <B> store native type.
+	 * @param <DV> domain-specific type.
+	 * @param <SV> store-native type.
 	 * @param <C> value conversion context to use.
-	 * @return
+	 * @return can be {@literal null}.
 	 */
 	@Nullable
-	<A, B, C extends ValueConversionContext<?>> PropertyValueConverter<A, B, C> getConverter(
-			Class<? extends PropertyValueConverter<A, B, C>> converterType);
+	<DV, SV, C extends ValueConversionContext<?>> PropertyValueConverter<DV, SV, C> getConverter(
+			Class<? extends PropertyValueConverter<DV, SV, C>> converterType);
 
 	/**
 	 * Obtain a simple {@link PropertyValueConverterFactory} capable of instantiating {@link PropertyValueConverter}