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}.