DATAMONGO-1848 - Use imported Querydsl support for Document API MongoDB.

Original Pull Request: #579

Author: mp911de

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/MongoDbFactory.java

@@ -62,7 +62,10 @@ public interface MongoDbFactory extends CodecRegistryProvider, MongoSessionProvi
 	 * Get the legacy database entry point. Please consider {@link #getDb()} instead.
 	 *
 	 * @return
+	 * @deprecated since 2.1, use {@link #getDb()}. This method will be removed with a future version as it works only
+	 *             with the legacy MongoDB driver.
 	 */
+	@Deprecated
 	DB getLegacyDb();
 
 	/**

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/AbstractMongodbQuery.java

@@ -146,7 +146,7 @@ protected Document createProjection(Expression<?> projection) {
 			}
 			return obj;
 		}
-		return null;
+		return new Document();
 	}
 
 	protected Document createQuery(@Nullable Predicate predicate) {

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/FetchableMongodbQuery.java

@@ -47,7 +47,8 @@
  * @param <Q> concrete subtype
  * @author Mark Paluch
  */
-class FetchableMongodbQuery<K> extends AbstractMongodbQuery<FetchableMongodbQuery<K>> implements Fetchable<K> {
+abstract class FetchableMongodbQuery<K, Q extends FetchableMongodbQuery<K, Q>> extends AbstractMongodbQuery<Q>
+		implements Fetchable<K> {
 
 	private final Class<K> entityClass;
 	private final String collection;

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/QuerydslMongoPredicateExecutor.java

@@ -39,7 +39,6 @@
 import com.querydsl.core.types.OrderSpecifier;
 import com.querydsl.core.types.Predicate;
 import com.querydsl.core.types.dsl.PathBuilder;
-import com.querydsl.mongodb.AbstractMongodbQuery;
 
 /**
  * MongoDB-specific {@link QuerydslPredicateExecutor} that allows execution {@link Predicate}s in various forms.
@@ -166,7 +165,7 @@ public Page<T> findAll(Predicate predicate, Pageable pageable) {
 		Assert.notNull(predicate, "Predicate must not be null!");
 		Assert.notNull(pageable, "Pageable must not be null!");
 
-		AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> query = createQueryFor(predicate);
+		SimpleFetchableQuery<T> query = createQueryFor(predicate);
 
 		return PageableExecutionUtils.getPage(applyPagination(query, pageable).fetch(), pageable, query::fetchCount);
 	}
@@ -201,7 +200,7 @@ public boolean exists(Predicate predicate) {
 	 * @param predicate
 	 * @return
 	 */
-	private AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> createQueryFor(Predicate predicate) {
+	private SimpleFetchableQuery<T> createQueryFor(Predicate predicate) {
 		return createQuery().where(predicate);
 	}
 
@@ -210,7 +209,7 @@ private AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> createQueryFor(Predic
 	 *
 	 * @return
 	 */
-	private AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> createQuery() {
+	private SimpleFetchableQuery<T> createQuery() {
 		return new SpringDataMongodbQuery<>(mongoOperations, entityInformation.getJavaType());
 	}
 
@@ -221,8 +220,7 @@ private AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> createQuery() {
 	 * @param pageable
 	 * @return
 	 */
-	private AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> applyPagination(
-			AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> query, Pageable pageable) {
+	private SimpleFetchableQuery<T> applyPagination(SimpleFetchableQuery<T> query, Pageable pageable) {
 
 		query = query.offset(pageable.getOffset()).limit(pageable.getPageSize());
 		return applySorting(query, pageable.getSort());
@@ -235,8 +233,7 @@ private AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> applyPagination(
 	 * @param sort
 	 * @return
 	 */
-	private AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> applySorting(
-			AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> query, Sort sort) {
+	private SimpleFetchableQuery<T> applySorting(SimpleFetchableQuery<T> query, Sort sort) {
 
 		// TODO: find better solution than instanceof check
 		if (sort instanceof QSort) {

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/QuerydslRepositorySupport.java

@@ -21,7 +21,6 @@
 import org.springframework.util.Assert;
 
 import com.querydsl.core.types.EntityPath;
-import com.querydsl.mongodb.AbstractMongodbQuery;
 
 /**
  * Base class to create repository implementations based on Querydsl.
@@ -54,7 +53,7 @@ public QuerydslRepositorySupport(MongoOperations operations) {
 	 * @param path
 	 * @return
 	 */
-	protected <T> AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> from(final EntityPath<T> path) {
+	protected <T> SpringDataMongodbQuery<T> from(final EntityPath<T> path) {
 
 		Assert.notNull(path, "EntityPath must not be null!");
 		MongoPersistentEntity<?> entity = context.getRequiredPersistentEntity(path.getType());
@@ -68,7 +67,7 @@ protected <T> AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> from(final Enti
 	 * @param collection must not be blank or {@literal null}
 	 * @return
 	 */
-	protected <T> AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> from(final EntityPath<T> path, String collection) {
+	protected <T> SpringDataMongodbQuery<T> from(final EntityPath<T> path, String collection) {
 
 		Assert.notNull(path, "EntityPath must not be null!");
 		Assert.hasText(collection, "Collection name must not be null or empty!");

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/SimpleFetchableQuery.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2018 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.mongodb.repository.support;
+
+import com.querydsl.core.Fetchable;
+import com.querydsl.core.SimpleQuery;
+
+/**
+ * Interface that combines {@link Fetchable} and {@link SimpleQuery}.
+ *
+ * @author Mark Paluch
+ * @since 2.1
+ */
+public interface SimpleFetchableQuery<K> extends Fetchable<K>, SimpleQuery<SimpleFetchableQuery<K>> {}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/SpringDataMongodbQuery.java

@@ -15,15 +15,17 @@
  */
 package org.springframework.data.mongodb.repository.support;
 
-import org.bson.Document;
+import java.util.List;
+
 import org.springframework.data.mongodb.core.MongoOperations;
-import org.springframework.data.mongodb.core.MongoTemplate;
-import org.springframework.lang.Nullable;
 
-import com.google.common.base.Function;
-import com.mongodb.BasicDBObject;
-import com.mongodb.DBCollection;
-import com.mongodb.DBObject;
+import com.mysema.commons.lang.CloseableIterator;
+import com.querydsl.core.NonUniqueResultException;
+import com.querydsl.core.QueryModifiers;
+import com.querydsl.core.QueryResults;
+import com.querydsl.core.types.OrderSpecifier;
+import com.querydsl.core.types.ParamExpression;
+import com.querydsl.core.types.Predicate;
 import com.querydsl.mongodb.AbstractMongodbQuery;
 
 /**
@@ -32,9 +34,9 @@
  * @author Oliver Gierke
  * @author Mark Paluch
  */
-public class SpringDataMongodbQuery<T> extends AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> {
+public class SpringDataMongodbQuery<T> implements SimpleFetchableQuery<T> {
 
-	private final MongoOperations operations;
+	private final OperationsMongodbQuery<T> query;
 
 	/**
 	 * Creates a new {@link SpringDataMongodbQuery}.
@@ -56,25 +58,144 @@ public SpringDataMongodbQuery(final MongoOperations operations, final Class<? ex
 	public SpringDataMongodbQuery(final MongoOperations operations, final Class<? extends T> type,
 			String collectionName) {
 
-		super(((MongoTemplate) operations).getMongoDbFactory().getLegacyDb().getCollection(collectionName),
-				new Function<DBObject, T>() {
+		query = new OperationsMongodbQuery<>(new SpringDataMongodbSerializer(operations.getConverter()), type,
+				collectionName, operations);
+	}
 
-					@Override
-					public T apply(@Nullable DBObject input) {
-						return operations.getConverter().read(type, new Document((BasicDBObject) input));
-					}
-				}, new SpringDataMongodbSerializer(operations.getConverter()));
+	/* 
+	 * (non-Javadoc)
+	 * @see com.querydsl.core.Fetchable#fetch()
+	 */
+	@Override
+	public List<T> fetch() {
+		return query.fetch();
+	}
 
-		this.operations = operations;
+	/* 
+	 * (non-Javadoc)
+	 * @see com.querydsl.core.Fetchable#fetchFirst()
+	 */
+	@Override
+	public T fetchFirst() {
+		return query.fetchFirst();
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see com.querydsl.core.Fetchable#fetchOne()
+	 */
+	@Override
+	public T fetchOne() throws NonUniqueResultException {
+		return query.fetchOne();
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see com.querydsl.core.Fetchable#iterate()
+	 */
+	@Override
+	public CloseableIterator<T> iterate() {
+		return query.iterate();
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see com.querydsl.core.Fetchable#fetchResults()
+	 */
+	@Override
+	public QueryResults<T> fetchResults() {
+		return query.fetchResults();
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see com.querydsl.core.Fetchable#fetchCount()
+	 */
+	@Override
+	public long fetchCount() {
+		return query.fetchCount();
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see com.querydsl.core.SimpleQuery#limit(long)
+	 */
+	@Override
+	public SpringDataMongodbQuery<T> limit(long limit) {
+		query.limit(limit);
+		return this;
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see com.querydsl.core.SimpleQuery#offset(long)
+	 */
+	@Override
+	public SpringDataMongodbQuery<T> offset(long offset) {
+		query.offset(offset);
+		return this;
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see com.querydsl.core.SimpleQuery#restrict(com.querydsl.core.QueryModifiers)
+	 */
+	@Override
+	public SpringDataMongodbQuery<T> restrict(QueryModifiers modifiers) {
+		query.restrict(modifiers);
+		return this;
 	}
 
 	/*
 	 * (non-Javadoc)
-	 * @see com.querydsl.mongodb.AbstractMongodbQuery#getCollection(java.lang.Class)
+	 * @see com.querydsl.core.SimpleQuery#orderBy(com.querydsl.core.types.OrderSpecifier[])
+	 */
+	@Override
+	public SpringDataMongodbQuery<T> orderBy(OrderSpecifier<?>... o) {
+		query.orderBy(o);
+		return this;
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see com.querydsl.core.SimpleQuery#set(com.querydsl.core.types.ParamExpression, java.lang.Object)
 	 */
 	@Override
-	protected DBCollection getCollection(Class<?> type) {
-		return ((MongoTemplate) operations).getMongoDbFactory().getLegacyDb()
-				.getCollection(operations.getCollectionName(type));
+	public <V> SpringDataMongodbQuery<T> set(ParamExpression<V> param, V value) {
+		query.set(param, value);
+		return this;
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see com.querydsl.core.SimpleQuery#distinct()
+	 */
+	@Override
+	public SpringDataMongodbQuery<T> distinct() {
+		query.distinct();
+		return this;
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see com.querydsl.core.FilteredClause#where(com.querydsl.core.types.Predicate[])
+	 */
+	@Override
+	public SpringDataMongodbQuery<T> where(Predicate... o) {
+		query.where(o);
+		return this;
+	}
+
+	/**
+	 * Concrete implementation of {@link FetchableMongodbQuery}.
+	 *
+	 * @param <T>
+	 */
+	static class OperationsMongodbQuery<T> extends FetchableMongodbQuery<T, OperationsMongodbQuery<T>> {
+
+		public OperationsMongodbQuery(MongodbDocumentSerializer serializer, Class<? extends T> entityClass,
+				String collection, MongoOperations mongoOperations) {
+			super(serializer, entityClass, collection, mongoOperations);
+		}
 	}
 }