Add a method that returns the number of existing keys

Author: pranne1224

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

@@ -176,19 +176,13 @@ default Mono<Boolean> exists(ByteBuffer key) {
 		return exists(Mono.just(new KeyCommand(key))).next().map(BooleanResponse::getOutput);
 	}
 	/**
-	 * Determine if given all {@literal keys} exist.
+	 * Determine the number of given {@literal keys} that exist.
 	 *
 	 * @param keys must not be {@literal null} or {@literal empty}.
-	 * @return {@link Mono} emitting {@literal true} if all keys exist.
-	 * @see <a href="https://redis.io/commands/exists">Redis Documentation: EXISTS</a>
+	 * @return {@link Mono} emitting {@literal the number of existing keys}.
+	 * @see <a href="https://redis.io/docs/commands/exists/">Redis Documentation: EXISTS</a>
 	 */
-	default Mono<Boolean> exists(List<ByteBuffer> keys) {
-
-		Assert.notNull(keys, "Keys must not be null");
-		Assert.notEmpty(keys, "Keys must not be empty");
-
-		return exists(Flux.fromIterable(keys).map(KeyCommand::new)).all(BooleanResponse::getOutput);
-	}
+	Mono<Long> exists(List<ByteBuffer> keys);
 
 	/**
 	 * Determine if given {@literal key} exists.

src/main/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveKeyCommands.java

@@ -319,4 +319,12 @@ public Mono<Duration> idletime(ByteBuffer key) {
 	public Mono<Long> refcount(ByteBuffer key) {
 		return connection.execute(cmd -> cmd.objectRefcount(key)).next();
 	}
+
+	@Override
+	public Mono<Long> exists(List<ByteBuffer> keys) {
+		Assert.notNull(keys, "Key list must not be null");
+		Assert.notEmpty(keys, "Key list must not be empty");
+
+		return connection.execute(cmd -> cmd.exists(keys.toArray(ByteBuffer[]::new))).next();
+	}
 }

src/main/java/org/springframework/data/redis/core/ReactiveRedisOperations.java

@@ -22,6 +22,7 @@
 import java.time.Duration;
 import java.time.Instant;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
@@ -402,6 +403,15 @@ default Flux<K> scan() {
 	 */
 	Mono<Duration> getExpire(K key);
 
+	/**
+	 * Get the number of given {@code keys} that exists.
+	 *
+	 * @param keys must not be {@literal null} or {@literal empty}.
+	 * @return the number of existing keys in redis. 0 if there are no existing keys.
+	 * @see <a href="https://redis.io/docs/commands/exists/">Redis Documentation: EXISTS</a>
+	 */
+	Mono<Long> countExistingKeys(Collection<K> keys);
+
 	// -------------------------------------------------------------------------
 	// Methods dealing with Redis Lua scripts
 	// -------------------------------------------------------------------------

src/main/java/org/springframework/data/redis/core/ReactiveRedisTemplate.java

@@ -23,6 +23,7 @@
 import java.time.Duration;
 import java.time.Instant;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -489,6 +490,14 @@ public Mono<Boolean> move(K key, int dbIndex) {
 		return doCreateMono(connection -> connection.keyCommands().move(rawKey(key), dbIndex));
 	}
 
+	@Override
+	public Mono<Long> countExistingKeys(Collection<K> keys) {
+		Assert.notNull(keys, "Keys must not be null");
+
+		ByteBuffer[] rawKeys = rawKeys(keys);
+		return doCreateMono(connection -> connection.keyCommands().exists(Arrays.asList(rawKeys)));
+	}
+
 	// -------------------------------------------------------------------------
 	// Methods dealing with Redis Lua scripts
 	// -------------------------------------------------------------------------
@@ -672,6 +681,17 @@ private ByteBuffer rawKey(K key) {
 		return getSerializationContext().getKeySerializationPair().getWriter().write(key);
 	}
 
+	private ByteBuffer[] rawKeys(Collection<K> keys) {
+		final ByteBuffer[] rawKeys = new ByteBuffer[keys.size()];
+
+		int i = 0;
+		for (K key : keys) {
+			rawKeys[i++] = rawKey(key);
+		}
+
+		return rawKeys;
+	}
+
 	@Nullable
 	private K readKey(ByteBuffer buffer) {
 		return getSerializationContext().getKeySerializationPair().getReader().read(buffer);

src/test/java/org/springframework/data/redis/connection/lettuce/LettuceReactiveKeyCommandsIntegrationTests.java

@@ -67,27 +67,21 @@ void existsShouldReturnFalseForNonExistingKeys() {
 	}
 
 	@ParameterizedRedisTest
-	void existsShouldReturnTrueWhenKeysExist() {
-
-		nativeCommands.set(KEY_1, VALUE_1);
-		nativeCommands.set(KEY_2, VALUE_2);
+	void existsKeyReturnsKeyCount() {
+		nativeCommands.set(KEY_1, "1000");
+		nativeCommands.set(KEY_2, "2000");
+		nativeCommands.set(KEY_3, "3000");
 
-		connection.keyCommands().exists(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER)).as(StepVerifier::create)
-				.expectNext(true)
-				.verifyComplete();
+		connection.keyCommands().exists(List.of(KEY_1_BBUFFER, KEY_2_BBUFFER, KEY_3_BBUFFER)).as(StepVerifier::create)
+				.expectNext(3L).verifyComplete();
 	}
 
 	@ParameterizedRedisTest
-	void existsShouldReturnFalseWhenKeysDoNotExist() {
-
-		nativeCommands.set(KEY_1, VALUE_1);
-
-		connection.keyCommands().exists(Arrays.asList(KEY_1_BBUFFER, KEY_2_BBUFFER)).as(StepVerifier::create)
-				.expectNext(false) //
-				.verifyComplete();
+	void existsKeyReturnsZeroWhenKeyDoesNotExist() {
+		connection.keyCommands().exists(List.of(KEY_1_BBUFFER, KEY_2_BBUFFER, KEY_3_BBUFFER)).as(StepVerifier::create)
+				.expectNext(0L).verifyComplete();
 	}
 
-
 	@ParameterizedRedisTest // DATAREDIS-525
 	void typeShouldReturnTypeCorrectly() {
 

src/test/java/org/springframework/data/redis/core/ReactiveRedisTemplateIntegrationTests.java

@@ -24,10 +24,7 @@
 
 import java.time.Duration;
 import java.time.Instant;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
+import java.util.*;
 import java.util.function.Function;
 
 import org.junit.jupiter.api.BeforeEach;
@@ -544,4 +541,24 @@ void listenToPatternLaterShouldReceiveChannelMessagesCorrectly() {
 				.thenCancel() //
 				.verify(Duration.ofSeconds(3));
 	}
+
+	@ParameterizedRedisTest
+	void countExistingKeysIfValidKeyExists() {
+
+		K key = keyFactory.instance();
+		K key2 = keyFactory.instance();
+		K key3 = keyFactory.instance();
+
+		redisTemplate.opsForValue().set(key, valueFactory.instance()).as(StepVerifier::create).expectNext(true).verifyComplete();
+		redisTemplate.opsForValue().set(key2, valueFactory.instance()).as(StepVerifier::create).expectNext(true).verifyComplete();
+		redisTemplate.opsForValue().set(key3, valueFactory.instance()).as(StepVerifier::create).expectNext(true).verifyComplete();
+
+		redisTemplate.countExistingKeys(Arrays.asList(key, key2, key3)).as(StepVerifier::create).expectNext(3L).verifyComplete();
+	}
+
+	@ParameterizedRedisTest
+	void countExistingKeysIfNotValidKeyExists() {
+		K key = keyFactory.instance();
+		redisTemplate.countExistingKeys(List.of(key)).as(StepVerifier::create).expectNext(0L).verifyComplete();
+	}
 }