DATAKV-105 - Polishing.

Moved KeySpaceResolver interfaces into mapping package. Let defaulting happen in BasicKeyValuePersistentEntity so that ClassNameKeySpaceResolver can be made package protected.

FowardingCloseableIterator is now generically typed and not bound to Map.Entry.

Original pull request: #11.

src/main/java/org/springframework/data/keyvalue/core/ForwardingCloseableIterator.java

@@ -16,39 +16,44 @@
 package org.springframework.data.keyvalue.core;
 
 import java.util.Iterator;
-import java.util.Map;
 
 import org.springframework.data.util.CloseableIterator;
+import org.springframework.util.Assert;
 
 /**
  * Forwards {@link CloseableIterator} invocations to the configured {@link Iterator} delegate.
  * 
  * @author Christoph Strobl
  * @author Thomas Darimont
+ * @author Oliver Gierke
  * @param <K>
  * @param <V>
  */
-public class ForwardingCloseableIterator<K, V> implements CloseableIterator<Map.Entry<K, V>> {
+public class ForwardingCloseableIterator<T> implements CloseableIterator<T> {
 
-	private final Iterator<? extends Map.Entry<K, V>> delegate;
+	private final Iterator<? extends T> delegate;
 	private final Runnable closeHandler;
 
 	/**
 	 * Creates a new {@link ForwardingCloseableIterator}.
 	 * 
-	 * @param delegate must not be {@literal null}
+	 * @param delegate must not be {@literal null}.
 	 */
-	public ForwardingCloseableIterator(Iterator<? extends Map.Entry<K, V>> delegate) {
+	public ForwardingCloseableIterator(Iterator<? extends T> delegate) {
 		this(delegate, null);
 	}
 
 	/**
-	 * Creates a new {@link ForwardingCloseableIterator} that invokes the configured {@code closeHanlder} on {@link #close()}.
+	 * Creates a new {@link ForwardingCloseableIterator} that invokes the configured {@code closeHandler} on
+	 * {@link #close()}.
 	 * 
-	 * @param delegate must not be {@literal null}
-	 * @param closeHandler may be {@literal null}
+	 * @param delegate must not be {@literal null}.
+	 * @param closeHandler may be {@literal null}.
 	 */
-	public ForwardingCloseableIterator(Iterator<? extends Map.Entry<K, V>> delegate, Runnable closeHandler) {
+	public ForwardingCloseableIterator(Iterator<? extends T> delegate, Runnable closeHandler) {
+
+		Assert.notNull(delegate, "Delegate iterator must not be null!");
+
 		this.delegate = delegate;
 		this.closeHandler = closeHandler;
 	}
@@ -67,7 +72,7 @@ public class ForwardingCloseableIterator<K, V> implements CloseableIterator<Map.
 	 * @see java.util.Iterator#next()
 	 */
 	@Override
-	public Map.Entry<K, V> next() {
+	public T next() {
 		return delegate.next();
 	}
 

src/main/java/org/springframework/data/keyvalue/core/KeyValueTemplate.java

@@ -55,12 +55,12 @@ public class KeyValueTemplate implements KeyValueOperations, ApplicationContextA
 	private static final PersistenceExceptionTranslator DEFAULT_PERSISTENCE_EXCEPTION_TRANSLATOR = new KeyValuePersistenceExceptionTranslator();
 
 	private final KeyValueAdapter adapter;
-
 	private final MappingContext<? extends KeyValuePersistentEntity<?>, ? extends KeyValuePersistentProperty> mappingContext;
 	private final IdentifierGenerator identifierGenerator;
-	private ApplicationEventPublisher eventPublisher;
 	private final Set<KeyValueEvent.Type> eventTypesToPublish = new HashSet<KeyValueEvent.Type>(4);
+
 	private PersistenceExceptionTranslator exceptionTranslator = DEFAULT_PERSISTENCE_EXCEPTION_TRANSLATOR;
+	private ApplicationEventPublisher eventPublisher;
 
 	/**
 	 * Create new {@link KeyValueTemplate} using the given {@link KeyValueAdapter} with a default

src/main/java/org/springframework/data/keyvalue/core/mapping/AnnotationBasedKeySpaceResolver.java

@@ -26,7 +26,6 @@ import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.core.style.ToStringCreator;
 import org.springframework.data.annotation.Persistent;
 import org.springframework.data.keyvalue.annotation.KeySpace;
-import org.springframework.data.keyvalue.core.KeySpaceResolver;
 import org.springframework.data.keyvalue.core.mapping.AnnotationBasedKeySpaceResolver.MetaAnnotationUtils.AnnotationDescriptor;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
@@ -58,7 +57,7 @@ enum AnnotationBasedKeySpaceResolver implements KeySpaceResolver {
 		return keySpace != null ? keySpace.toString() : null;
 	}
 
-	private Object getKeySpace(Class<?> type) {
+	private static Object getKeySpace(Class<?> type) {
 
 		KeySpace keyspace = AnnotationUtils.findAnnotation(type, KeySpace.class);
 
@@ -81,6 +80,7 @@ enum AnnotationBasedKeySpaceResolver implements KeySpaceResolver {
 				}
 			}
 		}
+
 		return null;
 	}
 
@@ -407,5 +407,4 @@ enum AnnotationBasedKeySpaceResolver implements KeySpaceResolver {
 			}
 		}
 	}
-
 }

src/main/java/org/springframework/data/keyvalue/core/mapping/BasicKeyValuePersistentEntity.java

@@ -15,37 +15,43 @@
  */
 package org.springframework.data.keyvalue.core.mapping;
 
-import org.springframework.data.keyvalue.core.KeySpaceResolver;
 import org.springframework.data.mapping.model.BasicPersistentEntity;
 import org.springframework.data.util.TypeInformation;
-import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
 
 /**
  * {@link KeyValuePersistentEntity} implementation that adds specific meta-data such as the {@literal keySpace}..
  * 
  * @author Christoph Strobl
+ * @author Oliver Gierke
  * @param <T>
  */
 public class BasicKeyValuePersistentEntity<T> extends BasicPersistentEntity<T, KeyValuePersistentProperty> implements
 		KeyValuePersistentEntity<T> {
 
+	private static final KeySpaceResolver DEFAULT_FALLBACK_RESOLVER = ClassNameKeySpaceResolver.INSTANCE;
+
 	private final String keyspace;
 
 	/**
 	 * @param information must not be {@literal null}.
-	 * @param keySpaceResolver must not be {@literal null}.
+	 * @param keySpaceResolver can be {@literal null}.
 	 */
 	public BasicKeyValuePersistentEntity(TypeInformation<T> information, KeySpaceResolver fallbackKeySpaceResolver) {
 
 		super(information);
 
-		Assert.notNull(fallbackKeySpaceResolver, "FallbackKeySpaceResolver must not be null!");
+		this.keyspace = detectKeySpace(information.getType(), fallbackKeySpaceResolver);
+	}
 
-		String resolvedKeySpace = AnnotationBasedKeySpaceResolver.INSTANCE.resolveKeySpace(information.getType());
-		this.keyspace = StringUtils.hasText(resolvedKeySpace) ? resolvedKeySpace : fallbackKeySpaceResolver
-				.resolveKeySpace(information.getType());
+	private static String detectKeySpace(Class<?> type, KeySpaceResolver fallback) {
 
+		String keySpace = AnnotationBasedKeySpaceResolver.INSTANCE.resolveKeySpace(type);
+
+		if (StringUtils.hasText(keySpace))
+			return keySpace;
+
+		return (fallback == null ? DEFAULT_FALLBACK_RESOLVER : fallback).resolveKeySpace(type);
 	}
 
 	/*

src/main/java/org/springframework/data/keyvalue/core/mapping/ClassNameKeySpaceResolver.java

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.springframework.data.keyvalue.core;
+package org.springframework.data.keyvalue.core.mapping;
 
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
@@ -22,8 +22,9 @@ import org.springframework.util.ClassUtils;
  * Most trivial implementation of {@link KeySpaceResolver} returning the {@link Class#getName()}.
  * 
  * @author Christoph Strobl
+ * @author Oliver Gierke
  */
-public enum ClassNameKeySpaceResolver implements KeySpaceResolver {
+enum ClassNameKeySpaceResolver implements KeySpaceResolver {
 
 	INSTANCE;
 
@@ -37,5 +38,4 @@ public enum ClassNameKeySpaceResolver implements KeySpaceResolver {
 		Assert.notNull(type, "Type must not be null!");
 		return ClassUtils.getUserClass(type).getName();
 	}
-
 }

src/main/java/org/springframework/data/keyvalue/core/mapping/KeySpaceResolver.java

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.springframework.data.keyvalue.core;
+package org.springframework.data.keyvalue.core.mapping;
 
 /**
  * {@link KeySpaceResolver} determines the {@literal keyspace} a given type is assigned to. A keyspace in this context

src/main/java/org/springframework/data/keyvalue/core/mapping/context/KeyValueMappingContext.java

@@ -18,44 +18,33 @@ package org.springframework.data.keyvalue.core.mapping.context;
 import java.beans.PropertyDescriptor;
 import java.lang.reflect.Field;
 
-import org.springframework.data.keyvalue.core.ClassNameKeySpaceResolver;
-import org.springframework.data.keyvalue.core.KeySpaceResolver;
 import org.springframework.data.keyvalue.core.mapping.BasicKeyValuePersistentEntity;
+import org.springframework.data.keyvalue.core.mapping.KeySpaceResolver;
 import org.springframework.data.keyvalue.core.mapping.KeyValuePersistentEntity;
 import org.springframework.data.keyvalue.core.mapping.KeyValuePersistentProperty;
 import org.springframework.data.mapping.context.AbstractMappingContext;
 import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.data.mapping.model.SimpleTypeHolder;
 import org.springframework.data.util.TypeInformation;
-import org.springframework.util.Assert;
 
 /**
  * Default implementation of a {@link MappingContext} using {@link KeyValuePersistentEntity} and
  * {@link KeyValuePersistentProperty} as primary abstractions.
  * 
  * @author Christoph Strobl
+ * @author Oliver Gierke
  */
 public class KeyValueMappingContext extends
 		AbstractMappingContext<KeyValuePersistentEntity<?>, KeyValuePersistentProperty> {
 
-	private final KeySpaceResolver fallbackKeySpaceResolver;
+	private KeySpaceResolver fallbackKeySpaceResolver;
 
 	/**
-	 * Creates new {@link KeyValueMappingContext} using an {@link ClassNameKeySpaceResolver} for {@literal keyspace}
-	 * resolution.
-	 */
-	public KeyValueMappingContext() {
-		this(ClassNameKeySpaceResolver.INSTANCE);
-	}
-
-	/**
-	 * Creates new {@link KeyValueMappingContext} using given {@link KeySpaceResolver}
+	 * Configures the {@link KeySpaceResolver} to be used if not explicit key space is annotated to the domain type.
 	 * 
-	 * @param keySpaceResolver must not be {@literal null}.
+	 * @param fallbackKeySpaceResolver can be {@literal null}.
 	 */
-	public KeyValueMappingContext(KeySpaceResolver fallbackKeySpaceResolver) {
-
-		Assert.notNull(fallbackKeySpaceResolver, "FallbackKeySpaceResolver must not be null!");
+	public void setFallbackKeySpaceResolver(KeySpaceResolver fallbackKeySpaceResolver) {
 		this.fallbackKeySpaceResolver = fallbackKeySpaceResolver;
 	}
 

src/main/java/org/springframework/data/map/MapKeyValueAdapter.java

@@ -18,6 +18,7 @@ package org.springframework.data.map;
 import java.io.Serializable;
 import java.util.Collection;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.concurrent.ConcurrentHashMap;
 
 import org.springframework.core.CollectionFactory;
@@ -148,8 +149,8 @@ public class MapKeyValueAdapter extends AbstractKeyValueAdapter {
 	 * @see org.springframework.data.keyvalue.core.KeyValueAdapter#entries(java.io.Serializable)
 	 */
 	@Override
-	public CloseableIterator<Map.Entry<Serializable, Object>> entries(Serializable keyspace) {
-		return new ForwardingCloseableIterator<Serializable, Object>(getKeySpaceMap(keyspace).entrySet().iterator());
+	public CloseableIterator<Entry<Serializable, Object>> entries(Serializable keyspace) {
+		return new ForwardingCloseableIterator<Entry<Serializable, Object>>(getKeySpaceMap(keyspace).entrySet().iterator());
 	}
 
 	/*
@@ -180,7 +181,7 @@ public class MapKeyValueAdapter extends AbstractKeyValueAdapter {
 	}
 
 	/**
-	 * Get map associated with given keyspace.
+	 * Get map associated with given key space.
 	 * 
 	 * @param keyspace must not be {@literal null}.
 	 * @return
@@ -202,5 +203,4 @@ public class MapKeyValueAdapter extends AbstractKeyValueAdapter {
 	private void addMapForKeySpace(Serializable keyspace) {
 		store.put(keyspace, CollectionFactory.<Serializable, Object> createMap(keySpaceMapType, 1000));
 	}
-
 }