DATAJDBC-235 - Add support for configurable conversion.

We now support configurable conversion by introducing CustomConversions and RelationalConverter. CustomConversions is a registry for converters that should be applied on a per-type basis for properties. CustomConversions is typically registered as bean and fed into RelationalMappingContext and the newly introduced RelationalConverter to consider simple types and conversion rules.

RelationalConverter with its implementation BasicRelationalConverter encapsulates conversion infrastructure such as EntityInstantiator, CustomConversions, and MappingContext that is required during relational value conversion. BasicRelationalConverter is responsible for simple value conversion and entity instantiation to pull related code together. It's not in full charge of row result to object mapping as this responsibility remains as part of DataAccessStrategy.

This change supersedes and removes ConversionCustomizer.

Author: mp911de

src/main/java/org/springframework/data/jdbc/core/DefaultDataAccessStrategy.java

@@ -27,15 +27,15 @@
 import org.springframework.dao.EmptyResultDataAccessException;
 import org.springframework.dao.InvalidDataAccessApiUsageException;
 import org.springframework.dao.NonTransientDataAccessException;
-import org.springframework.data.convert.EntityInstantiators;
 import org.springframework.data.jdbc.support.JdbcUtil;
 import org.springframework.data.mapping.PersistentPropertyAccessor;
 import org.springframework.data.mapping.PropertyHandler;
 import org.springframework.data.mapping.PropertyPath;
-import org.springframework.data.mapping.model.ConvertingPropertyAccessor;
+import org.springframework.data.relational.core.conversion.RelationalConverter;
 import org.springframework.data.relational.core.mapping.RelationalMappingContext;
 import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
 import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
+import org.springframework.data.util.ClassTypeInformation;
 import org.springframework.jdbc.core.RowMapper;
 import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
 import org.springframework.jdbc.core.namedparam.NamedParameterJdbcOperations;
@@ -48,6 +48,7 @@
  * The default {@link DataAccessStrategy} is to generate SQL statements based on meta data from the entity.
  *
  * @author Jens Schauder
+ * @author Mark Paluch
  * @since 1.0
  */
 @RequiredArgsConstructor
@@ -59,21 +60,21 @@ public class DefaultDataAccessStrategy implements DataAccessStrategy {
 
 	private final @NonNull SqlGeneratorSource sqlGeneratorSource;
 	private final @NonNull RelationalMappingContext context;
+	private final @NonNull RelationalConverter converter;
 	private final @NonNull NamedParameterJdbcOperations operations;
-	private final @NonNull EntityInstantiators instantiators;
 	private final @NonNull DataAccessStrategy accessStrategy;
 
 	/**
 	 * Creates a {@link DefaultDataAccessStrategy} which references it self for resolution of recursive data accesses.
 	 * Only suitable if this is the only access strategy in use.
 	 */
 	public DefaultDataAccessStrategy(SqlGeneratorSource sqlGeneratorSource, RelationalMappingContext context,
-			NamedParameterJdbcOperations operations, EntityInstantiators instantiators) {
+			RelationalConverter converter, NamedParameterJdbcOperations operations) {
 
 		this.sqlGeneratorSource = sqlGeneratorSource;
 		this.operations = operations;
 		this.context = context;
-		this.instantiators = instantiators;
+		this.converter = converter;
 		this.accessStrategy = this;
 	}
 
@@ -92,7 +93,8 @@ public <T> void insert(T instance, Class<T> domainType, Map<String, Object> addi
 
 			Assert.notNull(idProperty, "Since we have a non-null idValue, we must have an idProperty as well.");
 
-			additionalParameters.put(idProperty.getColumnName(), convert(idValue, idProperty.getColumnType()));
+			additionalParameters.put(idProperty.getColumnName(),
+					converter.writeValue(idValue, ClassTypeInformation.from(idProperty.getColumnType())));
 		}
 
 		additionalParameters.forEach(parameterSource::addValue);
@@ -231,7 +233,7 @@ public <T> Iterable<T> findAllById(Iterable<?> ids, Class<T> domainType) {
 		MapSqlParameterSource parameter = new MapSqlParameterSource( //
 				"ids", //
 				StreamSupport.stream(ids.spliterator(), false) //
-						.map(id -> convert(id, targetType)) //
+						.map(id -> converter.writeValue(id, ClassTypeInformation.from(targetType))) //
 						.collect(Collectors.toList()) //
 		);
 
@@ -281,11 +283,15 @@ private <S> MapSqlParameterSource getPropertyMap(final S instance, RelationalPer
 
 		MapSqlParameterSource parameters = new MapSqlParameterSource();
 
+		PersistentPropertyAccessor<S> propertyAccessor = persistentEntity.getPropertyAccessor(instance);
+
 		persistentEntity.doWithProperties((PropertyHandler<RelationalPersistentProperty>) property -> {
+
 			if (!property.isEntity()) {
-				Object value = persistentEntity.getPropertyAccessor(instance).getProperty(property);
 
-				Object convertedValue = convert(value, property.getColumnType());
+				Object value = propertyAccessor.getProperty(property);
+
+				Object convertedValue = converter.writeValue(value, ClassTypeInformation.from(property.getColumnType()));
 				parameters.addValue(property.getColumnName(), convertedValue, JdbcUtil.sqlTypeFor(property.getColumnType()));
 			}
 		});
@@ -318,12 +324,10 @@ private <S> void setIdFromJdbc(S instance, KeyHolder holder, RelationalPersisten
 
 			getIdFromHolder(holder, persistentEntity).ifPresent(it -> {
 
-				PersistentPropertyAccessor accessor = persistentEntity.getPropertyAccessor(instance);
-				ConvertingPropertyAccessor convertingPropertyAccessor = new ConvertingPropertyAccessor(accessor,
-						context.getConversions());
+				PersistentPropertyAccessor<S> accessor = converter.getPropertyAccessor(persistentEntity, instance);
 				RelationalPersistentProperty idProperty = persistentEntity.getRequiredIdProperty();
 
-				convertingPropertyAccessor.setProperty(idProperty, it);
+				accessor.setProperty(idProperty, it);
 			});
 
 		} catch (NonTransientDataAccessException e) {
@@ -344,7 +348,7 @@ private <S> Optional<Object> getIdFromHolder(KeyHolder holder, RelationalPersist
 	}
 
 	public EntityRowMapper<?> getEntityRowMapper(Class<?> domainType) {
-		return new EntityRowMapper<>(getRequiredPersistentEntity(domainType), context, instantiators, accessStrategy);
+		return new EntityRowMapper<>(getRequiredPersistentEntity(domainType), context, converter, accessStrategy);
 	}
 
 	@SuppressWarnings("unchecked")
@@ -360,28 +364,14 @@ private RowMapper<?> getMapEntityRowMapper(RelationalPersistentProperty property
 	private <T> MapSqlParameterSource createIdParameterSource(Object id, Class<T> domainType) {
 
 		Class<?> columnType = getRequiredPersistentEntity(domainType).getRequiredIdProperty().getColumnType();
-		return new MapSqlParameterSource("id", convert(id, columnType));
+		return new MapSqlParameterSource("id", converter.writeValue(id, ClassTypeInformation.from(columnType)));
 	}
 
 	@SuppressWarnings("unchecked")
 	private <S> RelationalPersistentEntity<S> getRequiredPersistentEntity(Class<S> domainType) {
 		return (RelationalPersistentEntity<S>) context.getRequiredPersistentEntity(domainType);
 	}
 
-	@Nullable
-	private <V> V convert(@Nullable Object from, Class<V> to) {
-
-		if (from == null) {
-			return null;
-		}
-
-		RelationalPersistentEntity<?> persistentEntity = context.getPersistentEntity(from.getClass());
-
-		Object id = persistentEntity == null ? null : persistentEntity.getIdentifierAccessor(from).getIdentifier();
-
-		return context.getConversions().convert(id == null ? from : id, to);
-	}
-
 	private SqlGenerator sql(Class<?> domainType) {
 		return sqlGeneratorSource.getSqlGenerator(domainType);
 	}

src/main/java/org/springframework/data/jdbc/core/EntityRowMapper.java

@@ -22,15 +22,13 @@
 import java.sql.SQLException;
 import java.util.Map;
 
-import org.springframework.core.convert.ConversionService;
 import org.springframework.core.convert.converter.Converter;
-import org.springframework.data.convert.EntityInstantiators;
 import org.springframework.data.mapping.MappingException;
 import org.springframework.data.mapping.PersistentProperty;
 import org.springframework.data.mapping.PersistentPropertyAccessor;
 import org.springframework.data.mapping.PreferredConstructor.Parameter;
-import org.springframework.data.mapping.model.ConvertingPropertyAccessor;
 import org.springframework.data.mapping.model.ParameterValueProvider;
+import org.springframework.data.relational.core.conversion.RelationalConverter;
 import org.springframework.data.relational.core.mapping.RelationalMappingContext;
 import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
 import org.springframework.data.relational.core.mapping.RelationalPersistentProperty;
@@ -39,9 +37,8 @@
 import org.springframework.util.Assert;
 
 /**
- * Maps a {@link ResultSet} to an entity of type {@code T}, including entities referenced.
- *
- * This {@link RowMapper} might trigger additional SQL statements in order to load other members of the same aggregate.
+ * Maps a {@link ResultSet} to an entity of type {@code T}, including entities referenced. This {@link RowMapper} might
+ * trigger additional SQL statements in order to load other members of the same aggregate.
  *
  * @author Jens Schauder
  * @author Oliver Gierke
@@ -54,19 +51,17 @@ public class EntityRowMapper<T> implements RowMapper<T> {
 
 	private final RelationalPersistentEntity<T> entity;
 
-	private final ConversionService conversions;
+	private final RelationalConverter converter;
 	private final RelationalMappingContext context;
 	private final DataAccessStrategy accessStrategy;
 	private final RelationalPersistentProperty idProperty;
-	private final EntityInstantiators instantiators;
 
-	public EntityRowMapper(RelationalPersistentEntity<T> entity, RelationalMappingContext context, EntityInstantiators instantiators,
-			DataAccessStrategy accessStrategy) {
+	public EntityRowMapper(RelationalPersistentEntity<T> entity, RelationalMappingContext context,
+			RelationalConverter converter, DataAccessStrategy accessStrategy) {
 
 		this.entity = entity;
-		this.conversions = context.getConversions();
+		this.converter = converter;
 		this.context = context;
-		this.instantiators = instantiators;
 		this.accessStrategy = accessStrategy;
 		this.idProperty = entity.getIdProperty();
 	}
@@ -80,8 +75,7 @@ public T mapRow(ResultSet resultSet, int rowNumber) {
 
 		T result = createInstance(entity, resultSet, "");
 
-		ConvertingPropertyAccessor propertyAccessor = new ConvertingPropertyAccessor(entity.getPropertyAccessor(result),
-				conversions);
+		PersistentPropertyAccessor<T> propertyAccessor = converter.getPropertyAccessor(entity, result);
 
 		Object id = idProperty == null ? null : readFrom(resultSet, idProperty, "");
 
@@ -118,7 +112,7 @@ private Object readFrom(ResultSet resultSet, RelationalPersistentProperty proper
 				return readEntityFrom(resultSet, property);
 			}
 
-			return resultSet.getObject(prefix + property.getColumnName());
+			return converter.readValue(resultSet.getObject(prefix + property.getColumnName()), property.getTypeInformation());
 
 		} catch (SQLException o_O) {
 			throw new MappingException(String.format("Could not read property %s from result set!", property), o_O);
@@ -138,37 +132,33 @@ private <S> S readEntityFrom(ResultSet rs, PersistentProperty<?> property) {
 			return null;
 		}
 
-		S instance =
-				createInstance(entity, rs, prefix);
+		S instance = createInstance(entity, rs, prefix);
 
-		PersistentPropertyAccessor accessor = entity.getPropertyAccessor(instance);
-		ConvertingPropertyAccessor propertyAccessor = new ConvertingPropertyAccessor(accessor, conversions);
+		PersistentPropertyAccessor<S> accessor = converter.getPropertyAccessor(entity, instance);
 
 		for (RelationalPersistentProperty p : entity) {
-			propertyAccessor.setProperty(p, readFrom(rs, p, prefix));
+			accessor.setProperty(p, readFrom(rs, p, prefix));
 		}
 
 		return instance;
 	}
 
 	private <S> S createInstance(RelationalPersistentEntity<S> entity, ResultSet rs, String prefix) {
-
-		return instantiators.getInstantiatorFor(entity) //
-				.createInstance(entity, new ResultSetParameterValueProvider(rs, entity, conversions, prefix));
+		return converter.createInstance(entity, new ResultSetParameterValueProvider(rs, entity, prefix));
 	}
 
 	@RequiredArgsConstructor
 	private static class ResultSetParameterValueProvider implements ParameterValueProvider<RelationalPersistentProperty> {
 
 		@NonNull private final ResultSet resultSet;
 		@NonNull private final RelationalPersistentEntity<?> entity;
-		@NonNull private final ConversionService conversionService;
 		@NonNull private final String prefix;
 
 		/*
 		 * (non-Javadoc)
 		 * @see org.springframework.data.mapping.model.ParameterValueProvider#getParameterValue(org.springframework.data.mapping.PreferredConstructor.Parameter)
 		 */
+		@SuppressWarnings("unchecked")
 		@Override
 		public <T> T getParameterValue(Parameter<T, RelationalPersistentProperty> parameter) {
 
@@ -177,7 +167,7 @@ public <T> T getParameterValue(Parameter<T, RelationalPersistentProperty> parame
 			String column = prefix + entity.getRequiredPersistentProperty(parameterName).getColumnName();
 
 			try {
-				return conversionService.convert(resultSet.getObject(column), parameter.getType().getType());
+				return (T) resultSet.getObject(column);
 			} catch (SQLException o_O) {
 				throw new MappingException(String.format("Couldn't read column %s from ResultSet.", column), o_O);
 			}

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

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.jdbc.core.convert;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.springframework.data.jdbc.core.mapping.JdbcSimpleTypes;
+
+/**
+ * Value object to capture custom conversion. {@link JdbcCustomConversions} also act as factory for
+ * {@link org.springframework.data.mapping.model.SimpleTypeHolder}
+ *
+ * @author Mark Paluch
+ * @see org.springframework.data.convert.CustomConversions
+ * @see org.springframework.data.mapping.model.SimpleTypeHolder
+ * @see JdbcSimpleTypes
+ */
+public class JdbcCustomConversions extends org.springframework.data.convert.CustomConversions {
+
+	private static final StoreConversions STORE_CONVERSIONS;
+	private static final List<Object> STORE_CONVERTERS;
+
+	static {
+
+		STORE_CONVERTERS = Collections.emptyList();
+		STORE_CONVERSIONS = StoreConversions.of(JdbcSimpleTypes.HOLDER, STORE_CONVERTERS);
+	}
+
+	/**
+	 * Creates an empty {@link JdbcCustomConversions} object.
+	 */
+	public JdbcCustomConversions() {
+		this(Collections.emptyList());
+	}
+
+	/**
+	 * Create a new {@link JdbcCustomConversions} instance registering the given converters.
+	 *
+	 * @param converters must not be {@literal null}.
+	 */
+	public JdbcCustomConversions(List<?> converters) {
+		super(STORE_CONVERSIONS, converters);
+	}
+
+}