Polishing.

Add missing package info, fix invalid nullness annotations, reduce nullability.

Add missing nullability annotations. Reformat code. Refine nullability flows and warnings.

See #3092
Original pull request: #3159

Author: mp911de

src/main/java/org/springframework/data/redis/ClusterRedirectException.java

@@ -30,8 +30,7 @@
  */
 public class ClusterRedirectException extends DataRetrievalFailureException {
 
-	@Serial
-	private static final long serialVersionUID = -857075813794333965L;
+	private static final @Serial long serialVersionUID = -857075813794333965L;
 
 	private final int slot;
 	private final String host;

src/main/java/org/springframework/data/redis/ClusterStateFailureException.java

@@ -31,8 +31,7 @@
  */
 public class ClusterStateFailureException extends DataAccessResourceFailureException {
 
-	@Serial
-	private static final long serialVersionUID = 333399051713240852L;
+	private static final @Serial long serialVersionUID = 333399051713240852L;
 
 	/**
 	 * Creates new {@link ClusterStateFailureException}.

src/main/java/org/springframework/data/redis/TooManyClusterRedirectionsException.java

@@ -28,8 +28,7 @@
  */
 public class TooManyClusterRedirectionsException extends DataRetrievalFailureException {
 
-	@Serial
-	private static final long serialVersionUID = -2818933672669154328L;
+	private static final @Serial long serialVersionUID = -2818933672669154328L;
 
 	/**
 	 * Creates new {@link TooManyClusterRedirectionsException}.

src/main/java/org/springframework/data/redis/aot/RedisRuntimeHints.java

@@ -174,11 +174,11 @@ public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader)
 		registerRedisConnectionProxy(TypeReference.of(RedisZSetCommands.class), hints);
 	}
 
-	static void boundOperationsProxy(Class<?> type, ClassLoader classLoader, RuntimeHints hints) {
+	static void boundOperationsProxy(Class<?> type, @Nullable ClassLoader classLoader, RuntimeHints hints) {
 		boundOperationsProxy(TypeReference.of(type), classLoader, hints);
 	}
 
-	static void boundOperationsProxy(TypeReference typeReference, ClassLoader classLoader, RuntimeHints hints) {
+	static void boundOperationsProxy(TypeReference typeReference, @Nullable ClassLoader classLoader, RuntimeHints hints) {
 
 		String boundTargetClass = typeReference.getPackageName() + "." + typeReference.getSimpleName().replace("Bound", "");
 		if (ClassUtils.isPresent(boundTargetClass, classLoader)) {

src/main/java/org/springframework/data/redis/aot/package-info.java

@@ -0,0 +1,21 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ *      https://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.
+ */
+
+/**
+ * AOT Runtime hints.
+ */
+@org.jspecify.annotations.NullMarked
+package org.springframework.data.redis.aot;

src/main/java/org/springframework/data/redis/cache/BatchStrategies.java

@@ -23,6 +23,7 @@
 import java.util.Optional;
 
 import org.springframework.data.redis.connection.RedisConnection;
+import org.springframework.data.redis.connection.RedisKeyCommands;
 import org.springframework.data.redis.core.Cursor;
 import org.springframework.data.redis.core.ScanOptions;
 import org.springframework.util.Assert;
@@ -79,11 +80,13 @@ static class Keys implements BatchStrategy {
 		@Override
 		public long cleanCache(RedisConnection connection, String name, byte[] pattern) {
 
-			byte[][] keys = Optional.ofNullable(connection.keys(pattern)).orElse(Collections.emptySet())
+			RedisKeyCommands commands = connection.keyCommands();
+
+			byte[][] keys = Optional.ofNullable(commands.keys(pattern)).orElse(Collections.emptySet())
 					.toArray(new byte[0][]);
 
 			if (keys.length > 0) {
-				connection.del(keys);
+				commands.del(keys);
 			}
 
 			return keys.length;
@@ -104,7 +107,9 @@ static class Scan implements BatchStrategy {
 		@Override
 		public long cleanCache(RedisConnection connection, String name, byte[] pattern) {
 
-			Cursor<byte[]> cursor = connection.scan(ScanOptions.scanOptions().count(batchSize).match(pattern).build());
+			RedisKeyCommands commands = connection.keyCommands();
+
+			Cursor<byte[]> cursor = commands.scan(ScanOptions.scanOptions().count(batchSize).match(pattern).build());
 
 			long count = 0;
 
@@ -116,8 +121,8 @@ public long cleanCache(RedisConnection connection, String name, byte[] pattern)
 
 				count += keys.size();
 
-				if (keys.size() > 0) {
-					connection.del(keys.toArray(new byte[0][]));
+				if (!keys.isEmpty()) {
+					commands.del(keys.toArray(new byte[0][]));
 				}
 			}
 

src/main/java/org/springframework/data/redis/cache/DefaultRedisCacheWriter.java

@@ -129,25 +129,24 @@ class DefaultRedisCacheWriter implements RedisCacheWriter {
 	}
 
 	@Override
-	public byte[] get(String name, byte[] key) {
+	public byte @Nullable [] get(String name, byte[] key) {
 		return get(name, key, null);
 	}
 
 	@Override
-	public byte[] get(String name, byte[] key, @Nullable Duration ttl) {
+	public byte @Nullable [] get(String name, byte[] key, @Nullable Duration ttl) {
 
 		Assert.notNull(name, "Name must not be null");
 		Assert.notNull(key, "Key must not be null");
 
 		return execute(name, connection -> doGet(connection, name, key, ttl));
 	}
 
-
 	@SuppressWarnings("NullAway")
 	private byte @Nullable[] doGet(RedisConnection connection, String name, byte[] key, @Nullable Duration ttl) {
 
-		byte[] result = shouldExpireWithin(ttl) ? connection.stringCommands().getEx(key, Expiration.from(ttl))
-				: connection.stringCommands().get(key);
+		RedisStringCommands commands = connection.stringCommands();
+		byte[] result = shouldExpireWithin(ttl) ? commands.getEx(key, Expiration.from(ttl)) : commands.get(key);
 
 		statistics.incGets(name);
 

src/main/java/org/springframework/data/redis/cache/RedisCacheManager.java

@@ -326,12 +326,12 @@ public boolean isAllowRuntimeCacheCreation() {
 	 * Return an {@link Collections#unmodifiableMap(Map) unmodifiable Map} containing {@link String caches name} mapped to
 	 * the {@link RedisCache} {@link RedisCacheConfiguration configuration}.
 	 *
-	 * @return unmodifiable {@link Map} containing {@link String cache name}
-	 * / {@link RedisCacheConfiguration configuration} pairs.
+	 * @return unmodifiable {@link Map} containing {@link String cache name} to {@link RedisCacheConfiguration
+	 *         configuration} pairs.
 	 */
-	public Map<String, RedisCacheConfiguration> getCacheConfigurations() {
+	public Map<String, @Nullable RedisCacheConfiguration> getCacheConfigurations() {
 
-		Map<String, RedisCacheConfiguration> cacheConfigurationMap = new HashMap<>(getCacheNames().size());
+		Map<String, @Nullable RedisCacheConfiguration> cacheConfigurationMap = new HashMap<>(getCacheNames().size());
 
 		getCacheNames().forEach(cacheName -> {
 			RedisCache cache = (RedisCache) lookupCache(cacheName);
@@ -412,12 +412,29 @@ private RedisCacheConfiguration resolveCacheConfiguration(@Nullable RedisCacheCo
 	 */
 	public static class RedisCacheManagerBuilder {
 
+		private boolean allowRuntimeCacheCreation = true;
+		private boolean enableTransactions;
+
+		private CacheStatisticsCollector statisticsCollector = CacheStatisticsCollector.none();
+
+		private final Map<String, RedisCacheConfiguration> initialCaches = new LinkedHashMap<>();
+
+		private RedisCacheConfiguration defaultCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
+
+		private @Nullable RedisCacheWriter cacheWriter;
+
+		private RedisCacheManagerBuilder() {}
+
+		private RedisCacheManagerBuilder(RedisCacheWriter cacheWriter) {
+			this.cacheWriter = cacheWriter;
+		}
+
 		/**
 		 * Factory method returning a new {@literal Builder} used to create and configure a {@link RedisCacheManager} using
 		 * the given {@link RedisCacheWriter}.
 		 *
-		 * @param cacheWriter {@link RedisCacheWriter} used to perform {@link RedisCache} operations
-		 * by executing appropriate Redis commands; must not be {@literal null}.
+		 * @param cacheWriter {@link RedisCacheWriter} used to perform {@link RedisCache} operations by executing
+		 *          appropriate Redis commands; must not be {@literal null}.
 		 * @return new {@link RedisCacheManagerBuilder}.
 		 * @throws IllegalArgumentException if the given {@link RedisCacheWriter} is {@literal null}.
 		 * @see org.springframework.data.redis.cache.RedisCacheWriter
@@ -433,8 +450,8 @@ public static RedisCacheManagerBuilder fromCacheWriter(RedisCacheWriter cacheWri
 		 * Factory method returning a new {@literal Builder} used to create and configure a {@link RedisCacheManager} using
 		 * the given {@link RedisConnectionFactory}.
 		 *
-		 * @param connectionFactory {@link RedisConnectionFactory} used by the {@link RedisCacheManager}
-		 * to acquire connections to Redis when performing {@link RedisCache} operations; must not be {@literal null}.
+		 * @param connectionFactory {@link RedisConnectionFactory} used by the {@link RedisCacheManager} to acquire
+		 *          connections to Redis when performing {@link RedisCache} operations; must not be {@literal null}.
 		 * @return new {@link RedisCacheManagerBuilder}.
 		 * @throws IllegalArgumentException if the given {@link RedisConnectionFactory} is {@literal null}.
 		 * @see org.springframework.data.redis.connection.RedisConnectionFactory
@@ -448,23 +465,6 @@ public static RedisCacheManagerBuilder fromConnectionFactory(RedisConnectionFact
 			return new RedisCacheManagerBuilder(cacheWriter);
 		}
 
-		private boolean allowRuntimeCacheCreation = true;
-		private boolean enableTransactions;
-
-		private CacheStatisticsCollector statisticsCollector = CacheStatisticsCollector.none();
-
-		private final Map<String, RedisCacheConfiguration> initialCaches = new LinkedHashMap<>();
-
-		private RedisCacheConfiguration defaultCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig();
-
-		private @Nullable RedisCacheWriter cacheWriter;
-
-		private RedisCacheManagerBuilder() {}
-
-		private RedisCacheManagerBuilder(RedisCacheWriter cacheWriter) {
-			this.cacheWriter = cacheWriter;
-		}
-
 		/**
 		 * Configure whether to allow cache creation at runtime.
 		 *

src/main/java/org/springframework/data/redis/connection/BitFieldSubCommands.java

@@ -232,7 +232,7 @@ public BitFieldSubCommands to(long value) {
 	 */
 	public static class BitFieldGetBuilder {
 
-		private BitFieldSubCommands ref;
+		private final BitFieldSubCommands ref;
 
 		BitFieldGet get = new BitFieldGet();
 

src/main/java/org/springframework/data/redis/connection/ClusterCommandExecutionFailureException.java

@@ -30,7 +30,7 @@
  */
 public class ClusterCommandExecutionFailureException extends UncategorizedDataAccessException {
 
-	@Serial private static final long serialVersionUID = 5727044227040368955L;
+	private static final @Serial long serialVersionUID = 5727044227040368955L;
 
 	/**
 	 * Creates new {@link ClusterCommandExecutionFailureException}.

src/main/java/org/springframework/data/redis/connection/ClusterCommandExecutor.java

@@ -15,19 +15,7 @@
  */
 package org.springframework.data.redis.connection;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Random;
-import java.util.TreeMap;
+import java.util.*;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
@@ -37,6 +25,7 @@
 import java.util.stream.Collectors;
 
 import org.jspecify.annotations.Nullable;
+
 import org.springframework.beans.factory.DisposableBean;
 import org.springframework.core.task.AsyncTaskExecutor;
 import org.springframework.core.task.SimpleAsyncTaskExecutor;
@@ -706,15 +695,7 @@ public int compare(PositionalKey o1, PositionalKey o2) {
 	 * @author Christoph Strobl
 	 * @since 2.0.3
 	 */
-	private static class PositionalKey {
-
-		private final ByteArrayWrapper key;
-		private final int position;
-
-		private PositionalKey(ByteArrayWrapper key, int position) {
-			this.key = key;
-			this.position = position;
-		}
+	private record PositionalKey(ByteArrayWrapper key, int position) {
 
 		static PositionalKey of(byte[] key, int index) {
 			return new PositionalKey(new ByteArrayWrapper(key), index);
@@ -724,36 +705,9 @@ static PositionalKey of(byte[] key, int index) {
 		 * @return binary key.
 		 */
 		byte[] getBytes() {
-			return getKey().getArray();
-		}
-
-		public ByteArrayWrapper getKey() {
-			return this.key;
-		}
-
-		public int getPosition() {
-			return this.position;
-		}
-
-		@Override
-		public boolean equals(@Nullable Object obj) {
-
-			if (this == obj) {
-				return true;
-			}
-
-			if (!(obj instanceof PositionalKey that))
-				return false;
-
-			return this.getPosition() == that.getPosition() && ObjectUtils.nullSafeEquals(this.getKey(), that.getKey());
+			return key().getArray();
 		}
 
-		@Override
-		public int hashCode() {
-			int result = ObjectUtils.nullSafeHashCode(getKey());
-			result = 31 * result + ObjectUtils.nullSafeHashCode(getPosition());
-			return result;
-		}
 	}
 
 	/**
@@ -763,13 +717,7 @@ public int hashCode() {
 	 * @author Christoph Strobl
 	 * @since 2.0.3
 	 */
-	private static class PositionalKeys implements Iterable<PositionalKey> {
-
-		private final List<PositionalKey> keys;
-
-		private PositionalKeys(List<PositionalKey> keys) {
-			this.keys = keys;
-		}
+	private record PositionalKeys(List<PositionalKey> keys) implements Iterable<PositionalKey> {
 
 		/**
 		 * Create an empty {@link PositionalKeys}.

src/main/java/org/springframework/data/redis/connection/ClusterInfo.java

@@ -31,12 +31,19 @@
 public class ClusterInfo {
 
 	public static enum Info {
-		STATE("cluster_state"), SLOTS_ASSIGNED("cluster_slots_assigned"), SLOTS_OK("cluster_slots_ok"), SLOTS_PFAIL(
-				"cluster_slots_pfail"), SLOTS_FAIL("cluster_slots_fail"), KNOWN_NODES("cluster_known_nodes"), SIZE(
-						"cluster_size"), CURRENT_EPOCH("cluster_current_epoch"), MY_EPOCH("cluster_my_epoch"), MESSAGES_SENT(
-								"cluster_stats_messages_sent"), MESSAGES_RECEIVED("cluster_stats_messages_received");
-
-		String key;
+		STATE("cluster_state"), //
+		SLOTS_ASSIGNED("cluster_slots_assigned"), //
+		SLOTS_OK("cluster_slots_ok"), //
+		SLOTS_PFAIL("cluster_slots_pfail"), //
+		SLOTS_FAIL("cluster_slots_fail"), //
+		KNOWN_NODES("cluster_known_nodes"), //
+		SIZE("cluster_size"), //
+		CURRENT_EPOCH("cluster_current_epoch"), //
+		MY_EPOCH("cluster_my_epoch"), //
+		MESSAGES_SENT("cluster_stats_messages_sent"), //
+		MESSAGES_RECEIVED("cluster_stats_messages_received");
+
+		final String key;
 
 		Info(String key) {
 			this.key = key;

src/main/java/org/springframework/data/redis/connection/ClusterTopology.java

@@ -203,7 +203,7 @@ public RedisClusterNode lookup(RedisClusterNode node) {
 		}
 
 		if (node.hasValidHost() && node.getPort() != null) {
-			return lookup(node.getHost(), node.getPort());
+			return lookup(node.getRequiredHost(), node.getRequiredPort());
 		}
 
 		if (StringUtils.hasText(node.getId())) {

src/main/java/org/springframework/data/redis/connection/DefaultSortParameters.java

@@ -71,7 +71,6 @@ public DefaultSortParameters(byte @Nullable[] byPattern, @Nullable Range limit,
 		setGetPattern(getPattern);
 	}
 
-
 	public byte @Nullable[] getByPattern() {
 		return byPattern;
 	}