Polishing.

Add since tags, extract KeyUtil to replace duplicate calls to Arrays.copyOfRange(…) to split a concatenated list of elements into the first and remaining elements.

See #3250

Author: mp911de

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

@@ -39,7 +39,28 @@
 public interface RedisStringCommands {
 
 	enum BitOperation {
-		AND, OR, XOR, NOT, DIFF, DIFF1, ANDOR, ONE;
+
+		AND, OR, XOR, NOT,
+
+		/**
+		 * @since 4.1
+		 */
+		DIFF,
+
+		/**
+		 * @since 4.1
+		 */
+		DIFF1,
+
+		/**
+		 * @since 4.1
+		 */
+		ANDOR,
+
+		/**
+		 * @since 4.1
+		 */
+		ONE;
 	}
 
 	/**

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

@@ -35,6 +35,7 @@
 import org.springframework.data.redis.core.ScanIteration;
 import org.springframework.data.redis.core.ScanOptions;
 import org.springframework.data.redis.util.ByteUtils;
+import org.springframework.data.redis.util.KeyUtils;
 import org.springframework.util.Assert;
 
 /**
@@ -320,25 +321,25 @@ public Set<byte[]> sDiff(byte[]... keys) {
 			}
 		}
 
-		byte[] source = keys[0];
-		byte[][] others = Arrays.copyOfRange(keys, 1, keys.length);
+		return KeyUtils.splitKeys(keys, (source, others) -> {
 
-		ByteArraySet values = new ByteArraySet(sMembers(source));
-		Collection<Set<byte[]>> resultList = connection.getClusterCommandExecutor()
-				.executeMultiKeyCommand(
-						(JedisMultiKeyClusterCommandCallback<Set<byte[]>>) (client, key) -> client.smembers(key),
-						Arrays.asList(others))
-				.resultsAsList();
+			ByteArraySet values = new ByteArraySet(sMembers(source));
+			Collection<Set<byte[]>> resultList = connection.getClusterCommandExecutor()
+					.executeMultiKeyCommand(
+							(JedisMultiKeyClusterCommandCallback<Set<byte[]>>) (client, key) -> client.smembers(key),
+							Arrays.asList(others))
+					.resultsAsList();
 
-		if (values.isEmpty()) {
-			return Collections.emptySet();
-		}
+			if (values.isEmpty()) {
+				return Collections.emptySet();
+			}
 
-		for (Set<byte[]> singleNodeValue : resultList) {
-			values.removeAll(singleNodeValue);
-		}
+			for (Set<byte[]> singleNodeValue : resultList) {
+				values.removeAll(singleNodeValue);
+			}
 
-		return values.asRawSet();
+			return values.asRawSet();
+		});
 	}
 
 	@Override

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

@@ -26,6 +26,7 @@
 import org.springframework.data.redis.connection.lettuce.LettuceClusterConnection.LettuceMultiKeyClusterCommandCallback;
 import org.springframework.data.redis.connection.util.ByteArraySet;
 import org.springframework.data.redis.util.ByteUtils;
+import org.springframework.data.redis.util.KeyUtils;
 import org.springframework.util.Assert;
 
 /**
@@ -191,24 +192,24 @@ public Set<byte[]> sDiff(byte[]... keys) {
 			return super.sDiff(keys);
 		}
 
-		byte[] source = keys[0];
-		byte[][] others = Arrays.copyOfRange(keys, 1, keys.length);
+		return KeyUtils.splitKeys(keys, (source, others) -> {
 
-		ByteArraySet values = new ByteArraySet(sMembers(source));
-		Collection<Set<byte[]>> nodeResult = connection.getClusterCommandExecutor()
-				.executeMultiKeyCommand((LettuceMultiKeyClusterCommandCallback<Set<byte[]>>) RedisSetCommands::smembers,
-						Arrays.asList(others))
-				.resultsAsList();
+			ByteArraySet values = new ByteArraySet(sMembers(source));
+			Collection<Set<byte[]>> nodeResult = connection.getClusterCommandExecutor()
+					.executeMultiKeyCommand((LettuceMultiKeyClusterCommandCallback<Set<byte[]>>) RedisSetCommands::smembers,
+							Arrays.asList(others))
+					.resultsAsList();
 
-		if (values.isEmpty()) {
-			return Collections.emptySet();
-		}
+			if (values.isEmpty()) {
+				return Collections.emptySet();
+			}
 
-		for (Set<byte[]> toSubstract : nodeResult) {
-			values.removeAll(toSubstract);
-		}
+			for (Set<byte[]> toSubstract : nodeResult) {
+				values.removeAll(toSubstract);
+			}
 
-		return values.asRawSet();
+			return values.asRawSet();
+		});
 	}
 
 	@Override

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

@@ -22,7 +22,6 @@
 import reactor.core.publisher.Mono;
 
 import java.nio.ByteBuffer;
-import java.util.Arrays;
 import java.util.List;
 import java.util.stream.Collectors;
 
@@ -39,6 +38,7 @@
 import org.springframework.data.redis.connection.ReactiveStringCommands;
 import org.springframework.data.redis.connection.RedisStringCommands;
 import org.springframework.data.redis.core.types.Expiration;
+import org.springframework.data.redis.util.KeyUtils;
 import org.springframework.util.Assert;
 
 /**
@@ -370,9 +370,12 @@ public Flux<NumericResponse<BitOpCommand, Long>> bitOp(Publisher<BitOpCommand> c
 					Assert.isTrue(sourceKeys.length == 1, "BITOP NOT does not allow more than 1 source key.");
 					yield reactiveCommands.bitopNot(destinationKey, sourceKeys[0]);
 				}
-				case DIFF -> reactiveCommands.bitopDiff(destinationKey, sourceKeys[0], Arrays.copyOfRange(sourceKeys, 1, sourceKeys.length));
-				case DIFF1 -> reactiveCommands.bitopDiff1(destinationKey, sourceKeys[0], Arrays.copyOfRange(sourceKeys, 1, sourceKeys.length));
-				case ANDOR -> reactiveCommands.bitopAndor(destinationKey, sourceKeys[0], Arrays.copyOfRange(sourceKeys, 1, sourceKeys.length));
+				case DIFF -> KeyUtils.splitKeys(sourceKeys,
+						(first, remaining) -> reactiveCommands.bitopDiff(destinationKey, first, remaining));
+				case DIFF1 -> KeyUtils.splitKeys(sourceKeys,
+						(first, remaining) -> reactiveCommands.bitopDiff1(destinationKey, first, remaining));
+				case ANDOR -> KeyUtils.splitKeys(sourceKeys,
+						(first, remaining) -> reactiveCommands.bitopAndor(destinationKey, first, remaining));
 				case ONE -> reactiveCommands.bitopOne(destinationKey, sourceKeys);
 			};
 

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

@@ -18,18 +18,19 @@
 import io.lettuce.core.BitFieldArgs;
 import io.lettuce.core.api.async.RedisStringAsyncCommands;
 
-import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 
 import org.jspecify.annotations.NonNull;
 import org.jspecify.annotations.NullUnmarked;
 import org.jspecify.annotations.Nullable;
+
 import org.springframework.data.domain.Range;
 import org.springframework.data.redis.connection.BitFieldSubCommands;
 import org.springframework.data.redis.connection.RedisStringCommands;
 import org.springframework.data.redis.connection.convert.Converters;
 import org.springframework.data.redis.core.types.Expiration;
+import org.springframework.data.redis.util.KeyUtils;
 import org.springframework.util.Assert;
 
 /**
@@ -309,9 +310,9 @@ public Long bitOp(@NonNull BitOperation op, byte @NonNull [] destination, byte @
 				}
 				yield it.bitopNot(destination, keys[0]);
 			}
-			case DIFF -> it.bitopDiff(destination, keys[0], Arrays.copyOfRange(keys, 1, keys.length));
-			case DIFF1 -> it.bitopDiff1(destination, keys[0], Arrays.copyOfRange(keys, 1, keys.length));
-			case ANDOR -> it.bitopAndor(destination, keys[0], Arrays.copyOfRange(keys, 1, keys.length));
+			case DIFF -> KeyUtils.splitKeys(keys, (first, remaining) -> it.bitopDiff(destination, first, remaining));
+			case DIFF1 -> KeyUtils.splitKeys(keys, (first, remaining) -> it.bitopDiff1(destination, first, remaining));
+			case ANDOR -> KeyUtils.splitKeys(keys, (first, remaining) -> it.bitopAndor(destination, first, remaining));
 			case ONE -> it.bitopOne(destination, keys);
 		});
 	}

src/main/java/org/springframework/data/redis/util/KeyUtils.java

@@ -0,0 +1,81 @@
+/*
+ * 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.util;
+
+import java.util.Arrays;
+
+/**
+ * Utility class for Redis keys.
+ *
+ * @author Mark Paluch
+ * @since 4.1
+ */
+public abstract class KeyUtils {
+
+	// ---------------------------------------------------------------------
+	// General convenience methods for working with keys
+	// ---------------------------------------------------------------------
+
+	/**
+	 * Utility method to split an array concatenated of keys into the first key and the remaining keys and invoke the
+	 * given function.
+	 *
+	 * @param keys array of keys to be separated into the first one and the remaining ones.
+	 * @param function function to be invoked with the first and remaining keys as input arguments.
+	 * @return result of the {@link SourceKeysFunction}.
+	 */
+	public static <T, R> R splitKeys(T[] keys, SourceKeysFunction<T, R> function) {
+
+		if (keys.length == 0) {
+			throw new IllegalArgumentException("Keys array must contain at least one element");
+		}
+
+		T firstKey = keys[0];
+		T[] otherKeys = Arrays.copyOfRange(keys, 1, keys.length);
+		return function.apply(firstKey, otherKeys);
+	}
+
+	/**
+	 * Represents a function that accepts two arguments of the same base type and produces a result while the second
+	 * argument is an array of {@code T}. This is similar to a {@link java.util.function.BiFunction} but restricts both
+	 * arguments to be of the same type. Typically used in arrangements where a composite collection of keys is split into
+	 * the first key and the remaining keys.
+	 * <p>
+	 * This is a <a href="package-summary.html">functional interface</a> whose functional method is
+	 * {@link #apply(Object, Object)}.
+	 *
+	 * @param <T> the type of the first argument to the function.
+	 * @param <R> the type of the result of the function.
+	 */
+	public interface SourceKeysFunction<T, R> {
+
+		/**
+		 * Applies this function to the given arguments.
+		 *
+		 * @param firstKey the first key argument.
+		 * @param otherKeys the other keys function argument.
+		 * @return the function result.
+		 */
+		R apply(T firstKey, T[] otherKeys);
+
+	}
+
+	// utility constructor
+	private KeyUtils() {
+
+	}
+
+}