Simplified structure of MappingRelationalConverter.readValue().

See #1828
Original pull request #2062

Author: schauder

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/core/convert/MappingJdbcConverter.java

@@ -27,10 +27,7 @@
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.springframework.context.ApplicationContextAware;
-import org.springframework.core.convert.ConversionException;
-import org.springframework.core.convert.ConversionFailedException;
 import org.springframework.core.convert.converter.Converter;
-import org.springframework.dao.DataAccessException;
 import org.springframework.dao.NonTransientDataAccessException;
 import org.springframework.data.convert.CustomConversions;
 import org.springframework.data.jdbc.core.mapping.AggregateReference;
@@ -39,7 +36,6 @@
 import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.data.mapping.model.SimpleTypeHolder;
 import org.springframework.data.mapping.model.ValueExpressionEvaluator;
-import org.springframework.data.relational.core.conversion.DbActionExecutionException;
 import org.springframework.data.relational.core.conversion.MappingRelationalConverter;
 import org.springframework.data.relational.core.conversion.ObjectPath;
 import org.springframework.data.relational.core.conversion.RelationalConverter;
@@ -177,8 +173,33 @@ private Class<?> doGetColumnType(RelationalPersistentProperty property) {
 		return componentColumnType;
 	}
 
+	/**
+	 * Read and convert a single value that is coming from a database to the {@literal targetType} expected by the domain
+	 * model.
+	 *
+	 * @param value a value as it is returned by the driver accessing the persistence store. May be {@code null}.
+	 * @param targetType {@link TypeInformation} into which the value is to be converted. Must not be {@code null}.
+	 * @return
+	 */
 	@Override
-	protected Object readTechnologyType(Object value) {
+	@Nullable
+	public Object readValue(@Nullable Object value, TypeInformation<?> targetType) {
+
+		if (null == value) {
+			return null;
+		}
+
+		TypeInformation<?> originalTargetType = targetType;
+		value = readJdbcArray(value);
+		targetType = determineNestedTargetType(targetType);
+
+		return readToAggregateReference(getPotentiallyConvertedSimpleRead(value, targetType), originalTargetType);
+	}
+
+	/**
+	 * Unwrap a Jdbc array, if such a value is provided
+	 */
+	private Object readJdbcArray(Object value) {
 
 		if (value instanceof Array array) {
 			try {
@@ -191,8 +212,11 @@ protected Object readTechnologyType(Object value) {
 		return value;
 	}
 
-	@Override
-	protected TypeInformation<?> determineModuleReadTarget(TypeInformation<?> ultimateTargetType) {
+	/**
+	 * Determine the id type of an {@link AggregateReference} that the rest of the conversion infrastructure needs to use
+	 * as a conversion target.
+	 */
+	private TypeInformation<?> determineNestedTargetType(TypeInformation<?> ultimateTargetType) {
 
 		if (AggregateReference.class.isAssignableFrom(ultimateTargetType.getType())) {
 			// the id type of a AggregateReference
@@ -201,8 +225,10 @@ protected TypeInformation<?> determineModuleReadTarget(TypeInformation<?> ultima
 		return ultimateTargetType;
 	}
 
-	@Override
-	protected Object readModuleType(Object value, TypeInformation<?> targetType) {
+	/**
+	 * Convert value to an {@link AggregateReference} if that is specified by the parameter targetType.
+	 */
+	private Object readToAggregateReference(Object value, TypeInformation<?> targetType) {
 
 		if (AggregateReference.class.isAssignableFrom(targetType.getType())) {
 			return AggregateReference.to(value);

spring-data-relational/src/main/java/org/springframework/data/relational/core/conversion/MappingRelationalConverter.java

@@ -609,9 +609,9 @@ private boolean shouldReadEmbeddable(ConversionContext context, RelationalPersis
 	}
 
 	/**
-	 * Read and convert a single value that is comming from a database to the {@literal targetType} expected by the domain
+	 * Read and convert a single value that is coming from a database to the {@literal targetType} expected by the domain
 	 * model.
-	 * 
+	 *
 	 * @param value a value as it is returned by the driver accessing the persistence store. May be {@code null}.
 	 * @param targetType {@link TypeInformation} into which the value is to be converted. Must not be {@code null}.
 	 * @return
@@ -624,49 +624,7 @@ public Object readValue(@Nullable Object value, TypeInformation<?> targetType) {
 			return null;
 		}
 
-		TypeInformation<?> originalTargetType = targetType;
-		value = readTechnologyType(value);
-		targetType = determineModuleReadTarget(targetType);
-
-		return readModuleType(getPotentiallyConvertedSimpleRead(value, targetType), originalTargetType);
-	}
-
-	/**
-	 * Convert a read value using module dependent special conversions. Spring Data JDBC for example uses this to
-	 * implement the conversion of AggregateReferences. There is no guarantee that the value is converted to the exact
-	 * required TypeInformation, nor that it is converted at all.
-	 * 
-	 * @param value the value read from the database. Must not be {@literal null}.
-	 * @param targetType the type to which the value should get converted if possible. Must not be {@literal null}.
-	 * @return a potentially converted value.
-	 */
-	protected Object readModuleType(Object value, TypeInformation<?> targetType) {
-		return value;
-	}
-
-	/**
-	 * Read technology specific values into objects that then can be fed in the normal conversion process for reading. An
-	 * example are the conversion of JDBCs {@literal Array} type to normal java arrays.
-	 * 
-	 * @param value a value read from the database
-	 * @return a preprocessed value suitable for technology-agnostic further processing.
-	 */
-	protected Object readTechnologyType(Object value) {
-		return value;
-	}
-
-	/**
-	 * When type is a type that has special support, this returns the type a value should be converted to before the
-	 * conversion to the special type happens. For example if type is AggregateReference this method returns the second
-	 * parameter type of AggregateReference, in order to allow conversions to handle that type.
-	 *
-	 * @param ultimateTargetType ultimate target type to be returned by the conversion process. Must not be
-	 *          {@literal null}.
-	 * @return a type that can be converted to the ultimate target type by module specific handling. Must not be
-	 *         {@literal null}.
-	 */
-	protected TypeInformation<?> determineModuleReadTarget(TypeInformation<?> ultimateTargetType) {
-		return ultimateTargetType;
+		return getPotentiallyConvertedSimpleRead(value, targetType);
 	}
 
 	/**