Polishing.

Formatting.

Original pull request #2000
See #1998

Author: schauder

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2020-2025 the original author or authors.
+ * Copyright 2025 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.
@@ -23,32 +23,38 @@
 import org.springframework.util.Assert;
 
 /**
- * Abstract {@link RowMapper} that delegates the actual mapping logic to a {@link AbstractDelegatingRowMapper#delegate delegate}
+ * Abstract {@link RowMapper} that delegates the actual mapping logic to a {@link AbstractDelegatingRowMapper#delegate
+ * delegate}
  *
  * @author Mikhail Polivakha
+ * @since 4.0
  */
 public abstract class AbstractDelegatingRowMapper<T> implements RowMapper<T> {
 
-    private final RowMapper<T> delegate;
+	private final RowMapper<T> delegate;
 
-    protected AbstractDelegatingRowMapper(RowMapper<T> delegate) {
-        Assert.notNull(delegate, "Delegating RowMapper cannot be null");
+	protected AbstractDelegatingRowMapper(RowMapper<T> delegate) {
 
-        this.delegate = delegate;
-    }
+		Assert.notNull(delegate, "Delegating RowMapper cannot be null");
 
-    @Override
-    public T mapRow(ResultSet rs, int rowNum) throws SQLException {
-        T intermediate = delegate.mapRow(rs, rowNum);
-        return postProcessMapping(intermediate);
-    }
+		this.delegate = delegate;
+	}
 
-    /**
-     * The post-processing callback for implementations.
-     *
-     * @return the mapped entity after applying post-processing logic
-     */
-    protected T postProcessMapping(@Nullable T object) {
-        return object;
-    }
+	@Override
+	@Nullable
+	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
+	 */
+	@Nullable
+	protected T postProcessMapping(@Nullable T object) {
+		return object;
+	}
 }

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

@@ -15,8 +15,6 @@
  */
 package org.springframework.data.jdbc.repository.query;
 
-import java.sql.ResultSet;
-import java.sql.SQLException;
 import java.util.List;
 import java.util.function.Supplier;
 import java.util.stream.Stream;
@@ -156,7 +154,7 @@ private <T> JdbcQueryExecution<T> createSingleReadingQueryExecution(ResultSetExt
 	 * @deprecated Use {@link org.springframework.data.jdbc.repository.query.RowMapperFactory} instead
 	 */
 	@Deprecated(forRemoval = true, since = "3.4.4")
-	public interface RowMapperFactory extends org.springframework.data.jdbc.repository.query.RowMapperFactory { }
+	public interface RowMapperFactory extends org.springframework.data.jdbc.repository.query.RowMapperFactory {}
 
 	/**
 	 * Delegating {@link RowMapper} that reads a row into {@code T} and converts it afterwards into {@code Object}.
@@ -166,8 +164,8 @@ public interface RowMapperFactory extends org.springframework.data.jdbc.reposito
 	 * @deprecated use {@link org.springframework.data.jdbc.repository.query.ConvertingRowMapper} instead
 	 */
 	@Deprecated(forRemoval = true, since = "3.4.4")
-	protected static class ConvertingRowMapper<T> extends
-			org.springframework.data.jdbc.repository.query.ConvertingRowMapper {
+	protected static class ConvertingRowMapper<T>
+			extends org.springframework.data.jdbc.repository.query.ConvertingRowMapper {
 
 		@SuppressWarnings("unchecked")
 		public ConvertingRowMapper(RowMapper<T> delegate, Converter<Object, Object> converter) {

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2020-2025 the original author or authors.
+ * Copyright 2025 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.
@@ -25,35 +25,41 @@
 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.
+ * 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
+ * @since 4.0
  */
 public class CallbackCapableRowMapper<T> extends AbstractDelegatingRowMapper<T> {
 
-    private final ApplicationEventPublisher publisher;
-    private final @Nullable EntityCallbacks callbacks;
+	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;
-    }
+	public CallbackCapableRowMapper(RowMapper<T> delegate, ApplicationEventPublisher publisher,
+			@Nullable EntityCallbacks callbacks) {
 
-    @Override
-    public T postProcessMapping(@Nullable T object) {
-        if (object != null) {
+		super(delegate);
 
-            publisher.publishEvent(new AfterConvertEvent<>(object));
+		this.publisher = publisher;
+		this.callbacks = callbacks;
+	}
 
-            if (callbacks != null) {
-                return callbacks.callback(AfterConvertCallback.class, object);
-            }
+	@Override
+	@Nullable
+	public T postProcessMapping(@Nullable T object) {
 
-        }
-        return 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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2020-2025 the original author or authors.
+ * Copyright 2025 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.
@@ -20,24 +20,26 @@
 import org.springframework.lang.Nullable;
 
 /**
- * Delegating {@link RowMapper} that reads a row into {@code T} and converts it afterwards into {@code Object}.
+ * Delegating {@link RowMapper} that reads a row into {@code T} and converts it afterward into {@code Object}.
  *
  * @author Mark Paluch
  * @author Mikhail Polivakha
- *
- * @since 2.3
+ * @since 4.0
  */
 public class ConvertingRowMapper extends AbstractDelegatingRowMapper<Object> {
 
-    private final Converter<Object, Object> converter;
+	private final Converter<Object, Object> converter;
+
+	public ConvertingRowMapper(RowMapper<Object> delegate, Converter<Object, Object> converter) {
+
+		super(delegate);
 
-    public ConvertingRowMapper(RowMapper<Object> delegate, Converter<Object, Object> converter) {
-        super(delegate);
-        this.converter = converter;
-    }
+		this.converter = converter;
+	}
 
-    @Override
-    public Object postProcessMapping(@Nullable Object object) {
-        return object != null ? converter.convert(object) : null;
-    }
+	@Override
+	@Nullable
+	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

@@ -27,64 +27,63 @@
 import org.springframework.jdbc.core.SingleColumnRowMapper;
 
 /**
- * Default implementation of {@link RowMapperFactory}. Honors the custom mappings defined
- * in {@link QueryMappingConfiguration}.
+ * 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}.
+ * 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
+ * @since 4.0
  */
 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;
+	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;
-    }
+	public DefaultRowMapperFactory(RelationalMappingContext context, JdbcConverter converter,
+			QueryMappingConfiguration queryMappingConfiguration, EntityCallbacks entityCallbacks,
+			ApplicationEventPublisher publisher) {
 
-    @Override
-    @SuppressWarnings("unchecked")
-    public RowMapper<Object> create(Class<?> returnedObjectType) {
+		this.context = context;
+		this.converter = converter;
+		this.queryMappingConfiguration = queryMappingConfiguration;
+		this.entityCallbacks = entityCallbacks;
+		this.publisher = publisher;
+	}
 
-        RelationalPersistentEntity<?> persistentEntity = context.getPersistentEntity(returnedObjectType);
+	@Override
+	@SuppressWarnings("unchecked")
+	public RowMapper<Object> create(Class<?> returnedObjectType) {
 
-        if (persistentEntity == null) {
-            return (RowMapper<Object>) SingleColumnRowMapper.newInstance(returnedObjectType,
-              converter.getConversionService());
-        }
+		RelationalPersistentEntity<?> persistentEntity = context.getPersistentEntity(returnedObjectType);
 
-        return (RowMapper<Object>) determineDefaultMapper(returnedObjectType);
-    }
+		if (persistentEntity == null) {
 
-    private RowMapper<?> determineDefaultMapper(Class<?> returnedObjectType) {
+			return (RowMapper<Object>) SingleColumnRowMapper.newInstance(returnedObjectType,
+					converter.getConversionService());
+		}
 
-        RowMapper<?> configuredQueryMapper = queryMappingConfiguration.getRowMapper(returnedObjectType);
+		return (RowMapper<Object>) determineDefaultMapper(returnedObjectType);
+	}
 
-        if (configuredQueryMapper != null) {
-            return configuredQueryMapper;
-        }
+	private RowMapper<?> determineDefaultMapper(Class<?> returnedObjectType) {
 
-        EntityRowMapper<?> defaultEntityRowMapper = new EntityRowMapper<>( //
-          context.getRequiredPersistentEntity(returnedObjectType), //
-          converter //
-        );
+		RowMapper<?> configuredQueryMapper = queryMappingConfiguration.getRowMapper(returnedObjectType);
 
-        return new CallbackCapableRowMapper<>(defaultEntityRowMapper, publisher, entityCallbacks);
-    }
+		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

@@ -97,7 +97,8 @@ public PartTreeJdbcQuery(RelationalMappingContext context, JdbcQueryMethod query
 	 * @since 2.3
 	 */
 	public PartTreeJdbcQuery(RelationalMappingContext context, JdbcQueryMethod queryMethod, Dialect dialect,
-			JdbcConverter converter, NamedParameterJdbcOperations operations, org.springframework.data.jdbc.repository.query.RowMapperFactory rowMapperFactory) {
+			JdbcConverter converter, NamedParameterJdbcOperations operations,
+			org.springframework.data.jdbc.repository.query.RowMapperFactory rowMapperFactory) {
 
 		super(queryMethod, operations);
 
@@ -160,13 +161,13 @@ private JdbcQueryExecution<?> getQueryExecution(ResultProcessor processor,
 		JdbcQueryExecution<?> queryExecution = getJdbcQueryExecution(extractor, rowMapper);
 
 		if (getQueryMethod().isSliceQuery()) {
-			//noinspection unchecked
+			// noinspection unchecked
 			return new SliceQueryExecution<>((JdbcQueryExecution<Collection<Object>>) queryExecution, accessor.getPageable());
 		}
 
 		if (getQueryMethod().isPageQuery()) {
 
-			//noinspection unchecked
+			// noinspection unchecked
 			return new PageQueryExecution<>((JdbcQueryExecution<Collection<Object>>) queryExecution, accessor.getPageable(),
 					() -> {
 
@@ -291,7 +292,8 @@ class CachedRowMapperFactory implements Supplier<RowMapper<?>> {
 		private final Lazy<RowMapper<?>> rowMapper;
 		private final Function<ResultProcessor, RowMapper<?>> rowMapperFunction;
 
-		public CachedRowMapperFactory(PartTree tree, org.springframework.data.jdbc.repository.query.RowMapperFactory rowMapperFactory, RelationalConverter converter,
+		public CachedRowMapperFactory(PartTree tree,
+				org.springframework.data.jdbc.repository.query.RowMapperFactory rowMapperFactory, RelationalConverter converter,
 				ResultProcessor defaultResultProcessor) {
 
 			this.rowMapperFunction = processor -> {
@@ -301,8 +303,8 @@ public CachedRowMapperFactory(PartTree tree, org.springframework.data.jdbc.repos
 				}
 				Converter<Object, Object> resultProcessingConverter = new ResultProcessingConverter(processor,
 						converter.getMappingContext(), converter.getEntityInstantiators());
-				return new org.springframework.data.jdbc.repository.query.ConvertingRowMapper(rowMapperFactory.create(processor.getReturnedType().getDomainType()),
-						resultProcessingConverter);
+				return new org.springframework.data.jdbc.repository.query.ConvertingRowMapper(
+						rowMapperFactory.create(processor.getReturnedType().getDomainType()), resultProcessingConverter);
 			};
 
 			this.rowMapper = Lazy.of(() -> this.rowMapperFunction.apply(defaultResultProcessor));