DATAJDBC-166 - Allow registration of RowMappers based on result type.

Author: schauder

README.adoc

@@ -70,6 +70,23 @@ List<DummyEntity> findByNameRange(@Param("lower") String lower, @Param("upper")
 
 If you compile your sources with the `-parameters` compiler flag you can omit the `@Param` annotations.
 
+==== Custom RowMapper
+
+You can configure the `RowMapper` to use using either the `@Query(rowMapperClass = ....)` or you can register a `RowMapperMap` bean and register `RowMapper` per method return type.
+
+[source,java]
+----
+
+		@Bean
+		RowMapperMap rowMappers() {
+			return new ConfigurableRowMapperMap() //
+					.register(DummyEntity.class, new MyDummyEntityRowMapper()) //
+					.register(String.class, new StringRowMapper());
+		}
+
+----
+
+
 === Id generation
 
 Spring Data JDBC uses the id to identify entities but also to determine if an entity is new or already existing in the database.

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

@@ -52,6 +52,7 @@ public class EntityRowMapper<T> implements RowMapper<T> {
 	private final DataAccessStrategy accessStrategy;
 	private final JdbcPersistentProperty idProperty;
 
+	// TODO: should just take a context and obtain conversions from there.
 	public EntityRowMapper(JdbcPersistentEntity<T> entity, ConversionService conversions, JdbcMappingContext context,
 			DataAccessStrategy accessStrategy) {
 

src/main/java/org/springframework/data/jdbc/repository/RowMapperMap.java

@@ -0,0 +1,38 @@
+/*
+ * 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.repository;
+
+import org.springframework.jdbc.core.RowMapper;
+
+/**
+ * A map from a type to a {@link RowMapper} to be used for extracting that type from {@link java.sql.ResultSet}s.
+ *
+ * @author Jens Schauder
+ */
+public interface RowMapperMap {
+
+	/**
+	 * An immutable empty instance that will return {@literal null} for all arguments.
+	 */
+	RowMapperMap EMPTY = new RowMapperMap() {
+
+		public <T> RowMapper<? extends T> rowMapperFor(Class<T> type){
+			return null;
+		}
+	};
+
+	<T> RowMapper<? extends T> rowMapperFor(Class<T> type);
+}

src/main/java/org/springframework/data/jdbc/repository/config/ConfigurableRowMapperMap.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.repository.config;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import org.springframework.data.jdbc.repository.RowMapperMap;
+import org.springframework.jdbc.core.RowMapper;
+
+/**
+ * A {@link RowMapperMap} that allows for registration of of {@link RowMapper}s.
+ *
+ * @author Jens Schauder
+ */
+public class ConfigurableRowMapperMap implements RowMapperMap {
+
+	private Map<Class<?>, RowMapper<?>> rowMappers = new LinkedHashMap<>();
+
+	/**
+	 * Registers a the given {@link RowMapper} as to be used for the given type.
+	 *
+	 * @return this instance, so this can be used as a fluent interface.
+	 */
+	public <T> ConfigurableRowMapperMap register(Class<T> type, RowMapper<? extends T> rowMapper) {
+
+		rowMappers.put(type, rowMapper);
+		return this;
+	}
+
+	@SuppressWarnings("unchecked")
+	public <T> RowMapper<? extends T> rowMapperFor(Class<T> type) {
+
+		RowMapper<? extends T> candidate = (RowMapper<? extends T>) rowMappers.get(type);
+
+		if (candidate == null) {
+			for (Map.Entry<Class<?>, RowMapper<?>> entry : rowMappers.entrySet()) {
+				if (type.isAssignableFrom(entry.getKey())) {
+					candidate = (RowMapper<? extends T>) entry.getValue();
+				}
+			}
+		}
+
+		return candidate;
+	}
+}

src/main/java/org/springframework/data/jdbc/repository/support/JdbcQueryLookupStrategy.java

@@ -20,6 +20,7 @@
 import org.springframework.data.jdbc.core.DataAccessStrategy;
 import org.springframework.data.jdbc.core.EntityRowMapper;
 import org.springframework.data.jdbc.mapping.model.JdbcMappingContext;
+import org.springframework.data.jdbc.repository.RowMapperMap;
 import org.springframework.data.projection.ProjectionFactory;
 import org.springframework.data.repository.core.NamedQueries;
 import org.springframework.data.repository.core.RepositoryMetadata;
@@ -37,23 +38,38 @@ class JdbcQueryLookupStrategy implements QueryLookupStrategy {
 
 	private final JdbcMappingContext context;
 	private final DataAccessStrategy accessStrategy;
+	private final RowMapperMap rowMapperMap;
 
 	JdbcQueryLookupStrategy(EvaluationContextProvider evaluationContextProvider, JdbcMappingContext context,
-			DataAccessStrategy accessStrategy) {
+			DataAccessStrategy accessStrategy, RowMapperMap rowMapperMap) {
 
 		this.context = context;
 		this.accessStrategy = accessStrategy;
+		this.rowMapperMap = rowMapperMap;
 	}
 
 	@Override
 	public RepositoryQuery resolveQuery(Method method, RepositoryMetadata repositoryMetadata,
 			ProjectionFactory projectionFactory, NamedQueries namedQueries) {
 
 		JdbcQueryMethod queryMethod = new JdbcQueryMethod(method, repositoryMetadata, projectionFactory);
-		Class<?> domainType = queryMethod.getReturnedObjectType();
-		RowMapper<?> rowMapper = new EntityRowMapper<>(context.getRequiredPersistentEntity(domainType),
-				context.getConversions(), context, accessStrategy);
+		RowMapper<?> rowMapper = determineDefaultRowMapper(queryMethod);
 
 		return new JdbcRepositoryQuery(queryMethod, context, rowMapper);
 	}
+
+	private RowMapper<?> determineDefaultRowMapper(JdbcQueryMethod queryMethod) {
+
+		Class<?> domainType = queryMethod.getReturnedObjectType();
+
+		RowMapper typeMappedRowMapper = rowMapperMap.rowMapperFor(domainType);
+
+		return typeMappedRowMapper == null //
+				? new EntityRowMapper<>( //
+						context.getRequiredPersistentEntity(domainType), //
+						context.getConversions(), //
+						context, //
+						accessStrategy) //
+				: typeMappedRowMapper;
+	}
 }

src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactory.java

@@ -22,6 +22,7 @@
 import org.springframework.data.jdbc.core.JdbcEntityTemplate;
 import org.springframework.data.jdbc.mapping.model.JdbcMappingContext;
 import org.springframework.data.jdbc.mapping.model.JdbcPersistentEntityInformation;
+import org.springframework.data.jdbc.repository.RowMapperMap;
 import org.springframework.data.jdbc.repository.SimpleJdbcRepository;
 import org.springframework.data.repository.core.EntityInformation;
 import org.springframework.data.repository.core.RepositoryInformation;
@@ -42,6 +43,7 @@ public class JdbcRepositoryFactory extends RepositoryFactorySupport {
 	private final JdbcMappingContext context;
 	private final ApplicationEventPublisher publisher;
 	private final DataAccessStrategy accessStrategy;
+	private RowMapperMap rowMapperMap = RowMapperMap.EMPTY;
 
 	public JdbcRepositoryFactory(ApplicationEventPublisher publisher, JdbcMappingContext context,
 			DataAccessStrategy dataAccessStrategy) {
@@ -84,6 +86,10 @@ protected Optional<QueryLookupStrategy> getQueryLookupStrategy(QueryLookupStrate
 			throw new IllegalArgumentException(String.format("Unsupported query lookup strategy %s!", key));
 		}
 
-		return Optional.of(new JdbcQueryLookupStrategy(evaluationContextProvider, context, accessStrategy));
+		return Optional.of(new JdbcQueryLookupStrategy(evaluationContextProvider, context, accessStrategy, rowMapperMap));
+	}
+
+	public void setRowMapperMap(RowMapperMap rowMapperMap) {
+		this.rowMapperMap = rowMapperMap;
 	}
 }

src/main/java/org/springframework/data/jdbc/repository/support/JdbcRepositoryFactoryBean.java

@@ -22,6 +22,7 @@
 import org.springframework.context.ApplicationEventPublisherAware;
 import org.springframework.data.jdbc.core.DataAccessStrategy;
 import org.springframework.data.jdbc.mapping.model.JdbcMappingContext;
+import org.springframework.data.jdbc.repository.RowMapperMap;
 import org.springframework.data.repository.Repository;
 import org.springframework.data.repository.core.support.RepositoryFactorySupport;
 import org.springframework.data.repository.core.support.TransactionalRepositoryFactoryBeanSupport;
@@ -41,6 +42,7 @@ public class JdbcRepositoryFactoryBean<T extends Repository<S, ID>, S, ID extend
 	private ApplicationEventPublisher publisher;
 	private JdbcMappingContext mappingContext;
 	private DataAccessStrategy dataAccessStrategy;
+	private RowMapperMap rowMapperMap = RowMapperMap.EMPTY;
 
 	JdbcRepositoryFactoryBean(Class<? extends T> repositoryInterface) {
 		super(repositoryInterface);
@@ -60,7 +62,14 @@ public void setApplicationEventPublisher(ApplicationEventPublisher publisher) {
 	 */
 	@Override
 	protected RepositoryFactorySupport doCreateRepositoryFactory() {
-		return new JdbcRepositoryFactory(publisher, mappingContext, dataAccessStrategy);
+
+		JdbcRepositoryFactory jdbcRepositoryFactory = new JdbcRepositoryFactory(publisher, mappingContext, dataAccessStrategy);
+
+		if (rowMapperMap != null) {
+			jdbcRepositoryFactory.setRowMapperMap(rowMapperMap);
+		}
+
+		return jdbcRepositoryFactory;
 	}
 
 	@Autowired
@@ -75,6 +84,11 @@ public void setDataAccessStrategy(DataAccessStrategy dataAccessStrategy) {
 		this.dataAccessStrategy = dataAccessStrategy;
 	}
 
+	@Autowired(required = false)
+	public void setRowMapperMap(RowMapperMap rowMapperMap) {
+		this.rowMapperMap = rowMapperMap;
+	}
+
 	@Override
 	public void afterPropertiesSet() {
 

src/test/java/org/springframework/data/jdbc/repository/config/ConfigurableRowMapperMapUnitTests.java

@@ -0,0 +1,97 @@
+/*
+ * 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.repository.config;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import org.junit.Test;
+import org.springframework.data.jdbc.repository.RowMapperMap;
+import org.springframework.jdbc.core.RowMapper;
+
+/**
+ * @author Jens Schauder
+ */
+public class ConfigurableRowMapperMapUnitTests {
+
+	@Test
+	public void freshInstanceReturnsNull() {
+
+		RowMapperMap map = new ConfigurableRowMapperMap();
+
+		assertThat(map.rowMapperFor(Object.class)).isNull();
+	}
+
+	@Test
+	public void returnsConfiguredInstanceForClass() {
+
+		RowMapper rowMapper = mock(RowMapper.class);
+
+		RowMapperMap map = new ConfigurableRowMapperMap().register(Object.class, rowMapper);
+
+		assertThat(map.rowMapperFor(Object.class)).isEqualTo(rowMapper);
+	}
+
+	@Test
+	public void returnsNullForClassNotConfigured() {
+
+		RowMapper rowMapper = mock(RowMapper.class);
+
+		RowMapperMap map = new ConfigurableRowMapperMap().register(Number.class, rowMapper);
+
+		assertThat(map.rowMapperFor(Integer.class)).isNull();
+		assertThat(map.rowMapperFor(String.class)).isNull();
+	}
+
+
+	@Test
+	public void returnsInstanceRegisteredForSubClass() {
+
+		RowMapper rowMapper = mock(RowMapper.class);
+
+		RowMapperMap map = new ConfigurableRowMapperMap().register(String.class, rowMapper);
+
+		assertThat(map.rowMapperFor(Object.class)).isEqualTo(rowMapper);
+	}
+
+
+	@Test
+	public void prefersExactTypeMatchClass() {
+
+		RowMapper rowMapper = mock(RowMapper.class);
+
+		RowMapperMap map = new ConfigurableRowMapperMap() //
+				.register(Object.class, mock(RowMapper.class)) //
+				.register(Integer.class, rowMapper) //
+				.register(Number.class, mock(RowMapper.class));
+
+		assertThat(map.rowMapperFor(Integer.class)).isEqualTo(rowMapper);
+	}
+
+
+	@Test
+	public void prefersLatestRegistrationForSuperTypeMatch() {
+
+		RowMapper rowMapper = mock(RowMapper.class);
+
+		RowMapperMap map = new ConfigurableRowMapperMap() //
+				.register(Integer.class, mock(RowMapper.class)) //
+				.register(Number.class, rowMapper);
+
+		assertThat(map.rowMapperFor(Object.class)).isEqualTo(rowMapper);
+	}
+
+}