Polishing.

Replace BiFunction with TtlFunction for a more concise definition. Deprecate RedisCacheConfiguration.getTtl in favor of Ttlfunction.
Enhance tests.

See spring-projects#1433
Original pull request: spring-projects#2587

Author: mp911de

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

@@ -31,6 +31,7 @@
 import org.springframework.core.convert.ConversionFailedException;
 import org.springframework.core.convert.ConversionService;
 import org.springframework.core.convert.TypeDescriptor;
+import org.springframework.data.redis.cache.RedisCacheConfiguration.TtlFunction;
 import org.springframework.data.redis.serializer.RedisSerializationContext;
 import org.springframework.data.redis.serializer.RedisSerializer;
 import org.springframework.data.redis.util.ByteUtils;
@@ -63,6 +64,8 @@ public class RedisCache extends AbstractValueAdaptingCache {
 
 	private final String name;
 
+	private final TtlFunction ttlFunction;
+
 	/**
 	 * Create a new {@link RedisCache}.
 	 *
@@ -85,6 +88,7 @@ protected RedisCache(String name, RedisCacheWriter cacheWriter, RedisCacheConfig
 		this.name = name;
 		this.cacheWriter = cacheWriter;
 		this.cacheConfiguration = cacheConfiguration;
+		this.ttlFunction = cacheConfiguration.getTtlFunction();
 	}
 
 
@@ -185,7 +189,7 @@ public void put(Object key, @Nullable Object value) {
 		}
 
 		getCacheWriter().put(getName(), createAndConvertCacheKey(key), serializeCacheValue(cacheValue),
-			getCacheConfiguration().getTtl(key, value));
+				ttlFunction.getTimeToLive(key, value));
 	}
 
 	@Override
@@ -198,7 +202,7 @@ public ValueWrapper putIfAbsent(Object key, @Nullable Object value) {
 		}
 
 		byte[] result = getCacheWriter().putIfAbsent(getName(), createAndConvertCacheKey(key),
-			serializeCacheValue(cacheValue), getCacheConfiguration().getTtl(key, value));
+				serializeCacheValue(cacheValue), ttlFunction.getTimeToLive(key, value));
 
 		return result != null ? new SimpleValueWrapper(fromStoreValue(deserializeCacheValue(result))) : null;
 	}

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

@@ -17,7 +17,6 @@
 
 import java.nio.charset.StandardCharsets;
 import java.time.Duration;
-import java.util.function.BiFunction;
 import java.util.function.Consumer;
 
 import org.springframework.cache.Cache;
@@ -35,8 +34,8 @@
  * Immutable {@link RedisCacheConfiguration} used to customize {@link RedisCache} behaviour, such as caching
  * {@literal null} values, computing cache key prefixes and handling binary serialization.
  * <p>
- * Start with {@link RedisCacheConfiguration#defaultCacheConfig()} and customize {@link RedisCache} behaviour
- * from that point on.
+ * Start with {@link RedisCacheConfiguration#defaultCacheConfig()} and customize {@link RedisCache} behaviour from that
+ * point on.
  *
  * @author Christoph Strobl
  * @author Mark Paluch
@@ -109,8 +108,7 @@ public static RedisCacheConfiguration defaultCacheConfig(@Nullable ClassLoader c
 		registerDefaultConverters(conversionService);
 
 		return new RedisCacheConfiguration((k, v) -> Duration.ZERO, DEFAULT_CACHE_NULL_VALUES, DEFAULT_USE_PREFIX,
-				CacheKeyPrefix.simple(),
-				SerializationPair.fromSerializer(RedisSerializer.string()),
+				CacheKeyPrefix.simple(), SerializationPair.fromSerializer(RedisSerializer.string()),
 				SerializationPair.fromSerializer(RedisSerializer.java(classLoader)), conversionService);
 	}
 
@@ -121,17 +119,17 @@ public static RedisCacheConfiguration defaultCacheConfig(@Nullable ClassLoader c
 
 	private final ConversionService conversionService;
 
-	private final BiFunction<Object, Object, Duration> ttlProvider;
+	private final TtlFunction ttlFunction;
 
 	private final SerializationPair<String> keySerializationPair;
 	private final SerializationPair<Object> valueSerializationPair;
 
 	@SuppressWarnings("unchecked")
-	private RedisCacheConfiguration(BiFunction<Object, Object, Duration> ttlProvider, Boolean cacheNullValues, Boolean usePrefix, CacheKeyPrefix keyPrefix,
-			SerializationPair<String> keySerializationPair, SerializationPair<?> valueSerializationPair,
-			ConversionService conversionService) {
+	private RedisCacheConfiguration(TtlFunction ttlFunction, Boolean cacheNullValues, Boolean usePrefix,
+			CacheKeyPrefix keyPrefix, SerializationPair<String> keySerializationPair,
+			SerializationPair<?> valueSerializationPair, ConversionService conversionService) {
 
-		this.ttlProvider = ttlProvider;
+		this.ttlFunction = ttlFunction;
 		this.cacheNullValues = cacheNullValues;
 		this.usePrefix = usePrefix;
 		this.keyPrefix = keyPrefix;
@@ -167,7 +165,7 @@ public RedisCacheConfiguration computePrefixWith(CacheKeyPrefix cacheKeyPrefix)
 
 		Assert.notNull(cacheKeyPrefix, "Function for computing prefix must not be null");
 
-		return new RedisCacheConfiguration(ttlProvider, cacheNullValues, DEFAULT_USE_PREFIX, cacheKeyPrefix,
+		return new RedisCacheConfiguration(ttlFunction, cacheNullValues, DEFAULT_USE_PREFIX, cacheKeyPrefix,
 				keySerializationPair, valueSerializationPair, conversionService);
 	}
 
@@ -180,8 +178,8 @@ public RedisCacheConfiguration computePrefixWith(CacheKeyPrefix cacheKeyPrefix)
 	 * @return new {@link RedisCacheConfiguration}.
 	 */
 	public RedisCacheConfiguration disableCachingNullValues() {
-		return new RedisCacheConfiguration(ttlProvider, DO_NOT_CACHE_NULL_VALUES, usePrefix, keyPrefix, keySerializationPair,
-				valueSerializationPair, conversionService);
+		return new RedisCacheConfiguration(ttlFunction, DO_NOT_CACHE_NULL_VALUES, usePrefix, keyPrefix,
+				keySerializationPair, valueSerializationPair, conversionService);
 	}
 
 	/**
@@ -193,7 +191,7 @@ public RedisCacheConfiguration disableCachingNullValues() {
 	 */
 	public RedisCacheConfiguration disableKeyPrefix() {
 
-		return new RedisCacheConfiguration(ttlProvider, cacheNullValues, DO_NOT_USE_PREFIX, keyPrefix, keySerializationPair,
+		return new RedisCacheConfiguration(ttlFunction, cacheNullValues, DO_NOT_USE_PREFIX, keyPrefix, keySerializationPair,
 				valueSerializationPair, conversionService);
 	}
 
@@ -207,22 +205,22 @@ public RedisCacheConfiguration entryTtl(Duration ttl) {
 
 		Assert.notNull(ttl, "TTL duration must not be null");
 
-		return new RedisCacheConfiguration((k, v) -> ttl, cacheNullValues, usePrefix, keyPrefix, keySerializationPair,
-			valueSerializationPair, conversionService);
+		return entryTtl(new SingletonTtlFunction(ttl));
 	}
 
 	/**
-	 * Set the ttl Provider, which can dynamic provide ttl to apply for cache entries.
-	 * @param ttlProvider {@link BiFunction} calculate ttl with the actual original cache key and value,
-	 * which must not be {@literal null}, and the ttl must not be {@literal null} either.
+	 * Set the {@link TtlFunction TTL function} to compute the time to live for cache entries.
 	 *
+	 * @param ttlFunction the {@link TtlFunction} to compute the time to live for cache entries, must not be
+	 *          {@literal null}.
 	 * @return new {@link RedisCacheConfiguration}.
+	 * @since 3.2
 	 */
-	public RedisCacheConfiguration entryTtlProvider(BiFunction<Object, Object, Duration> ttlProvider) {
+	public RedisCacheConfiguration entryTtl(TtlFunction ttlFunction) {
 
-		Assert.notNull(ttlProvider, "ttlProvider must not be null");
+		Assert.notNull(ttlFunction, "TtlFunction must not be null");
 
-		return new RedisCacheConfiguration(ttlProvider, cacheNullValues, usePrefix, keyPrefix, keySerializationPair,
+		return new RedisCacheConfiguration(ttlFunction, cacheNullValues, usePrefix, keyPrefix, keySerializationPair,
 				valueSerializationPair, conversionService);
 	}
 
@@ -236,7 +234,7 @@ public RedisCacheConfiguration serializeKeysWith(SerializationPair<String> keySe
 
 		Assert.notNull(keySerializationPair, "KeySerializationPair must not be null");
 
-		return new RedisCacheConfiguration(ttlProvider, cacheNullValues, usePrefix, keyPrefix, keySerializationPair,
+		return new RedisCacheConfiguration(ttlFunction, cacheNullValues, usePrefix, keyPrefix, keySerializationPair,
 				valueSerializationPair, conversionService);
 	}
 
@@ -250,7 +248,7 @@ public RedisCacheConfiguration serializeValuesWith(SerializationPair<?> valueSer
 
 		Assert.notNull(valueSerializationPair, "ValueSerializationPair must not be null");
 
-		return new RedisCacheConfiguration(ttlProvider, cacheNullValues, usePrefix, keyPrefix, keySerializationPair,
+		return new RedisCacheConfiguration(ttlFunction, cacheNullValues, usePrefix, keyPrefix, keySerializationPair,
 				valueSerializationPair, conversionService);
 	}
 
@@ -264,8 +262,8 @@ public RedisCacheConfiguration withConversionService(ConversionService conversio
 
 		Assert.notNull(conversionService, "ConversionService must not be null");
 
-		return new RedisCacheConfiguration(ttlProvider, cacheNullValues, usePrefix, keyPrefix, keySerializationPair,
-			valueSerializationPair, conversionService);
+		return new RedisCacheConfiguration(ttlFunction, cacheNullValues, usePrefix, keyPrefix, keySerializationPair,
+				valueSerializationPair, conversionService);
 	}
 
 	/**
@@ -319,26 +317,26 @@ public SerializationPair<Object> getValueSerializationPair() {
 
 	/**
 	 * @return The constant expiration time (ttl) for cache entries. Never {@literal null}.
+	 * @deprecated since 3.2, use {@link #getTtlFunction()} instead.
 	 */
+	@Deprecated(since = "3.2", forRemoval = true)
 	public Duration getTtl() {
-		Duration ttl = ttlProvider.apply(Object.class, Object.class);
-		Assert.notNull(ttl, "TTL duration must not be null");
-		return ttl;
+		return getTtlFunction().getTimeToLive(Object.class, null);
 	}
 
 	/**
-	 * @return The expiration time (ttl) for cache entries with original key and value. Never {@literal null}.
+	 * Returns the function to compute the time to live.
+	 *
+	 * @return the function to compute the time to live.
+	 * @since 3.2
 	 */
-	public Duration getTtl(Object key, Object val) {
-		Duration ttl = ttlProvider.apply(key, val);
-		Assert.notNull(ttl, "TTL duration must not be null");
-
-		return ttl;
+	public TtlFunction getTtlFunction() {
+		return ttlFunction;
 	}
 
 	/**
-	 * Adds a {@link Converter} to extract the {@link String} representation of a {@literal cache key}
-	 * if no suitable {@link Object#toString()} method is present.
+	 * Adds a {@link Converter} to extract the {@link String} representation of a {@literal cache key} if no suitable
+	 * {@link Object#toString()} method is present.
 	 *
 	 * @param cacheKeyConverter {@link Converter} used to convert a {@literal cache key} into a {@link String}.
 	 * @throws IllegalStateException if {@link #getConversionService()} does not allow {@link Converter} registration.
@@ -352,8 +350,8 @@ public void addCacheKeyConverter(Converter<?, String> cacheKeyConverter) {
 	/**
 	 * Configure the underlying {@link ConversionService} used to extract the {@literal cache key}.
 	 *
-	 * @param registryConsumer {@link Consumer} used to register a {@link Converter}
-	 * with the configured {@link ConverterRegistry}; never {@literal null}.
+	 * @param registryConsumer {@link Consumer} used to register a {@link Converter} with the configured
+	 *          {@link ConverterRegistry}; never {@literal null}.
 	 * @throws IllegalStateException if {@link #getConversionService()} does not allow {@link Converter} registration.
 	 * @see org.springframework.core.convert.converter.ConverterRegistry
 	 * @since 2.2
@@ -381,8 +379,8 @@ public void configureKeyConverters(Consumer<ConverterRegistry> registryConsumer)
 	 * <li>{@link SimpleKey} to {@link String}</li>
 	 * </ul>
 	 *
-	 * @param registry {@link ConverterRegistry} in which the {@link Converter key converters} are registered;
-	 * must not be {@literal null}.
+	 * @param registry {@link ConverterRegistry} in which the {@link Converter key converters} are registered; must not be
+	 *          {@literal null}.
 	 * @see org.springframework.core.convert.converter.ConverterRegistry
 	 */
 	public static void registerDefaultConverters(ConverterRegistry registry) {
@@ -392,4 +390,34 @@ public static void registerDefaultConverters(ConverterRegistry registry) {
 		registry.addConverter(String.class, byte[].class, source -> source.getBytes(StandardCharsets.UTF_8));
 		registry.addConverter(SimpleKey.class, String.class, SimpleKey::toString);
 	}
+
+	/**
+	 * Function to compute the time to live from the cache {@code key} and {@code value}.
+	 *
+	 * @author Mark Paluch
+	 * @since 3.2
+	 */
+	@FunctionalInterface
+	interface TtlFunction {
+
+		/**
+		 * Compute a {@link Duration time to live duration} using the cache {@code key} and {@code value}. The time to live
+		 * is computed on each write operation. Redis uses milliseconds granularity for timeouts. Any more granular values
+		 * (e.g. micros or nanos) are not considered and are truncated due to rounding. Returning {@link Duration#ZERO} (or
+		 * a value less than {@code Duration.ofMillis(1)}) results in a persistent value that does not expire.
+		 *
+		 * @param key the cache key.
+		 * @param value the cache value. Can be {@code null} if the cache supports {@code null} value caching.
+		 * @return the time to live. Can be {@link Duration#ZERO} for persistent values (i.e. cache entry does not expire).
+		 */
+		Duration getTimeToLive(Object key, @Nullable Object value);
+	}
+
+	private record SingletonTtlFunction(Duration duration) implements TtlFunction {
+
+		@Override
+		public Duration getTimeToLive(Object key, @Nullable Object value) {
+			return this.duration;
+		}
+	}
 }

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

@@ -15,22 +15,21 @@
  */
 package org.springframework.data.redis.cache;
 
-import org.junit.jupiter.api.Test;
-
 import static org.assertj.core.api.Assertions.*;
 
+import java.time.Duration;
+
+import org.junit.jupiter.api.Test;
 import org.springframework.beans.DirectFieldAccessor;
 import org.springframework.core.convert.converter.Converter;
 import org.springframework.instrument.classloading.ShadowingClassLoader;
 import org.springframework.lang.Nullable;
 
-import java.time.Duration;
-import java.util.function.BiFunction;
-
 /**
  * Unit tests for {@link RedisCacheConfiguration}.
  *
  * @author Mark Paluch
+ * @author Koy Zhuang
  */
 class RedisCacheConfigurationUnitTests {
 
@@ -59,19 +58,28 @@ void shouldAllowConverterRegistration() {
 		assertThat(config.getConversionService().canConvert(DomainType.class, String.class)).isTrue();
 	}
 
+	@Test // GH-1433
+	void shouldApplySingletonTtlFunction() {
 
-	@Test
-	void shouldGetDynamicTtlGivenTtlProvider() {
+		RedisCacheConfiguration defaultCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
+				.entryTtl(Duration.ofSeconds(10));
+
+		assertThat(defaultCacheConfiguration.getTtlFunction().getTimeToLive(Object.class, null))
+				.isEqualTo(Duration.ofSeconds(10));
+		assertThat(defaultCacheConfiguration.getTtlFunction().getTimeToLive(Object.class, null))
+				.isEqualTo(Duration.ofSeconds(10));
+	}
 
-		BiFunction<Object, Object, Duration> ttlProvider = (key, val) ->
-				Duration.ofSeconds(Integer.parseInt(key + String.valueOf(val)));
+	@Test // GH-1433
+	void shouldApplyTtlFunction() {
 
 		RedisCacheConfiguration defaultCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
-				.entryTtlProvider(ttlProvider);
+				.entryTtl((key, value) -> Duration.ofSeconds((Integer) value + 10));
 
-		assertThat(defaultCacheConfiguration.getTtl(1, 12)).isEqualTo(Duration.ofSeconds(112));
-		assertThat(defaultCacheConfiguration.getTtl(15, 22)).isEqualTo(Duration.ofSeconds(1522));
-		assertThat(defaultCacheConfiguration.getTtl(77, 0)).isEqualTo(Duration.ofSeconds(770));
+		assertThat(defaultCacheConfiguration.getTtlFunction().getTimeToLive(Object.class, 10))
+				.isEqualTo(Duration.ofSeconds(20));
+		assertThat(defaultCacheConfiguration.getTtlFunction().getTimeToLive(Object.class, 20))
+				.isEqualTo(Duration.ofSeconds(30));
 	}
 
 	private static class DomainType {

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

@@ -40,7 +40,6 @@
 import java.util.stream.IntStream;
 
 import org.junit.jupiter.api.BeforeEach;
-
 import org.springframework.cache.Cache.ValueWrapper;
 import org.springframework.cache.interceptor.SimpleKey;
 import org.springframework.cache.interceptor.SimpleKeyGenerator;
@@ -446,6 +445,24 @@ void cacheShouldFailOnNonConvertibleCacheKey() {
 		assertThatExceptionOfType(IllegalStateException.class).isThrownBy(() -> cache.put(key, sample));
 	}
 
+	@ParameterizedRedisTest // GH-1433
+	void shouldApplyTimeToLive() {
+
+		SerializationPair<?> serializer = SerializationPair.fromSerializer(this.serializer);
+		RedisCache cache = new RedisCache("cache", RedisCacheWriter.nonLockingRedisCacheWriter(connectionFactory),
+				RedisCacheConfiguration.defaultCacheConfig().entryTtl((k, v) -> Duration.ofSeconds(60))
+						.serializeValuesWith(serializer));
+
+		Object key = SimpleKeyGenerator.generateKey(Collections.singletonList("my-ttl-cache"));
+		cache.put(key, sample);
+
+		try (RedisConnection connection = connectionFactory.getConnection()) {
+
+			Long ttl = connection.keyCommands().ttl("cache::my-ttl-cache".getBytes(), TimeUnit.SECONDS);
+			assertThat(ttl).isBetween(40L, 80L);
+		}
+	}
+
 	@ParameterizedRedisTest // GH-2079
 	void multipleThreadsLoadValueOnce() throws InterruptedException {