DATACMNS-650 - Introduced CloseableIterator abstraction as a foundation for streaming of results.

A CloseableIterator abstracts the underlying result with support for releasing the associated resources via close() which can be transparently be used with try-with-resources in Java 7 since Closeable implements AutoCloseable from Java 7 on upwards. Added detector methods to QueryMethod to check whether the current method returns a Stream. 

Introduced ReflectionUtils.isJava8StreamType to safely detect whether the given type is assignable to a Java 8 Stream. Introduced CloseableIteratorDisposingRunnable that can be registered as a cleanup action on a Stream.

Original pull request: #116.

Author: Thomas Darimont

src/main/java/org/springframework/data/repository/core/support/AbstractRepositoryMetadata.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2014 the original author or authors.
+ * Copyright 2011-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.
@@ -24,6 +24,7 @@
 import org.springframework.data.repository.core.RepositoryMetadata;
 import org.springframework.data.repository.util.QueryExecutionConverters;
 import org.springframework.data.util.ClassTypeInformation;
+import org.springframework.data.util.ReflectionUtils;
 import org.springframework.data.util.TypeInformation;
 import org.springframework.util.Assert;
 
@@ -125,7 +126,7 @@ private static Class<?> unwrapWrapperTypes(TypeInformation<?> type) {
 		Class<?> rawType = type.getType();
 
 		boolean needToUnwrap = Iterable.class.isAssignableFrom(rawType) || rawType.isArray()
-				|| QueryExecutionConverters.supports(rawType);
+				|| QueryExecutionConverters.supports(rawType) || ReflectionUtils.isJava8StreamType(rawType);
 
 		return needToUnwrap ? unwrapWrapperTypes(type.getComponentType()) : rawType;
 	}

src/main/java/org/springframework/data/repository/query/QueryMethod.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2008-2014 the original author or authors.
+ * Copyright 2008-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.
@@ -26,13 +26,15 @@
 import org.springframework.data.domain.Sort;
 import org.springframework.data.repository.core.EntityMetadata;
 import org.springframework.data.repository.core.RepositoryMetadata;
+import org.springframework.data.util.ReflectionUtils;
 import org.springframework.util.Assert;
 
 /**
  * Abstraction of a method that is designated to execute a finder query. Enriches the standard {@link Method} interface
  * with specific information that is necessary to construct {@link RepositoryQuery}s for the method.
  * 
  * @author Oliver Gierke
+ * @author Thomas Darimont
  */
 public class QueryMethod {
 
@@ -220,4 +222,12 @@ public boolean isQueryForEntity() {
 	public String toString() {
 		return method.toString();
 	}
+
+	/**
+	 * @return
+	 * @since 1.10
+	 */
+	public boolean isStreamQuery() {
+		return ReflectionUtils.isJava8StreamType(method.getReturnType());
+	}
 }

src/main/java/org/springframework/data/util/CloseableIterator.java

@@ -0,0 +1,38 @@
+/*
+ * 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.util;
+
+import java.io.Closeable;
+import java.util.Iterator;
+
+/**
+ * A {@link CloseableIterator} serves as a bridging data structure for the underlying data store specific results that
+ * can be wrapped in a Java 8 {@link java.util.stream.Stream}.
+ * <p>
+ * 
+ * @author Thomas Darimont
+ * @param <T>
+ * @since 1.10
+ */
+public interface CloseableIterator<T> extends Iterator<T>, Closeable {
+
+	/**
+	 * Closes this iterator, freeing any resources created.
+	 */
+	@Override
+	void close();
+
+}

src/main/java/org/springframework/data/util/CloseableIteratorDisposingRunnable.java

@@ -0,0 +1,57 @@
+/*
+ * 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.util;
+
+/**
+ * A {@link Runnable} that closes the given {@link CloseableIterator} in its {@link #run()} method. If the given
+ * {@code closeable} is {@literal null} the {@link #run()} method effectively becomes a noop.
+ * <p>
+ * Can be used in conjunction with streams as close action via:
+ * 
+ * <pre>
+ * CloseableIterator<T> result = ...;
+ * Spliterator<T> spliterator = ...;
+ * 
+ * return StreamSupport.stream(spliterator, false).onClose(new CloseableIteratorDisposingRunnable(result));
+ * </pre>
+ * 
+ * @author Thomas Darimont
+ */
+public class CloseableIteratorDisposingRunnable implements Runnable {
+
+	private CloseableIterator<?> closeable;
+
+	/**
+	 * Creates a new {@link CloseableIteratorDisposingRunnable}.
+	 * 
+	 * @param closeable may be {@literal null}
+	 */
+	public CloseableIteratorDisposingRunnable(CloseableIterator<?> closeable) {
+		this.closeable = closeable;
+	}
+
+	@Override
+	public void run() {
+
+		CloseableIterator<?> ci = closeable;
+		if (ci == null) {
+			return;
+		}
+
+		closeable = null;
+		ci.close();
+	}
+}

src/main/java/org/springframework/data/util/Java8StreamUtils.java

@@ -0,0 +1,56 @@
+/*
+ * 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.util;
+
+import java.util.Iterator;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+import org.springframework.util.Assert;
+
+/**
+ * Spring Data specific Java {@link Stream} utility methods and classes.
+ * 
+ * @author Thomas Darimont
+ * @since 1.8
+ */
+public class Java8StreamUtils {
+
+	private Java8StreamUtils() {}
+
+	/**
+	 * Returns a {@link Stream} backed by the given {@link Iterator}.
+	 * <p>
+	 * If the given iterator is an {@link CloseableIterator} add a {@link CloseableIteratorDisposingRunnable} wrapping the
+	 * given iterator to propagate {@link Stream#close()} accordingly.
+	 * 
+	 * @param iterator must not be {@literal null}
+	 * @return
+	 * @since 1.8
+	 */
+	public static <T> Stream<T> createStreamFromIterator(Iterator<T> iterator) {
+
+		Assert.notNull(iterator, "Iterator must not be null!");
+
+		Spliterator<T> spliterator = Spliterators.spliteratorUnknownSize(iterator, Spliterator.NONNULL);
+		Stream<T> stream = StreamSupport.stream(spliterator, false);
+
+		return iterator instanceof CloseableIterator ? stream.onClose(new CloseableIteratorDisposingRunnable(
+				(CloseableIterator<T>) iterator)) : stream;
+	}
+}

src/main/java/org/springframework/data/util/ReflectionUtils.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2013 the original author or authors.
+ * Copyright 2012-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.
@@ -19,6 +19,7 @@
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
+import java.util.stream.Stream;
 
 import org.springframework.beans.BeanUtils;
 import org.springframework.core.annotation.AnnotationUtils;
@@ -30,10 +31,24 @@
  * Spring Data specific reflection utility methods and classes.
  * 
  * @author Oliver Gierke
+ * @author Thomas Darimont
  * @since 1.5
  */
 public abstract class ReflectionUtils {
 
+	private static final Class<?> JAVA8_STREAM_TYPE;
+
+	static {
+
+		Class<?> cls = null;
+
+		try {
+			cls = Class.forName("java.util.stream.Stream");
+		} catch (ClassNotFoundException ignore) {}
+
+		JAVA8_STREAM_TYPE = cls;
+	}
+
 	private ReflectionUtils() {}
 
 	/**
@@ -208,4 +223,19 @@ public static void setField(Field field, Object target, Object value) {
 		org.springframework.util.ReflectionUtils.makeAccessible(field);
 		org.springframework.util.ReflectionUtils.setField(field, target, value);
 	}
+
+	/**
+	 * Tests whether the given {@code type} is assignable from a Java 8 {@link Stream}.
+	 * 
+	 * @param type may be {@literal null}
+	 * @return
+	 */
+	public static boolean isJava8StreamType(Class<?> type) {
+
+		if (type == null || JAVA8_STREAM_TYPE == null) {
+			return false;
+		}
+
+		return JAVA8_STREAM_TYPE.isAssignableFrom(type);
+	}
 }

src/test/java/org/springframework/data/util/Java8StreamUtilsTests.java

@@ -0,0 +1,48 @@
+/*
+ * 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.util;
+
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import org.junit.Test;
+
+/**
+ * Spring Data specific Java {@link Stream} utility methods and classes.
+ * 
+ * @author Thomas Darimont
+ * @since 1.8
+ */
+public class Java8StreamUtilsTests {
+
+	/**
+	 * @see DATACMNS-650
+	 */
+	@Test
+	public void shouldConvertAnIteratorToAStream() {
+
+		List<String> input = Arrays.asList("a", "b", "c");
+		Stream<String> stream = Java8StreamUtils.createStreamFromIterator(input.iterator());
+		List<String> output = stream.collect(Collectors.<String> toList());
+
+		assertThat(input, is(equalTo(output)));
+	}
+}