Polishing.

Hide actual converters by making these private classes, expose factory method to construct converters. Avoid stream API usage on converter code paths. Remove unused imports. Clean up tests.

Original pull request: #993.
See #992

Author: mp911de

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

@@ -15,6 +15,8 @@
  */
 package org.springframework.data.jdbc.core.convert;
 
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Set;
 
@@ -32,20 +34,31 @@
  * content of the {@link AggregateReference}.
  *
  * @author Jens Schauder
- * @since 2.6
+ * @author Mark Paluch
+ * @since 2.3
  */
 class AggregateReferenceConverters {
+
 	/**
-	 * Prevent instantiation.
+	 * Returns the converters to be registered.
+	 *
+	 * @return a collection of converters. Guaranteed to be not {@literal null}.
 	 */
-	private AggregateReferenceConverters() {}
+	public static Collection<GenericConverter> getConvertersToRegister(ConversionService conversionService) {
+
+		return Arrays.asList(new AggregateReferenceToSimpleTypeConverter(conversionService),
+				new SimpleTypeToAggregateReferenceConverter(conversionService));
+	}
 
 	/**
 	 * Converts from an AggregateReference to its id, leaving the conversion of the id to the ultimate target type to the
 	 * delegate {@link ConversionService}.
 	 */
 	@WritingConverter
-	static class AggregateReferenceToSimpleTypeConverter implements GenericConverter {
+	private static class AggregateReferenceToSimpleTypeConverter implements GenericConverter {
+
+		private static final Set<ConvertiblePair> CONVERTIBLE_TYPES = Collections
+				.singleton(new ConvertiblePair(AggregateReference.class, Object.class));
 
 		private final ConversionService delegate;
 
@@ -55,7 +68,7 @@ static class AggregateReferenceToSimpleTypeConverter implements GenericConverter
 
 		@Override
 		public Set<ConvertiblePair> getConvertibleTypes() {
-			return Collections.singleton(new ConvertiblePair(AggregateReference.class, Object.class));
+			return CONVERTIBLE_TYPES;
 		}
 
 		@Override
@@ -90,7 +103,10 @@ public Object convert(@Nullable Object source, TypeDescriptor sourceDescriptor,
 	 * {@link ConversionService}.
 	 */
 	@ReadingConverter
-	static class SimpleTypeToAggregateReferenceConverter implements GenericConverter {
+	private static class SimpleTypeToAggregateReferenceConverter implements GenericConverter {
+
+		private static final Set<ConvertiblePair> CONVERTIBLE_TYPES = Collections
+				.singleton(new ConvertiblePair(Object.class, AggregateReference.class));
 
 		private final ConversionService delegate;
 
@@ -100,7 +116,7 @@ static class SimpleTypeToAggregateReferenceConverter implements GenericConverter
 
 		@Override
 		public Set<ConvertiblePair> getConvertibleTypes() {
-			return Collections.singleton(new ConvertiblePair(Object.class, AggregateReference.class));
+			return CONVERTIBLE_TYPES;
 		}
 
 		@Override

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

@@ -19,11 +19,13 @@
 import java.sql.JDBCType;
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
 import org.springframework.core.ResolvableType;
@@ -224,7 +226,7 @@ public Object readValue(@Nullable Object value, TypeInformation<?> type) {
 		if (getConversions().hasCustomReadTarget(value.getClass(), type.getType())) {
 
 			TypeDescriptor sourceDescriptor = TypeDescriptor.valueOf(value.getClass());
-			TypeDescriptor targetDescriptor = typeInformationToTypeDescriptor(type);
+			TypeDescriptor targetDescriptor = createTypeDescriptor(type);
 
 			return getConversionService().convert(value, sourceDescriptor,
 					targetDescriptor);
@@ -241,11 +243,15 @@ public Object readValue(@Nullable Object value, TypeInformation<?> type) {
 		return super.readValue(value, type);
 	}
 
-	private static TypeDescriptor typeInformationToTypeDescriptor(TypeInformation<?> type) {
+	private static TypeDescriptor createTypeDescriptor(TypeInformation<?> type) {
 
-		Class<?>[] generics = type.getTypeArguments().stream().map(TypeInformation::getType).toArray(Class[]::new);
+		List<TypeInformation<?>> typeArguments = type.getTypeArguments();
+		Class<?>[] generics = new Class[typeArguments.size()];
+		for (int i = 0; i < typeArguments.size(); i++) {
+			generics[i] = typeArguments.get(i).getType();
+		}
 
-		return new TypeDescriptor(ResolvableType.forClassWithGenerics(type.getType(), generics), null, null);
+		return new TypeDescriptor(ResolvableType.forClassWithGenerics(type.getType(), generics), type.getType(), null);
 	}
 
 	/*

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

@@ -20,8 +20,6 @@
 import java.util.Collections;
 import java.util.List;
 
-import org.springframework.core.convert.ConversionService;
-import org.springframework.core.convert.converter.Converter;
 import org.springframework.core.convert.converter.GenericConverter.ConvertiblePair;
 import org.springframework.core.convert.support.DefaultConversionService;
 import org.springframework.data.convert.CustomConversions;
@@ -46,9 +44,8 @@ public class JdbcCustomConversions extends CustomConversions {
 
 		List<Object> converters = new ArrayList<>(Jsr310TimestampBasedConverters.getConvertersToRegister());
 
-		ConversionService conversionService = DefaultConversionService.getSharedInstance();
-		converters.add(new AggregateReferenceConverters.AggregateReferenceToSimpleTypeConverter(conversionService));
-		converters.add(new AggregateReferenceConverters.SimpleTypeToAggregateReferenceConverter(conversionService));
+		converters
+				.addAll(AggregateReferenceConverters.getConvertersToRegister(DefaultConversionService.getSharedInstance()));
 
 		STORE_CONVERTERS = Collections.unmodifiableCollection(converters);
 

spring-data-jdbc/src/test/java/org/springframework/data/jdbc/core/convert/AggregateReferenceConvertersUnitTests.java

@@ -15,69 +15,83 @@
  */
 package org.springframework.data.jdbc.core.convert;
 
+import static org.assertj.core.api.Assertions.*;
+
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+
 import org.springframework.core.ResolvableType;
 import org.springframework.core.convert.TypeDescriptor;
+import org.springframework.core.convert.support.ConfigurableConversionService;
 import org.springframework.core.convert.support.DefaultConversionService;
 import org.springframework.data.jdbc.core.mapping.AggregateReference;
 
-import static org.assertj.core.api.Assertions.*;
-
 /**
  * Tests for converters from an to {@link org.springframework.data.jdbc.core.mapping.AggregateReference}.
  *
  * @author Jens Schauder
+ * @author Mark Paluch
  */
 class AggregateReferenceConvertersUnitTests {
 
-	AggregateReferenceConverters.SimpleTypeToAggregateReferenceConverter simpleToAggregate = new AggregateReferenceConverters.SimpleTypeToAggregateReferenceConverter(DefaultConversionService.getSharedInstance());
-	AggregateReferenceConverters.AggregateReferenceToSimpleTypeConverter aggregateToSimple = new AggregateReferenceConverters.AggregateReferenceToSimpleTypeConverter(DefaultConversionService.getSharedInstance());
+	ConfigurableConversionService conversionService;
+
+	@BeforeEach
+	void setUp() {
+		conversionService = new DefaultConversionService();
+		AggregateReferenceConverters.getConvertersToRegister(DefaultConversionService.getSharedInstance())
+				.forEach(it -> conversionService.addConverter(it));
+	}
 
-	@Test // #992
+	@Test // GH-992
 	void convertsFromSimpleValue() {
 
 		ResolvableType aggregateReferenceWithIdTypeInteger = ResolvableType.forClassWithGenerics(AggregateReference.class, String.class, Integer.class);
-		final Object converted = simpleToAggregate.convert(23, TypeDescriptor.forObject(23), new TypeDescriptor(aggregateReferenceWithIdTypeInteger, null, null));
+		Object converted = conversionService.convert(23, TypeDescriptor.forObject(23),
+				new TypeDescriptor(aggregateReferenceWithIdTypeInteger, null, null));
 
 		assertThat(converted).isEqualTo(AggregateReference.to(23));
 	}
 
-	@Test // #992
+	@Test // GH-992
 	void convertsFromSimpleValueThatNeedsSeparateConversion() {
 
 		ResolvableType aggregateReferenceWithIdTypeInteger = ResolvableType.forClassWithGenerics(AggregateReference.class, String.class, Long.class);
-		final Object converted = simpleToAggregate.convert(23, TypeDescriptor.forObject(23), new TypeDescriptor(aggregateReferenceWithIdTypeInteger, null, null));
+		Object converted = conversionService.convert(23, TypeDescriptor.forObject(23),
+				new TypeDescriptor(aggregateReferenceWithIdTypeInteger, null, null));
 
 		assertThat(converted).isEqualTo(AggregateReference.to(23L));
 	}
 
-	@Test // #992
+	@Test // GH-992
 	void convertsFromSimpleValueWithMissingTypeInformation() {
 
-		final Object converted = simpleToAggregate.convert(23, TypeDescriptor.forObject(23), TypeDescriptor.valueOf(AggregateReference.class));
+		Object converted = conversionService.convert(23, TypeDescriptor.forObject(23),
+				TypeDescriptor.valueOf(AggregateReference.class));
 
 		assertThat(converted).isEqualTo(AggregateReference.to(23));
 	}
 
-	@Test // #992
+	@Test // GH-992
 	void convertsToSimpleValue() {
 
-		final AggregateReference<Object, Integer> source = AggregateReference.to(23);
+		AggregateReference<Object, Integer> source = AggregateReference.to(23);
 
-		final Object converted = aggregateToSimple.convert(source, TypeDescriptor.forObject(source), TypeDescriptor.valueOf(Integer.class));
+		Object converted = conversionService.convert(source, TypeDescriptor.forObject(source),
+				TypeDescriptor.valueOf(Integer.class));
 
 		assertThat(converted).isEqualTo(23);
 	}
 
-	@Test // #992
+	@Test // GH-992
 	void convertsToSimpleValueThatNeedsSeparateConversion() {
 
-		final AggregateReference<Object, Integer> source = AggregateReference.to(23);
+		AggregateReference<Object, Integer> source = AggregateReference.to(23);
 
-		final Object converted = aggregateToSimple.convert(source, TypeDescriptor.forObject(source), TypeDescriptor.valueOf(Long.class));
+		Object converted = conversionService.convert(source, TypeDescriptor.forObject(source),
+				TypeDescriptor.valueOf(Long.class));
 
 		assertThat(converted).isEqualTo(23L);
 	}
 
-
-}
+}

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

@@ -19,9 +19,7 @@
 import java.util.Optional;
 import java.util.function.Function;
 
-import org.springframework.core.ResolvableType;
 import org.springframework.core.convert.ConversionService;
-import org.springframework.core.convert.TypeDescriptor;
 import org.springframework.core.convert.support.ConfigurableConversionService;
 import org.springframework.core.convert.support.DefaultConversionService;
 import org.springframework.data.convert.CustomConversions;