tmp save - introduce options for hash field expiration

Author: christophstrobl

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

@@ -30,6 +30,7 @@
 import org.springframework.data.geo.Metric;
 import org.springframework.data.geo.Point;
 import org.springframework.data.redis.RedisSystemException;
+import org.springframework.data.redis.connection.Hash.FieldExpirationOptions;
 import org.springframework.data.redis.connection.convert.Converters;
 import org.springframework.data.redis.connection.convert.ListConverter;
 import org.springframework.data.redis.connection.convert.MapConverter;
@@ -2566,6 +2567,11 @@ public Long hStrLen(byte[] key, byte[] field) {
 		return convertAndReturn(delegate.hStrLen(key, field), Converters.identityConverter());
 	}
 
+	public @Nullable List<Long> expireHashField(byte[] key, org.springframework.data.redis.core.types.Expiration expiration,
+		FieldExpirationOptions options, byte[]... fields) {
+		return this.delegate.expireHashField(key, expiration, options, fields);
+	}
+
 	@Override
 	public List<Long> hExpire(byte[] key, long seconds, byte[]... fields) {
 		return this.delegate.hExpire(key, seconds, fields);
@@ -2606,6 +2612,11 @@ public List<Long> hTtl(byte[] key, TimeUnit timeUnit, byte[]... fields) {
 		return this.delegate.hTtl(key, timeUnit, fields);
 	}
 
+	public @Nullable List<Long> expireHashField(String key, org.springframework.data.redis.core.types.Expiration expiration,
+		FieldExpirationOptions options, String... fields) {
+		return expireHashField(serialize(key), expiration, options, serializeMulti(fields));
+	}
+
 	@Override
 	public List<Long> hExpire(String key, long seconds, String... fields) {
 		return hExpire(serialize(key), seconds, serializeMulti(fields));

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

@@ -28,6 +28,7 @@
 import org.springframework.data.geo.GeoResults;
 import org.springframework.data.geo.Metric;
 import org.springframework.data.geo.Point;
+import org.springframework.data.redis.connection.Hash.FieldExpirationOptions;
 import org.springframework.data.redis.connection.stream.ByteRecord;
 import org.springframework.data.redis.connection.stream.Consumer;
 import org.springframework.data.redis.connection.stream.MapRecord;
@@ -1527,6 +1528,14 @@ default List<Long> hpTtl(byte[] key, byte[]... fields) {
 		return hashCommands().hpTtl(key, fields);
 	}
 
+	/** @deprecated in favor of {@link RedisConnection#hashCommands()}}. */
+	@Override
+	@Deprecated
+	default @Nullable List<Long> expireHashField(byte[] key, org.springframework.data.redis.core.types.Expiration expiration,
+		FieldExpirationOptions options, byte[]... fields) {
+		return hashCommands().expireHashField(key, expiration, options, fields);
+	}
+
 	// GEO COMMANDS
 
 	/** @deprecated in favor of {@link RedisConnection#geoCommands()}}. */

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

@@ -0,0 +1,115 @@
+/*
+ * 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.
+ */
+package org.springframework.data.redis.connection;
+
+import java.util.Objects;
+
+import org.springframework.lang.Contract;
+import org.springframework.lang.Nullable;
+import org.springframework.util.ObjectUtils;
+
+/**
+ * @author Christoph Strobl
+ * @since 3.5
+ */
+public interface Hash {
+
+	class FieldExpirationOptions {
+
+		private static final FieldExpirationOptions NONE = new FieldExpirationOptions(null);
+		private @Nullable Condition condition;
+
+		FieldExpirationOptions(@Nullable Condition condition) {
+			this.condition = condition;
+		}
+
+		public static FieldExpirationOptions none() {
+			return NONE;
+		}
+
+		@Contract("_ -> new")
+		public static FieldExpireOptionsBuilder builder() {
+			return new FieldExpireOptionsBuilder();
+		}
+
+		public @Nullable Condition getCondition() {
+			return condition;
+		}
+
+		@Override
+		public boolean equals(Object o) {
+			if (o == this) {
+				return true;
+			}
+			if (o == null || getClass() != o.getClass()) {
+				return false;
+			}
+			FieldExpirationOptions that = (FieldExpirationOptions) o;
+			return ObjectUtils.nullSafeEquals(this.condition, that.condition);
+		}
+
+		@Override
+		public int hashCode() {
+			return Objects.hash(condition);
+		}
+
+		public static class FieldExpireOptionsBuilder {
+
+			@Nullable Condition condition;
+
+			@Contract("_ -> this")
+			public FieldExpireOptionsBuilder nx() {
+				this.condition = Condition.NX;
+				return this;
+			}
+
+			@Contract("_ -> this")
+			public FieldExpireOptionsBuilder xx() {
+				this.condition = Condition.XX;
+				return this;
+			}
+
+			@Contract("_ -> this")
+			public FieldExpireOptionsBuilder gt() {
+				this.condition = Condition.GT;
+				return this;
+			}
+
+			@Contract("_ -> this")
+			public FieldExpireOptionsBuilder lt() {
+				this.condition = Condition.LT;
+				return this;
+			}
+
+			@Contract("_ -> !null")
+			public FieldExpirationOptions build() {
+				return condition == null ? NONE : new FieldExpirationOptions(condition);
+			}
+		}
+
+		public enum Condition {
+
+			/** Set expiration only when the field has no expiration. */
+			NX,
+			/** Set expiration only when the field has an existing expiration. */
+			XX,
+			/** Set expiration only when the new expiration is greater than current one. */
+			GT,
+			/** Set expiration only when the new expiration is greater than current one. */
+			LT
+		}
+	}
+}

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

@@ -21,6 +21,7 @@
 import java.util.Set;
 import java.util.concurrent.TimeUnit;
 
+import org.springframework.data.redis.connection.Hash.FieldExpirationOptions;
 import org.springframework.data.redis.core.Cursor;
 import org.springframework.data.redis.core.ScanOptions;
 import org.springframework.lang.Nullable;
@@ -253,19 +254,28 @@ public interface RedisHashCommands {
 	@Nullable
 	Long hStrLen(byte[] key, byte[] field);
 
-	/**
-	 * Set time to live for given {@code fields} in seconds.
-	 *
-	 * @param key must not be {@literal null}.
-	 * @param seconds the amount of time after which the fields will be expired in seconds, must not be {@literal null}.
-	 * @param fields must not be {@literal null}.
-	 * @return a list of {@link Long} values for each of the fields provided: {@code 2} indicating the specific field is deleted
-	 *         already due to expiration, or provided expiry interval is 0; {@code 1} indicating expiration time is set/updated;
-	 *         {@code 0} indicating the expiration time is not set (a provided NX | XX | GT | LT condition is not met);
-	 *         {@code -2} indicating there is no such field; {@literal null} when used in pipeline / transaction.
-	 * @see <a href="https://redis.io/docs/latest/commands/hexpire/">Redis Documentation: HEXPIRE</a>
-	 * @since 3.5
-	 */
+	default @Nullable List<Long> expireHashField(byte[] key, org.springframework.data.redis.core.types.Expiration expiration,
+		byte[]... fields) {
+		return expireHashField(key, expiration, FieldExpirationOptions.none(), fields);
+	}
+
+
+	@Nullable List<Long> expireHashField(byte[] key, org.springframework.data.redis.core.types.Expiration expiration,
+		FieldExpirationOptions options, byte[]... fields);
+
+		/**
+         * Set time to live for given {@code fields} in seconds.
+         *
+         * @param key must not be {@literal null}.
+         * @param seconds the amount of time after which the fields will be expired in seconds, must not be {@literal null}.
+         * @param fields must not be {@literal null}.
+         * @return a list of {@link Long} values for each of the fields provided: {@code 2} indicating the specific field is deleted
+         *         already due to expiration, or provided expiry interval is 0; {@code 1} indicating expiration time is set/updated;
+         *         {@code 0} indicating the expiration time is not set (a provided NX | XX | GT | LT condition is not met);
+         *         {@code -2} indicating there is no such field; {@literal null} when used in pipeline / transaction.
+         * @see <a href="https://redis.io/docs/latest/commands/hexpire/">Redis Documentation: HEXPIRE</a>
+         * @since 3.5
+         */
 	@Nullable
 	List<Long> hExpire(byte[] key, long seconds, byte[]... fields);
 

src/main/java/org/springframework/data/redis/connection/jedis/JedisClusterHashCommands.java

@@ -15,6 +15,7 @@
  */
 package org.springframework.data.redis.connection.jedis;
 
+import redis.clients.jedis.args.ExpiryOption;
 import redis.clients.jedis.params.ScanParams;
 import redis.clients.jedis.resps.ScanResult;
 
@@ -26,13 +27,16 @@
 import java.util.concurrent.TimeUnit;
 
 import org.springframework.dao.DataAccessException;
+import org.springframework.data.redis.connection.Hash.FieldExpirationOptions;
 import org.springframework.data.redis.connection.RedisHashCommands;
 import org.springframework.data.redis.core.Cursor;
 import org.springframework.data.redis.core.ScanCursor;
 import org.springframework.data.redis.core.ScanIteration;
 import org.springframework.data.redis.core.ScanOptions;
+import org.springframework.data.redis.core.types.Expiration;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
+import org.springframework.util.ObjectUtils;
 
 /**
  * Cluster {@link RedisHashCommands} implementation for Jedis.
@@ -281,16 +285,54 @@ protected ScanIteration<Entry<byte[], byte[]>> doScan(CursorId cursorId, ScanOpt
 
 				ScanParams params = JedisConverters.toScanParams(options);
 
-				ScanResult<Entry<byte[], byte[]>> result = connection.getCluster().hscan(key,
-						JedisConverters.toBytes(cursorId),
+				ScanResult<Entry<byte[], byte[]>> result = connection.getCluster().hscan(key, JedisConverters.toBytes(cursorId),
 						params);
 				return new ScanIteration<>(CursorId.of(result.getCursor()), result.getResult());
 			}
 		}.open();
 	}
 
+	@Nullable
+	@Override
+	public List<Long> expireHashField(byte[] key, Expiration expiration, FieldExpirationOptions options,
+			byte[]... fields) {
+
+		if (expiration.isPersistent()) {
+			return hPersist(key, fields);
+		}
+
+		if (ObjectUtils.nullSafeEquals(FieldExpirationOptions.none(), options)) {
+			if (ObjectUtils.nullSafeEquals(TimeUnit.MILLISECONDS, expiration.getTimeUnit())) {
+				if (expiration.isUnixTimestamp()) {
+					return hpExpireAt(key, expiration.getExpirationTimeInMilliseconds(), fields);
+				}
+				return hpExpire(key, expiration.getExpirationTimeInMilliseconds(), fields);
+			}
+			if (expiration.isUnixTimestamp()) {
+				return hExpireAt(key, expiration.getExpirationTimeInSeconds(), fields);
+			}
+			return hExpire(key, expiration.getExpirationTimeInSeconds(), fields);
+		}
+
+		ExpiryOption option = ExpiryOption.valueOf(options.getCondition().name());
+
+		if (ObjectUtils.nullSafeEquals(TimeUnit.MILLISECONDS, expiration.getTimeUnit())) {
+			if (expiration.isUnixTimestamp()) {
+				return connection.getCluster().hpexpireAt(key, expiration.getExpirationTimeInMilliseconds(), option, fields);
+			}
+			return connection.getCluster().hpexpire(key, expiration.getExpirationTimeInMilliseconds(), option, fields);
+		}
+
+		if (expiration.isUnixTimestamp()) {
+			return connection.getCluster().hexpireAt(key, expiration.getExpirationTimeInSeconds(), option, fields);
+		}
+		return connection.getCluster().hexpire(key, expiration.getExpirationTimeInSeconds(), option, fields);
+
+	}
+
 	@Override
 	public List<Long> hExpire(byte[] key, long seconds, byte[]... fields) {
+
 		Assert.notNull(key, "Key must not be null");
 		Assert.notNull(fields, "Fields must not be null");
 
@@ -368,8 +410,7 @@ public List<Long> hTtl(byte[] key, TimeUnit timeUnit, byte[]... fields) {
 
 		try {
 			return connection.getCluster().httl(key, fields).stream()
-					.map(it -> it != null ? timeUnit.convert(it, TimeUnit.SECONDS) : null)
-					.toList();
+					.map(it -> it != null ? timeUnit.convert(it, TimeUnit.SECONDS) : null).toList();
 		} catch (Exception ex) {
 			throw convertJedisAccessException(ex);
 		}