DATAREDIS-425 - Simplify usage of RedisCallback for retrieving values.

RedisCallbacks now be directly used for eg. accessing index values by key to retrieve a set of domain types by ids.

Author: christophstrobl

src/asciidoc/reference/redis-repositories.adoc

@@ -458,12 +458,12 @@ WARNING: Referenced Objects are not subject of persisting changes when saving th
 Indexes set on properties of referenced types will not be resolved.
 
 [[redis.repositories.queries]]
-== Query Methods
+== Queries and Query Methods
 Query methods allow automatic derivation of simple finder queries from the method name. 
 
 .Sample Repository finder Method
 ====
-[source]
+[source,java]
 ----
 public interface PersonRepository extends CrudRepository<Person, String> {
   
@@ -474,3 +474,23 @@ public interface PersonRepository extends CrudRepository<Person, String> {
 
 NOTE: Please make sure properties used in finder methods are set up correctly for indexing.
 
+Using derived finder methods might not always be sufficient to model the queries to execute. `RedisCallback` offers more control over the actual matching of index structures or even customly added ones. All it takes is providing a `RedisCallback` that returns a single or `Iterable` set of _id_ values. 
+
+.Sample finder using RedisCallback
+====
+[source,java]
+----
+String user = //...
+
+List<RedisSession> sessionsByUser = template.find(new RedisCallback<Set<byte[]>>() {
+
+  public Set<byte[]> doInRedis(RedisConnection connection) throws DataAccessException {
+    return connection
+      .sMembers("sessions:securityContext.authentication.principal.username:" + user);
+  }}, RedisSession.class);
+----
+====
+
+
+
+

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

@@ -15,10 +15,16 @@
  */
 package org.springframework.data.redis.core;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
 import org.springframework.data.keyvalue.core.KeyValueAdapter;
 import org.springframework.data.keyvalue.core.KeyValueCallback;
 import org.springframework.data.keyvalue.core.KeyValueTemplate;
 import org.springframework.data.redis.core.mapping.RedisMappingContext;
+import org.springframework.util.Assert;
+import org.springframework.util.ClassUtils;
 
 /**
  * Redis specific implementation of {@link KeyValueTemplate}.
@@ -47,6 +53,63 @@ public RedisMappingContext getMappingContext() {
 		return (RedisMappingContext) super.getMappingContext();
 	}
 
+	/**
+	 * Retrieve entities by resolving their {@literal id}s and converting them into required type. <br />
+	 * The callback provides either a single {@literal id} or an {@link Iterable} of {@literal id}s, used for retrieving
+	 * the actual domain types and shortcuts manual retrieval and conversion of {@literal id}s via {@link RedisTemplate}.
+	 * 
+	 * <pre>
+	 * <code>
+	 * List&#60;RedisSession&#62; sessions = template.find(new RedisCallback&#60;Set&#60;byte[]&#62;&#62;() {
+	 *   public Set&#60;byte[]&#60; doInRedis(RedisConnection connection) throws DataAccessException {
+	 *     return connection
+	 *       .sMembers("spring:session:sessions:securityContext.authentication.principal.username:user"
+	 *         .getBytes());
+	 *   }
+	 * }, RedisSession.class);
+	 * </code>
+	 * 
+	 * <pre>
+	 * @param callback provides the to retrieve entity ids. Must not be {@literal null}.
+	 * @param type must not be {@literal null}.
+	 * @return empty list if not elements found.
+	 */
+	public <T> List<T> find(final RedisCallback<?> callback, final Class<T> type) {
+
+		Assert.notNull(callback, "Callback must not be null.");
+
+		return execute(new RedisKeyValueCallback<List<T>>() {
+
+			@Override
+			public List<T> doInRedis(RedisKeyValueAdapter adapter) {
+
+				Object callbackResult = adapter.execute(callback);
+
+				if (callbackResult == null) {
+					return Collections.emptyList();
+				}
+
+				Iterable<?> ids = ClassUtils.isAssignable(Iterable.class, callbackResult.getClass()) ? (Iterable<?>) callbackResult
+						: Collections.singleton(callbackResult);
+
+				List<T> result = new ArrayList<T>();
+				for (Object id : ids) {
+
+					String idToUse = adapter.getConverter().getConversionService().canConvert(id.getClass(), String.class) ? adapter
+							.getConverter().getConversionService().convert(id, String.class)
+							: id.toString();
+
+					T candidate = findById(idToUse, type);
+					if (candidate != null) {
+						result.add(candidate);
+					}
+				}
+
+				return result;
+			}
+		});
+	}
+
 	/**
 	 * Redis specific {@link KeyValueCallback}.
 	 * 

src/test/java/org/springframework/data/redis/core/RedisKeyValueTemplateTests.java

@@ -0,0 +1,235 @@
+/*
+ * Copyright 2015 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
+ *
+ *      http://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.core;
+
+import static org.hamcrest.core.Is.*;
+import static org.hamcrest.core.IsCollectionContaining.*;
+import static org.junit.Assert.*;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+import org.springframework.dao.DataAccessException;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.redis.ConnectionFactoryTracker;
+import org.springframework.data.redis.connection.RedisConnection;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
+import org.springframework.data.redis.core.mapping.RedisMappingContext;
+import org.springframework.util.ObjectUtils;
+
+/**
+ * @author Christoph Strobl
+ */
+@RunWith(Parameterized.class)
+public class RedisKeyValueTemplateTests {
+
+	RedisConnectionFactory connectionFactory;
+	RedisKeyValueTemplate template;
+	RedisTemplate<Object, Object> nativeTemplate;
+
+	public RedisKeyValueTemplateTests(RedisConnectionFactory connectionFactory) {
+
+		this.connectionFactory = connectionFactory;
+		ConnectionFactoryTracker.add(connectionFactory);
+	}
+
+	@Parameters
+	public static List<RedisConnectionFactory> params() {
+
+		JedisConnectionFactory jedis = new JedisConnectionFactory();
+		jedis.afterPropertiesSet();
+
+		return Collections.<RedisConnectionFactory> singletonList(jedis);
+	}
+
+	@AfterClass
+	public static void cleanUp() {
+		ConnectionFactoryTracker.cleanUp();
+	}
+
+	@Before
+	public void setUp() {
+
+		nativeTemplate = new RedisTemplate<Object, Object>();
+		nativeTemplate.setConnectionFactory(connectionFactory);
+		nativeTemplate.afterPropertiesSet();
+
+		RedisMappingContext context = new RedisMappingContext();
+
+		RedisKeyValueAdapter adapter = new RedisKeyValueAdapter(nativeTemplate, context);
+		template = new RedisKeyValueTemplate(adapter, context);
+	}
+
+	@After
+	public void tearDown() {
+
+		nativeTemplate.execute(new RedisCallback<Void>() {
+
+			@Override
+			public Void doInRedis(RedisConnection connection) throws DataAccessException {
+
+				connection.flushDb();
+				return null;
+			}
+		});
+	}
+
+	/**
+	 * @see DATAREDIS-425
+	 */
+	@Test
+	public void savesObjectCorrectly() {
+
+		final Person rand = new Person();
+		rand.firstname = "rand";
+
+		template.insert(rand);
+
+		nativeTemplate.execute(new RedisCallback<Void>() {
+
+			@Override
+			public Void doInRedis(RedisConnection connection) throws DataAccessException {
+
+				assertThat(connection.exists(("template-test-person:" + rand.id).getBytes()), is(true));
+				return null;
+			}
+		});
+	}
+
+	/**
+	 * @see DATAREDIS-425
+	 */
+	@Test
+	public void findProcessesCallbackReturningSingleIdCorrectly() {
+
+		Person rand = new Person();
+		rand.firstname = "rand";
+
+		final Person mat = new Person();
+		mat.firstname = "mat";
+
+		template.insert(rand);
+		template.insert(mat);
+
+		List<Person> result = template.find(new RedisCallback<byte[]>() {
+
+			@Override
+			public byte[] doInRedis(RedisConnection connection) throws DataAccessException {
+				return mat.id.getBytes();
+			}
+		}, Person.class);
+
+		assertThat(result.size(), is(1));
+		assertThat(result, hasItems(mat));
+	}
+
+	/**
+	 * @see DATAREDIS-425
+	 */
+	@Test
+	public void findProcessesCallbackReturningMultipleIdsCorrectly() {
+
+		final Person rand = new Person();
+		rand.firstname = "rand";
+
+		final Person mat = new Person();
+		mat.firstname = "mat";
+
+		template.insert(rand);
+		template.insert(mat);
+
+		List<Person> result = template.find(new RedisCallback<List<byte[]>>() {
+
+			@Override
+			public List<byte[]> doInRedis(RedisConnection connection) throws DataAccessException {
+				return Arrays.asList(rand.id.getBytes(), mat.id.getBytes());
+			}
+		}, Person.class);
+
+		assertThat(result.size(), is(2));
+		assertThat(result, hasItems(rand, mat));
+	}
+
+	/**
+	 * @see DATAREDIS-425
+	 */
+	@Test
+	public void findProcessesCallbackReturningNullCorrectly() {
+
+		Person rand = new Person();
+		rand.firstname = "rand";
+
+		Person mat = new Person();
+		mat.firstname = "mat";
+
+		template.insert(rand);
+		template.insert(mat);
+
+		List<Person> result = template.find(new RedisCallback<List<byte[]>>() {
+
+			@Override
+			public List<byte[]> doInRedis(RedisConnection connection) throws DataAccessException {
+				return null;
+			}
+		}, Person.class);
+
+		assertThat(result.size(), is(0));
+	}
+
+	@RedisHash("template-test-person")
+	static class Person {
+
+		@Id String id;
+		String firstname;
+
+		@Override
+		public int hashCode() {
+
+			int result = ObjectUtils.nullSafeHashCode(firstname);
+			return result + ObjectUtils.nullSafeHashCode(id);
+		}
+
+		@Override
+		public boolean equals(Object obj) {
+			if (this == obj) {
+				return true;
+			}
+			if (obj == null) {
+				return false;
+			}
+			if (!(obj instanceof Person)) {
+				return false;
+			}
+			Person that = (Person) obj;
+
+			if (!ObjectUtils.nullSafeEquals(this.firstname, that.firstname)) {
+				return false;
+			}
+
+			return ObjectUtils.nullSafeEquals(this.id, that.id);
+		}
+
+	}
+}