Rename clean to clear which aligns with what the method does.

Author: christophstrobl

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

@@ -438,13 +438,13 @@ public boolean removeIfPresent(String name, byte[] key) {
 	}
 
 	@Override
-	public void clean(String name, byte[] pattern) {
+	public void clear(String name, byte[] pattern) {
 
 		Assert.notNull(name, "Name must not be null");
 		Assert.notNull(pattern, "Pattern must not be null");
 
 		if (writeAsynchronously()) {
-			asyncCacheWriter.clean(name, pattern, batchStrategy)
+			asyncCacheWriter.clear(name, pattern, batchStrategy)
 					.thenAccept(deleteCount -> statistics.incDeletesBy(name, deleteCount.intValue()));
 			return;
 		}
@@ -651,8 +651,9 @@ interface AsyncCacheWriter {
 		 * @param pattern {@link String pattern} used to match Redis keys to clear.
 		 * @param batchStrategy strategy to use.
 		 * @return a future that signals completion emitting the number of removed keys.
+		 * @since 4.0
 		 */
-		CompletableFuture<Long> clean(String name, byte[] pattern, BatchStrategy batchStrategy);
+		CompletableFuture<Long> clear(String name, byte[] pattern, BatchStrategy batchStrategy);
 
 	}
 
@@ -686,7 +687,7 @@ public CompletableFuture<Void> remove(String name, byte[] key) {
 		}
 
 		@Override
-		public CompletableFuture<Long> clean(String name, byte[] pattern, BatchStrategy batchStrategy) {
+		public CompletableFuture<Long> clear(String name, byte[] pattern, BatchStrategy batchStrategy) {
 			throw new UnsupportedOperationException("async clean not supported");
 		}
 
@@ -701,10 +702,10 @@ public CompletableFuture<Long> clean(String name, byte[] pattern, BatchStrategy
 	class AsynchronousCacheWriterDelegate implements AsyncCacheWriter {
 
 		private static final int DEFAULT_SCAN_BATCH_SIZE = 64;
-		private final int cleanBatchSize;
+		private final int clearBatchSize;
 
 		public AsynchronousCacheWriterDelegate() {
-			this.cleanBatchSize = batchStrategy instanceof BatchStrategies.Scan scan ? scan.batchSize()
+			this.clearBatchSize = batchStrategy instanceof BatchStrategies.Scan scan ? scan.batchSize()
 					: DEFAULT_SCAN_BATCH_SIZE;
 		}
 
@@ -765,14 +766,14 @@ public CompletableFuture<Void> remove(String name, byte[] key) {
 		}
 
 		@Override
-		public CompletableFuture<Long> clean(String name, byte[] pattern, BatchStrategy batchStrategy) {
+		public CompletableFuture<Long> clear(String name, byte[] pattern, BatchStrategy batchStrategy) {
 
 			return doWithConnection(connection -> {
-				return doWithLocking(name, pattern, null, connection, () -> doClean(pattern, connection));
+				return doWithLocking(name, pattern, null, connection, () -> doClear(pattern, connection));
 			});
 		}
 
-		private Mono<Long> doClean(byte[] pattern, ReactiveRedisConnection connection) {
+		private Mono<Long> doClear(byte[] pattern, ReactiveRedisConnection connection) {
 
 			ReactiveKeyCommands commands = connection.keyCommands();
 
@@ -781,11 +782,11 @@ private Mono<Long> doClean(byte[] pattern, ReactiveRedisConnection connection) {
 			if (batchStrategy instanceof BatchStrategies.Keys) {
 				keys = commands.keys(ByteBuffer.wrap(pattern)).flatMapMany(Flux::fromIterable);
 			} else {
-				keys = commands.scan(ScanOptions.scanOptions().count(cleanBatchSize).match(pattern).build());
+				keys = commands.scan(ScanOptions.scanOptions().count(clearBatchSize).match(pattern).build());
 			}
 
 			return keys
-					.buffer(cleanBatchSize) //
+					.buffer(clearBatchSize) //
 					.flatMap(commands::mUnlink) //
 					.collect(Collectors.summingLong(Long::longValue));
 		}

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

@@ -285,8 +285,24 @@ default boolean removeIfPresent(String name, byte[] key) {
 	 *
 	 * @param name cache name must not be {@literal null}.
 	 * @param pattern pattern for the keys to remove. Must not be {@literal null}.
+	 * @deprecated since 4.0 in favor of {@link #clear(String, byte[])}
 	 */
-	void clean(String name, byte[] pattern);
+	@Deprecated(since = "4.0", forRemoval = true)
+	default void clean(String name, byte[] pattern) {
+		clear(name, pattern);
+	}
+
+	/**
+	 * Remove all keys following the given pattern.
+	 * <p>
+	 * Actual clearing may be performed in an asynchronous or deferred fashion, with subsequent lookups possibly still
+	 * seeing the entries.
+	 *
+	 * @param name cache name must not be {@literal null}.
+	 * @param pattern pattern for the keys to remove. Must not be {@literal null}.
+	 * @since 4.0
+	 */
+	void clear(String name, byte[] pattern);
 
 	/**
 	 * Remove all keys following the given pattern expecting all entries to be immediately invisible for subsequent
@@ -298,7 +314,7 @@ default boolean removeIfPresent(String name, byte[] key) {
 	 *         presence of entries could not be determined).
 	 */
 	default boolean invalidate(String name, byte[] pattern) {
-		clean(name, pattern);
+		clear(name, pattern);
 		return false;
 	}
 
@@ -379,7 +395,7 @@ default RedisCacheWriterConfigurer enableLocking(Consumer<CacheLockingConfigurat
 
 		/**
 		 * Use immediate writes (i.e. write operations such as
-		 * {@link RedisCacheWriter#put(String, byte[], byte[], Duration)} or {@link #clean(String, byte[])}) shall apply
+		 * {@link RedisCacheWriter#put(String, byte[], byte[], Duration)} or {@link #clear(String, byte[])}) shall apply
 		 * immediately.
 		 * <p>
 		 * Several {@link org.springframework.cache.Cache} operations can be performed asynchronously or deferred and this
@@ -395,7 +411,7 @@ default RedisCacheWriterConfigurer immediateWrites() {
 
 		/**
 		 * Configure whether to use immediate writes (i.e. write operations such as
-		 * {@link RedisCacheWriter#put(String, byte[], byte[], Duration)} or {@link #clean(String, byte[])}) shall apply
+		 * {@link RedisCacheWriter#put(String, byte[], byte[], Duration)} or {@link #clear(String, byte[])}) shall apply
 		 * immediately.
 		 * <p>
 		 * Several {@link org.springframework.cache.Cache} operations can be performed asynchronously or deferred and this

src/test/java/org/springframework/data/redis/cache/DefaultRedisCacheWriterTests.java

@@ -15,9 +15,12 @@
  */
 package org.springframework.data.redis.cache;
 
-import static org.assertj.core.api.Assertions.*;
-import static org.junit.Assume.*;
-import static org.springframework.data.redis.cache.RedisCacheWriter.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.Assume.assumeTrue;
+import static org.springframework.data.redis.cache.RedisCacheWriter.RedisCacheWriterConfigurer;
+import static org.springframework.data.redis.cache.RedisCacheWriter.TtlFunction;
+import static org.springframework.data.redis.cache.RedisCacheWriter.lockingRedisCacheWriter;
+import static org.springframework.data.redis.cache.RedisCacheWriter.nonLockingRedisCacheWriter;
 
 import java.nio.charset.StandardCharsets;
 import java.time.Duration;
@@ -31,6 +34,7 @@
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
+import java.util.stream.Stream;
 
 import org.awaitility.Awaitility;
 import org.jspecify.annotations.Nullable;
@@ -39,8 +43,9 @@
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-
 import org.springframework.data.redis.connection.RedisConnection;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
 import org.springframework.data.redis.connection.RedisStringCommands.SetOption;
@@ -78,6 +83,10 @@ public static Collection<Object[]> testParams() {
 		return CacheTestParams.justConnectionFactories();
 	}
 
+	static Stream<Arguments> clearRemovesAffectedKeysArgs() {
+		return Stream.of(Arguments.of(BatchStrategies.keys()), Arguments.of(BatchStrategies.scan(37)));
+	}
+
 	@BeforeEach
 	void setUp() {
 		doWithConnection(RedisConnection::flushAll);
@@ -533,6 +542,30 @@ void noOpStatisticsCollectorReturnsEmptyStatsInstance() {
 		assertThat(stats.getPuts()).isZero();
 	}
 
+	@ParameterizedTest // GH-3236
+	@MethodSource("clearRemovesAffectedKeysArgs")
+	void clearRemovesAffectedKeys(BatchStrategy batchStrategy) {
+
+		DefaultRedisCacheWriter cw = (DefaultRedisCacheWriter) lockingRedisCacheWriter(connectionFactory, batchStrategy)
+				.withStatisticsCollector(CacheStatisticsCollector.create());
+
+		int nrKeys = 100;
+		for (int i = 0; i < nrKeys; i++) {
+			cw.putIfAbsent(CACHE_NAME, "%s::key-%s".formatted(CACHE_NAME, i).getBytes(StandardCharsets.UTF_8),
+					binaryCacheValue, Duration.ofSeconds(30));
+		}
+
+		cw.clear(CACHE_NAME, (CACHE_NAME + "::*").getBytes(StandardCharsets.UTF_8));
+
+		doWithConnection(connection -> {
+			Awaitility.await().pollInSameThread().atMost(Duration.ofSeconds(5)).pollDelay(Duration.ZERO)
+					.until(() -> !connection.exists(binaryCacheKey));
+			assertThat(connection.keyCommands().exists(binaryCacheKey)).isFalse();
+		});
+
+		assertThat(cw.getCacheStatistics(CACHE_NAME).getDeletes()).isEqualTo(nrKeys);
+	}
+
 	@Test // GH-1686
 	@Disabled("Occasional failures on CI but not locally")
 	void doLockShouldGetLock() throws InterruptedException {