DATAREDIS-425 - Additional mapping options.

- Allow Converters to read/write Map<String,byte[]> for more influence on actual mapping.
- Use provided type passed down from template to not require to have an explicit _class field on root level.

This one requires DATAKV-117

Author: christophstrobl

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

@@ -38,6 +38,7 @@
 import org.springframework.data.redis.connection.Message;
 import org.springframework.data.redis.connection.RedisConnection;
 import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.core.convert.CustomConversions;
 import org.springframework.data.redis.core.convert.IndexResolverImpl;
 import org.springframework.data.redis.core.convert.MappingRedisConverter;
 import org.springframework.data.redis.core.convert.RedisConverter;
@@ -65,18 +66,44 @@ public class RedisKeyValueAdapter extends AbstractKeyValueAdapter implements App
 	private RedisMessageListenerContainer messageListenerContainer;
 	private KeyExpirationEventMessageListener expirationListener;
 
+	/**
+	 * Creates new {@link RedisKeyValueAdapter} with default {@link RedisMappingContext} and default
+	 * {@link CustomConversions}.
+	 * 
+	 * @param redisOps must not be {@literal null}.
+	 */
 	public RedisKeyValueAdapter(RedisOperations<?, ?> redisOps) {
 		this(redisOps, new RedisMappingContext());
 	}
 
+	/**
+	 * Creates new {@link RedisKeyValueAdapter} with default {@link CustomConversions}.
+	 * 
+	 * @param redisOps must not be {@literal null}.
+	 * @param mappingContext must not be {@literal null}.
+	 */
 	public RedisKeyValueAdapter(RedisOperations<?, ?> redisOps, RedisMappingContext mappingContext) {
+		this(redisOps, mappingContext, new CustomConversions());
+	}
+
+	/**
+	 * Creates new {@link RedisKeyValueAdapter}.
+	 * 
+	 * @param redisOps must not be {@literal null}.
+	 * @param mappingContext must not be {@literal null}.
+	 * @param customConversions can be {@literal null}.
+	 */
+	public RedisKeyValueAdapter(RedisOperations<?, ?> redisOps, RedisMappingContext mappingContext,
+			CustomConversions customConversions) {
 
 		super(new RedisQueryEngine());
 
 		Assert.notNull(redisOps, "RedisOperations must not be null!");
+		Assert.notNull(mappingContext, "RedisMappingContext must not be null!");
 
 		MappingRedisConverter mappingConverter = new MappingRedisConverter(mappingContext, new IndexResolverImpl(
 				mappingContext.getMappingConfiguration().getIndexConfiguration()), new ReferenceResolverImpl(this));
+		mappingConverter.setCustomConversions(customConversions == null ? new CustomConversions() : customConversions);
 		mappingConverter.afterPropertiesSet();
 
 		converter = mappingConverter;
@@ -179,6 +206,16 @@ public Boolean doInRedis(RedisConnection connection) throws DataAccessException
 	 * @see org.springframework.data.keyvalue.core.KeyValueAdapter#get(java.io.Serializable, java.io.Serializable)
 	 */
 	public Object get(Serializable id, Serializable keyspace) {
+		return get(id, keyspace, Object.class);
+	}
+
+	/**
+	 * @param id
+	 * @param keyspace
+	 * @param type
+	 * @return
+	 */
+	public <T> T get(Serializable id, Serializable keyspace, Class<T> type) {
 
 		final byte[] binId = createKey(keyspace, id);
 
@@ -190,19 +227,31 @@ public Map<byte[], byte[]> doInRedis(RedisConnection connection) throws DataAcce
 			}
 		});
 
-		return converter.read(Object.class, new RedisData(raw));
+		RedisData data = new RedisData(raw);
+		data.setId(id);
+		data.setKeyspace(keyspace.toString());
+
+		return converter.read(type, data);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.keyvalue.core.KeyValueAdapter#delete(java.io.Serializable, java.io.Serializable)
 	 */
 	public Object delete(final Serializable id, final Serializable keyspace) {
+		return delete(id, keyspace, Object.class);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.keyvalue.core.AbstractKeyValueAdapter#delete(java.io.Serializable, java.io.Serializable, java.lang.Class)
+	 */
+	public <T> T delete(final Serializable id, final Serializable keyspace, final Class<T> type) {
 
 		final byte[] binId = toBytes(id);
 		final byte[] binKeyspace = toBytes(keyspace);
 
-		Object o = get(id, keyspace);
+		T o = get(id, keyspace, type);
 
 		if (o != null) {
 
@@ -472,6 +521,11 @@ private boolean isKeyExpirationMessage(Message message) {
 		}
 	}
 
+	/**
+	 * {@link ReferenceResolver} using {@link RedisKeyValueAdapter} to read and convert referenced entities.
+	 * 
+	 * @author Christoph Strobl
+	 */
 	static class ReferenceResolverImpl implements ReferenceResolver {
 
 		private RedisKeyValueAdapter adapter;
@@ -487,6 +541,9 @@ public ReferenceResolverImpl(RedisKeyValueAdapter adapter) {
 			this.adapter = adapter;
 		}
 
+		/**
+		 * @param adapter
+		 */
 		public void setAdapter(RedisKeyValueAdapter adapter) {
 			this.adapter = adapter;
 		}
@@ -497,7 +554,7 @@ public void setAdapter(RedisKeyValueAdapter adapter) {
 		 */
 		@Override
 		public <T> T resolveReference(Serializable id, Serializable keyspace, Class<T> type) {
-			return (T) adapter.get(id, keyspace);
+			return (T) adapter.get(id, keyspace, type);
 		}
 	}
 

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

@@ -20,6 +20,7 @@
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Comparator;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -49,14 +50,13 @@ public RedisQueryEngine(CriteriaAccessor<RedisOperationChain> criteriaAccessor,
 		super(criteriaAccessor, sortAccessor);
 	}
 
-	@Override
-	public Collection<?> execute(final RedisOperationChain criteria, Comparator<?> sort, int offset, int rows,
-			final Serializable keyspace) {
+	public <T> Collection<T> execute(final RedisOperationChain criteria, final Comparator<?> sort, int offset, int rows,
+			final Serializable keyspace, Class<T> type) {
 
-		RedisCallback<List<Map<byte[], byte[]>>> callback = new RedisCallback<List<Map<byte[], byte[]>>>() {
+		RedisCallback<Map<byte[], Map<byte[], byte[]>>> callback = new RedisCallback<Map<byte[], Map<byte[], byte[]>>>() {
 
 			@Override
-			public List<Map<byte[], byte[]>> doInRedis(RedisConnection connection) throws DataAccessException {
+			public Map<byte[], Map<byte[], byte[]>> doInRedis(RedisConnection connection) throws DataAccessException {
 
 				String key = keyspace + ":";
 				byte[][] keys = new byte[criteria.getSismember().size()][];
@@ -70,33 +70,45 @@ public List<Map<byte[], byte[]>> doInRedis(RedisConnection connection) throws Da
 
 				byte[] keyspaceBin = getAdapter().getConverter().getConversionService().convert(keyspace + ":", byte[].class);
 
-				final List<Map<byte[], byte[]>> rawData = new ArrayList<Map<byte[], byte[]>>();
+				final Map<byte[], Map<byte[], byte[]>> rawData = new LinkedHashMap<byte[], Map<byte[], byte[]>>();
 
 				for (byte[] id : allKeys) {
 
 					byte[] singleKey = Arrays.copyOf(keyspaceBin, id.length + keyspaceBin.length);
 					System.arraycopy(id, 0, singleKey, keyspaceBin.length, id.length);
 
-					rawData.add(connection.hGetAll(singleKey));
+					rawData.put(id, connection.hGetAll(singleKey));
 				}
 
 				return rawData;
 
 			}
 		};
 
-		List<Map<byte[], byte[]>> raw = this.getAdapter().execute(callback);
+		Map<byte[], Map<byte[], byte[]>> raw = this.getAdapter().execute(callback);
+
+		List<T> result = new ArrayList<T>(raw.size());
+		for (Map.Entry<byte[], Map<byte[], byte[]>> entry : raw.entrySet()) {
+
+			RedisData data = new RedisData(entry.getValue());
+			data.setId(getAdapter().getConverter().getConversionService().convert(entry.getKey(), String.class));
+			data.setKeyspace(keyspace.toString());
+
+			T converted = this.getAdapter().getConverter().read(type, data);
 
-		List<Object> result = new ArrayList<Object>(raw.size());
-		for (Map<byte[], byte[]> rawData : raw) {
-			Object converted = this.getAdapter().getConverter().read(Object.class, new RedisData(rawData));
 			if (converted != null) {
 				result.add(converted);
 			}
 		}
 		return result;
 	}
 
+	@Override
+	public Collection<?> execute(final RedisOperationChain criteria, Comparator<?> sort, int offset, int rows,
+			final Serializable keyspace) {
+		return execute(criteria, sort, offset, rows, keyspace, Object.class);
+	}
+
 	@Override
 	public long count(final RedisOperationChain criteria, final Serializable keyspace) {
 

src/main/java/org/springframework/data/redis/core/convert/Bucket.java

@@ -17,6 +17,7 @@
 
 import java.nio.charset.Charset;
 import java.util.Collection;
+import java.util.Collections;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.Map;
@@ -78,6 +79,11 @@ public byte[] get(String path) {
 		return data.get(path);
 	}
 
+	/**
+	 * A set view of the mappings contained in this bucket.
+	 * 
+	 * @return never {@literal null}.
+	 */
 	public Set<Entry<String, byte[]>> entrySet() {
 		return data.entrySet();
 	}
@@ -89,14 +95,29 @@ public boolean isEmpty() {
 		return data.isEmpty();
 	}
 
+	/**
+	 * @return never {@literal null}.
+	 */
 	public Collection<byte[]> values() {
 		return data.values();
 	}
 
+	/**
+	 * @return never {@literal null}.
+	 */
 	public Set<String> keySet() {
 		return data.keySet();
 	}
 
+	/**
+	 * Key/value pairs contained in the {@link Bucket}.
+	 * 
+	 * @return never {@literal null}.
+	 */
+	public Map<String, byte[]> asMap() {
+		return Collections.unmodifiableMap(this.data);
+	}
+
 	public Bucket extract(String prefix) {
 
 		Bucket partial = new Bucket();