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

Author: schauder

README.adoc

@@ -124,6 +124,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);
+}
+
+}