DATAKV-99 - Polishing.

Removed dedicated Entry<K,V> interface, since Map.Entry<K,V> is already sufficient. Favoured CloseableIterator over KeyValueIterator since it offers no additional functionality but less generic parameter clutter.
Added missing JavaDoc.

Author: christophstrobl

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

@@ -0,0 +1,72 @@
+/*
+ * 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.keyvalue.core;
+
+import java.util.Iterator;
+import java.util.Map;
+
+import org.springframework.data.util.CloseableIterator;
+
+/**
+ * Forwards {@link CloseableIterator} invocations to the configured {@link Iterator} delegate.
+ * 
+ * @author Christoph Strobl
+ * @author Thomas Darimont
+ * @param <K>
+ * @param <V>
+ */
+public class ForwardingCloseableIterator<K, V> implements CloseableIterator<Map.Entry<K, V>> {
+
+	private final Iterator<? extends Map.Entry<K, V>> delegate;
+	private final Runnable closeHandler;
+
+	/**
+	 * Creates a new {@link ForwardingCloseableIterator}.
+	 * 
+	 * @param delegate must not be {@literal null}
+	 */
+	public ForwardingCloseableIterator(Iterator<? extends Map.Entry<K, V>> delegate) {
+		this(delegate, null);
+	}
+
+	/**
+	 * Creates a new {@link ForwardingCloseableIterator} that invokes the configured {@code closeHanlder} on {@link #close()}.
+	 * 
+	 * @param delegate must not be {@literal null}
+	 * @param closeHandler may be {@literal null}
+	 */
+	public ForwardingCloseableIterator(Iterator<? extends Map.Entry<K, V>> delegate, Runnable closeHandler) {
+		this.delegate = delegate;
+		this.closeHandler = closeHandler;
+	}
+
+	@Override
+	public boolean hasNext() {
+		return delegate.hasNext();
+	}
+
+	@Override
+	public Map.Entry<K, V> next() {
+		return delegate.next();
+	}
+
+	@Override
+	public void close() {
+		if (closeHandler != null) {
+			closeHandler.run();
+		}
+	}
+}

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

@@ -17,9 +17,11 @@
 
 import java.io.Serializable;
 import java.util.Collection;
+import java.util.Map;
 
 import org.springframework.beans.factory.DisposableBean;
 import org.springframework.data.keyvalue.core.query.KeyValueQuery;
+import org.springframework.data.util.CloseableIterator;
 
 /**
  * {@link KeyValueAdapter} unifies access and shields the underlying key/value specific implementation.
@@ -79,7 +81,7 @@ public interface KeyValueAdapter extends DisposableBean {
 	 * @param keyspace
 	 * @return
 	 */
-	KeyValueIterator<? extends Serializable, ?> entries(Serializable keyspace);
+	CloseableIterator<Map.Entry<Serializable, Object>> entries(Serializable keyspace);
 
 	/**
 	 * Remove all objects of given type.

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

@@ -17,14 +17,16 @@
 
 import java.io.Serializable;
 import java.util.Collection;
+import java.util.Iterator;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.concurrent.ConcurrentHashMap;
 
 import org.springframework.core.CollectionFactory;
 import org.springframework.data.keyvalue.core.AbstractKeyValueAdapter;
-import org.springframework.data.keyvalue.core.ForwardingKeyValueIterator;
+import org.springframework.data.keyvalue.core.ForwardingCloseableIterator;
 import org.springframework.data.keyvalue.core.KeyValueAdapter;
-import org.springframework.data.keyvalue.core.KeyValueIterator;
+import org.springframework.data.util.CloseableIterator;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 
@@ -104,7 +106,6 @@ public boolean contains(Serializable id, Serializable keyspace) {
 		return get(id, keyspace) != null;
 	}
 
-
 	/* (non-Javadoc)
 	 * @see org.springframework.data.keyvalue.core.KeyValueAdapter#count(java.io.Serializable)
 	 */
@@ -149,8 +150,8 @@ public Collection<?> getAllOf(Serializable keyspace) {
 	 * @see org.springframework.data.keyvalue.core.KeyValueAdapter#entries(java.io.Serializable)
 	 */
 	@Override
-	public KeyValueIterator<Serializable, ?> entries(Serializable keyspace) {
-		return new ForwardingKeyValueIterator<Serializable, Object>(getKeySpaceMap(keyspace).entrySet().iterator());
+	public CloseableIterator<Map.Entry<Serializable, Object>> entries(Serializable keyspace) {
+		return new ForwardingCloseableIterator<Serializable, Object>(getKeySpaceMap(keyspace).entrySet().iterator());
 	}
 
 	/*

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

@@ -20,7 +20,6 @@
 import static org.junit.Assert.*;
 import static org.mockito.Mockito.*;
 
-import java.io.IOException;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.NoSuchElementException;
@@ -32,11 +31,13 @@
 
 /**
  * @author Christoph Strobl
+ * @author Thomas Darimont
  */
 @RunWith(MockitoJUnitRunner.class)
-public class ForwardingIteratorUnitTests<K, V> {
+public class ForwardingCloseableIteratorUnitTests<K, V> {
 
 	@Mock Iterator<Map.Entry<K, V>> iteratorMock;
+	@Mock Runnable closeActionMock;
 
 	/**
 	 * @see DATAKV-99
@@ -46,7 +47,7 @@ public void hasNextShoudDelegateToWrappedIterator() {
 
 		when(iteratorMock.hasNext()).thenReturn(true);
 
-		assertThat(new ForwardingKeyValueIterator<K, V>(iteratorMock).hasNext(), is(true));
+		assertThat(new ForwardingCloseableIterator<K, V>(iteratorMock).hasNext(), is(true));
 
 		verify(iteratorMock, times(1)).hasNext();
 	}
@@ -59,7 +60,7 @@ public void nextShoudDelegateToWrappedIterator() {
 
 		when(iteratorMock.next()).thenReturn((Map.Entry<K, V>) mock(Map.Entry.class));
 
-		assertThat(new ForwardingKeyValueIterator<K, V>(iteratorMock).next(), notNullValue());
+		assertThat(new ForwardingCloseableIterator<K, V>(iteratorMock).next(), notNullValue());
 
 		verify(iteratorMock, times(1)).next();
 	}
@@ -72,18 +73,28 @@ public void nextShoudThrowErrorWhenWrappedIteratorHasNoMoreElements() {
 
 		when(iteratorMock.next()).thenThrow(new NoSuchElementException());
 
-		new ForwardingKeyValueIterator<K, V>(iteratorMock).next();
+		new ForwardingCloseableIterator<K, V>(iteratorMock).next();
 	}
 
 	/**
 	 * @see DATAKV-99
 	 */
 	@Test
-	public void closeShouldDoNothing() throws IOException {
+	public void closeShouldDoNothingByDefault() {
 
-		new ForwardingKeyValueIterator<K, V>(iteratorMock).close();
+		new ForwardingCloseableIterator<K, V>(iteratorMock).close();
 
 		verifyZeroInteractions(iteratorMock);
 	}
 
+	/**
+	 * @see DATAKV-99
+	 */
+	@Test
+	public void closeShouldInvokeConfiguredCloseAction() {
+
+		new ForwardingCloseableIterator<K, V>(iteratorMock, closeActionMock).close();
+
+		verify(closeActionMock, times(1)).run();
+	}
 }