rowmappers extraction

Author: mipo256

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/query/AbstractDelegatingRowMapper.java

@@ -0,0 +1,39 @@
+package org.springframework.data.jdbc.repository.query;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import org.springframework.jdbc.core.RowMapper;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+
+/**
+ * Abstract {@link RowMapper} that delegates the actual mapping logic to a {@link AbstractDelegatingRowMapper#delegate delegate}
+ *
+ * @author Mikhail Polivakha
+ */
+public abstract class AbstractDelegatingRowMapper<T> implements RowMapper<T> {
+
+    private final RowMapper<T> delegate;
+
+    protected AbstractDelegatingRowMapper(RowMapper<T> delegate) {
+        Assert.notNull(delegate, "Delegating RowMapper cannot be null");
+
+        this.delegate = delegate;
+    }
+
+    @Override
+    public T mapRow(ResultSet rs, int rowNum) throws SQLException {
+        T intermediate = delegate.mapRow(rs, rowNum);
+        return postProcessMapping(intermediate);
+    }
+
+    /**
+     * The post-processing callback for implementations.
+     *
+     * @return the mapped entity after applying post-processing logic
+     */
+    protected T postProcessMapping(@Nullable T object) {
+        return object;
+    }
+}

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/query/AbstractJdbcQuery.java

@@ -148,65 +148,4 @@ private <T> JdbcQueryExecution<Stream<T>> streamQuery(RowMapper<T> rowMapper) {
 	private <T> JdbcQueryExecution<T> createSingleReadingQueryExecution(ResultSetExtractor<T> resultSetExtractor) {
 		return (query, parameters) -> operations.query(query, parameters, resultSetExtractor);
 	}
-
-	/**
-	 * Factory to create a {@link RowMapper} for a given class.
-	 *
-	 * @since 2.3
-	 */
-	public interface RowMapperFactory {
-
-		/**
-		 * Create a {@link RowMapper} based on the expected return type passed in as an argument.
-		 *
-		 * @param result must not be {@code null}.
-		 * @return a {@code RowMapper} producing instances of {@code result}.
-		 */
-		RowMapper<Object> create(Class<?> result);
-
-		/**
-		 * Obtain a {@code RowMapper} from some other source, typically a {@link org.springframework.beans.factory.BeanFactory}.
-		 *
-		 * @param reference must not be {@code null}.
-		 * @since 3.4
-		 */
-		default RowMapper<Object> getRowMapper(String reference) {
-			throw new UnsupportedOperationException("getRowMapper is not supported");
-		}
-
-		/**
-		 * Obtain a {@code ResultSetExtractor} from some other source, typically a {@link org.springframework.beans.factory.BeanFactory}.
-		 *
-		 * @param reference must not be {@code null}.
-		 * @since 3.4
-		 */
-		default ResultSetExtractor<Object> getResultSetExtractor(String reference) {
-			throw new UnsupportedOperationException("getResultSetExtractor is not supported");
-		}
-	}
-
-	/**
-	 * Delegating {@link RowMapper} that reads a row into {@code T} and converts it afterwards into {@code Object}.
-	 *
-	 * @param <T>
-	 * @since 2.3
-	 */
-	protected static class ConvertingRowMapper<T> implements RowMapper<Object> {
-
-		private final RowMapper<T> delegate;
-		private final Converter<Object, Object> converter;
-
-		public ConvertingRowMapper(RowMapper<T> delegate, Converter<Object, Object> converter) {
-			this.delegate = delegate;
-			this.converter = converter;
-		}
-
-		@Override
-		public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
-
-			T object = delegate.mapRow(rs, rowNum);
-
-			return object == null ? null : converter.convert(object);
-		}
-	}
 }

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/query/CallbackCapableRowMapper.java

@@ -0,0 +1,44 @@
+package org.springframework.data.jdbc.repository.query;
+
+import java.sql.ResultSet;
+
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.data.mapping.callback.EntityCallbacks;
+import org.springframework.data.relational.core.mapping.event.AfterConvertCallback;
+import org.springframework.data.relational.core.mapping.event.AfterConvertEvent;
+import org.springframework.jdbc.core.RowMapper;
+import org.springframework.lang.Nullable;
+
+/**
+ * Delegating {@link RowMapper} implementation that applies post-processing logic
+ * after the {@link RowMapper#mapRow(ResultSet, int)}. In particular, it emits the
+ * {@link AfterConvertEvent} event and invokes the {@link AfterConvertCallback} callbacks.
+ *
+ * @author Mark Paluch
+ * @author Mikhail Polivakha
+ */
+public class CallbackCapableRowMapper<T> extends AbstractDelegatingRowMapper<T> {
+
+    private final ApplicationEventPublisher publisher;
+    private final @Nullable EntityCallbacks callbacks;
+
+    public CallbackCapableRowMapper(RowMapper<T> delegate, ApplicationEventPublisher publisher, @Nullable EntityCallbacks callbacks) {
+        super(delegate);
+        this.publisher = publisher;
+        this.callbacks = callbacks;
+    }
+
+    @Override
+    public T postProcessMapping(@Nullable T object) {
+        if (object != null) {
+
+            publisher.publishEvent(new AfterConvertEvent<>(object));
+
+            if (callbacks != null) {
+                return callbacks.callback(AfterConvertCallback.class, object);
+            }
+
+        }
+        return object;
+    }
+}

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/query/ConvertingRowMapper.java

@@ -0,0 +1,28 @@
+package org.springframework.data.jdbc.repository.query;
+
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.jdbc.core.RowMapper;
+import org.springframework.lang.Nullable;
+
+/**
+ * Delegating {@link RowMapper} that reads a row into {@code T} and converts it afterwards into {@code Object}.
+ *
+ * @author Mark Paluch
+ * @author Mikhail Polivakha
+ *
+ * @since 2.3
+ */
+public class ConvertingRowMapper extends AbstractDelegatingRowMapper<Object> {
+
+    private final Converter<Object, Object> converter;
+
+    public ConvertingRowMapper(RowMapper<Object> delegate, Converter<Object, Object> converter) {
+        super(delegate);
+        this.converter = converter;
+    }
+
+    @Override
+    public Object postProcessMapping(@Nullable Object object) {
+        return object != null ? converter.convert(object) : null;
+    }
+}

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/query/DefaultRowMapperFactory.java

@@ -0,0 +1,75 @@
+package org.springframework.data.jdbc.repository.query;
+
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.data.jdbc.core.convert.EntityRowMapper;
+import org.springframework.data.jdbc.core.convert.JdbcConverter;
+import org.springframework.data.jdbc.repository.QueryMappingConfiguration;
+import org.springframework.data.mapping.callback.EntityCallbacks;
+import org.springframework.data.relational.core.mapping.RelationalMappingContext;
+import org.springframework.data.relational.core.mapping.RelationalPersistentEntity;
+import org.springframework.jdbc.core.ResultSetExtractor;
+import org.springframework.jdbc.core.RowMapper;
+import org.springframework.jdbc.core.SingleColumnRowMapper;
+
+/**
+ * Default implementation of {@link RowMapperFactory}. Honors the custom mappings defined
+ * in {@link QueryMappingConfiguration}.
+ * <p>
+ * This implementation is not capable of loading the {@link RowMapper} or {@link ResultSetExtractor}
+ * by reference via corresponding methods from {@link RowMapperFactory}.
+ *
+ * @implNote Public APIs of this class are thread-safe.
+ * @author Mikhail Polivakha
+ */
+public class DefaultRowMapperFactory implements RowMapperFactory {
+
+    private final RelationalMappingContext context;
+    private final JdbcConverter converter;
+    private final QueryMappingConfiguration queryMappingConfiguration;
+    private final EntityCallbacks entityCallbacks;
+    private final ApplicationEventPublisher publisher;
+
+    public DefaultRowMapperFactory(
+      RelationalMappingContext context,
+      JdbcConverter converter,
+      QueryMappingConfiguration queryMappingConfiguration,
+      EntityCallbacks entityCallbacks,
+      ApplicationEventPublisher publisher
+    ) {
+        this.context = context;
+        this.converter = converter;
+        this.queryMappingConfiguration = queryMappingConfiguration;
+        this.entityCallbacks = entityCallbacks;
+        this.publisher = publisher;
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public RowMapper<Object> getRowMapper(Class<?> returnedObjectType) {
+
+        RelationalPersistentEntity<?> persistentEntity = context.getPersistentEntity(returnedObjectType);
+
+        if (persistentEntity == null) {
+            return (RowMapper<Object>) SingleColumnRowMapper.newInstance(returnedObjectType,
+              converter.getConversionService());
+        }
+
+        return (RowMapper<Object>) determineDefaultMapper(returnedObjectType);
+    }
+
+    private RowMapper<?> determineDefaultMapper(Class<?> returnedObjectType) {
+
+        RowMapper<?> configuredQueryMapper = queryMappingConfiguration.getRowMapper(returnedObjectType);
+
+        if (configuredQueryMapper != null) {
+            return configuredQueryMapper;
+        }
+
+        EntityRowMapper<?> defaultEntityRowMapper = new EntityRowMapper<>( //
+          context.getRequiredPersistentEntity(returnedObjectType), //
+          converter //
+        );
+
+        return new CallbackCapableRowMapper<>(defaultEntityRowMapper, publisher, entityCallbacks);
+    }
+}

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/query/PartTreeJdbcQuery.java

@@ -24,7 +24,6 @@
 import java.util.function.Function;
 import java.util.function.LongSupplier;
 import java.util.function.Supplier;
-import java.util.stream.Stream;
 
 import org.springframework.core.convert.converter.Converter;
 import org.springframework.data.domain.Pageable;
@@ -298,11 +297,11 @@ public CachedRowMapperFactory(PartTree tree, RowMapperFactory rowMapperFactory,
 			this.rowMapperFunction = processor -> {
 
 				if (tree.isCountProjection() || tree.isExistsProjection()) {
-					return rowMapperFactory.create(resolveTypeToRead(processor));
+					return rowMapperFactory.getRowMapper(resolveTypeToRead(processor));
 				}
 				Converter<Object, Object> resultProcessingConverter = new ResultProcessingConverter(processor,
 						converter.getMappingContext(), converter.getEntityInstantiators());
-				return new ConvertingRowMapper<>(rowMapperFactory.create(processor.getReturnedType().getDomainType()),
+				return new ConvertingRowMapper(rowMapperFactory.getRowMapper(processor.getReturnedType().getDomainType()),
 						resultProcessingConverter);
 			};
 

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/query/RowMapperFactory.java

@@ -0,0 +1,43 @@
+package org.springframework.data.jdbc.repository.query;
+
+import org.springframework.jdbc.core.ResultSetExtractor;
+import org.springframework.jdbc.core.RowMapper;
+
+/**
+ * Factory to create a {@link RowMapper} for a given class.
+ *
+ * @author Jens Schauder
+ * @author Mikhail Polivakha
+ *
+ * @since 2.3
+ */
+public interface RowMapperFactory {
+
+    /**
+     * Obtain a {@link RowMapper} based on the expected return type passed in as an argument.
+     *
+     * @param result must not be {@code null}.
+     * @return a {@code RowMapper} producing instances of {@code result}.
+     */
+    RowMapper<Object> getRowMapper(Class<?> result);
+
+    /**
+     * Obtain a {@link RowMapper}  from some other source, typically a {@link org.springframework.beans.factory.BeanFactory}.
+     *
+     * @param reference must not be {@code null}.
+     * @since 3.4
+     */
+    default RowMapper<Object> getRowMapper(String reference) {
+        throw new UnsupportedOperationException("getRowMapper by reference is not supported");
+    }
+
+    /**
+     * Obtain a {@code ResultSetExtractor} from some other source, typically a {@link org.springframework.beans.factory.BeanFactory}.
+     *
+     * @param reference must not be {@code null}.
+     * @since 3.4
+     */
+    default ResultSetExtractor<Object> getResultSetExtractor(String reference) {
+        throw new UnsupportedOperationException("getResultSetExtractor by reference is not supported");
+    }
+}

spring-data-jdbc/src/main/java/org/springframework/data/jdbc/repository/query/StringBasedJdbcQuery.java

@@ -179,7 +179,7 @@ public StringBasedJdbcQuery(String query, JdbcQueryMethod queryMethod, NamedPara
 		}
 
 		this.cachedRowMapperFactory = new CachedRowMapperFactory(
-				() -> rowMapperFactory.create(queryMethod.getResultProcessor().getReturnedType().getReturnedType()));
+				() -> rowMapperFactory.getRowMapper(queryMethod.getResultProcessor().getReturnedType().getReturnedType()));
 		this.cachedResultSetExtractorFactory = new CachedResultSetExtractorFactory(
 				this.cachedRowMapperFactory::getRowMapper);
 
@@ -376,11 +376,11 @@ RowMapper<Object> determineRowMapper(ResultProcessor resultProcessor, boolean ha
 
 		if (hasDynamicProjection) {
 
-			RowMapper<Object> rowMapperToUse = rowMapperFactory.create(resultProcessor.getReturnedType().getDomainType());
+			RowMapper<Object> rowMapperToUse = rowMapperFactory.getRowMapper(resultProcessor.getReturnedType().getDomainType());
 
 			ResultProcessingConverter converter = new ResultProcessingConverter(resultProcessor,
 					this.converter.getMappingContext(), this.converter.getEntityInstantiators());
-			return new ConvertingRowMapper<>(rowMapperToUse, converter);
+			return new ConvertingRowMapper(rowMapperToUse, converter);
 		}
 
 		return cachedRowMapperFactory.getRowMapper();