Support AggregateReferences with custom id type.

Restructured reading conversion process into:
- converting technology base types (JDBC Arrays).
- standard and custom conversions.
- module specific conversions (AggregateReference).

Closes #1828

Author: schauder

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

@@ -27,9 +27,7 @@
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.springframework.context.ApplicationContextAware;
-import org.springframework.core.convert.ConverterNotFoundException;
 import org.springframework.core.convert.converter.Converter;
-import org.springframework.core.convert.converter.ConverterRegistry;
 import org.springframework.data.convert.CustomConversions;
 import org.springframework.data.jdbc.core.mapping.AggregateReference;
 import org.springframework.data.jdbc.core.mapping.JdbcValue;
@@ -80,7 +78,7 @@ public class MappingJdbcConverter extends MappingRelationalConverter implements
 	 * {@link #MappingJdbcConverter(RelationalMappingContext, RelationResolver, CustomConversions, JdbcTypeFactory)}
 	 * (MappingContext, RelationResolver, JdbcTypeFactory)} to convert arrays and large objects into JDBC-specific types.
 	 *
-	 * @param context          must not be {@literal null}.
+	 * @param context must not be {@literal null}.
 	 * @param relationResolver used to fetch additional relations from the database. Must not be {@literal null}.
 	 */
 	public MappingJdbcConverter(RelationalMappingContext context, RelationResolver relationResolver) {
@@ -91,19 +89,17 @@ public MappingJdbcConverter(RelationalMappingContext context, RelationResolver r
 
 		this.typeFactory = JdbcTypeFactory.unsupported();
 		this.relationResolver = relationResolver;
-
-		registerAggregateReferenceConverters();
 	}
 
 	/**
 	 * Creates a new {@link MappingJdbcConverter} given {@link MappingContext}.
 	 *
-	 * @param context          must not be {@literal null}.
+	 * @param context must not be {@literal null}.
 	 * @param relationResolver used to fetch additional relations from the database. Must not be {@literal null}.
-	 * @param typeFactory      must not be {@literal null}
+	 * @param typeFactory must not be {@literal null}
 	 */
 	public MappingJdbcConverter(RelationalMappingContext context, RelationResolver relationResolver,
-								CustomConversions conversions, JdbcTypeFactory typeFactory) {
+			CustomConversions conversions, JdbcTypeFactory typeFactory) {
 
 		super(context, conversions);
 
@@ -112,14 +108,6 @@ public MappingJdbcConverter(RelationalMappingContext context, RelationResolver r
 
 		this.typeFactory = typeFactory;
 		this.relationResolver = relationResolver;
-
-		registerAggregateReferenceConverters();
-	}
-
-	private void registerAggregateReferenceConverters() {
-
-		ConverterRegistry registry = (ConverterRegistry) getConversionService();
-		AggregateReferenceConverters.getConvertersToRegister(getConversionService()).forEach(registry::addConverter);
 	}
 
 	@Nullable
@@ -185,33 +173,48 @@ private Class<?> doGetColumnType(RelationalPersistentProperty property) {
 	}
 
 	@Override
-	@Nullable
-	public Object readValue(@Nullable Object value, TypeInformation<?> type) {
-
-		if (value == null) {
-			return value;
-		}
+	protected Object readTechnologyType(Object value) {
 
 		if (value instanceof Array array) {
 			try {
-				return super.readValue(array.getArray(), type);
-			} catch (SQLException | ConverterNotFoundException e) {
+				return array.getArray();
+			} catch (SQLException e) {
 				LOG.info("Failed to extract a value of type %s from an Array; Attempting to use standard conversions", e);
+
 			}
 		}
 
-		return super.readValue(value, type);
+		return value;
+	}
+
+	@Override
+	protected TypeInformation<?> determineModuleReadTarget(TypeInformation<?> ultimateTargetType) {
+
+		if (AggregateReference.class.isAssignableFrom(ultimateTargetType.getType())) {
+			// the id type of a AggregateReference
+			return ultimateTargetType.getTypeArguments().get(1);
+		}
+		return ultimateTargetType;
 	}
 
 	@Override
+	protected Object readModuleType(Object value, TypeInformation<?> targetType) {
+
+		if (AggregateReference.class.isAssignableFrom(targetType.getType())) {
+			return AggregateReference.to(value);
+		}
+		return value;
+	}
+
 	@Nullable
-	public Object writeValue(@Nullable Object value, TypeInformation<?> type) {
+	@Override
+	protected Object getPotentiallyConvertedSimpleWrite(Object value, TypeInformation<?> type) {
 
-		if (value == null) {
-			return null;
+		if (value instanceof AggregateReference<?, ?> aggregateReference) {
+			return writeValue(aggregateReference.getId(), type);
 		}
 
-		return super.writeValue(value, type);
+		return super.getPotentiallyConvertedSimpleWrite(value, type);
 	}
 
 	private boolean canWriteAsJdbcValue(@Nullable Object value) {
@@ -285,7 +288,7 @@ public <R> R readAndResolve(TypeInformation<R> type, RowDocument source, Identif
 
 	@Override
 	protected RelationalPropertyValueProvider newValueProvider(RowDocumentAccessor documentAccessor,
-															   ValueExpressionEvaluator evaluator, ConversionContext context) {
+			ValueExpressionEvaluator evaluator, ConversionContext context) {
 
 		if (context instanceof ResolvingConversionContext rcc) {
 
@@ -314,7 +317,7 @@ class ResolvingRelationalPropertyValueProvider implements RelationalPropertyValu
 		private final Identifier identifier;
 
 		private ResolvingRelationalPropertyValueProvider(AggregatePathValueProvider delegate, RowDocumentAccessor accessor,
-														 ResolvingConversionContext context, Identifier identifier) {
+				ResolvingConversionContext context, Identifier identifier) {
 
 			AggregatePath path = context.aggregatePath();
 
@@ -323,15 +326,15 @@ private ResolvingRelationalPropertyValueProvider(AggregatePathValueProvider dele
 			this.context = context;
 			this.identifier = path.isEntity()
 					? potentiallyAppendIdentifier(identifier, path.getRequiredLeafEntity(),
-					property -> delegate.getValue(path.append(property)))
+							property -> delegate.getValue(path.append(property)))
 					: identifier;
 		}
 
 		/**
 		 * Conditionally append the identifier if the entity has an identifier property.
 		 */
 		static Identifier potentiallyAppendIdentifier(Identifier base, RelationalPersistentEntity<?> entity,
-													  Function<RelationalPersistentProperty, Object> getter) {
+				Function<RelationalPersistentProperty, Object> getter) {
 
 			if (entity.hasIdProperty()) {
 
@@ -460,7 +463,7 @@ public RelationalPropertyValueProvider withContext(ConversionContext context) {
 
 			return context == this.context ? this
 					: new ResolvingRelationalPropertyValueProvider(delegate.withContext(context), accessor,
-					(ResolvingConversionContext) context, identifier);
+							(ResolvingConversionContext) context, identifier);
 		}
 	}
 
@@ -472,7 +475,7 @@ public RelationalPropertyValueProvider withContext(ConversionContext context) {
 	 * @param identifier
 	 */
 	private record ResolvingConversionContext(ConversionContext delegate, AggregatePath aggregatePath,
-											  Identifier identifier) implements ConversionContext {
+			Identifier identifier) implements ConversionContext {
 
 		@Override
 		public <S> S convert(Object source, TypeInformation<? extends S> typeHint) {

spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/convert/BasicRelationalConverterAggregateReferenceUnitTests.java renamed to spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/convert/MappingJdbcConverterAggregateReferenceUnitTests.java

@@ -32,15 +32,15 @@
  *
  * @author Jens Schauder
  */
-public class BasicRelationalConverterAggregateReferenceUnitTests {
+class MappingJdbcConverterAggregateReferenceUnitTests {
 
 	JdbcMappingContext context = new JdbcMappingContext();
 	JdbcConverter converter = new MappingJdbcConverter(context, mock(RelationResolver.class));
 
 	RelationalPersistentEntity<?> entity = context.getRequiredPersistentEntity(DummyEntity.class);
 
 	@Test // DATAJDBC-221
-	public void convertsToAggregateReference() {
+	void convertsToAggregateReference() {
 
 		final RelationalPersistentProperty property = entity.getRequiredPersistentProperty("reference");
 
@@ -51,7 +51,7 @@ public void convertsToAggregateReference() {
 	}
 
 	@Test // DATAJDBC-221
-	public void convertsFromAggregateReference() {
+	void convertsFromAggregateReference() {
 
 		final RelationalPersistentProperty property = entity.getRequiredPersistentProperty("reference");