Introduce doWithKeys.

Original Pull Request: #2276

Author: mp911de

src/main/java/org/springframework/data/redis/core/RedisTemplate.java

@@ -26,6 +26,7 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
 
 import org.springframework.beans.factory.BeanClassLoaderAware;
 import org.springframework.dao.InvalidDataAccessApiUsageException;
@@ -551,21 +552,35 @@ protected <T> T postProcessResult(@Nullable T result, RedisConnection conn, bool
 	// Methods dealing with Redis Keys
 	// -------------------------------------------------------------------------
 
+	@Override
+	public void convertAndSend(String channel, Object message) {
+
+		Assert.hasText(channel, "a non-empty channel is required");
+
+		byte[] rawChannel = rawString(channel);
+		byte[] rawMessage = rawValue(message);
+
+		execute(connection -> {
+			connection.publish(rawChannel, rawMessage);
+			return null;
+		}, true);
+	}
+
 	@Override
 	public Boolean copy(K source, K target, boolean replace) {
 
 		byte[] sourceKey = rawKey(source);
 		byte[] targetKey = rawKey(target);
 
-		return execute(connection -> connection.copy(sourceKey, targetKey, replace), true);
+		return doWithKeys(connection -> connection.copy(sourceKey, targetKey, replace));
 	}
 
 	@Override
 	public Boolean delete(K key) {
 
 		byte[] rawKey = rawKey(key);
 
-		Long result = execute(connection -> connection.del(rawKey), true);
+		Long result = doWithKeys(connection -> connection.del(rawKey));
 		return result != null && result.intValue() == 1;
 	}
 
@@ -578,15 +593,15 @@ public Long delete(Collection<K> keys) {
 
 		byte[][] rawKeys = rawKeys(keys);
 
-		return execute(connection -> connection.del(rawKeys), true);
+		return doWithKeys(connection -> connection.del(rawKeys));
 	}
 
 	@Override
 	public Boolean unlink(K key) {
 
 		byte[] rawKey = rawKey(key);
 
-		Long result = execute(connection -> connection.unlink(rawKey), true);
+		Long result = doWithKeys(connection -> connection.unlink(rawKey));
 
 		return result != null && result.intValue() == 1;
 	}
@@ -600,15 +615,15 @@ public Long unlink(Collection<K> keys) {
 
 		byte[][] rawKeys = rawKeys(keys);
 
-		return execute(connection -> connection.unlink(rawKeys), true);
+		return doWithKeys(connection -> connection.unlink(rawKeys));
 	}
 
 	@Override
 	public Boolean hasKey(K key) {
 
 		byte[] rawKey = rawKey(key);
 
-		return execute(connection -> connection.exists(rawKey), true);
+		return doWithKeys(connection -> connection.exists(rawKey));
 	}
 
 	@Override
@@ -617,7 +632,7 @@ public Long countExistingKeys(Collection<K> keys) {
 		Assert.notNull(keys, "Keys must not be null!");
 
 		byte[][] rawKeys = rawKeys(keys);
-		return execute(connection -> connection.exists(rawKeys), true);
+		return doWithKeys(connection -> connection.exists(rawKeys));
 	}
 
 	@Override
@@ -626,75 +641,61 @@ public Boolean expire(K key, final long timeout, final TimeUnit unit) {
 		byte[] rawKey = rawKey(key);
 		long rawTimeout = TimeoutUtils.toMillis(timeout, unit);
 
-		return execute(connection -> {
+		return doWithKeys(connection -> {
 			try {
 				return connection.pExpire(rawKey, rawTimeout);
 			} catch (Exception e) {
 				// Driver may not support pExpire or we may be running on Redis 2.4
 				return connection.expire(rawKey, TimeoutUtils.toSeconds(timeout, unit));
 			}
-		}, true);
+		});
 	}
 
 	@Override
 	public Boolean expireAt(K key, final Date date) {
 
 		byte[] rawKey = rawKey(key);
 
-		return execute(connection -> {
+		return doWithKeys(connection -> {
 			try {
 				return connection.pExpireAt(rawKey, date.getTime());
 			} catch (Exception e) {
 				return connection.expireAt(rawKey, date.getTime() / 1000);
 			}
-		}, true);
-	}
-
-	@Override
-	public void convertAndSend(String channel, Object message) {
-
-		Assert.hasText(channel, "a non-empty channel is required");
-
-		byte[] rawChannel = rawString(channel);
-		byte[] rawMessage = rawValue(message);
-
-		execute(connection -> {
-			connection.publish(rawChannel, rawMessage);
-			return null;
-		}, true);
+		});
 	}
 
-	//
-	// Value operations
-	//
+	// -------------------------------------------------------------------------
+	// Methods dealing with value operations
+	// -------------------------------------------------------------------------
 
 	@Override
 	public Long getExpire(K key) {
 
 		byte[] rawKey = rawKey(key);
-		return execute(connection -> connection.ttl(rawKey), true);
+		return doWithKeys(connection -> connection.ttl(rawKey));
 	}
 
 	@Override
 	public Long getExpire(K key, final TimeUnit timeUnit) {
 
 		byte[] rawKey = rawKey(key);
-		return execute(connection -> {
+		return doWithKeys(connection -> {
 			try {
 				return connection.pTtl(rawKey, timeUnit);
 			} catch (Exception e) {
 				// Driver may not support pTtl or we may be running on Redis 2.4
 				return connection.ttl(rawKey, timeUnit);
 			}
-		}, true);
+		});
 	}
 
 	@Override
 	@SuppressWarnings("unchecked")
 	public Set<K> keys(K pattern) {
 
 		byte[] rawKey = rawKey(pattern);
-		Set<byte[]> rawKeys = execute(connection -> connection.keys(rawKey), true);
+		Set<byte[]> rawKeys = doWithKeys(connection -> connection.keys(rawKey));
 
 		return keySerializer != null ? SerializationUtils.deserialize(rawKeys, keySerializer) : (Set<K>) rawKeys;
 	}
@@ -712,20 +713,20 @@ public Cursor<K> scan(ScanOptions options) {
 	public Boolean persist(K key) {
 
 		byte[] rawKey = rawKey(key);
-		return execute(connection -> connection.persist(rawKey), true);
+		return doWithKeys(connection -> connection.persist(rawKey));
 	}
 
 	@Override
 	public Boolean move(K key, final int dbIndex) {
 
 		byte[] rawKey = rawKey(key);
-		return execute(connection -> connection.move(rawKey, dbIndex), true);
+		return doWithKeys(connection -> connection.move(rawKey, dbIndex));
 	}
 
 	@Override
 	public K randomKey() {
 
-		byte[] rawKey = execute(RedisKeyCommands::randomKey, true);
+		byte[] rawKey = doWithKeys(RedisKeyCommands::randomKey);
 		return deserializeKey(rawKey);
 	}
 
@@ -735,25 +736,25 @@ public void rename(K oldKey, K newKey) {
 		byte[] rawOldKey = rawKey(oldKey);
 		byte[] rawNewKey = rawKey(newKey);
 
-		execute(connection -> {
+		doWithKeys(connection -> {
 			connection.rename(rawOldKey, rawNewKey);
 			return null;
-		}, true);
+		});
 	}
 
 	@Override
 	public Boolean renameIfAbsent(K oldKey, K newKey) {
 
 		byte[] rawOldKey = rawKey(oldKey);
 		byte[] rawNewKey = rawKey(newKey);
-		return execute(connection -> connection.renameNX(rawOldKey, rawNewKey), true);
+		return doWithKeys(connection -> connection.renameNX(rawOldKey, rawNewKey));
 	}
 
 	@Override
 	public DataType type(K key) {
 
 		byte[] rawKey = rawKey(key);
-		return execute(connection -> connection.type(rawKey), true);
+		return doWithKeys(connection -> connection.type(rawKey));
 	}
 
 	/**
@@ -768,7 +769,7 @@ public DataType type(K key) {
 	public byte[] dump(K key) {
 
 		byte[] rawKey = rawKey(key);
-		return execute(connection -> connection.dump(rawKey), true);
+		return doWithKeys(connection -> connection.dump(rawKey));
 	}
 
 	/**
@@ -784,18 +785,26 @@ public byte[] dump(K key) {
 	 *           {@literal false}.
 	 */
 	@Override
-	public void restore(K key, final byte[] value, long timeToLive, TimeUnit unit, boolean replace) {
+	public void restore(K key, byte[] value, long timeToLive, TimeUnit unit, boolean replace) {
 
 		byte[] rawKey = rawKey(key);
 		long rawTimeout = TimeoutUtils.toMillis(timeToLive, unit);
 
-		execute(connection -> {
+		doWithKeys(connection -> {
 			connection.restore(rawKey, rawTimeout, value, replace);
 			return null;
-		}, true);
+		});
+	}
+
+	@Nullable
+	private <T> T doWithKeys(Function<RedisKeyCommands, T> action) {
+		return execute((RedisCallback<? extends T>) connection -> action.apply(connection.keyCommands()), true);
 	}
 
-	// Sort operations
+
+	// -------------------------------------------------------------------------
+	// Methods dealing with sorting
+	// -------------------------------------------------------------------------
 
 	@Override
 	@SuppressWarnings("unchecked")
@@ -809,7 +818,7 @@ public <T> List<T> sort(SortQuery<K> query, @Nullable RedisSerializer<T> resultS
 		byte[] rawKey = rawKey(query.getKey());
 		SortParameters params = QueryUtils.convertQuery(query, stringSerializer);
 
-		List<byte[]> vals = execute(connection -> connection.sort(rawKey, params), true);
+		List<byte[]> vals = doWithKeys(connection -> connection.sort(rawKey, params));
 
 		return SerializationUtils.deserialize(vals, resultSerializer);
 	}
@@ -858,10 +867,9 @@ public Long sort(SortQuery<K> query, K storeKey) {
 	}
 
 	// -------------------------------------------------------------------------
-	// Methods dealing with Redis Transactions
+	// Methods dealing with Transactions
 	// -------------------------------------------------------------------------
 
-
 	@Override
 	public void watch(K key) {
 
@@ -893,6 +901,7 @@ public void unwatch() {
 		}, true);
 	}
 
+
 	@Override
 	public void multi() {
 		execute(connection -> {