[OPTIONAL] Implement retrieve(key) and retrieve(key, Supplier<CompletableFuture<T>> Cache operations without Jedis support.

Closes #2650

Author: jxblum

Diff for: src/main/java/org/springframework/data/redis/cache/DefaultRedisCacheWriter.java

@@ -137,6 +137,11 @@ public byte[] get(String name, byte[] key, @Nullable Duration ttl) {
 		return result;
 	}
 
+	@Override
+	public boolean isRetrieveSupported() {
+		return isReactive();
+	}
+
 	@Override
 	public CompletableFuture<byte[]> retrieve(String name, byte[] key, @Nullable Duration ttl) {
 
@@ -165,6 +170,8 @@ private BiFunction<byte[], Duration, CompletableFuture<byte[]>> nonBlockingRetri
 		return isReactive() ? reactiveRetrieveFunction(cacheName) : asyncRetrieveFunction(cacheName);
 	}
 
+	// TODO: Possibly remove if we rely on the default Cache.retrieve(..) behavior
+	//  after assessing RedisCacheWriter.isRetrieveSupported().
 	// Function applied for Cache.retrieve(key) when a non-reactive Redis driver is used, such as Jedis.
 	private BiFunction<byte[], Duration, CompletableFuture<byte[]>> asyncRetrieveFunction(String cacheName) {
 

Diff for: src/main/java/org/springframework/data/redis/cache/RedisCache.java

@@ -293,18 +293,27 @@ protected Object preProcessCacheValue(@Nullable Object value) {
 
 	@Override
 	public CompletableFuture<?> retrieve(Object key) {
-		return retrieveValue(key).thenApply(this::nullSafeDeserializedStoreValue);
+
+		if (getCacheWriter().isRetrieveSupported()) {
+			return retrieveValue(key).thenApply(this::nullSafeDeserializedStoreValue);
+		}
+
+		return super.retrieve(key);
 	}
 
 	@Override
 	@SuppressWarnings("unchecked")
 	public <T> CompletableFuture<T> retrieve(Object key, Supplier<CompletableFuture<T>> valueLoader) {
 
-		return retrieveValue(key)
+		if (getCacheWriter().isRetrieveSupported()) {
+			return retrieveValue(key)
 				.thenApply(this::nullSafeDeserializedStoreValue)
 				.thenCompose(cachedValue -> cachedValue != null
-						? CompletableFuture.completedFuture((T) cachedValue)
-						: valueLoader.get());
+					? CompletableFuture.completedFuture((T) cachedValue)
+					: valueLoader.get());
+		}
+
+		return super.retrieve(key, valueLoader);
 	}
 
 	CompletableFuture<byte[]> retrieveValue(Object key) {

Diff for: src/main/java/org/springframework/data/redis/cache/RedisCacheWriter.java

@@ -17,6 +17,7 @@
 
 import java.time.Duration;
 import java.util.concurrent.CompletableFuture;
+import java.util.function.Supplier;
 
 import org.springframework.data.redis.connection.RedisConnectionFactory;
 import org.springframework.lang.Nullable;
@@ -136,6 +137,22 @@ default byte[] get(String name, byte[] key, @Nullable Duration ttl) {
 		return get(name, key);
 	}
 
+	/**
+	 * Determines whether the asynchronous {@link #retrieve(String, byte[])}
+	 * and {@link #retrieve(String, byte[], Duration)} cache operations are supported by the implementation.
+	 * <p>
+	 * The main factor for whether the {@literal retrieve} operation can be supported will primarily be determined by
+	 * the Redis driver in use at runtime.
+	 * <p>
+	 * Returns {@literal false} by default. This will have an effect of {@link RedisCache#retrieve(Object)}
+	 * and {@link RedisCache#retrieve(Object, Supplier)} throwing an {@link UnsupportedOperationException}.
+	 *
+	 * @return {@literal true} if asynchronous {@literal retrieve} operations are supported by the implementation.
+	 */
+	default boolean isRetrieveSupported() {
+		return false;
+	}
+
 	/**
 	 * Returns the {@link CompletableFuture value} to which the {@link RedisCache} maps the given {@link byte[] key}.
 	 * <p>

Diff for: src/test/java/org/springframework/data/redis/cache/RedisCacheTests.java

@@ -16,6 +16,7 @@
 package org.springframework.data.redis.cache;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.assertThatIllegalStateException;
 import static org.assertj.core.api.Assumptions.assumeThat;
 import static org.awaitility.Awaitility.await;
@@ -52,9 +53,12 @@
 import org.springframework.data.redis.connection.RedisConnection;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
 import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
+import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
 import org.springframework.data.redis.serializer.RedisSerializationContext.SerializationPair;
 import org.springframework.data.redis.serializer.RedisSerializer;
 import org.springframework.data.redis.test.condition.EnabledOnCommand;
+import org.springframework.data.redis.test.condition.EnabledOnRedisDriver;
+import org.springframework.data.redis.test.condition.RedisDriver;
 import org.springframework.data.redis.test.extension.parametrized.MethodSource;
 import org.springframework.data.redis.test.extension.parametrized.ParameterizedRedisTest;
 import org.springframework.lang.Nullable;
@@ -568,10 +572,37 @@ void cacheGetWithTimeToIdleExpirationAfterEntryExpiresShouldReturnNull() {
 		assertThat(cache.get(this.cacheKey, Person.class)).isNull();
 	}
 
+	@ParameterizedRedisTest
+	void retrieveCacheValueUsingJedis() {
+
+		// TODO: Is there a better way to do this? @EnableOnRedisDriver(RedisDriver.JEDIS) does not work!
+		assumeThat(this.connectionFactory instanceof JedisConnectionFactory).isTrue();
+
+		assertThatExceptionOfType(UnsupportedOperationException.class)
+			.isThrownBy(() -> this.cache.retrieve(this.binaryCacheKey))
+			.withMessageContaining(RedisCache.class.getName())
+			.withNoCause();
+	}
+
+	@ParameterizedRedisTest
+	void retrieveCacheValueWithLoaderUsingJedis() {
+
+		// TODO: Is there a better way to do this? @EnableOnRedisDriver(RedisDriver.JEDIS) does not work!
+		assumeThat(this.connectionFactory instanceof JedisConnectionFactory).isTrue();
+
+		assertThatExceptionOfType(UnsupportedOperationException.class)
+			.isThrownBy(() -> this.cache.retrieve(this.binaryCacheKey, () -> CompletableFuture.completedFuture("TEST")))
+			.withMessageContaining(RedisCache.class.getName())
+			.withNoCause();
+	}
+
 	@ParameterizedRedisTest // GH-2650
 	@SuppressWarnings("unchecked")
 	void retrieveReturnsCachedValue() throws Exception {
 
+		// TODO: Is there a better way to do this? @EnableOnRedisDriver(RedisDriver.LETTUCE) does not work!
+		assumeThat(this.connectionFactory instanceof LettuceConnectionFactory).isTrue();
+
 		doWithConnection(connection -> connection.stringCommands().set(this.binaryCacheKey, this.binarySample));
 
 		RedisCache cache = new RedisCache("cache", usingLockingRedisCacheWriter(), usingRedisCacheConfiguration());
@@ -587,6 +618,9 @@ void retrieveReturnsCachedValue() throws Exception {
 	@SuppressWarnings("unchecked")
 	void retrieveReturnsCachedValueWhenLockIsReleased() throws Exception {
 
+		// TODO: Is there a better way to do this? @EnableOnRedisDriver(RedisDriver.LETTUCE) does not work!
+		assumeThat(this.connectionFactory instanceof LettuceConnectionFactory).isTrue();
+
 		String mockValue = "MockValue";
 		String testValue = "TestValue";
 
@@ -618,6 +652,9 @@ void retrieveReturnsCachedValueWhenLockIsReleased() throws Exception {
 	@ParameterizedRedisTest // GH-2650
 	void retrieveReturnsLoadedValue() throws Exception {
 
+		// TODO: Is there a better way to do this? @EnableOnRedisDriver(RedisDriver.LETTUCE) does not work!
+		assumeThat(this.connectionFactory instanceof LettuceConnectionFactory).isTrue();
+
 		RedisCache cache = new RedisCache("cache", usingLockingRedisCacheWriter(), usingRedisCacheConfiguration());
 
 		AtomicBoolean loaded = new AtomicBoolean(false);
@@ -646,6 +683,9 @@ void retrieveReturnsLoadedValue() throws Exception {
 	@ParameterizedRedisTest // GH-2650
 	void retrieveReturnsNull() throws Exception {
 
+		// TODO: Is there a better way to do this? @EnableOnRedisDriver(RedisDriver.LETTUCE) does not work!
+		assumeThat(this.connectionFactory instanceof LettuceConnectionFactory).isTrue();
+
 		doWithConnection(connection -> connection.stringCommands().set(this.binaryCacheKey, this.binaryNullValue));
 
 		RedisCache cache = new RedisCache("cache", usingLockingRedisCacheWriter(), usingRedisCacheConfiguration());