Add support for HRANDFIELD.

Closes: #2048
Original Pull Request: #2104

Author: mp911de

src/main/asciidoc/new-features.adoc

@@ -7,7 +7,7 @@ This section briefly covers items that are new and noteworthy in the latest rele
 == New in Spring Data Redis 2.6
 
 * Support for `SubscriptionListener` when using `MessageListener` for subscription confirmation callbacks. `ReactiveRedisMessageListenerContainer` and `ReactiveRedisOperations` provide `receiveLater(…)` and `listenToLater(…)` methods to await until Redis acknowledges the subscription.
-* Support Redis 6.2 commands (`LPOP`/`RPOP` with `count`, `COPY`, `GETEX`, `GETDEL`, `ZPOPMIN`, `BZPOPMIN`, `ZPOPMAX`, `BZPOPMAX`, `ZMSCORE`, `ZDIFF`, `ZDIFFSTORE`, `ZINTER`, `ZUNION`).
+* Support Redis 6.2 commands (`LPOP`/`RPOP` with `count`, `COPY`, `GETEX`, `GETDEL`, `ZPOPMIN`, `BZPOPMIN`, `ZPOPMAX`, `BZPOPMAX`, `ZMSCORE`, `ZDIFF`, `ZDIFFSTORE`, `ZINTER`, `ZUNION`, `HRANDFIELD`).
 
 [[new-in-2.5.0]]
 == New in Spring Data Redis 2.5

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

@@ -106,6 +106,26 @@ public StringRecord convert(ByteRecord source) {
 	@SuppressWarnings("rawtypes") private Queue<Converter> txConverters = new LinkedList<>();
 	private boolean deserializePipelineAndTxResults = false;
 
+	private Entry<String, String> convertEntry(Entry<byte[], byte[]> source) {
+		return new Entry<String, String>() {
+
+			@Override
+			public String getKey() {
+				return bytesToString.convert(source.getKey());
+			}
+
+			@Override
+			public String getValue() {
+				return bytesToString.convert(source.getValue());
+			}
+
+			@Override
+			public String setValue(String value) {
+				throw new UnsupportedOperationException("Cannot set value for entry");
+			}
+		};
+	}
+
 	private class DeserializingConverter implements Converter<byte[], String> {
 		public String convert(byte[] source) {
 			return serializer.deserialize(source);
@@ -2307,6 +2327,88 @@ public Double hIncrBy(String key, String field, double delta) {
 		return hIncrBy(serialize(key), serialize(field), delta);
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.redis.connection.RedisHashCommands#hRandField(byte[])
+	 */
+	@Nullable
+	@Override
+	public byte[] hRandField(byte[] key) {
+		return convertAndReturn(delegate.hRandField(key), Converters.identityConverter());
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.redis.connection.RedisHashCommands#hRandFieldWithValues(byte[])
+	 */
+	@Nullable
+	@Override
+	public Entry<byte[], byte[]> hRandFieldWithValues(byte[] key) {
+		return convertAndReturn(delegate.hRandFieldWithValues(key), Converters.identityConverter());
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.redis.connection.RedisHashCommands#hRandField(byte[], long)
+	 */
+	@Nullable
+	@Override
+	public List<byte[]> hRandField(byte[] key, long count) {
+		return convertAndReturn(delegate.hRandField(key, count), Converters.identityConverter());
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.redis.connection.RedisHashCommands#hRandFieldWithValues(byte[], long)
+	 */
+	@Nullable
+	@Override
+	public List<Entry<byte[], byte[]>> hRandFieldWithValues(byte[] key, long count) {
+		return convertAndReturn(delegate.hRandFieldWithValues(key, count), Converters.identityConverter());
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.redis.connection.StringRedisConnection#hRandField(java.lang.String)
+	 */
+	@Nullable
+	@Override
+	public String hRandField(String key) {
+		return convertAndReturn(delegate.hRandField(serialize(key)), bytesToString);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.redis.connection.StringRedisConnection#hRandFieldWithValues(java.lang.String)
+	 */
+	@Nullable
+	@Override
+	public Entry<String, String> hRandFieldWithValues(String key) {
+		return convertAndReturn(delegate.hRandFieldWithValues(serialize(key)),
+				(Converter<Entry<byte[], byte[]>, Entry<String, String>>) this::convertEntry);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.redis.connection.StringRedisConnection#hRandField(java.lang.String, long)
+	 */
+	@Nullable
+	@Override
+	public List<String> hRandField(String key, long count) {
+		return convertAndReturn(delegate.hRandField(serialize(key), count), byteListToStringList);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.redis.connection.StringRedisConnection#hRandFieldWithValues(java.lang.String, long)
+	 */
+	@Nullable
+	@Override
+	public List<Entry<String, String>> hRandFieldWithValues(String key, long count) {
+		return convertAndReturn(delegate.hRandFieldWithValues(serialize(key), count),
+				new ListConverter<>(this::convertEntry));
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.redis.connection.StringRedisConnection#hKeys(java.lang.String)
@@ -3924,24 +4026,7 @@ public String getClientName() {
 	@Override
 	public Cursor<Entry<String, String>> hScan(String key, ScanOptions options) {
 
-		return new ConvertingCursor<>(this.delegate.hScan(this.serialize(key), options),
-				source -> new Entry<String, String>() {
-
-					@Override
-					public String getKey() {
-						return bytesToString.convert(source.getKey());
-					}
-
-					@Override
-					public String getValue() {
-						return bytesToString.convert(source.getValue());
-					}
-
-					@Override
-					public String setValue(String value) {
-						throw new UnsupportedOperationException("Cannot set value for entry in cursor");
-					}
-				});
+		return new ConvertingCursor<>(this.delegate.hScan(this.serialize(key), options), this::convertEntry);
 	}
 
 	/*

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

@@ -1329,6 +1329,34 @@ default Long hIncrBy(byte[] key, byte[] field, long delta) {
 		return hashCommands().hIncrBy(key, field, delta);
 	}
 
+	/** @deprecated in favor of {@link RedisConnection#hashCommands()}}. */
+	@Override
+	@Deprecated
+	default byte[] hRandField(byte[] key) {
+		return hashCommands().hRandField(key);
+	}
+
+	/** @deprecated in favor of {@link RedisConnection#hashCommands()}}. */
+	@Override
+	@Deprecated
+	default Entry<byte[], byte[]> hRandFieldWithValues(byte[] key) {
+		return hashCommands().hRandFieldWithValues(key);
+	}
+
+	/** @deprecated in favor of {@link RedisConnection#hashCommands()}}. */
+	@Override
+	@Deprecated
+	default List<byte[]> hRandField(byte[] key, long count) {
+		return hashCommands().hRandField(key, count);
+	}
+
+	/** @deprecated in favor of {@link RedisConnection#hashCommands()}}. */
+	@Override
+	@Deprecated
+	default List<Entry<byte[], byte[]>> hRandFieldWithValues(byte[] key, long count) {
+		return hashCommands().hRandFieldWithValues(key, count);
+	}
+
 	/** @deprecated in favor of {@link RedisConnection#hashCommands()}}. */
 	@Override
 	@Deprecated

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

@@ -512,6 +512,145 @@ default Mono<Long> hLen(ByteBuffer key) {
 	 */
 	Flux<NumericResponse<KeyCommand, Long>> hLen(Publisher<KeyCommand> commands);
 
+	/**
+	 * {@literal HRANDFIELD} {@link Command}.
+	 *
+	 * @author Mark Paluch
+	 * @since 2.6
+	 * @see <a href="https://redis.io/commands/hrandfield">Redis Documentation: HRANDFIELD</a>
+	 */
+	class HRandFieldCommand extends KeyCommand {
+
+		private long count;
+
+		private HRandFieldCommand(@Nullable ByteBuffer key, long count) {
+
+			super(key);
+
+			this.count = count;
+		}
+
+		/**
+		 * Applies the hash {@literal key}. Constructs a new command instance with all previously configured properties.
+		 *
+		 * @param key must not be {@literal null}.
+		 * @return a new {@link HRandFieldCommand} with {@literal key} applied.
+		 */
+		public static HRandFieldCommand key(ByteBuffer key) {
+
+			Assert.notNull(key, "Key must not be null!");
+
+			return new HRandFieldCommand(key, 1);
+		}
+
+		/**
+		 * Applies the {@literal count}. Constructs a new command instance with all previously configured properties. If the
+		 * provided {@code count} argument is positive, return a list of distinct fields, capped either at {@code count} or
+		 * the hash size. If {@code count} is negative, the behavior changes and the command is allowed to return the same
+		 * field multiple times. In this case, the number of returned fields is the absolute value of the specified count.
+		 *
+		 * @param count
+		 * @return a new {@link HRandFieldCommand} with {@literal key} applied.
+		 */
+		public HRandFieldCommand count(long count) {
+			return new HRandFieldCommand(getKey(), count);
+		}
+
+		public long getCount() {
+			return count;
+		}
+	}
+
+	/**
+	 * Return a random field from the hash value stored at {@code key}.
+	 *
+	 * @param key must not be {@literal null}.
+	 * @return
+	 * @since 2.6
+	 * @see <a href="https://redis.io/commands/hrandfield">Redis Documentation: HRANDFIELD</a>
+	 */
+	default Mono<ByteBuffer> hRandField(ByteBuffer key) {
+
+		Assert.notNull(key, "Key must not be null!");
+
+		return hRandField(Mono.just(HRandFieldCommand.key(key).count(1))).flatMap(CommandResponse::getOutput).next();
+	}
+
+	/**
+	 * Return a random field from the hash value stored at {@code key}.
+	 *
+	 * @param key must not be {@literal null}.
+	 * @return
+	 * @since 2.6
+	 * @see <a href="https://redis.io/commands/hrandfield">Redis Documentation: HRANDFIELD</a>
+	 */
+	default Mono<Map.Entry<ByteBuffer, ByteBuffer>> hRandFieldWithValues(ByteBuffer key) {
+
+		Assert.notNull(key, "Key must not be null!");
+
+		return hRandFieldWithValues(Mono.just(HRandFieldCommand.key(key).count(1))).flatMap(CommandResponse::getOutput)
+				.next();
+	}
+
+	/**
+	 * Return a random field from the hash value stored at {@code key}. If the provided {@code count} argument is
+	 * positive, return a list of distinct fields, capped either at {@code count} or the hash size. If {@code count} is
+	 * negative, the behavior changes and the command is allowed to return the same field multiple times. In this case,
+	 * the number of returned fields is the absolute value of the specified count.
+	 *
+	 * @param key must not be {@literal null}.
+	 * @param count number of fields to return.
+	 * @return
+	 * @since 2.6
+	 * @see <a href="https://redis.io/commands/hrandfield">Redis Documentation: HRANDFIELD</a>
+	 */
+	default Flux<ByteBuffer> hRandField(ByteBuffer key, long count) {
+
+		Assert.notNull(key, "Key must not be null!");
+
+		return hRandField(Mono.just(HRandFieldCommand.key(key).count(count))).flatMap(CommandResponse::getOutput);
+	}
+
+	/**
+	 * Return a random field from the hash value stored at {@code key}. If the provided {@code count} argument is
+	 * positive, return a list of distinct fields, capped either at {@code count} or the hash size. If {@code count} is
+	 * negative, the behavior changes and the command is allowed to return the same field multiple times. In this case,
+	 * the number of returned fields is the absolute value of the specified count.
+	 *
+	 * @param key must not be {@literal null}.
+	 * @param count number of fields to return.
+	 * @return {@literal null} if key does not exist or when used in pipeline / transaction.
+	 * @since 2.6
+	 * @see <a href="https://redis.io/commands/hrandfield">Redis Documentation: HRANDFIELD</a>
+	 */
+	default Flux<Map.Entry<ByteBuffer, ByteBuffer>> hRandFieldWithValues(ByteBuffer key, long count) {
+
+		Assert.notNull(key, "Key must not be null!");
+
+		return hRandFieldWithValues(Mono.just(HRandFieldCommand.key(key).count(count))).flatMap(CommandResponse::getOutput);
+	}
+
+	/**
+	 * Get random fields of hash at {@literal key}.
+	 *
+	 * @param commands must not be {@literal null}.
+	 * @return
+	 * @since 2.6
+	 * @see <a href="https://redis.io/commands/hrandfield">Redis Documentation: HRANDFIELD</a>
+	 */
+	Flux<CommandResponse<HRandFieldCommand, Flux<ByteBuffer>>> hRandField(Publisher<HRandFieldCommand> commands);
+
+	/**
+	 * Get random fields along their values of hash at {@literal key}.
+	 *
+	 * @param commands must not be {@literal null}.
+	 * @return
+	 * @since 2.6
+	 * @see <a href="https://redis.io/commands/hrandfield">Redis Documentation: HRANDFIELD</a>
+	 */
+	Flux<CommandResponse<HRandFieldCommand, Flux<Map.Entry<ByteBuffer, ByteBuffer>>>> hRandFieldWithValues(
+			Publisher<HRandFieldCommand> commands);
+
 	/**
 	 * Get key set (fields) of hash at {@literal key}.
 	 *

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

@@ -173,6 +173,58 @@ public interface RedisHashCommands {
 	@Nullable
 	Map<byte[], byte[]> hGetAll(byte[] key);
 
+	/**
+	 * Return a random field from the hash value stored at {@code key}.
+	 *
+	 * @param key must not be {@literal null}.
+	 * @return {@literal null} if key does not exist or when used in pipeline / transaction.
+	 * @since 2.6
+	 * @see <a href="https://redis.io/commands/hrandfield">Redis Documentation: HRANDFIELD</a>
+	 */
+	@Nullable
+	byte[] hRandField(byte[] key);
+
+	/**
+	 * Return a random field from the hash value stored at {@code key}.
+	 *
+	 * @param key must not be {@literal null}.
+	 * @return {@literal null} if key does not exist or when used in pipeline / transaction.
+	 * @since 2.6
+	 * @see <a href="https://redis.io/commands/hrandfield">Redis Documentation: HRANDFIELD</a>
+	 */
+	@Nullable
+	Map.Entry<byte[], byte[]> hRandFieldWithValues(byte[] key);
+
+	/**
+	 * Return a random field from the hash value stored at {@code key}. If the provided {@code count} argument is
+	 * positive, return a list of distinct fields, capped either at {@code count} or the hash size. If {@code count} is
+	 * negative, the behavior changes and the command is allowed to return the same field multiple times. In this case,
+	 * the number of returned fields is the absolute value of the specified count.
+	 *
+	 * @param key must not be {@literal null}.
+	 * @param count number of fields to return.
+	 * @return {@literal null} if key does not exist or when used in pipeline / transaction.
+	 * @since 2.6
+	 * @see <a href="https://redis.io/commands/hrandfield">Redis Documentation: HRANDFIELD</a>
+	 */
+	@Nullable
+	List<byte[]> hRandField(byte[] key, long count);
+
+	/**
+	 * Return a random field from the hash value stored at {@code key}. If the provided {@code count} argument is
+	 * positive, return a list of distinct fields, capped either at {@code count} or the hash size. If {@code count} is
+	 * negative, the behavior changes and the command is allowed to return the same field multiple times. In this case,
+	 * the number of returned fields is the absolute value of the specified count.
+	 *
+	 * @param key must not be {@literal null}.
+	 * @param count number of fields to return.
+	 * @return {@literal null} if key does not exist or when used in pipeline / transaction.
+	 * @since 2.6
+	 * @see <a href="https://redis.io/commands/hrandfield">Redis Documentation: HRANDFIELD</a>
+	 */
+	@Nullable
+	List<Map.Entry<byte[], byte[]>> hRandFieldWithValues(byte[] key, long count);
+
 	/**
 	 * Use a {@link Cursor} to iterate over entries in hash at {@code key}.
 	 *