DATAMONGO-1366 - Release version 1.9 M1 (Hopper).

Refactored the query execution out of AbstractMongoQuery into MongoQueryExecution. Made sure the streaming execution lazily applies the projections, too.

Added a DtoInstantiatingConverter to be able to copy data from created entities into DTOs as we cannot hand the DTO type into the MongoTemplate execution in the first place as it's going to be used for the query mapping currently.

CODE_OF_CONDUCT.adoc

@@ -0,0 +1,27 @@
+= Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of fostering an open and welcoming community, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic addresses,
+  without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to fairly and consistently applying these principles to every aspect of managing this project. Project maintainers who do not follow or enforce the Code of Conduct may be permanently removed from the project team.
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting a project maintainer at spring-code-of-conduct@pivotal.io.
+All complaints will be reviewed and investigated and will result in a response that is deemed necessary and appropriate to the circumstances.
+Maintainers are obligated to maintain confidentiality with regard to the reporter of an incident.
+
+This Code of Conduct is adapted from the http://contributor-covenant.org[Contributor Covenant], version 1.3.0, available at http://contributor-covenant.org/version/1/3/0/[contributor-covenant.org/version/1/3/0/].

CONTRIBUTING.MD

@@ -1 +0,0 @@
-You find the contribution guidelines for Spring Data projects [here](https://github.com/spring-projects/spring-data-build/blob/master/CONTRIBUTING.md).

CONTRIBUTING.adoc

@@ -0,0 +1,3 @@
+= Spring Data contribution guidelines
+
+You find the contribution guidelines for Spring Data projects https://github.com/spring-projects/spring-data-build/blob/master/CONTRIBUTING.adoc[here].

pom.xml

@@ -1,11 +1,11 @@
-<?xml version="1.0" encoding="UTF-8"?>
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 
 	<modelVersion>4.0.0</modelVersion>
 
 	<groupId>org.springframework.data</groupId>
 	<artifactId>spring-data-mongodb-parent</artifactId>
-	<version>1.8.0.M1</version>
+	<version>1.9.0.M1</version>
 	<packaging>pom</packaging>
 
 	<name>Spring Data MongoDB</name>
@@ -15,7 +15,7 @@
 	<parent>
 		<groupId>org.springframework.data.build</groupId>
 		<artifactId>spring-data-parent</artifactId>
-		<version>1.7.0.M1</version>
+		<version>1.8.0.M1</version>
 	</parent>
 
 	<modules>
@@ -28,8 +28,8 @@
 	<properties>
 		<project.type>multi</project.type>
 		<dist.id>spring-data-mongodb</dist.id>
-		<springdata.commons>1.11.0.M1</springdata.commons>
-		<mongo>2.13.0</mongo>
+		<springdata.commons>1.12.0.M1</springdata.commons>
+		<mongo>2.14.0</mongo>
 		<mongo.osgi>2.13.0</mongo.osgi>
 	</properties>
 
@@ -123,7 +123,7 @@
 
 			<id>mongo3</id>
 			<properties>
-				<mongo>3.0.0</mongo>
+				<mongo>3.0.4</mongo>
 			</properties>
 
 		</profile>
@@ -132,7 +132,7 @@
 
 			<id>mongo3-next</id>
 			<properties>
-				<mongo>3.0.0-SNAPSHOT</mongo>
+				<mongo>3.0.5-SNAPSHOT</mongo>
 			</properties>
 
 			<repositories>
@@ -143,6 +143,45 @@
 			</repositories>
 
 		</profile>
+
+		<profile>
+
+			<id>mongo31</id>
+			<properties>
+				<mongo>3.1.0</mongo>
+			</properties>
+
+		</profile>
+
+		<profile>
+
+			<id>mongo32-next</id>
+			<properties>
+				<mongo>3.2.0-SNAPSHOT</mongo>
+			</properties>
+
+			<repositories>
+				<repository>
+					<id>mongo-snapshots</id>
+					<url>https://oss.sonatype.org/content/repositories/snapshots</url>
+				</repository>
+			</repositories>
+
+		</profile>
+
+		<profile>
+			<id>release</id>
+			<build>
+				<plugins>
+					<plugin>
+						<groupId>org.jfrog.buildinfo</groupId>
+						<artifactId>artifactory-maven-plugin</artifactId>
+						<inherited>false</inherited>
+					</plugin>
+				</plugins>
+			</build>
+		</profile>
+
 	</profiles>
 
 	<dependencies>

spring-data-mongodb-cross-store/pom.xml

@@ -6,7 +6,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>1.8.0.M1</version>
+		<version>1.9.0.M1</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 
@@ -48,7 +48,7 @@
 		<dependency>
 			<groupId>org.springframework.data</groupId>
 			<artifactId>spring-data-mongodb</artifactId>
-			<version>1.8.0.M1</version>
+			<version>1.9.0.M1</version>
 		</dependency>
 
 		<dependency>

spring-data-mongodb-cross-store/src/main/java/org/springframework/data/mongodb/crossstore/MongoChangeSetPersister.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2014 the original author or authors.
+ * Copyright 2011-2016 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.
@@ -37,6 +37,8 @@ import com.mongodb.MongoException;
 /**
  * @author Thomas Risberg
  * @author Oliver Gierke
+ * @author Alex Vengrovsk
+ * @author Mark Paluch
  */
 public class MongoChangeSetPersister implements ChangeSetPersister<Object> {
 
@@ -45,7 +47,7 @@ public class MongoChangeSetPersister implements ChangeSetPersister<Object> {
 	private static final String ENTITY_FIELD_NAME = "_entity_field_name";
 	private static final String ENTITY_FIELD_CLASS = "_entity_field_class";
 
-	protected final Logger log = LoggerFactory.getLogger(getClass());
+	private final Logger log = LoggerFactory.getLogger(getClass());
 
 	private MongoTemplate mongoTemplate;
 	private EntityManagerFactory entityManagerFactory;
@@ -76,25 +78,25 @@ public class MongoChangeSetPersister implements ChangeSetPersister<Object> {
 		dbk.put(ENTITY_ID, id);
 		dbk.put(ENTITY_CLASS, entityClass.getName());
 		if (log.isDebugEnabled()) {
-			log.debug("Loading MongoDB data for " + dbk);
+			log.debug("Loading MongoDB data for {}", dbk);
 		}
 		mongoTemplate.execute(collName, new CollectionCallback<Object>() {
 			public Object doInCollection(DBCollection collection) throws MongoException, DataAccessException {
 				for (DBObject dbo : collection.find(dbk)) {
 					String key = (String) dbo.get(ENTITY_FIELD_NAME);
 					if (log.isDebugEnabled()) {
-						log.debug("Processing key: " + key);
+						log.debug("Processing key: {}", key);
 					}
 					if (!changeSet.getValues().containsKey(key)) {
 						String className = (String) dbo.get(ENTITY_FIELD_CLASS);
 						if (className == null) {
-							throw new DataIntegrityViolationException("Unble to convert property " + key + ": Invalid metadata, "
-									+ ENTITY_FIELD_CLASS + " not available");
+							throw new DataIntegrityViolationException(
+									"Unble to convert property " + key + ": Invalid metadata, " + ENTITY_FIELD_CLASS + " not available");
 						}
 						Class<?> clazz = ClassUtils.resolveClassName(className, ClassUtils.getDefaultClassLoader());
 						Object value = mongoTemplate.getConverter().read(clazz, dbo);
 						if (log.isDebugEnabled()) {
-							log.debug("Adding to ChangeSet: " + key);
+							log.debug("Adding to ChangeSet: {}", key);
 						}
 						changeSet.set(key, value);
 					}
@@ -109,9 +111,9 @@ public class MongoChangeSetPersister implements ChangeSetPersister<Object> {
 	 * @see org.springframework.data.crossstore.ChangeSetPersister#getPersistentId(org.springframework.data.crossstore.ChangeSetBacked, org.springframework.data.crossstore.ChangeSet)
 	 */
 	public Object getPersistentId(ChangeSetBacked entity, ChangeSet cs) throws DataAccessException {
-
-		log.debug("getPersistentId called on " + entity);
-
+		if (log.isDebugEnabled()) {
+			log.debug("getPersistentId called on {}", entity);
+		}
 		if (entityManagerFactory == null) {
 			throw new DataAccessResourceFailureException("EntityManagerFactory cannot be null");
 		}
@@ -130,7 +132,7 @@ public class MongoChangeSetPersister implements ChangeSetPersister<Object> {
 		}
 
 		if (log.isDebugEnabled()) {
-			log.debug("Flush: changeset: " + cs.getValues());
+			log.debug("Flush: changeset: {}", cs.getValues());
 		}
 
 		String collName = getCollectionNameForEntity(entity.getClass());
@@ -152,7 +154,7 @@ public class MongoChangeSetPersister implements ChangeSetPersister<Object> {
 				});
 				if (value == null) {
 					if (log.isDebugEnabled()) {
-						log.debug("Flush: removing: " + dbQuery);
+						log.debug("Flush: removing: {}", dbQuery);
 					}
 					mongoTemplate.execute(collName, new CollectionCallback<Object>() {
 						public Object doInCollection(DBCollection collection) throws MongoException, DataAccessException {
@@ -164,7 +166,7 @@ public class MongoChangeSetPersister implements ChangeSetPersister<Object> {
 					final DBObject dbDoc = new BasicDBObject();
 					dbDoc.putAll(dbQuery);
 					if (log.isDebugEnabled()) {
-						log.debug("Flush: saving: " + dbQuery);
+						log.debug("Flush: saving: {}", dbQuery);
 					}
 					mongoTemplate.getConverter().write(value, dbDoc);
 					dbDoc.put(ENTITY_FIELD_CLASS, value.getClass().getName());

spring-data-mongodb-distribution/pom.xml

@@ -13,7 +13,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>1.8.0.M1</version>
+		<version>1.9.0.M1</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 

spring-data-mongodb-log4j/pom.xml

@@ -5,7 +5,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>1.8.0.M1</version>
+		<version>1.9.0.M1</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 

spring-data-mongodb-log4j/src/main/java/org/springframework/data/mongodb/log4j/MongoLog4jAppender.java

@@ -160,7 +160,7 @@ public class MongoLog4jAppender extends AppenderSkeleton {
 
 		// Copy properties into document
 		Map<Object, Object> props = event.getProperties();
-		if (null != props && props.size() > 0) {
+		if (null != props && !props.isEmpty()) {
 			BasicDBObject propsDbo = new BasicDBObject();
 			for (Map.Entry<Object, Object> entry : props.entrySet()) {
 				propsDbo.put(entry.getKey().toString(), entry.getValue().toString());

spring-data-mongodb-log4j/src/test/java/org/springframework/data/mongodb/log4j/MongoLog4jAppenderIntegrationTests.java

@@ -39,7 +39,7 @@ public class MongoLog4jAppenderIntegrationTests {
 
 	static final String NAME = MongoLog4jAppenderIntegrationTests.class.getName();
 
-	Logger log = Logger.getLogger(NAME);
+	private static final Logger log = Logger.getLogger(NAME);
 	Mongo mongo;
 	DB db;
 	String collection;

spring-data-mongodb/Spring Data MongoDB.sonargraph

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<context version="7.1.10.209">
+<context version="7.2.2.230">
     <scope type="Project" name="spring-data-mongodb">
         <element type="TypeFilterReferenceOverridden" name="Filter">
             <element type="IncludeTypePattern" name="org.springframework.data.mongodb.**"/>
@@ -35,6 +35,12 @@
                     <dependency toName="Project|spring-data-mongodb::Layer|Repositories::Subsystem|API" type="AllowedDependency"/>
                     <dependency toName="Project|spring-data-mongodb::Layer|Repositories::Subsystem|Implementation" type="AllowedDependency"/>
                 </element>
+                <element type="Subsystem" name="CDI">
+                    <element type="TypeFilter" name="Assignment">
+                        <element type="IncludeTypePattern" name="**.cdi.**"/>
+                    </element>
+                    <stereotype name="Unrestricted"/>
+                </element>
                 <dependency toName="Project|spring-data-mongodb::Layer|Config" type="AllowedDependency"/>
                 <dependency toName="Project|spring-data-mongodb::Layer|Core" type="AllowedDependency"/>
             </element>
@@ -76,6 +82,11 @@
                     </element>
                     <dependency toName="Project|spring-data-mongodb::Layer|Core::Subsystem|Geospatial" type="AllowedDependency"/>
                 </element>
+                <element type="Subsystem" name="Script">
+                    <element type="TypeFilter" name="Assignment">
+                        <element type="IncludeTypePattern" name="**.script.**"/>
+                    </element>
+                </element>
                 <element type="Subsystem" name="Conversion">
                     <element type="TypeFilter" name="Assignment">
                         <element type="IncludeTypePattern" name="**.core.convert.**"/>
@@ -83,6 +94,7 @@
                     <dependency toName="Project|spring-data-mongodb::Layer|Core::Subsystem|Geospatial" type="AllowedDependency"/>
                     <dependency toName="Project|spring-data-mongodb::Layer|Core::Subsystem|Mapping" type="AllowedDependency"/>
                     <dependency toName="Project|spring-data-mongodb::Layer|Core::Subsystem|Query" type="AllowedDependency"/>
+                    <dependency toName="Project|spring-data-mongodb::Layer|Core::Subsystem|Script" type="AllowedDependency"/>
                 </element>
                 <element type="Subsystem" name="SpEL">
                     <element type="TypeFilter" name="Assignment">
@@ -105,6 +117,11 @@
                     <dependency toName="Project|spring-data-mongodb::Layer|Core::Subsystem|Mapping" type="AllowedDependency"/>
                     <dependency toName="Project|spring-data-mongodb::Layer|Core::Subsystem|Query" type="AllowedDependency"/>
                 </element>
+                <element type="Subsystem" name="MapReduce">
+                    <element type="TypeFilter" name="Assignment">
+                        <element type="IncludeTypePattern" name="**.mapreduce.**"/>
+                    </element>
+                </element>
                 <element type="Subsystem" name="Core">
                     <element type="TypeFilter" name="Assignment">
                         <element type="WeakTypePattern" name="**.core.**"/>
@@ -113,8 +130,10 @@
                     <dependency toName="Project|spring-data-mongodb::Layer|Core::Subsystem|Conversion" type="AllowedDependency"/>
                     <dependency toName="Project|spring-data-mongodb::Layer|Core::Subsystem|Geospatial" type="AllowedDependency"/>
                     <dependency toName="Project|spring-data-mongodb::Layer|Core::Subsystem|Index" type="AllowedDependency"/>
+                    <dependency toName="Project|spring-data-mongodb::Layer|Core::Subsystem|MapReduce" type="AllowedDependency"/>
                     <dependency toName="Project|spring-data-mongodb::Layer|Core::Subsystem|Mapping" type="AllowedDependency"/>
                     <dependency toName="Project|spring-data-mongodb::Layer|Core::Subsystem|Query" type="AllowedDependency"/>
+                    <dependency toName="Project|spring-data-mongodb::Layer|Core::Subsystem|Script" type="AllowedDependency"/>
                 </element>
                 <element type="Subsystem" name="Util">
                     <element type="TypeFilter" name="Assignment">
@@ -169,7 +188,32 @@
             </element>
             <element type="Subsystem" name="Querydsl">
                 <element type="TypeFilter" name="Assignment">
-                    <element type="IncludeTypePattern" name="com.mysema.query.**"/>
+                    <element type="IncludeTypePattern" name="com.querydsl.**"/>
+                </element>
+            </element>
+            <element type="Subsystem" name="Slf4j">
+                <element type="TypeFilter" name="Assignment">
+                    <element type="IncludeTypePattern" name="org.slf4j.**"/>
+                </element>
+            </element>
+            <element type="Subsystem" name="Jackson">
+                <element type="TypeFilter" name="Assignment">
+                    <element type="IncludeTypePattern" name="com.fasterxml.jackson.**"/>
+                </element>
+            </element>
+            <element type="Subsystem" name="DOM">
+                <element type="TypeFilter" name="Assignment">
+                    <element type="IncludeTypePattern" name="org.w3c.dom.**"/>
+                </element>
+            </element>
+            <element type="Subsystem" name="AOP Alliance">
+                <element type="TypeFilter" name="Assignment">
+                    <element type="IncludeTypePattern" name="org.aopalliance.**"/>
+                </element>
+            </element>
+            <element type="Subsystem" name="Guava">
+                <element type="TypeFilter" name="Assignment">
+                    <element type="IncludeTypePattern" name="com.google.common.**"/>
                 </element>
             </element>
         </architecture>

spring-data-mongodb/pom.xml

@@ -11,7 +11,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>1.8.0.M1</version>
+		<version>1.9.0.M1</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 
@@ -59,14 +59,14 @@
 		</dependency>
 
 		<dependency>
-			<groupId>com.mysema.querydsl</groupId>
+			<groupId>com.querydsl</groupId>
 			<artifactId>querydsl-mongodb</artifactId>
 			<version>${querydsl}</version>
 			<optional>true</optional>
 		</dependency>
 
 		<dependency>
-			<groupId>com.mysema.querydsl</groupId>
+			<groupId>com.querydsl</groupId>
 			<artifactId>querydsl-apt</artifactId>
 			<version>${querydsl}</version>
 			<scope>provided</scope>
@@ -183,7 +183,7 @@
 				<version>${apt}</version>
 				<dependencies>
 					<dependency>
-						<groupId>com.mysema.querydsl</groupId>
+						<groupId>com.querydsl</groupId>
 						<artifactId>querydsl-apt</artifactId>
 						<version>${querydsl}</version>
 					</dependency>

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

@@ -0,0 +1,61 @@
+/*
+ * 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.mongodb;
+
+import java.util.List;
+
+import org.springframework.dao.DataAccessException;
+
+import com.mongodb.BulkWriteError;
+import com.mongodb.BulkWriteException;
+import com.mongodb.BulkWriteResult;
+
+/**
+ * Is thrown when errors occur during bulk operations.
+ * 
+ * @author Tobias Trelle
+ * @author Oliver Gierke
+ * @since 1.9
+ */
+public class BulkOperationException extends DataAccessException {
+
+	private static final long serialVersionUID = 73929601661154421L;
+
+	private final List<BulkWriteError> errors;
+	private final BulkWriteResult result;
+
+	/**
+	 * Creates a new {@link BulkOperationException} with the given message and source {@link BulkWriteException}.
+	 * 
+	 * @param message must not be {@literal null}.
+	 * @param source must not be {@literal null}.
+	 */
+	public BulkOperationException(String message, BulkWriteException source) {
+
+		super(message, source);
+
+		this.errors = source.getWriteErrors();
+		this.result = source.getWriteResult();
+	}
+
+	public List<BulkWriteError> getErrors() {
+		return errors;
+	}
+
+	public BulkWriteResult getResult() {
+		return result;
+	}
+}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/config/MongoCredentialPropertyEditor.java

@@ -17,8 +17,11 @@ package org.springframework.data.mongodb.config;
 
 import java.beans.PropertyEditorSupport;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Properties;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 import org.springframework.util.StringUtils;
 
@@ -28,10 +31,13 @@ import com.mongodb.MongoCredential;
  * Parse a {@link String} to a Collection of {@link MongoCredential}.
  * 
  * @author Christoph Strobl
+ * @author Oliver Gierke
  * @since 1.7
  */
 public class MongoCredentialPropertyEditor extends PropertyEditorSupport {
 
+	private static final Pattern GROUP_PATTERN = Pattern.compile("(\\\\?')(.*?)\\1");
+
 	private static final String AUTH_MECHANISM_KEY = "uri.authMechanism";
 	private static final String USERNAME_PASSWORD_DELIMINATOR = ":";
 	private static final String DATABASE_DELIMINATOR = "@";
@@ -51,11 +57,7 @@ public class MongoCredentialPropertyEditor extends PropertyEditorSupport {
 
 		List<MongoCredential> credentials = new ArrayList<MongoCredential>();
 
-		for (String credentialString : text.split(",")) {
-
-			if (!text.contains(USERNAME_PASSWORD_DELIMINATOR) || !text.contains(DATABASE_DELIMINATOR)) {
-				throw new IllegalArgumentException("Credentials need to be in format 'username:password@database'!");
-			}
+		for (String credentialString : extractCredentialsString(text)) {
 
 			String[] userNameAndPassword = extractUserNameAndPassword(credentialString);
 			String database = extractDB(credentialString);
@@ -68,43 +70,83 @@ public class MongoCredentialPropertyEditor extends PropertyEditorSupport {
 					String authMechanism = options.getProperty(AUTH_MECHANISM_KEY);
 
 					if (MongoCredential.GSSAPI_MECHANISM.equals(authMechanism)) {
+
+						verifyUserNamePresent(userNameAndPassword);
 						credentials.add(MongoCredential.createGSSAPICredential(userNameAndPassword[0]));
 					} else if (MongoCredential.MONGODB_CR_MECHANISM.equals(authMechanism)) {
+
+						verifyUsernameAndPasswordPresent(userNameAndPassword);
+						verifyDatabasePresent(database);
 						credentials.add(MongoCredential.createMongoCRCredential(userNameAndPassword[0], database,
 								userNameAndPassword[1].toCharArray()));
 					} else if (MongoCredential.MONGODB_X509_MECHANISM.equals(authMechanism)) {
+
+						verifyUserNamePresent(userNameAndPassword);
 						credentials.add(MongoCredential.createMongoX509Credential(userNameAndPassword[0]));
 					} else if (MongoCredential.PLAIN_MECHANISM.equals(authMechanism)) {
+
+						verifyUsernameAndPasswordPresent(userNameAndPassword);
+						verifyDatabasePresent(database);
 						credentials.add(MongoCredential.createPlainCredential(userNameAndPassword[0], database,
 								userNameAndPassword[1].toCharArray()));
 					} else if (MongoCredential.SCRAM_SHA_1_MECHANISM.equals(authMechanism)) {
+
+						verifyUsernameAndPasswordPresent(userNameAndPassword);
+						verifyDatabasePresent(database);
 						credentials.add(MongoCredential.createScramSha1Credential(userNameAndPassword[0], database,
 								userNameAndPassword[1].toCharArray()));
 					} else {
-						throw new IllegalArgumentException(String.format(
-								"Cannot create MongoCredentials for unknown auth mechanism '%s'!", authMechanism));
+						throw new IllegalArgumentException(
+								String.format("Cannot create MongoCredentials for unknown auth mechanism '%s'!", authMechanism));
 					}
 				}
 			} else {
-				credentials.add(MongoCredential.createCredential(userNameAndPassword[0], database,
-						userNameAndPassword[1].toCharArray()));
+
+				verifyUsernameAndPasswordPresent(userNameAndPassword);
+				verifyDatabasePresent(database);
+				credentials.add(
+						MongoCredential.createCredential(userNameAndPassword[0], database, userNameAndPassword[1].toCharArray()));
 			}
 		}
 
 		setValue(credentials);
 	}
 
+	private List<String> extractCredentialsString(String source) {
+
+		Matcher matcher = GROUP_PATTERN.matcher(source);
+		List<String> list = new ArrayList<String>();
+
+		while (matcher.find()) {
+
+			String value = StringUtils.trimLeadingCharacter(matcher.group(), '\'');
+			list.add(StringUtils.trimTrailingCharacter(value, '\''));
+		}
+
+		if (!list.isEmpty()) {
+			return list;
+		}
+
+		return Arrays.asList(source.split(","));
+	}
+
 	private static String[] extractUserNameAndPassword(String text) {
 
-		int dbSeperationIndex = text.lastIndexOf(DATABASE_DELIMINATOR);
-		String userNameAndPassword = text.substring(0, dbSeperationIndex);
-		return userNameAndPassword.split(USERNAME_PASSWORD_DELIMINATOR);
+		int index = text.lastIndexOf(DATABASE_DELIMINATOR);
+
+		index = index != -1 ? index : text.lastIndexOf(OPTIONS_DELIMINATOR);
+
+		return index == -1 ? new String[] {} : text.substring(0, index).split(USERNAME_PASSWORD_DELIMINATOR);
 	}
 
 	private static String extractDB(String text) {
 
 		int dbSeperationIndex = text.lastIndexOf(DATABASE_DELIMINATOR);
 
+		if (dbSeperationIndex == -1) {
+			return "";
+		}
+
 		String tmp = text.substring(dbSeperationIndex + 1);
 		int optionsSeperationIndex = tmp.lastIndexOf(OPTIONS_DELIMINATOR);
 
@@ -129,4 +171,28 @@ public class MongoCredentialPropertyEditor extends PropertyEditorSupport {
 
 		return properties;
 	}
+
+	private static void verifyUsernameAndPasswordPresent(String[] source) {
+
+		verifyUserNamePresent(source);
+
+		if (source.length != 2) {
+			throw new IllegalArgumentException(
+					"Credentials need to specify username and password like in 'username:password@database'!");
+		}
+	}
+
+	private static void verifyDatabasePresent(String source) {
+
+		if (!StringUtils.hasText(source)) {
+			throw new IllegalArgumentException("Credentials need to specify database like in 'username:password@database'!");
+		}
+	}
+
+	private static void verifyUserNamePresent(String[] source) {
+
+		if (source.length == 0 || !StringUtils.hasText(source[0])) {
+			throw new IllegalArgumentException("Credentials need to specify username!");
+		}
+	}
 }

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/config/MongoDbFactoryParser.java

@@ -18,6 +18,10 @@ package org.springframework.data.mongodb.config;
 import static org.springframework.data.config.ParsingUtils.*;
 import static org.springframework.data.mongodb.config.MongoParsingUtils.*;
 
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
 import org.springframework.beans.factory.BeanDefinitionStoreException;
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.parsing.BeanComponentDefinition;
@@ -44,9 +48,21 @@ import com.mongodb.MongoURI;
  * @author Oliver Gierke
  * @author Thomas Darimont
  * @author Christoph Strobl
+ * @author Viktor Khoroshko
  */
 public class MongoDbFactoryParser extends AbstractBeanDefinitionParser {
 
+	private static final Set<String> MONGO_URI_ALLOWED_ADDITIONAL_ATTRIBUTES;
+
+	static {
+
+		Set<String> mongoUriAllowedAdditionalAttributes = new HashSet<String>();
+		mongoUriAllowedAdditionalAttributes.add("id");
+		mongoUriAllowedAdditionalAttributes.add("write-concern");
+
+		MONGO_URI_ALLOWED_ADDITIONAL_ATTRIBUTES = Collections.unmodifiableSet(mongoUriAllowedAdditionalAttributes);
+	}
+
 	/* 
 	 * (non-Javadoc)
 	 * @see org.springframework.beans.factory.xml.AbstractBeanDefinitionParser#resolveId(org.w3c.dom.Element, org.springframework.beans.factory.support.AbstractBeanDefinition, org.springframework.beans.factory.xml.ParserContext)
@@ -70,13 +86,10 @@ public class MongoDbFactoryParser extends AbstractBeanDefinitionParser {
 		BeanDefinitionBuilder dbFactoryBuilder = BeanDefinitionBuilder.genericBeanDefinition(SimpleMongoDbFactory.class);
 		setPropertyValue(dbFactoryBuilder, element, "write-concern", "writeConcern");
 
-		BeanDefinition mongoUri = getMongoUri(element);
+		BeanDefinition mongoUri = getMongoUri(element, parserContext);
 
 		if (mongoUri != null) {
-			if (element.getAttributes().getLength() >= 2 && !element.hasAttribute("write-concern")) {
-				parserContext.getReaderContext().error("Configure either Mongo URI or details individually!",
-						parserContext.extractSource(element));
-			}
+
 			dbFactoryBuilder.addConstructorArgValue(mongoUri);
 			return getSourceBeanDefinition(dbFactoryBuilder, parserContext, element);
 		}
@@ -149,12 +162,15 @@ public class MongoDbFactoryParser extends AbstractBeanDefinitionParser {
 
 	/**
 	 * Creates a {@link BeanDefinition} for a {@link MongoURI} or {@link MongoClientURI} depending on configured
-	 * attributes.
+	 * attributes. <br />
+	 * Errors when configured element contains {@literal uri} or {@literal client-uri} along with other attributes except
+	 * {@literal write-concern} and/or {@literal id}.
 	 * 
 	 * @param element must not be {@literal null}.
+	 * @param parserContext
 	 * @return {@literal null} in case no client-/uri defined.
 	 */
-	private BeanDefinition getMongoUri(Element element) {
+	private BeanDefinition getMongoUri(Element element, ParserContext parserContext) {
 
 		boolean hasClientUri = element.hasAttribute("client-uri");
 
@@ -162,6 +178,21 @@ public class MongoDbFactoryParser extends AbstractBeanDefinitionParser {
 			return null;
 		}
 
+		int allowedAttributesCount = 1;
+		for (String attribute : MONGO_URI_ALLOWED_ADDITIONAL_ATTRIBUTES) {
+
+			if (element.hasAttribute(attribute)) {
+				allowedAttributesCount++;
+			}
+		}
+
+		if (element.getAttributes().getLength() > allowedAttributesCount) {
+
+			parserContext.getReaderContext().error(
+					"Configure either " + (hasClientUri ? "Mongo Client URI" : "Mongo URI") + " or details individually!",
+					parserContext.extractSource(element));
+		}
+
 		Class<?> type = hasClientUri ? MongoClientURI.class : MongoURI.class;
 		String uri = hasClientUri ? element.getAttribute("client-uri") : element.getAttribute("uri");
 

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/BulkOperations.java

@@ -0,0 +1,145 @@
+/*
+ * 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.mongodb.core;
+
+import java.util.List;
+
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.mongodb.core.query.Update;
+import org.springframework.data.util.Tuple;
+
+import com.mongodb.BulkWriteResult;
+
+/**
+ * Bulk operations for insert/update/remove actions on a collection. These bulks operation are available since MongoDB
+ * 2.6 and make use of low level bulk commands on the protocol level. This interface defines a fluent API to add
+ * multiple single operations or list of similar operations in sequence which can then eventually be executed by calling
+ * {@link #execute()}.
+ * 
+ * @author Tobias Trelle
+ * @author Oliver Gierke
+ * @since 1.9
+ */
+public interface BulkOperations {
+
+	/**
+	 * Mode for bulk operation.
+	 **/
+	public enum BulkMode {
+
+		/** Perform bulk operations in sequence. The first error will cancel processing. */
+		ORDERED,
+
+		/** Perform bulk operations in parallel. Processing will continue on errors. */
+		UNORDERED
+	};
+
+	/**
+	 * Add a single insert to the bulk operation.
+	 * 
+	 * @param documents the document to insert, must not be {@literal null}.
+	 * @return the current {@link BulkOperations} instance with the insert added, will never be {@literal null}.
+	 */
+	BulkOperations insert(Object documents);
+
+	/**
+	 * Add a list of inserts to the bulk operation.
+	 * 
+	 * @param documents List of documents to insert, must not be {@literal null}.
+	 * @return the current {@link BulkOperations} instance with the insert added, will never be {@literal null}.
+	 */
+	BulkOperations insert(List<? extends Object> documents);
+
+	/**
+	 * Add a single update to the bulk operation. For the update request, only the first matching document is updated.
+	 * 
+	 * @param query update criteria, must not be {@literal null}.
+	 * @param update {@link Update} operation to perform, must not be {@literal null}.
+	 * @return the current {@link BulkOperations} instance with the update added, will never be {@literal null}.
+	 */
+	BulkOperations updateOne(Query query, Update update);
+
+	/**
+	 * Add a list of updates to the bulk operation. For each update request, only the first matching document is updated.
+	 * 
+	 * @param updates Update operations to perform.
+	 * @return the current {@link BulkOperations} instance with the update added, will never be {@literal null}.
+	 */
+	BulkOperations updateOne(List<Tuple<Query, Update>> updates);
+
+	/**
+	 * Add a single update to the bulk operation. For the update request, all matching documents are updated.
+	 * 
+	 * @param query Update criteria.
+	 * @param update Update operation to perform.
+	 * @return the current {@link BulkOperations} instance with the update added, will never be {@literal null}.
+	 */
+	BulkOperations updateMulti(Query query, Update update);
+
+	/**
+	 * Add a list of updates to the bulk operation. For each update request, all matching documents are updated.
+	 * 
+	 * @param updates Update operations to perform.
+	 * @return The bulk operation.
+	 * @return the current {@link BulkOperations} instance with the update added, will never be {@literal null}.
+	 */
+	BulkOperations updateMulti(List<Tuple<Query, Update>> updates);
+
+	/**
+	 * Add a single upsert to the bulk operation. An upsert is an update if the set of matching documents is not empty,
+	 * else an insert.
+	 * 
+	 * @param query Update criteria.
+	 * @param update Update operation to perform.
+	 * @return The bulk operation.
+	 * @return the current {@link BulkOperations} instance with the update added, will never be {@literal null}.
+	 */
+	BulkOperations upsert(Query query, Update update);
+
+	/**
+	 * Add a list of upserts to the bulk operation. An upsert is an update if the set of matching documents is not empty,
+	 * else an insert.
+	 * 
+	 * @param updates Updates/insert operations to perform.
+	 * @return The bulk operation.
+	 * @return the current {@link BulkOperations} instance with the update added, will never be {@literal null}.
+	 */
+	BulkOperations upsert(List<Tuple<Query, Update>> updates);
+
+	/**
+	 * Add a single remove operation to the bulk operation.
+	 * 
+	 * @param remove the {@link Query} to select the documents to be removed, must not be {@literal null}.
+	 * @return the current {@link BulkOperations} instance with the removal added, will never be {@literal null}.
+	 */
+	BulkOperations remove(Query remove);
+
+	/**
+	 * Add a list of remove operations to the bulk operation.
+	 * 
+	 * @param removes the remove operations to perform, must not be {@literal null}.
+	 * @return the current {@link BulkOperations} instance with the removal added, will never be {@literal null}.
+	 */
+	BulkOperations remove(List<Query> removes);
+
+	/**
+	 * Execute all bulk operations using the default write concern.
+	 * 
+	 * @return Result of the bulk operation providing counters for inserts/updates etc.
+	 * @throws {@link BulkOperationException} if an error occurred during bulk processing.
+	 */
+	BulkWriteResult execute();
+}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/CursorPreparer.java

@@ -25,7 +25,7 @@ import com.mongodb.DBCursor;
 interface CursorPreparer {
 
 	/**
-	 * Prepare the given cursor (apply limits, skips and so on). Returns th eprepared cursor.
+	 * Prepare the given cursor (apply limits, skips and so on). Returns the prepared cursor.
 	 * 
 	 * @param cursor
 	 */

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/DefaultBulkOperations.java

@@ -0,0 +1,327 @@
+/*
+ * 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.mongodb.core;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.springframework.dao.DataAccessException;
+import org.springframework.dao.support.PersistenceExceptionTranslator;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.mongodb.core.query.Update;
+import org.springframework.data.util.Tuple;
+import org.springframework.util.Assert;
+
+import com.mongodb.BulkWriteException;
+import com.mongodb.BulkWriteOperation;
+import com.mongodb.BulkWriteRequestBuilder;
+import com.mongodb.BulkWriteResult;
+import com.mongodb.DBCollection;
+import com.mongodb.DBObject;
+import com.mongodb.WriteConcern;
+
+/**
+ * Default implementation for {@link BulkOperations}.
+ * 
+ * @author Tobias Trelle
+ * @author Oliver Gierke
+ * @since 1.9
+ */
+class DefaultBulkOperations implements BulkOperations {
+
+	private final MongoOperations mongoOperations;
+	private final BulkMode bulkMode;
+	private final String collectionName;
+	private final Class<?> entityType;
+
+	private PersistenceExceptionTranslator exceptionTranslator;
+	private WriteConcernResolver writeConcernResolver;
+	private WriteConcern defaultWriteConcern;
+
+	private BulkWriteOperation bulk;
+
+	/**
+	 * Creates a new {@link DefaultBulkOperations} for the given {@link MongoOperations}, {@link BulkMode}, collection
+	 * name and {@link WriteConcern}.
+	 * 
+	 * @param mongoOperations The underlying {@link MongoOperations}, must not be {@literal null}.
+	 * @param bulkMode must not be {@literal null}.
+	 * @param collectionName Name of the collection to work on, must not be {@literal null} or empty.
+	 * @param entityType the entity type, can be {@literal null}.
+	 */
+	DefaultBulkOperations(MongoOperations mongoOperations, BulkMode bulkMode, String collectionName,
+			Class<?> entityType) {
+
+		Assert.notNull(mongoOperations, "MongoOperations must not be null!");
+		Assert.notNull(bulkMode, "BulkMode must not be null!");
+		Assert.hasText(collectionName, "Collection name must not be null or empty!");
+
+		this.mongoOperations = mongoOperations;
+		this.bulkMode = bulkMode;
+		this.collectionName = collectionName;
+		this.entityType = entityType;
+
+		this.exceptionTranslator = new MongoExceptionTranslator();
+		this.writeConcernResolver = DefaultWriteConcernResolver.INSTANCE;
+
+		this.bulk = initBulkOperation();
+	}
+
+	/**
+	 * Configures the {@link PersistenceExceptionTranslator} to be used. Defaults to {@link MongoExceptionTranslator}.
+	 * 
+	 * @param exceptionTranslator can be {@literal null}.
+	 */
+	public void setExceptionTranslator(PersistenceExceptionTranslator exceptionTranslator) {
+		this.exceptionTranslator = exceptionTranslator == null ? new MongoExceptionTranslator() : exceptionTranslator;
+	}
+
+	/**
+	 * Configures the {@link WriteConcernResolver} to be used. Defaults to {@link DefaultWriteConcernResolver}.
+	 * 
+	 * @param writeConcernResolver can be {@literal null}.
+	 */
+	public void setWriteConcernResolver(WriteConcernResolver writeConcernResolver) {
+		this.writeConcernResolver = writeConcernResolver == null ? DefaultWriteConcernResolver.INSTANCE
+				: writeConcernResolver;
+	}
+
+	/**
+	 * Configures the default {@link WriteConcern} to be used. Defaults to {@literal null}.
+	 * 
+	 * @param defaultWriteConcern can be {@literal null}.
+	 */
+	public void setDefaultWriteConcern(WriteConcern defaultWriteConcern) {
+		this.defaultWriteConcern = defaultWriteConcern;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.BulkOperations#insert(java.lang.Object)
+	 */
+	@Override
+	public BulkOperations insert(Object document) {
+
+		Assert.notNull(document, "Document must not be null!");
+
+		bulk.insert((DBObject) mongoOperations.getConverter().convertToMongoType(document));
+		return this;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.BulkOperations#insert(java.util.List)
+	 */
+	@Override
+	public BulkOperations insert(List<? extends Object> documents) {
+
+		Assert.notNull(documents, "Documents must not be null!");
+
+		for (Object document : documents) {
+			insert(document);
+		}
+
+		return this;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.BulkOperations#updateOne(org.springframework.data.mongodb.core.query.Query, org.springframework.data.mongodb.core.query.Update)
+	 */
+	@Override
+	@SuppressWarnings("unchecked")
+	public BulkOperations updateOne(Query query, Update update) {
+
+		Assert.notNull(query, "Query must not be null!");
+		Assert.notNull(update, "Update must not be null!");
+
+		return updateOne(Arrays.asList(Tuple.of(query, update)));
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.BulkOperations#updateOne(java.util.List)
+	 */
+	@Override
+	public BulkOperations updateOne(List<Tuple<Query, Update>> updates) {
+
+		Assert.notNull(updates, "Updates must not be null!");
+
+		for (Tuple<Query, Update> update : updates) {
+			update(update.getFirst(), update.getSecond(), false, false);
+		}
+
+		return this;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.BulkOperations#updateMulti(org.springframework.data.mongodb.core.query.Query, org.springframework.data.mongodb.core.query.Update)
+	 */
+	@Override
+	@SuppressWarnings("unchecked")
+	public BulkOperations updateMulti(Query query, Update update) {
+
+		Assert.notNull(query, "Query must not be null!");
+		Assert.notNull(update, "Update must not be null!");
+
+		return updateMulti(Arrays.asList(Tuple.of(query, update)));
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.BulkOperations#updateMulti(java.util.List)
+	 */
+	@Override
+	public BulkOperations updateMulti(List<Tuple<Query, Update>> updates) {
+
+		Assert.notNull(updates, "Updates must not be null!");
+
+		for (Tuple<Query, Update> update : updates) {
+			update(update.getFirst(), update.getSecond(), false, true);
+		}
+
+		return this;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.BulkOperations#upsert(org.springframework.data.mongodb.core.query.Query, org.springframework.data.mongodb.core.query.Update)
+	 */
+	@Override
+	public BulkOperations upsert(Query query, Update update) {
+		return update(query, update, true, true);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.BulkOperations#upsert(java.util.List)
+	 */
+	@Override
+	public BulkOperations upsert(List<Tuple<Query, Update>> updates) {
+
+		for (Tuple<Query, Update> update : updates) {
+			upsert(update.getFirst(), update.getSecond());
+		}
+
+		return this;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.BulkOperations#remove(org.springframework.data.mongodb.core.query.Query)
+	 */
+	@Override
+	public BulkOperations remove(Query query) {
+
+		Assert.notNull(query, "Query must not be null!");
+
+		bulk.find(query.getQueryObject()).remove();
+
+		return this;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.BulkOperations#remove(java.util.List)
+	 */
+	@Override
+	public BulkOperations remove(List<Query> removes) {
+
+		Assert.notNull(removes, "Removals must not be null!");
+
+		for (Query query : removes) {
+			remove(query);
+		}
+
+		return this;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.BulkOperations#executeBulk()
+	 */
+	@Override
+	public BulkWriteResult execute() {
+
+		MongoAction action = new MongoAction(defaultWriteConcern, MongoActionOperation.BULK, collectionName, entityType,
+				null, null);
+		WriteConcern writeConcern = writeConcernResolver.resolve(action);
+
+		try {
+
+			return writeConcern == null ? bulk.execute() : bulk.execute(writeConcern);
+
+		} catch (BulkWriteException o_O) {
+
+			DataAccessException toThrow = exceptionTranslator.translateExceptionIfPossible(o_O);
+			throw toThrow == null ? o_O : toThrow;
+
+		} finally {
+			this.bulk = initBulkOperation();
+		}
+	}
+
+	/**
+	 * Performs update and upsert bulk operations.
+	 * 
+	 * @param query the {@link Query} to determine documents to update.
+	 * @param update the {@link Update} to perform, must not be {@literal null}.
+	 * @param upsert whether to upsert.
+	 * @param multi whether to issue a multi-update.
+	 * @return the {@link BulkOperations} with the update registered.
+	 */
+	private BulkOperations update(Query query, Update update, boolean upsert, boolean multi) {
+
+		Assert.notNull(query, "Query must not be null!");
+		Assert.notNull(update, "Update must not be null!");
+
+		BulkWriteRequestBuilder builder = bulk.find(query.getQueryObject());
+
+		if (upsert) {
+
+			if (multi) {
+				builder.upsert().update(update.getUpdateObject());
+			} else {
+				builder.upsert().updateOne(update.getUpdateObject());
+			}
+
+		} else {
+
+			if (multi) {
+				builder.update(update.getUpdateObject());
+			} else {
+				builder.updateOne(update.getUpdateObject());
+			}
+		}
+
+		return this;
+	}
+
+	private final BulkWriteOperation initBulkOperation() {
+
+		DBCollection collection = mongoOperations.getCollection(collectionName);
+
+		switch (bulkMode) {
+			case ORDERED:
+				return collection.initializeOrderedBulkOperation();
+			case UNORDERED:
+				return collection.initializeUnorderedBulkOperation();
+		}
+
+		throw new IllegalStateException("BulkMode was null!");
+	}
+}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/DefaultWriteConcernResolver.java

@@ -0,0 +1,32 @@
+/*
+ * 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.mongodb.core;
+
+import com.mongodb.WriteConcern;
+
+/**
+ * Default {@link WriteConcernResolver} resolving the {@link WriteConcern} from the given {@link MongoAction}.
+ *
+ * @author Oliver Gierke
+ */
+enum DefaultWriteConcernResolver implements WriteConcernResolver {
+
+	INSTANCE;
+
+	public WriteConcern resolve(MongoAction action) {
+		return action.getDefaultWriteConcern();
+	}
+}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/GeoCommandStatistics.java

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2016 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.core;
+
+import org.springframework.util.Assert;
+
+import com.mongodb.BasicDBObject;
+import com.mongodb.DBObject;
+
+/**
+ * Value object to mitigate different representations of geo command execution results in MongoDB.
+ * 
+ * @author Oliver Gierke
+ * @soundtrack Fruitcake - Jeff Coffin (The Inside of the Outside)
+ */
+class GeoCommandStatistics {
+
+	private static final GeoCommandStatistics NONE = new GeoCommandStatistics(new BasicDBObject());
+
+	private final DBObject source;
+
+	/**
+	 * Creates a new {@link GeoCommandStatistics} instance with the given source document.
+	 * 
+	 * @param source must not be {@literal null}.
+	 */
+	private GeoCommandStatistics(DBObject source) {
+
+		Assert.notNull(source, "Source document must not be null!");
+		this.source = source;
+	}
+
+	/**
+	 * Creates a new {@link GeoCommandStatistics} from the given command result extracting the statistics.
+	 * 
+	 * @param commandResult must not be {@literal null}.
+	 * @return
+	 */
+	public static GeoCommandStatistics from(DBObject commandResult) {
+
+		Assert.notNull(commandResult, "Command result must not be null!");
+
+		Object stats = commandResult.get("stats");
+		return stats == null ? NONE : new GeoCommandStatistics((DBObject) stats);
+	}
+
+	/**
+	 * Returns the average distance reported by the command result. Mitigating a removal of the field in case the command
+	 * didn't return any result introduced in MongoDB 3.2 RC1.
+	 * 
+	 * @return
+	 * @see https://jira.mongodb.org/browse/SERVER-21024
+	 */
+	public double getAverageDistance() {
+
+		Object averageDistance = source.get("avgDistance");
+		return averageDistance == null ? Double.NaN : (Double) averageDistance;
+	}
+}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoAction.java

@@ -49,7 +49,7 @@ public class MongoAction {
 	 * @param collectionName the collection name, must not be {@literal null} or empty.
 	 * @param entityType the POJO that is being operated against
 	 * @param document the converted DBObject from the POJO or Spring Update object
-	 * @param query the converted DBOjbect from the Spring Query object
+	 * @param query the converted DBObject from the Spring Query object
 	 */
 	public MongoAction(WriteConcern defaultWriteConcern, MongoActionOperation mongoActionOperation,
 			String collectionName, Class<?> entityType, DBObject document, DBObject query) {

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoActionOperation.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2012 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.
@@ -25,5 +25,5 @@ package org.springframework.data.mongodb.core;
  */
 public enum MongoActionOperation {
 
-	REMOVE, UPDATE, INSERT, INSERT_LIST, SAVE
+	REMOVE, UPDATE, INSERT, INSERT_LIST, SAVE, BULK;
 }

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoDbUtils.java

@@ -199,8 +199,8 @@ public abstract class MongoDbUtils {
 	}
 
 	/**
-	 * Check if credentials present. In case we're using a monog-java-driver version 3 or above we do not have the need
-	 * for authentication as the auth data has to be provied within the MongoClient
+	 * Check if credentials present. In case we're using a mongo-java-driver version 3 or above we do not have the need
+	 * for authentication as the auth data has to be provided within the MongoClient
 	 * 
 	 * @param credentials
 	 * @return

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoExceptionTranslator.java

@@ -25,10 +25,14 @@ import org.springframework.dao.DataIntegrityViolationException;
 import org.springframework.dao.DuplicateKeyException;
 import org.springframework.dao.InvalidDataAccessApiUsageException;
 import org.springframework.dao.InvalidDataAccessResourceUsageException;
+import org.springframework.dao.PermissionDeniedDataAccessException;
 import org.springframework.dao.support.PersistenceExceptionTranslator;
+import org.springframework.data.mongodb.BulkOperationException;
 import org.springframework.data.mongodb.UncategorizedMongoDbException;
+import org.springframework.data.mongodb.util.MongoDbErrorCodes;
 import org.springframework.util.ClassUtils;
 
+import com.mongodb.BulkWriteException;
 import com.mongodb.MongoException;
 
 /**
@@ -42,12 +46,12 @@ import com.mongodb.MongoException;
  */
 public class MongoExceptionTranslator implements PersistenceExceptionTranslator {
 
-	private static final Set<String> DULICATE_KEY_EXCEPTIONS = new HashSet<String>(Arrays.asList(
-			"MongoException.DuplicateKey", "DuplicateKeyException"));
+	private static final Set<String> DULICATE_KEY_EXCEPTIONS = new HashSet<String>(
+			Arrays.asList("MongoException.DuplicateKey", "DuplicateKeyException"));
 
-	private static final Set<String> RESOURCE_FAILURE_EXCEPTIONS = new HashSet<String>(Arrays.asList(
-			"MongoException.Network", "MongoSocketException", "MongoException.CursorNotFound",
-			"MongoCursorNotFoundException", "MongoServerSelectionException", "MongoTimeoutException"));
+	private static final Set<String> RESOURCE_FAILURE_EXCEPTIONS = new HashSet<String>(
+			Arrays.asList("MongoException.Network", "MongoSocketException", "MongoException.CursorNotFound",
+					"MongoCursorNotFoundException", "MongoServerSelectionException", "MongoTimeoutException"));
 
 	private static final Set<String> RESOURCE_USAGE_EXCEPTIONS = new HashSet<String>(
 			Arrays.asList("MongoInternalException"));
@@ -81,17 +85,24 @@ public class MongoExceptionTranslator implements PersistenceExceptionTranslator
 			return new DataIntegrityViolationException(ex.getMessage(), ex);
 		}
 
+		if (ex instanceof BulkWriteException) {
+			return new BulkOperationException(ex.getMessage(), (BulkWriteException) ex);
+		}
+
 		// All other MongoExceptions
 		if (ex instanceof MongoException) {
 
 			int code = ((MongoException) ex).getCode();
 
-			if (code == 11000 || code == 11001) {
+			if (MongoDbErrorCodes.isDuplicateKeyCode(code)) {
 				throw new DuplicateKeyException(ex.getMessage(), ex);
-			} else if (code == 12000 || code == 13440) {
+			} else if (MongoDbErrorCodes.isDataAccessResourceFailureCode(code)) {
 				throw new DataAccessResourceFailureException(ex.getMessage(), ex);
-			} else if (code == 10003 || code == 12001 || code == 12010 || code == 12011 || code == 12012) {
+			} else if (MongoDbErrorCodes.isInvalidDataAccessApiUsageCode(code) || code == 10003 || code == 12001
+					|| code == 12010 || code == 12011 || code == 12012) {
 				throw new InvalidDataAccessApiUsageException(ex.getMessage(), ex);
+			} else if (MongoDbErrorCodes.isPermissionDeniedCode(code)) {
+				throw new PermissionDeniedDataAccessException(ex.getMessage(), ex);
 			}
 			return new UncategorizedMongoDbException(ex.getMessage(), ex);
 		}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoOperations.java

@@ -20,6 +20,7 @@ import java.util.List;
 import java.util.Set;
 
 import org.springframework.data.geo.GeoResults;
+import org.springframework.data.mongodb.core.BulkOperations.BulkMode;
 import org.springframework.data.mongodb.core.aggregation.Aggregation;
 import org.springframework.data.mongodb.core.aggregation.AggregationResults;
 import org.springframework.data.mongodb.core.aggregation.TypedAggregation;
@@ -190,7 +191,7 @@ public interface MongoOperations {
 	<T> DBCollection createCollection(Class<T> entityClass);
 
 	/**
-	 * Create a collect with a name based on the provided entity class using the options.
+	 * Create a collection with a name based on the provided entity class using the options.
 	 * 
 	 * @param entityClass class that determines the collection to create
 	 * @param collectionOptions options to use when creating the collection.
@@ -207,7 +208,7 @@ public interface MongoOperations {
 	DBCollection createCollection(String collectionName);
 
 	/**
-	 * Create a collect with the provided name and options.
+	 * Create a collection with the provided name and options.
 	 * 
 	 * @param collectionName name of the collection
 	 * @param collectionOptions options to use when creating the collection.
@@ -292,6 +293,34 @@ public interface MongoOperations {
 	 */
 	ScriptOperations scriptOps();
 
+	/**
+	 * Returns a new {@link BulkOperations} for the given collection.
+	 * 
+	 * @param mode the {@link BulkMode} to use for bulk operations, must not be {@literal null}.
+	 * @param collectionName the name of the collection to work on, must not be {@literal null} or empty.
+	 * @return {@link BulkOperations} on the named collection
+	 */
+	BulkOperations bulkOps(BulkMode mode, String collectionName);
+
+	/**
+	 * Returns a new {@link BulkOperations} for the given entity type.
+	 * 
+	 * @param mode the {@link BulkMode} to use for bulk operations, must not be {@literal null}.
+	 * @param entityType the name of the entity class, must not be {@literal null}.
+	 * @return {@link BulkOperations} on the named collection associated of the given entity class.
+	 */
+	BulkOperations bulkOps(BulkMode mode, Class<?> entityType);
+
+	/**
+	 * Returns a new {@link BulkOperations} for the given entity type and collection name.
+	 * 
+	 * @param mode the {@link BulkMode} to use for bulk operations, must not be {@literal null}.
+	 * @param entityClass the name of the entity class, must not be {@literal null}.
+	 * @param collectionName the name of the collection to work on, must not be {@literal null} or empty.
+	 * @return {@link BulkOperations} on the named collection associated with the given entity class.
+	 */
+	BulkOperations bulkOps(BulkMode mode, Class<?> entityType, String collectionName);
+
 	/**
 	 * Query for a list of objects of type T from the collection used by the entity class.
 	 * <p/>
@@ -600,8 +629,8 @@ public interface MongoOperations {
 	<T> T findById(Object id, Class<T> entityClass, String collectionName);
 
 	/**
-	 * Triggers <a href="http://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify<a/>
-	 * to apply provided {@link Update} on documents matching {@link Criteria} of given {@link Query}.
+	 * Triggers <a href="http://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify
+	 * <a/> to apply provided {@link Update} on documents matching {@link Criteria} of given {@link Query}.
 	 * 
 	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
 	 *          fields specification.
@@ -612,8 +641,8 @@ public interface MongoOperations {
 	<T> T findAndModify(Query query, Update update, Class<T> entityClass);
 
 	/**
-	 * Triggers <a href="http://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify<a/>
-	 * to apply provided {@link Update} on documents matching {@link Criteria} of given {@link Query}.
+	 * Triggers <a href="http://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify
+	 * <a/> to apply provided {@link Update} on documents matching {@link Criteria} of given {@link Query}.
 	 * 
 	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
 	 *          fields specification.
@@ -625,8 +654,8 @@ public interface MongoOperations {
 	<T> T findAndModify(Query query, Update update, Class<T> entityClass, String collectionName);
 
 	/**
-	 * Triggers <a href="http://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify<a/>
-	 * to apply provided {@link Update} on documents matching {@link Criteria} of given {@link Query} taking
+	 * Triggers <a href="http://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify
+	 * <a/> to apply provided {@link Update} on documents matching {@link Criteria} of given {@link Query} taking
 	 * {@link FindAndModifyOptions} into account.
 	 * 
 	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
@@ -639,8 +668,8 @@ public interface MongoOperations {
 	<T> T findAndModify(Query query, Update update, FindAndModifyOptions options, Class<T> entityClass);
 
 	/**
-	 * Triggers <a href="http://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify<a/>
-	 * to apply provided {@link Update} on documents matching {@link Criteria} of given {@link Query} taking
+	 * Triggers <a href="http://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify
+	 * <a/> to apply provided {@link Update} on documents matching {@link Criteria} of given {@link Query} taking
 	 * {@link FindAndModifyOptions} into account.
 	 * 
 	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
@@ -728,9 +757,9 @@ public interface MongoOperations {
 	 * <p/>
 	 * If you object has an "Id' property, it will be set with the generated Id from MongoDB. If your Id property is a
 	 * String then MongoDB ObjectId will be used to populate that string. Otherwise, the conversion from ObjectId to your
-	 * property type will be handled by Spring's BeanWrapper class that leverages Type Conversion API. See <a
-	 * href="http://docs.spring.io/spring/docs/current/spring-framework-reference/html/validation.html#core-convert"
-	 * >Spring's Type Conversion"</a> for more details.
+	 * property type will be handled by Spring's BeanWrapper class that leverages Type Conversion API. See
+	 * <a href="http://docs.spring.io/spring/docs/current/spring-framework-reference/html/validation.html#core-convert" >
+	 * Spring's Type Conversion"</a> for more details.
 	 * <p/>
 	 * <p/>
 	 * Insert is used to initially store the object into the database. To update an existing object use the save method.
@@ -785,9 +814,9 @@ public interface MongoOperations {
 	 * <p/>
 	 * If you object has an "Id' property, it will be set with the generated Id from MongoDB. If your Id property is a
 	 * String then MongoDB ObjectId will be used to populate that string. Otherwise, the conversion from ObjectId to your
-	 * property type will be handled by Spring's BeanWrapper class that leverages Type Conversion API. See <a
-	 * href="http://docs.spring.io/spring/docs/current/spring-framework-reference/html/validation.html#core-convert"
-	 * >Spring's Type Conversion"</a> for more details.
+	 * property type will be handled by Spring's BeanWrapper class that leverages Type Conversion API. See
+	 * <a href="http://docs.spring.io/spring/docs/current/spring-framework-reference/html/validation.html#core-convert" >
+	 * Spring's Type Conversion"</a> for more details.
 	 * 
 	 * @param objectToSave the object to store in the collection
 	 */

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoTemplate.java

@@ -60,6 +60,7 @@ import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.data.mapping.model.ConvertingPropertyAccessor;
 import org.springframework.data.mapping.model.MappingException;
 import org.springframework.data.mongodb.MongoDbFactory;
+import org.springframework.data.mongodb.core.BulkOperations.BulkMode;
 import org.springframework.data.mongodb.core.aggregation.Aggregation;
 import org.springframework.data.mongodb.core.aggregation.AggregationOperationContext;
 import org.springframework.data.mongodb.core.aggregation.AggregationResults;
@@ -338,9 +339,10 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 				DBCursor cursor = collection.find(mappedQuery, mappedFields);
 				QueryCursorPreparer cursorPreparer = new QueryCursorPreparer(query, entityType);
 
-				ReadDbObjectCallback<T> readCallback = new ReadDbObjectCallback<T>(mongoConverter, entityType);
+				ReadDbObjectCallback<T> readCallback = new ReadDbObjectCallback<T>(mongoConverter, entityType,
+						collection.getName());
 
-				return new CloseableIterableCusorAdapter<T>(cursorPreparer.prepare(cursor), exceptionTranslator, readCallback);
+				return new CloseableIterableCursorAdapter<T>(cursorPreparer.prepare(cursor), exceptionTranslator, readCallback);
 			}
 		});
 	}
@@ -371,8 +373,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	 */
 	@Deprecated
 	public CommandResult executeCommand(final DBObject command, final int options) {
-		return executeCommand(command, (options & Bytes.QUERYOPTION_SLAVEOK) != 0 ? ReadPreference.secondaryPreferred()
-				: ReadPreference.primary());
+		return executeCommand(command,
+				(options & Bytes.QUERYOPTION_SLAVEOK) != 0 ? ReadPreference.secondaryPreferred() : ReadPreference.primary());
 	}
 
 	/*
@@ -385,7 +387,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 		CommandResult result = execute(new DbCallback<CommandResult>() {
 			public CommandResult doInDB(DB db) throws MongoException, DataAccessException {
-				return db.command(command, readPreference);
+				return readPreference != null ? db.command(command, readPreference) : db.command(command);
 			}
 		});
 
@@ -420,7 +422,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	 * @param preparer allows for customization of the {@link DBCursor} used when iterating over the result set, (apply
 	 *          limits, skips and so on).
 	 */
-	protected void executeQuery(Query query, String collectionName, DocumentCallbackHandler dch, CursorPreparer preparer) {
+	protected void executeQuery(Query query, String collectionName, DocumentCallbackHandler dch,
+			CursorPreparer preparer) {
 
 		Assert.notNull(query);
 
@@ -444,7 +447,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 			DB db = this.getDb();
 			return action.doInDB(db);
 		} catch (RuntimeException e) {
-			throw potentiallyConvertRuntimeException(e);
+			throw potentiallyConvertRuntimeException(e, exceptionTranslator);
 		}
 	}
 
@@ -460,7 +463,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 			DBCollection collection = getAndPrepareCollection(getDb(), collectionName);
 			return callback.doInCollection(collection);
 		} catch (RuntimeException e) {
-			throw potentiallyConvertRuntimeException(e);
+			throw potentiallyConvertRuntimeException(e, exceptionTranslator);
 		}
 	}
 
@@ -543,6 +546,28 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 		return new DefaultIndexOperations(this, determineCollectionName(entityClass));
 	}
 
+	public BulkOperations bulkOps(BulkMode bulkMode, String collectionName) {
+		return bulkOps(bulkMode, null, collectionName);
+	}
+
+	public BulkOperations bulkOps(BulkMode bulkMode, Class<?> entityClass) {
+		return bulkOps(bulkMode, entityClass, determineCollectionName(entityClass));
+	}
+
+	public BulkOperations bulkOps(BulkMode mode, Class<?> entityType, String collectionName) {
+
+		Assert.notNull(mode, "BulkMode must not be null!");
+		Assert.hasText(collectionName, "Collection name must not be null or empty!");
+
+		DefaultBulkOperations operations = new DefaultBulkOperations(this, mode, collectionName, entityType);
+
+		operations.setExceptionTranslator(exceptionTranslator);
+		operations.setWriteConcernResolver(writeConcernResolver);
+		operations.setDefaultWriteConcern(writeConcern);
+
+		return operations;
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.mongodb.core.MongoOperations#scriptOps()
@@ -629,15 +654,22 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 		}
 
 		String collection = StringUtils.hasText(collectionName) ? collectionName : determineCollectionName(entityClass);
-		BasicDBObject command = new BasicDBObject("geoNear", collection);
-		command.putAll(near.toDBObject());
+		DBObject nearDbObject = near.toDBObject();
 
-		CommandResult commandResult = executeCommand(command);
+		BasicDBObject command = new BasicDBObject("geoNear", collection);
+		command.putAll(nearDbObject);
+
+		if (nearDbObject.containsField("query")) {
+			DBObject query = (DBObject) nearDbObject.get("query");
+			command.put("query", queryMapper.getMappedObject(query, getPersistentEntity(entityClass)));
+		}
+
+		CommandResult commandResult = executeCommand(command, this.readPreference);
 		List<Object> results = (List<Object>) commandResult.get("results");
 		results = results == null ? Collections.emptyList() : results;
 
-		DbObjectCallback<GeoResult<T>> callback = new GeoNearResultDbObjectCallback<T>(new ReadDbObjectCallback<T>(
-				mongoConverter, entityClass), near.getMetric());
+		DbObjectCallback<GeoResult<T>> callback = new GeoNearResultDbObjectCallback<T>(
+				new ReadDbObjectCallback<T>(mongoConverter, entityClass, collectionName), near.getMetric());
 		List<GeoResult<T>> result = new ArrayList<GeoResult<T>>(results.size());
 
 		int index = 0;
@@ -662,9 +694,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 			return new GeoResults<T>(result, near.getMetric());
 		}
 
-		DBObject stats = (DBObject) commandResult.get("stats");
-		double averageDistance = stats == null ? 0 : (Double) stats.get("avgDistance");
-		return new GeoResults<T>(result, new Distance(averageDistance, near.getMetric()));
+		GeoCommandStatistics stats = GeoCommandStatistics.from(commandResult);
+		return new GeoResults<T>(result, new Distance(stats.getAverageDistance(), near.getMetric()));
 	}
 
 	public <T> T findAndModify(Query query, Update update, Class<T> entityClass) {
@@ -714,8 +745,9 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	public long count(Query query, Class<?> entityClass, String collectionName) {
 
 		Assert.hasText(collectionName);
-		final DBObject dbObject = query == null ? null : queryMapper.getMappedObject(query.getQueryObject(),
-				entityClass == null ? null : mappingContext.getPersistentEntity(entityClass));
+		final DBObject dbObject = query == null ? null
+				: queryMapper.getMappedObject(query.getQueryObject(),
+						entityClass == null ? null : mappingContext.getPersistentEntity(entityClass));
 
 		return execute(collectionName, new CollectionCallback<Long>() {
 			public Long doInCollection(DBCollection collection) throws MongoException, DataAccessException {
@@ -774,11 +806,17 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	protected WriteConcern prepareWriteConcern(MongoAction mongoAction) {
 
 		WriteConcern wc = writeConcernResolver.resolve(mongoAction);
+		return potentiallyForceAcknowledgedWrite(wc);
+	}
 
-		if (MongoClientVersion.isMongo3Driver()
-				&& ObjectUtils.nullSafeEquals(WriteResultChecking.EXCEPTION, writeResultChecking)
-				&& (wc == null || wc.getW() < 1)) {
-			return WriteConcern.ACKNOWLEDGED;
+	private WriteConcern potentiallyForceAcknowledgedWrite(WriteConcern wc) {
+
+		if (ObjectUtils.nullSafeEquals(WriteResultChecking.EXCEPTION, writeResultChecking)
+				&& MongoClientVersion.isMongo3Driver()) {
+			if (wc == null || wc.getWObject() == null
+					|| (wc.getWObject() instanceof Number && ((Number) wc.getWObject()).intValue() < 1)) {
+				return WriteConcern.ACKNOWLEDGED;
+			}
 		}
 		return wc;
 	}
@@ -789,15 +827,15 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 		initializeVersionProperty(objectToSave);
 
-		maybeEmitEvent(new BeforeConvertEvent<T>(objectToSave));
+		maybeEmitEvent(new BeforeConvertEvent<T>(objectToSave, collectionName));
 
 		DBObject dbDoc = toDbObject(objectToSave, writer);
 
-		maybeEmitEvent(new BeforeSaveEvent<T>(objectToSave, dbDoc));
+		maybeEmitEvent(new BeforeSaveEvent<T>(objectToSave, dbDoc, collectionName));
 		Object id = insertDBObject(collectionName, dbDoc, objectToSave.getClass());
 
 		populateIdIfNecessary(objectToSave, id);
-		maybeEmitEvent(new AfterSaveEvent<T>(objectToSave, dbDoc));
+		maybeEmitEvent(new AfterSaveEvent<T>(objectToSave, dbDoc, collectionName));
 	}
 
 	/**
@@ -885,10 +923,10 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 			initializeVersionProperty(o);
 			BasicDBObject dbDoc = new BasicDBObject();
 
-			maybeEmitEvent(new BeforeConvertEvent<T>(o));
+			maybeEmitEvent(new BeforeConvertEvent<T>(o, collectionName));
 			writer.write(o, dbDoc);
 
-			maybeEmitEvent(new BeforeSaveEvent<T>(o, dbDoc));
+			maybeEmitEvent(new BeforeSaveEvent<T>(o, dbDoc, collectionName));
 			dbObjectList.add(dbDoc);
 		}
 		List<ObjectId> ids = insertDBObjectList(collectionName, dbObjectList);
@@ -896,7 +934,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 		for (T obj : batchToSave) {
 			if (i < ids.size()) {
 				populateIdIfNecessary(obj, ids.get(i));
-				maybeEmitEvent(new AfterSaveEvent<T>(obj, dbObjectList.get(i)));
+				maybeEmitEvent(new AfterSaveEvent<T>(obj, dbObjectList.get(i), collectionName));
 			}
 			i++;
 		}
@@ -951,14 +989,14 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 			BasicDBObject dbObject = new BasicDBObject();
 
-			maybeEmitEvent(new BeforeConvertEvent<T>(objectToSave));
+			maybeEmitEvent(new BeforeConvertEvent<T>(objectToSave, collectionName));
 			this.mongoConverter.write(objectToSave, dbObject);
 
-			maybeEmitEvent(new BeforeSaveEvent<T>(objectToSave, dbObject));
+			maybeEmitEvent(new BeforeSaveEvent<T>(objectToSave, dbObject, collectionName));
 			Update update = Update.fromDBObject(dbObject, ID_FIELD);
 
 			doUpdate(collectionName, query, update, objectToSave.getClass(), false, false);
-			maybeEmitEvent(new AfterSaveEvent<T>(objectToSave, dbObject));
+			maybeEmitEvent(new AfterSaveEvent<T>(objectToSave, dbObject, collectionName));
 		}
 	}
 
@@ -966,15 +1004,15 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 		assertUpdateableIdIfNotSet(objectToSave);
 
-		maybeEmitEvent(new BeforeConvertEvent<T>(objectToSave));
+		maybeEmitEvent(new BeforeConvertEvent<T>(objectToSave, collectionName));
 
 		DBObject dbDoc = toDbObject(objectToSave, writer);
 
-		maybeEmitEvent(new BeforeSaveEvent<T>(objectToSave, dbDoc));
+		maybeEmitEvent(new BeforeSaveEvent<T>(objectToSave, dbDoc, collectionName));
 		Object id = saveDBObject(collectionName, dbDoc, objectToSave.getClass());
 
 		populateIdIfNecessary(objectToSave, id);
-		maybeEmitEvent(new AfterSaveEvent<T>(objectToSave, dbDoc));
+		maybeEmitEvent(new AfterSaveEvent<T>(objectToSave, dbDoc, collectionName));
 	}
 
 	protected Object insertDBObject(final String collectionName, final DBObject dbDoc, final Class<?> entityClass) {
@@ -986,8 +1024,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 				MongoAction mongoAction = new MongoAction(writeConcern, MongoActionOperation.INSERT, collectionName,
 						entityClass, dbDoc, null);
 				WriteConcern writeConcernToUse = prepareWriteConcern(mongoAction);
-				WriteResult writeResult = writeConcernToUse == null ? collection.insert(dbDoc) : collection.insert(dbDoc,
-						writeConcernToUse);
+				WriteResult writeResult = writeConcernToUse == null ? collection.insert(dbDoc)
+						: collection.insert(dbDoc, writeConcernToUse);
 				handleAnyWriteResultErrors(writeResult, dbDoc, MongoActionOperation.INSERT);
 				return dbDoc.get(ID_FIELD);
 			}
@@ -1007,8 +1045,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 				MongoAction mongoAction = new MongoAction(writeConcern, MongoActionOperation.INSERT_LIST, collectionName, null,
 						null, null);
 				WriteConcern writeConcernToUse = prepareWriteConcern(mongoAction);
-				WriteResult writeResult = writeConcernToUse == null ? collection.insert(dbDocList) : collection.insert(
-						dbDocList.toArray((DBObject[]) new BasicDBObject[dbDocList.size()]), writeConcernToUse);
+				WriteResult writeResult = writeConcernToUse == null ? collection.insert(dbDocList)
+						: collection.insert(dbDocList.toArray((DBObject[]) new BasicDBObject[dbDocList.size()]), writeConcernToUse);
 				handleAnyWriteResultErrors(writeResult, null, MongoActionOperation.INSERT_LIST);
 				return null;
 			}
@@ -1036,8 +1074,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 				MongoAction mongoAction = new MongoAction(writeConcern, MongoActionOperation.SAVE, collectionName, entityClass,
 						dbDoc, null);
 				WriteConcern writeConcernToUse = prepareWriteConcern(mongoAction);
-				WriteResult writeResult = writeConcernToUse == null ? collection.save(dbDoc) : collection.save(dbDoc,
-						writeConcernToUse);
+				WriteResult writeResult = writeConcernToUse == null ? collection.save(dbDoc)
+						: collection.save(dbDoc, writeConcernToUse);
 				handleAnyWriteResultErrors(writeResult, dbDoc, MongoActionOperation.SAVE);
 				return dbDoc.get(ID_FIELD);
 			}
@@ -1090,10 +1128,10 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 				increaseVersionForUpdateIfNecessary(entity, update);
 
-				DBObject queryObj = query == null ? new BasicDBObject() : queryMapper.getMappedObject(query.getQueryObject(),
-						entity);
-				DBObject updateObj = update == null ? new BasicDBObject() : updateMapper.getMappedObject(
-						update.getUpdateObject(), entity);
+				DBObject queryObj = query == null ? new BasicDBObject()
+						: queryMapper.getMappedObject(query.getQueryObject(), entity);
+				DBObject updateObj = update == null ? new BasicDBObject()
+						: updateMapper.getMappedObject(update.getUpdateObject(), entity);
 
 				if (LOGGER.isDebugEnabled()) {
 					LOGGER.debug(String.format("Calling update using query: %s and update: %s in collection: %s",
@@ -1234,9 +1272,9 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 		Object idValue = persistentEntity.getPropertyAccessor(entity).getProperty(idProperty);
 
 		if (idValue == null && !MongoSimpleTypes.AUTOGENERATED_ID_TYPES.contains(idProperty.getType())) {
-			throw new InvalidDataAccessApiUsageException(String.format(
-					"Cannot autogenerate id of type %s for entity of type %s!", idProperty.getType().getName(), entity.getClass()
-							.getName()));
+			throw new InvalidDataAccessApiUsageException(
+					String.format("Cannot autogenerate id of type %s for entity of type %s!", idProperty.getType().getName(),
+							entity.getClass().getName()));
 		}
 	}
 
@@ -1266,7 +1304,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 		return execute(collectionName, new CollectionCallback<WriteResult>() {
 			public WriteResult doInCollection(DBCollection collection) throws MongoException, DataAccessException {
 
-				maybeEmitEvent(new BeforeDeleteEvent<T>(queryObject, entityClass));
+				maybeEmitEvent(new BeforeDeleteEvent<T>(queryObject, entityClass, collectionName));
 
 				DBObject dboq = queryMapper.getMappedObject(queryObject, entity);
 
@@ -1275,16 +1313,16 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 				WriteConcern writeConcernToUse = prepareWriteConcern(mongoAction);
 
 				if (LOGGER.isDebugEnabled()) {
-					LOGGER.debug("Remove using query: {} in collection: {}.", new Object[] { serializeToJsonSafely(dboq),
-							collection.getName() });
+					LOGGER.debug("Remove using query: {} in collection: {}.",
+							new Object[] { serializeToJsonSafely(dboq), collection.getName() });
 				}
 
-				WriteResult wr = writeConcernToUse == null ? collection.remove(dboq) : collection.remove(dboq,
-						writeConcernToUse);
+				WriteResult wr = writeConcernToUse == null ? collection.remove(dboq)
+						: collection.remove(dboq, writeConcernToUse);
 
 				handleAnyWriteResultErrors(wr, dboq, MongoActionOperation.REMOVE);
 
-				maybeEmitEvent(new AfterDeleteEvent<T>(queryObject, entityClass));
+				maybeEmitEvent(new AfterDeleteEvent<T>(queryObject, entityClass, collectionName));
 
 				return wr;
 			}
@@ -1292,13 +1330,12 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	}
 
 	public <T> List<T> findAll(Class<T> entityClass) {
-		return executeFindMultiInternal(new FindCallback(null), null, new ReadDbObjectCallback<T>(mongoConverter,
-				entityClass), determineCollectionName(entityClass));
+		return findAll(entityClass, determineCollectionName(entityClass));
 	}
 
 	public <T> List<T> findAll(Class<T> entityClass, String collectionName) {
-		return executeFindMultiInternal(new FindCallback(null), null, new ReadDbObjectCallback<T>(mongoConverter,
-				entityClass), collectionName);
+		return executeFindMultiInternal(new FindCallback(null), null,
+				new ReadDbObjectCallback<T>(mongoConverter, entityClass, collectionName), collectionName);
 	}
 
 	public <T> MapReduceResults<T> mapReduce(String inputCollectionName, String mapFunction, String reduceFunction,
@@ -1314,8 +1351,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 	public <T> MapReduceResults<T> mapReduce(Query query, String inputCollectionName, String mapFunction,
 			String reduceFunction, Class<T> entityClass) {
-		return mapReduce(query, inputCollectionName, mapFunction, reduceFunction,
-				new MapReduceOptions().outputTypeInline(), entityClass);
+		return mapReduce(query, inputCollectionName, mapFunction, reduceFunction, new MapReduceOptions().outputTypeInline(),
+				entityClass);
 	}
 
 	public <T> MapReduceResults<T> mapReduce(Query query, String inputCollectionName, String mapFunction,
@@ -1326,8 +1363,9 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 		DBCollection inputCollection = getCollection(inputCollectionName);
 
 		MapReduceCommand command = new MapReduceCommand(inputCollection, mapFunc, reduceFunc,
-				mapReduceOptions.getOutputCollection(), mapReduceOptions.getOutputType(), query == null
-						|| query.getQueryObject() == null ? null : queryMapper.getMappedObject(query.getQueryObject(), null));
+				mapReduceOptions.getOutputCollection(), mapReduceOptions.getOutputType(),
+				query == null || query.getQueryObject() == null ? null
+						: queryMapper.getMappedObject(query.getQueryObject(), null));
 
 		copyMapReduceOptionsToCommand(query, mapReduceOptions, command);
 
@@ -1343,7 +1381,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 		}
 
 		List<T> mappedResults = new ArrayList<T>();
-		DbObjectCallback<T> callback = new ReadDbObjectCallback<T>(mongoConverter, entityClass);
+		DbObjectCallback<T> callback = new ReadDbObjectCallback<T>(mongoConverter, entityClass, inputCollectionName);
 
 		for (DBObject dbObject : mapReduceOutput.results()) {
 			mappedResults.add(callback.doWith(dbObject));
@@ -1404,7 +1442,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 		@SuppressWarnings("unchecked")
 		Iterable<DBObject> resultSet = (Iterable<DBObject>) commandResult.get("retval");
 		List<T> mappedResults = new ArrayList<T>();
-		DbObjectCallback<T> callback = new ReadDbObjectCallback<T>(mongoConverter, entityClass);
+		DbObjectCallback<T> callback = new ReadDbObjectCallback<T>(mongoConverter, entityClass, inputCollectionName);
 
 		for (DBObject dbObject : resultSet) {
 			mappedResults.add(callback.doWith(dbObject));
@@ -1503,10 +1541,11 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 			LOGGER.debug("Executing aggregation: {}", serializeToJsonSafely(command));
 		}
 
-		CommandResult commandResult = executeCommand(command);
+		CommandResult commandResult = executeCommand(command, this.readPreference);
 		handleCommandError(commandResult, command);
 
-		return new AggregationResults<O>(returnPotentiallyMappedResults(outputType, commandResult), commandResult);
+		return new AggregationResults<O>(returnPotentiallyMappedResults(outputType, commandResult, collectionName),
+				commandResult);
 	}
 
 	/**
@@ -1516,7 +1555,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	 * @param commandResult
 	 * @return
 	 */
-	private <O> List<O> returnPotentiallyMappedResults(Class<O> outputType, CommandResult commandResult) {
+	private <O> List<O> returnPotentiallyMappedResults(Class<O> outputType, CommandResult commandResult,
+			String collectionName) {
 
 		@SuppressWarnings("unchecked")
 		Iterable<DBObject> resultSet = (Iterable<DBObject>) commandResult.get("result");
@@ -1524,7 +1564,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 			return Collections.emptyList();
 		}
 
-		DbObjectCallback<O> callback = new UnwrapAndReadDbObjectCallback<O>(mongoConverter, outputType);
+		DbObjectCallback<O> callback = new UnwrapAndReadDbObjectCallback<O>(mongoConverter, outputType, collectionName);
 
 		List<O> mappedResults = new ArrayList<O>();
 		for (DBObject dbObject : resultSet) {
@@ -1546,10 +1586,17 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 				throw new InvalidDataAccessApiUsageException(String.format("Resource %s not found!", function));
 			}
 
+			Scanner scanner = null;
+
 			try {
-				return new Scanner(functionResource.getInputStream()).useDelimiter("\\A").next();
+				scanner = new Scanner(functionResource.getInputStream());
+				return scanner.useDelimiter("\\A").next();
 			} catch (IOException e) {
 				throw new InvalidDataAccessApiUsageException(String.format("Cannot read map-reduce file %s!", function), e);
+			} finally {
+				if (scanner != null) {
+					scanner.close();
+				}
 			}
 		}
 
@@ -1564,8 +1611,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 				throw new InvalidDataAccessApiUsageException(
 						"Can not use skip or field specification with map reduce operations");
 			}
-
-			if (query.getLimit() > 0) {
+			if (query.getLimit() > 0 && mapReduceOptions.getLimit() == null) {
 				mapReduceCommand.setLimit(query.getLimit());
 			}
 			if (query.getSortObject() != null) {
@@ -1573,6 +1619,10 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 			}
 		}
 
+		if (mapReduceOptions.getLimit() != null && mapReduceOptions.getLimit().intValue() > 0) {
+			mapReduceCommand.setLimit(mapReduceOptions.getLimit());
+		}
+
 		if (mapReduceOptions.getJavaScriptMode() != null) {
 			mapReduceCommand.setJsMode(true);
 		}
@@ -1651,8 +1701,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 					serializeToJsonSafely(query), mappedFields, entityClass, collectionName));
 		}
 
-		return executeFindOneInternal(new FindOneCallback(mappedQuery, mappedFields), new ReadDbObjectCallback<T>(
-				this.mongoConverter, entityClass), collectionName);
+		return executeFindOneInternal(new FindOneCallback(mappedQuery, mappedFields),
+				new ReadDbObjectCallback<T>(this.mongoConverter, entityClass, collectionName), collectionName);
 	}
 
 	/**
@@ -1666,8 +1716,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	 * @return the List of converted objects.
 	 */
 	protected <T> List<T> doFind(String collectionName, DBObject query, DBObject fields, Class<T> entityClass) {
-		return doFind(collectionName, query, fields, entityClass, null, new ReadDbObjectCallback<T>(this.mongoConverter,
-				entityClass));
+		return doFind(collectionName, query, fields, entityClass, null,
+				new ReadDbObjectCallback<T>(this.mongoConverter, entityClass, collectionName));
 	}
 
 	/**
@@ -1685,8 +1735,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	 */
 	protected <T> List<T> doFind(String collectionName, DBObject query, DBObject fields, Class<T> entityClass,
 			CursorPreparer preparer) {
-		return doFind(collectionName, query, fields, entityClass, preparer, new ReadDbObjectCallback<T>(mongoConverter,
-				entityClass));
+		return doFind(collectionName, query, fields, entityClass, preparer,
+				new ReadDbObjectCallback<T>(mongoConverter, entityClass, collectionName));
 	}
 
 	protected <S, T> List<T> doFind(String collectionName, DBObject query, DBObject fields, Class<S> entityClass,
@@ -1742,7 +1792,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 		}
 		MongoPersistentEntity<?> entity = mappingContext.getPersistentEntity(entityClass);
 		return executeFindOneInternal(new FindAndRemoveCallback(queryMapper.getMappedObject(query, entity), fields, sort),
-				new ReadDbObjectCallback<T>(readerToUse, entityClass), collectionName);
+				new ReadDbObjectCallback<T>(readerToUse, entityClass, collectionName), collectionName);
 	}
 
 	protected <T> T doFindAndModify(String collectionName, DBObject query, DBObject fields, DBObject sort,
@@ -1762,13 +1812,17 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 		DBObject mappedUpdate = updateMapper.getMappedObject(update.getUpdateObject(), entity);
 
 		if (LOGGER.isDebugEnabled()) {
-			LOGGER.debug(String.format("findAndModify using query: %s fields: %s sort: %s for class: %s and update: %s "
-					+ "in collection: %s", serializeToJsonSafely(mappedQuery), fields, sort, entityClass,
-					serializeToJsonSafely(mappedUpdate), collectionName));
+			LOGGER
+					.debug(
+							String.format(
+									"findAndModify using query: %s fields: %s sort: %s for class: %s and update: %s "
+											+ "in collection: %s",
+									serializeToJsonSafely(mappedQuery), fields, sort, entityClass, serializeToJsonSafely(mappedUpdate),
+									collectionName));
 		}
 
 		return executeFindOneInternal(new FindAndModifyCallback(mappedQuery, fields, sort, mappedUpdate, options),
-				new ReadDbObjectCallback<T>(readerToUse, entityClass), collectionName);
+				new ReadDbObjectCallback<T>(readerToUse, entityClass, collectionName), collectionName);
 	}
 
 	/**
@@ -1812,7 +1866,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 			prepareCollection(collection);
 			return collection;
 		} catch (RuntimeException e) {
-			throw potentiallyConvertRuntimeException(e);
+			throw potentiallyConvertRuntimeException(e, exceptionTranslator);
 		}
 	}
 
@@ -1834,11 +1888,11 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 			DbObjectCallback<T> objectCallback, String collectionName) {
 
 		try {
-			T result = objectCallback.doWith(collectionCallback.doInCollection(getAndPrepareCollection(getDb(),
-					collectionName)));
+			T result = objectCallback
+					.doWith(collectionCallback.doInCollection(getAndPrepareCollection(getDb(), collectionName)));
 			return result;
 		} catch (RuntimeException e) {
-			throw potentiallyConvertRuntimeException(e);
+			throw potentiallyConvertRuntimeException(e, exceptionTranslator);
 		}
 	}
 
@@ -1860,8 +1914,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	 * @param collectionName the collection to be queried
 	 * @return
 	 */
-	private <T> List<T> executeFindMultiInternal(CollectionCallback<DBCursor> collectionCallback,
-			CursorPreparer preparer, DbObjectCallback<T> objectCallback, String collectionName) {
+	private <T> List<T> executeFindMultiInternal(CollectionCallback<DBCursor> collectionCallback, CursorPreparer preparer,
+			DbObjectCallback<T> objectCallback, String collectionName) {
 
 		try {
 
@@ -1891,7 +1945,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 				}
 			}
 		} catch (RuntimeException e) {
-			throw potentiallyConvertRuntimeException(e);
+			throw potentiallyConvertRuntimeException(e, exceptionTranslator);
 		}
 	}
 
@@ -1921,7 +1975,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 			}
 
 		} catch (RuntimeException e) {
-			throw potentiallyConvertRuntimeException(e);
+			throw potentiallyConvertRuntimeException(e, exceptionTranslator);
 		}
 	}
 
@@ -1951,8 +2005,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 		MongoPersistentEntity<?> entity = mappingContext.getPersistentEntity(entityClass);
 		if (entity == null) {
-			throw new InvalidDataAccessApiUsageException("No Persitent Entity information found for the class "
-					+ entityClass.getName());
+			throw new InvalidDataAccessApiUsageException(
+					"No Persistent Entity information found for the class " + entityClass.getName());
 		}
 		return entity.getCollection();
 	}
@@ -2000,18 +2054,6 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 		}
 	}
 
-	/**
-	 * Tries to convert the given {@link RuntimeException} into a {@link DataAccessException} but returns the original
-	 * exception if the conversation failed. Thus allows safe rethrowing of the return value.
-	 * 
-	 * @param ex
-	 * @return
-	 */
-	private RuntimeException potentiallyConvertRuntimeException(RuntimeException ex) {
-		RuntimeException resolved = this.exceptionTranslator.translateExceptionIfPossible(ex);
-		return resolved == null ? ex : resolved;
-	}
-
 	/**
 	 * Inspects the given {@link CommandResult} for erros and potentially throws an
 	 * {@link InvalidDataAccessApiUsageException} for that error.
@@ -2028,8 +2070,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 			String error = result.getErrorMessage();
 			error = error == null ? "NO MESSAGE" : error;
 
-			throw new InvalidDataAccessApiUsageException("Command execution failed:  Error [" + error + "], Command = "
-					+ source, ex);
+			throw new InvalidDataAccessApiUsageException(
+					"Command execution failed:  Error [" + error + "], Command = " + source, ex);
 		}
 	}
 
@@ -2050,6 +2092,20 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 		return queryMapper.getMappedSort(query.getSortObject(), mappingContext.getPersistentEntity(type));
 	}
 
+	/**
+	 * Tries to convert the given {@link RuntimeException} into a {@link DataAccessException} but returns the original
+	 * exception if the conversation failed. Thus allows safe re-throwing of the return value.
+	 * 
+	 * @param ex the exception to translate
+	 * @param exceptionTranslator the {@link PersistenceExceptionTranslator} to be used for translation
+	 * @return
+	 */
+	private static RuntimeException potentiallyConvertRuntimeException(RuntimeException ex,
+			PersistenceExceptionTranslator exceptionTranslator) {
+		RuntimeException resolved = exceptionTranslator.translateExceptionIfPossible(ex);
+		return resolved == null ? ex : resolved;
+	}
+
 	// Callback implementations
 
 	/**
@@ -2180,26 +2236,30 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	 * {@link MongoReader}.
 	 * 
 	 * @author Oliver Gierke
+	 * @author Christoph Strobl
 	 */
 	private class ReadDbObjectCallback<T> implements DbObjectCallback<T> {
 
 		private final EntityReader<? super T, DBObject> reader;
 		private final Class<T> type;
+		private final String collectionName;
+
+		public ReadDbObjectCallback(EntityReader<? super T, DBObject> reader, Class<T> type, String collectionName) {
 
-		public ReadDbObjectCallback(EntityReader<? super T, DBObject> reader, Class<T> type) {
 			Assert.notNull(reader);
 			Assert.notNull(type);
 			this.reader = reader;
 			this.type = type;
+			this.collectionName = collectionName;
 		}
 
 		public T doWith(DBObject object) {
 			if (null != object) {
-				maybeEmitEvent(new AfterLoadEvent<T>(object, type));
+				maybeEmitEvent(new AfterLoadEvent<T>(object, type, collectionName));
 			}
 			T source = reader.read(type, object);
 			if (null != source) {
-				maybeEmitEvent(new AfterConvertEvent<T>(object, source));
+				maybeEmitEvent(new AfterConvertEvent<T>(object, source, collectionName));
 			}
 			return source;
 		}
@@ -2207,8 +2267,9 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 	class UnwrapAndReadDbObjectCallback<T> extends ReadDbObjectCallback<T> {
 
-		public UnwrapAndReadDbObjectCallback(EntityReader<? super T, DBObject> reader, Class<T> type) {
-			super(reader, type);
+		public UnwrapAndReadDbObjectCallback(EntityReader<? super T, DBObject> reader, Class<T> type,
+				String collectionName) {
+			super(reader, type, collectionName);
 		}
 
 		@Override
@@ -2234,15 +2295,6 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 		}
 	}
 
-	private enum DefaultWriteConcernResolver implements WriteConcernResolver {
-
-		INSTANCE;
-
-		public WriteConcern resolve(MongoAction action) {
-			return action.getDefaultWriteConcern();
-		}
-	}
-
 	class QueryCursorPreparer implements CursorPreparer {
 
 		private final Query query;
@@ -2292,7 +2344,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 				}
 
 			} catch (RuntimeException e) {
-				throw potentiallyConvertRuntimeException(e);
+				throw potentiallyConvertRuntimeException(e, exceptionTranslator);
 			}
 
 			return cursorToUse;
@@ -2339,20 +2391,20 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	 * @since 1.7
 	 * @author Thomas Darimont
 	 */
-	static class CloseableIterableCusorAdapter<T> implements CloseableIterator<T> {
+	static class CloseableIterableCursorAdapter<T> implements CloseableIterator<T> {
 
 		private volatile Cursor cursor;
 		private PersistenceExceptionTranslator exceptionTranslator;
 		private DbObjectCallback<T> objectReadCallback;
 
 		/**
-		 * Creates a new {@link CloseableIterableCusorAdapter} backed by the given {@link Cursor}.
+		 * Creates a new {@link CloseableIterableCursorAdapter} backed by the given {@link Cursor}.
 		 * 
 		 * @param cursor
 		 * @param exceptionTranslator
 		 * @param objectReadCallback
 		 */
-		public CloseableIterableCusorAdapter(Cursor cursor, PersistenceExceptionTranslator exceptionTranslator,
+		public CloseableIterableCursorAdapter(Cursor cursor, PersistenceExceptionTranslator exceptionTranslator,
 				DbObjectCallback<T> objectReadCallback) {
 
 			this.cursor = cursor;
@@ -2370,7 +2422,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 			try {
 				return cursor.hasNext();
 			} catch (RuntimeException ex) {
-				throw exceptionTranslator.translateExceptionIfPossible(ex);
+				throw potentiallyConvertRuntimeException(ex, exceptionTranslator);
 			}
 		}
 
@@ -2386,7 +2438,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 				T converted = objectReadCallback.doWith(item);
 				return converted;
 			} catch (RuntimeException ex) {
-				throw exceptionTranslator.translateExceptionIfPossible(ex);
+				throw potentiallyConvertRuntimeException(ex, exceptionTranslator);
 			}
 		}
 
@@ -2397,7 +2449,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 			try {
 				c.close();
 			} catch (RuntimeException ex) {
-				throw exceptionTranslator.translateExceptionIfPossible(ex);
+				throw potentiallyConvertRuntimeException(ex, exceptionTranslator);
 			} finally {
 				cursor = null;
 				exceptionTranslator = null;

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/SimpleMongoDbFactory.java

@@ -19,6 +19,7 @@ import java.net.UnknownHostException;
 
 import org.springframework.beans.factory.DisposableBean;
 import org.springframework.dao.DataAccessException;
+import org.springframework.dao.InvalidDataAccessApiUsageException;
 import org.springframework.dao.support.PersistenceExceptionTranslator;
 import org.springframework.data.authentication.UserCredentials;
 import org.springframework.data.mongodb.MongoDbFactory;
@@ -103,8 +104,8 @@ public class SimpleMongoDbFactory implements DisposableBean, MongoDbFactory {
 	 */
 	@Deprecated
 	public SimpleMongoDbFactory(MongoURI uri) throws MongoException, UnknownHostException {
-		this(new Mongo(uri), uri.getDatabase(), new UserCredentials(uri.getUsername(), parseChars(uri.getPassword())),
-				true, uri.getDatabase());
+		this(new Mongo(uri), uri.getDatabase(), new UserCredentials(uri.getUsername(), parseChars(uri.getPassword())), true,
+				uri.getDatabase());
 	}
 
 	/**
@@ -132,6 +133,11 @@ public class SimpleMongoDbFactory implements DisposableBean, MongoDbFactory {
 	private SimpleMongoDbFactory(Mongo mongo, String databaseName, UserCredentials credentials,
 			boolean mongoInstanceCreated, String authenticationDatabaseName) {
 
+		if (mongo instanceof MongoClient && (credentials != null && !UserCredentials.NO_CREDENTIALS.equals(credentials))) {
+			throw new InvalidDataAccessApiUsageException(
+					"Usage of 'UserCredentials' with 'MongoClient' is no longer supported. Please use 'MongoCredential' for 'MongoClient' or just 'Mongo'.");
+		}
+
 		Assert.notNull(mongo, "Mongo must not be null");
 		Assert.hasText(databaseName, "Database name must not be empty");
 		Assert.isTrue(databaseName.matches("[\\w-]+"),

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/aggregation/Aggregation.java

@@ -153,7 +153,7 @@ public class Aggregation {
 	protected Aggregation(List<AggregationOperation> aggregationOperations, AggregationOptions options) {
 
 		Assert.notNull(aggregationOperations, "AggregationOperations must not be null!");
-		Assert.isTrue(aggregationOperations.size() > 0, "At least one AggregationOperation has to be provided");
+		Assert.isTrue(!aggregationOperations.isEmpty(), "At least one AggregationOperation has to be provided");
 		Assert.notNull(options, "AggregationOptions must not be null!");
 
 		this.operations = aggregationOperations;

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/aggregation/AggregationFunctionExpressions.java

@@ -16,6 +16,7 @@
 package org.springframework.data.mongodb.core.aggregation;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
 import org.springframework.util.Assert;
@@ -56,7 +57,7 @@ public enum AggregationFunctionExpressions {
 	static class FunctionExpression implements AggregationExpression {
 
 		private final String name;
-		private final Object[] values;
+		private final List<Object> values;
 
 		/**
 		 * Creates a new {@link FunctionExpression} for the given name and values.
@@ -70,7 +71,7 @@ public enum AggregationFunctionExpressions {
 			Assert.notNull(values, "Values must not be null!");
 
 			this.name = name;
-			this.values = values;
+			this.values = Arrays.asList(values);
 		}
 
 		/*
@@ -80,10 +81,10 @@ public enum AggregationFunctionExpressions {
 		@Override
 		public DBObject toDbObject(AggregationOperationContext context) {
 
-			List<Object> args = new ArrayList<Object>(values.length);
+			List<Object> args = new ArrayList<Object>(values.size());
 
-			for (int i = 0; i < values.length; i++) {
-				args.add(unpack(values[i], context));
+			for (Object value : values) {
+				args.add(unpack(value, context));
 			}
 
 			return new BasicDBObject("$" + name, args);

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/aggregation/ExposedFields.java

@@ -88,7 +88,7 @@ public final class ExposedFields implements Iterable<ExposedField> {
 	}
 
 	/**
-	 * Creates a new {@link ExposedFields} instance for the given fields in either sythetic or non-synthetic way.
+	 * Creates a new {@link ExposedFields} instance for the given fields in either synthetic or non-synthetic way.
 	 * 
 	 * @param fields must not be {@literal null}.
 	 * @param synthetic
@@ -107,7 +107,7 @@ public final class ExposedFields implements Iterable<ExposedField> {
 	}
 
 	/**
-	 * Creates a new {@link ExposedFields} with the given orignals and synthetics.
+	 * Creates a new {@link ExposedFields} with the given originals and synthetics.
 	 * 
 	 * @param originals must not be {@literal null}.
 	 * @param synthetic must not be {@literal null}.
@@ -363,7 +363,7 @@ public final class ExposedFields implements Iterable<ExposedField> {
 		}
 
 		/**
-		 * Returns the referenve value for the given field reference. Will return 1 for a synthetic, unaliased field or the
+		 * Returns the reference value for the given field reference. Will return 1 for a synthetic, unaliased field or the
 		 * raw rendering of the reference otherwise.
 		 * 
 		 * @return

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/aggregation/ProjectionOperation.java

@@ -21,6 +21,7 @@ import java.util.Collections;
 import java.util.List;
 
 import org.springframework.data.mongodb.core.aggregation.ExposedFields.ExposedField;
+import org.springframework.data.mongodb.core.aggregation.Fields.AggregationField;
 import org.springframework.data.mongodb.core.aggregation.ProjectionOperation.ProjectionOperationBuilder.FieldProjection;
 import org.springframework.util.Assert;
 
@@ -40,6 +41,7 @@ import com.mongodb.DBObject;
  * @author Tobias Trelle
  * @author Thomas Darimont
  * @author Oliver Gierke
+ * @author Christoph Strobl
  * @since 1.3
  */
 public class ProjectionOperation implements FieldsExposingAggregationOperation {
@@ -763,6 +765,20 @@ public class ProjectionOperation implements FieldsExposingAggregationOperation {
 				return field;
 			}
 
+			/*
+			 * (non-Javadoc)
+			 * @see org.springframework.data.mongodb.core.aggregation.ProjectionOperation.Projection#getExposedField()
+			 */
+			@Override
+			public ExposedField getExposedField() {
+
+				if (!getField().isAliased()) {
+					return super.getExposedField();
+				}
+
+				return new ExposedField(new AggregationField(getField().getName()), true);
+			}
+
 			/**
 			 * Creates a new instance of this {@link OperationProjection} with the given alias.
 			 * 

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/AbstractMongoConverter.java

@@ -75,15 +75,13 @@ public abstract class AbstractMongoConverter implements MongoConverter, Initiali
 	 */
 	private void initializeConverters() {
 
-		if (!conversionService.canConvert(ObjectId.class, String.class)) {
-			conversionService.addConverter(ObjectIdToStringConverter.INSTANCE);
-		}
-		if (!conversionService.canConvert(String.class, ObjectId.class)) {
-			conversionService.addConverter(StringToObjectIdConverter.INSTANCE);
-		}
+		conversionService.addConverter(ObjectIdToStringConverter.INSTANCE);
+		conversionService.addConverter(StringToObjectIdConverter.INSTANCE);
+
 		if (!conversionService.canConvert(ObjectId.class, BigInteger.class)) {
 			conversionService.addConverter(ObjectIdToBigIntegerConverter.INSTANCE);
 		}
+
 		if (!conversionService.canConvert(BigInteger.class, ObjectId.class)) {
 			conversionService.addConverter(BigIntegerToObjectIdConverter.INSTANCE);
 		}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/CustomConversions.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2015 the original author or authors.
+ * Copyright 2011-2016 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.
@@ -42,16 +42,6 @@ import org.springframework.data.convert.ReadingConverter;
 import org.springframework.data.convert.ThreeTenBackPortConverters;
 import org.springframework.data.convert.WritingConverter;
 import org.springframework.data.mapping.model.SimpleTypeHolder;
-import org.springframework.data.mongodb.core.convert.MongoConverters.BigDecimalToStringConverter;
-import org.springframework.data.mongodb.core.convert.MongoConverters.BigIntegerToStringConverter;
-import org.springframework.data.mongodb.core.convert.MongoConverters.NamedMongoScriptToDBObjectConverter;
-import org.springframework.data.mongodb.core.convert.MongoConverters.DBObjectToNamedMongoScriptCoverter;
-import org.springframework.data.mongodb.core.convert.MongoConverters.DBObjectToStringConverter;
-import org.springframework.data.mongodb.core.convert.MongoConverters.StringToBigDecimalConverter;
-import org.springframework.data.mongodb.core.convert.MongoConverters.StringToBigIntegerConverter;
-import org.springframework.data.mongodb.core.convert.MongoConverters.StringToURLConverter;
-import org.springframework.data.mongodb.core.convert.MongoConverters.TermToStringConverter;
-import org.springframework.data.mongodb.core.convert.MongoConverters.URLToStringConverter;
 import org.springframework.data.mongodb.core.mapping.MongoSimpleTypes;
 import org.springframework.data.util.CacheValue;
 import org.springframework.util.Assert;
@@ -112,17 +102,7 @@ public class CustomConversions {
 		// Add user provided converters to make sure they can override the defaults
 		toRegister.addAll(converters);
 		toRegister.add(CustomToStringConverter.INSTANCE);
-		toRegister.add(BigDecimalToStringConverter.INSTANCE);
-		toRegister.add(StringToBigDecimalConverter.INSTANCE);
-		toRegister.add(BigIntegerToStringConverter.INSTANCE);
-		toRegister.add(StringToBigIntegerConverter.INSTANCE);
-		toRegister.add(URLToStringConverter.INSTANCE);
-		toRegister.add(StringToURLConverter.INSTANCE);
-		toRegister.add(DBObjectToStringConverter.INSTANCE);
-		toRegister.add(TermToStringConverter.INSTANCE);
-		toRegister.add(NamedMongoScriptToDBObjectConverter.INSTANCE);
-		toRegister.add(DBObjectToNamedMongoScriptCoverter.INSTANCE);
-
+		toRegister.addAll(MongoConverters.getConvertersToRegister());
 		toRegister.addAll(JodaTimeConverters.getConvertersToRegister());
 		toRegister.addAll(GeoConverters.getConvertersToRegister());
 		toRegister.addAll(Jsr310Converters.getConvertersToRegister());
@@ -186,14 +166,15 @@ public class CustomConversions {
 			}
 
 			if (!added) {
-				throw new IllegalArgumentException("Given set contains element that is neither Converter nor ConverterFactory!");
+				throw new IllegalArgumentException(
+						"Given set contains element that is neither Converter nor ConverterFactory!");
 			}
 		}
 	}
 
 	/**
-	 * Registers a conversion for the given converter. Inspects either generics or the {@link ConvertiblePair}s returned
-	 * by a {@link GenericConverter}.
+	 * Registers a conversion for the given converter. Inspects either generics of {@link Converter} and
+	 * {@link ConverterFactory} or the {@link ConvertiblePair}s returned by a {@link GenericConverter}.
 	 * 
 	 * @param converter
 	 */
@@ -208,6 +189,10 @@ public class CustomConversions {
 			for (ConvertiblePair pair : genericConverter.getConvertibleTypes()) {
 				register(new ConverterRegistration(pair, isReading, isWriting));
 			}
+		} else if (converter instanceof ConverterFactory) {
+
+			Class<?>[] arguments = GenericTypeResolver.resolveTypeArguments(converter.getClass(), ConverterFactory.class);
+			register(new ConverterRegistration(arguments[0], arguments[1], isReading, isWriting));
 		} else if (converter instanceof Converter) {
 			Class<?>[] arguments = GenericTypeResolver.resolveTypeArguments(converter.getClass(), Converter.class);
 			register(new ConverterRegistration(arguments[0], arguments[1], isReading, isWriting));
@@ -412,6 +397,10 @@ public class CustomConversions {
 
 		INSTANCE;
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.core.convert.converter.GenericConverter#getConvertibleTypes()
+		 */
 		public Set<ConvertiblePair> getConvertibleTypes() {
 
 			ConvertiblePair localeToString = new ConvertiblePair(Locale.class, String.class);
@@ -420,6 +409,10 @@ public class CustomConversions {
 			return new HashSet<ConvertiblePair>(Arrays.asList(localeToString, booleanToString));
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.core.convert.converter.GenericConverter#convert(java.lang.Object, org.springframework.core.convert.TypeDescriptor, org.springframework.core.convert.TypeDescriptor)
+		 */
 		public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
 			return source.toString();
 		}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/DBObjectAccessor.java

@@ -75,9 +75,7 @@ class DBObjectAccessor {
 			String part = parts.next();
 
 			if (parts.hasNext()) {
-				BasicDBObject nestedDbObject = new BasicDBObject();
-				dbObject.put(part, nestedDbObject);
-				dbObject = nestedDbObject;
+				dbObject = getOrCreateNestedDbObject(part, dbObject);
 			} else {
 				dbObject.put(part, value);
 			}
@@ -116,8 +114,14 @@ class DBObjectAccessor {
 		return result;
 	}
 
+	/**
+	 * Returns the given source object as map, i.e. {@link BasicDBObject}s and maps as is or {@literal null} otherwise.
+	 * 
+	 * @param source can be {@literal null}.
+	 * @return
+	 */
 	@SuppressWarnings("unchecked")
-	private Map<String, Object> getAsMap(Object source) {
+	private static Map<String, Object> getAsMap(Object source) {
 
 		if (source instanceof BasicDBObject) {
 			return (BasicDBObject) source;
@@ -129,4 +133,26 @@ class DBObjectAccessor {
 
 		return null;
 	}
+
+	/**
+	 * Returns the {@link DBObject} which either already exists in the given source under the given key, or creates a new
+	 * nested one, registers it with the source and returns it.
+	 * 
+	 * @param key must not be {@literal null} or empty.
+	 * @param source must not be {@literal null}.
+	 * @return
+	 */
+	private static DBObject getOrCreateNestedDbObject(String key, DBObject source) {
+
+		Object existing = source.get(key);
+
+		if (existing instanceof BasicDBObject) {
+			return (BasicDBObject) existing;
+		}
+
+		DBObject nested = new BasicDBObject();
+		source.put(key, nested);
+
+		return nested;
+	}
 }

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/DefaultMongoTypeMapper.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2013 the original author or authors.
+ * Copyright 2011-2016 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.
@@ -45,9 +45,9 @@ import com.mongodb.DBObject;
 public class DefaultMongoTypeMapper extends DefaultTypeMapper<DBObject> implements MongoTypeMapper {
 
 	public static final String DEFAULT_TYPE_KEY = "_class";
-	@SuppressWarnings("rawtypes")//
+	@SuppressWarnings("rawtypes") //
 	private static final TypeInformation<List> LIST_TYPE_INFO = ClassTypeInformation.from(List.class);
-	@SuppressWarnings("rawtypes")//
+	@SuppressWarnings("rawtypes") //
 	private static final TypeInformation<Map> MAP_TYPE_INFO = ClassTypeInformation.from(Map.class);
 
 	private final TypeAliasAccessor<DBObject> accessor;
@@ -58,12 +58,12 @@ public class DefaultMongoTypeMapper extends DefaultTypeMapper<DBObject> implemen
 	}
 
 	public DefaultMongoTypeMapper(String typeKey) {
-		this(typeKey, Arrays.asList(SimpleTypeInformationMapper.INSTANCE));
+		this(typeKey, Arrays.asList(new SimpleTypeInformationMapper()));
 	}
 
 	public DefaultMongoTypeMapper(String typeKey, MappingContext<? extends PersistentEntity<?, ?>, ?> mappingContext) {
-		this(typeKey, new DBObjectTypeAliasAccessor(typeKey), mappingContext, Arrays
-				.asList(SimpleTypeInformationMapper.INSTANCE));
+		this(typeKey, new DBObjectTypeAliasAccessor(typeKey), mappingContext,
+				Arrays.asList(new SimpleTypeInformationMapper()));
 	}
 
 	public DefaultMongoTypeMapper(String typeKey, List<? extends TypeInformationMapper> mappers) {
@@ -71,7 +71,8 @@ public class DefaultMongoTypeMapper extends DefaultTypeMapper<DBObject> implemen
 	}
 
 	private DefaultMongoTypeMapper(String typeKey, TypeAliasAccessor<DBObject> accessor,
-			MappingContext<? extends PersistentEntity<?, ?>, ?> mappingContext, List<? extends TypeInformationMapper> mappers) {
+			MappingContext<? extends PersistentEntity<?, ?>, ?> mappingContext,
+			List<? extends TypeInformationMapper> mappers) {
 
 		super(accessor, mappingContext, mappers);
 

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/GeoConverters.java

@@ -111,9 +111,13 @@ abstract class GeoConverters {
 		@Override
 		public Point convert(DBObject source) {
 
+			if (source == null) {
+				return null;
+			}
+
 			Assert.isTrue(source.keySet().size() == 2, "Source must contain 2 elements");
 
-			return source == null ? null : new Point((Double) source.get("x"), (Double) source.get("y"));
+			return new Point((Double) source.get("x"), (Double) source.get("y"));
 		}
 	}
 

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/MappingMongoConverter.java

@@ -264,7 +264,8 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 			accessor.setProperty(idProperty, idValue);
 		}
 
-		final ObjectPath currentPath = path.push(result, entity, idValue);
+		final ObjectPath currentPath = path.push(result, entity,
+				idValue != null ? dbo.get(idProperty.getFieldName()) : null);
 
 		// Set properties not already set in the constructor
 		entity.doWithProperties(new PropertyHandler<MongoPersistentProperty>() {
@@ -290,7 +291,7 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 				final MongoPersistentProperty property = association.getInverse();
 				Object value = dbo.get(property.getFieldName());
 
-				if (value == null) {
+				if (value == null || entity.isConstructorArgument(property)) {
 					return;
 				}
 
@@ -1197,10 +1198,6 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 
 		Object object = dbref == null ? null : path.getPathItem(dbref.getId(), dbref.getCollectionName());
 
-		if (object != null) {
-			return (T) object;
-		}
-
 		return (T) (object != null ? object : read(type, readRef(dbref), path));
 	}
 

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/MongoConverters.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2015 the original author or authors.
+ * Copyright 2011-2016 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,16 +19,26 @@ import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.net.MalformedURLException;
 import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Currency;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
 
 import org.bson.types.Code;
 import org.bson.types.ObjectId;
 import org.springframework.core.convert.ConversionFailedException;
 import org.springframework.core.convert.TypeDescriptor;
+import org.springframework.core.convert.converter.ConditionalConverter;
 import org.springframework.core.convert.converter.Converter;
+import org.springframework.core.convert.converter.ConverterFactory;
 import org.springframework.data.convert.ReadingConverter;
 import org.springframework.data.convert.WritingConverter;
 import org.springframework.data.mongodb.core.query.Term;
 import org.springframework.data.mongodb.core.script.NamedMongoScript;
+import org.springframework.util.Assert;
+import org.springframework.util.NumberUtils;
 import org.springframework.util.StringUtils;
 
 import com.mongodb.BasicDBObject;
@@ -49,6 +59,33 @@ abstract class MongoConverters {
 	 */
 	private MongoConverters() {}
 
+	/**
+	 * Returns the converters to be registered.
+	 * 
+	 * @return
+	 * @since 1.9
+	 */
+	public static Collection<Object> getConvertersToRegister() {
+
+		List<Object> converters = new ArrayList<Object>();
+
+		converters.add(BigDecimalToStringConverter.INSTANCE);
+		converters.add(StringToBigDecimalConverter.INSTANCE);
+		converters.add(BigIntegerToStringConverter.INSTANCE);
+		converters.add(StringToBigIntegerConverter.INSTANCE);
+		converters.add(URLToStringConverter.INSTANCE);
+		converters.add(StringToURLConverter.INSTANCE);
+		converters.add(DBObjectToStringConverter.INSTANCE);
+		converters.add(TermToStringConverter.INSTANCE);
+		converters.add(NamedMongoScriptToDBObjectConverter.INSTANCE);
+		converters.add(DBObjectToNamedMongoScriptCoverter.INSTANCE);
+		converters.add(CurrencyToStringConverter.INSTANCE);
+		converters.add(StringToCurrencyConverter.INSTANCE);
+		converters.add(NumberToNumberConverterFactory.INSTANCE);
+
+		return converters;
+	}
+
 	/**
 	 * Simple singleton to convert {@link ObjectId}s to their {@link String} representation.
 	 * 
@@ -228,4 +265,113 @@ abstract class MongoConverters {
 			return builder.get();
 		}
 	}
+
+	/**
+	 * {@link Converter} implementation converting {@link Currency} into its ISO 4217 {@link String} representation.
+	 * 
+	 * @author Christoph Strobl
+	 * @since 1.9
+	 */
+	@WritingConverter
+	public static enum CurrencyToStringConverter implements Converter<Currency, String> {
+
+		INSTANCE;
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.core.convert.converter.Converter#convert(java.lang.Object)
+		 */
+		@Override
+		public String convert(Currency source) {
+			return source == null ? null : source.getCurrencyCode();
+		}
+	}
+
+	/**
+	 * {@link Converter} implementation converting ISO 4217 {@link String} into {@link Currency}.
+	 * 
+	 * @author Christoph Strobl
+	 * @since 1.9
+	 */
+	@ReadingConverter
+	public static enum StringToCurrencyConverter implements Converter<String, Currency> {
+
+		INSTANCE;
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.core.convert.converter.Converter#convert(java.lang.Object)
+		 */
+		@Override
+		public Currency convert(String source) {
+			return StringUtils.hasText(source) ? Currency.getInstance(source) : null;
+		}
+	}
+
+	/**
+	 * {@link ConverterFactory} implementation using {@link NumberUtils} for number conversion and parsing. Additionally
+	 * deals with {@link AtomicInteger} and {@link AtomicLong} by calling {@code get()} before performing the actual
+	 * conversion.
+	 * 
+	 * @author Christoph Strobl
+	 * @since 1.9
+	 */
+	@WritingConverter
+	public static enum NumberToNumberConverterFactory implements ConverterFactory<Number, Number>,ConditionalConverter {
+
+		INSTANCE;
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.core.convert.converter.ConverterFactory#getConverter(java.lang.Class)
+		 */
+		@Override
+		public <T extends Number> Converter<Number, T> getConverter(Class<T> targetType) {
+			return new NumberToNumberConverter<T>(targetType);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.core.convert.converter.ConditionalConverter#matches(org.springframework.core.convert.TypeDescriptor, org.springframework.core.convert.TypeDescriptor)
+		 */
+		@Override
+		public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
+			return !sourceType.equals(targetType);
+		}
+
+		private final static class NumberToNumberConverter<T extends Number> implements Converter<Number, T> {
+
+			private final Class<T> targetType;
+
+			/**
+			 * Creates a new {@link NumberToNumberConverter} for the given target type.
+			 * 
+			 * @param targetType must not be {@literal null}.
+			 */
+			public NumberToNumberConverter(Class<T> targetType) {
+				
+				Assert.notNull(targetType, "Target type must not be null!");
+				
+				this.targetType = targetType;
+			}
+
+			/*
+			 * (non-Javadoc)
+			 * @see org.springframework.core.convert.converter.Converter#convert(java.lang.Object)
+			 */
+			@Override
+			public T convert(Number source) {
+
+				if (source instanceof AtomicInteger) {
+					return NumberUtils.convertNumberToTargetClass(((AtomicInteger) source).get(), this.targetType);
+				}
+
+				if (source instanceof AtomicLong) {
+					return NumberUtils.convertNumberToTargetClass(((AtomicLong) source).get(), this.targetType);
+				}
+
+				return NumberUtils.convertNumberToTargetClass(source, this.targetType);
+			}
+		}
+	}
 }

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/QueryMapper.java

@@ -867,7 +867,7 @@ public class QueryMapper {
 		 * @return
 		 */
 		protected Converter<MongoPersistentProperty, String> getPropertyConverter() {
-			return PropertyToFieldNameConverter.INSTANCE;
+			return new PositionParameterRetainingPropertyKeyConverter(name);
 		}
 
 		/**
@@ -881,6 +881,28 @@ public class QueryMapper {
 			return new AssociationConverter(getAssociation());
 		}
 
+		/**
+		 * @author Christoph Strobl
+		 * @since 1.8
+		 */
+		static class PositionParameterRetainingPropertyKeyConverter implements Converter<MongoPersistentProperty, String> {
+
+			private final KeyMapper keyMapper;
+
+			public PositionParameterRetainingPropertyKeyConverter(String rawKey) {
+				this.keyMapper = new KeyMapper(rawKey);
+			}
+
+			/*
+			 * (non-Javadoc)
+			 * @see org.springframework.core.convert.converter.Converter#convert(java.lang.Object)
+			 */
+			@Override
+			public String convert(MongoPersistentProperty source) {
+				return keyMapper.mapPropertyName(source);
+			}
+		}
+
 		/* 
 		 * (non-Javadoc)
 		 * @see org.springframework.data.mongodb.core.convert.QueryMapper.Field#getTypeHint()
@@ -901,6 +923,61 @@ public class QueryMapper {
 
 			return NESTED_DOCUMENT;
 		}
+
+		/**
+		 * @author Christoph Strobl
+		 * @since 1.8
+		 */
+		static class KeyMapper {
+
+			private final Iterator<String> iterator;
+
+			public KeyMapper(String key) {
+
+				this.iterator = Arrays.asList(key.split("\\.")).iterator();
+				this.iterator.next();
+			}
+
+			/**
+			 * Maps the property name while retaining potential positional operator {@literal $}.
+			 * 
+			 * @param property
+			 * @return
+			 */
+			protected String mapPropertyName(MongoPersistentProperty property) {
+
+				StringBuilder mappedName = new StringBuilder(PropertyToFieldNameConverter.INSTANCE.convert(property));
+				boolean inspect = iterator.hasNext();
+
+				while (inspect) {
+
+					String partial = iterator.next();
+					boolean isPositional = (isPositionalParameter(partial) && (property.isMap() || property.isCollectionLike()));
+
+					if (isPositional) {
+						mappedName.append(".").append(partial);
+					}
+
+					inspect = isPositional && iterator.hasNext();
+				}
+
+				return mappedName.toString();
+			}
+
+			private static boolean isPositionalParameter(String partial) {
+
+				if ("$".equals(partial)) {
+					return true;
+				}
+
+				try {
+					Long.valueOf(partial);
+					return true;
+				} catch (NumberFormatException e) {
+					return false;
+				}
+			}
+		}
 	}
 
 	/**

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/UpdateMapper.java

@@ -15,8 +15,6 @@
  */
 package org.springframework.data.mongodb.core.convert;
 
-import java.util.Arrays;
-import java.util.Iterator;
 import java.util.Map.Entry;
 
 import org.springframework.core.convert.converter.Converter;
@@ -24,13 +22,11 @@ import org.springframework.data.mapping.Association;
 import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
-import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty.PropertyToFieldNameConverter;
 import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.data.mongodb.core.query.Update.Modifier;
 import org.springframework.data.mongodb.core.query.Update.Modifiers;
 import org.springframework.data.util.ClassTypeInformation;
 import org.springframework.data.util.TypeInformation;
-import org.springframework.util.Assert;
 
 import com.mongodb.BasicDBObject;
 import com.mongodb.DBObject;
@@ -66,8 +62,8 @@ public class UpdateMapper extends QueryMapper {
 	 */
 	@Override
 	protected Object delegateConvertToMongoType(Object source, MongoPersistentEntity<?> entity) {
-		return entity == null ? super.delegateConvertToMongoType(source, null)
-				: converter.convertToMongoType(source, getTypeHintForEntity(entity));
+		return converter.convertToMongoType(source,
+				entity == null ? ClassTypeInformation.OBJECT : getTypeHintForEntity(source, entity));
 	}
 
 	/*
@@ -90,7 +86,7 @@ public class UpdateMapper extends QueryMapper {
 			return getMappedUpdateModifier(field, rawValue);
 		}
 
-		return super.getMappedObjectForField(field, getMappedValue(field, rawValue));
+		return super.getMappedObjectForField(field, rawValue);
 	}
 
 	private Entry<String, Object> getMappedUpdateModifier(Field field, Object rawValue) {
@@ -141,18 +137,20 @@ public class UpdateMapper extends QueryMapper {
 		return new BasicDBObject(modifier.getKey(), value);
 	}
 
-	private TypeInformation<?> getTypeHintForEntity(MongoPersistentEntity<?> entity) {
-		return processTypeHintForNestedDocuments(entity.getTypeInformation());
-	}
-
-	private TypeInformation<?> processTypeHintForNestedDocuments(TypeInformation<?> info) {
+	private TypeInformation<?> getTypeHintForEntity(Object source, MongoPersistentEntity<?> entity) {
 
+		TypeInformation<?> info = entity.getTypeInformation();
 		Class<?> type = info.getActualType().getType();
-		if (type.isInterface() || java.lang.reflect.Modifier.isAbstract(type.getModifiers())) {
+
+		if (source == null || type.isInterface() || java.lang.reflect.Modifier.isAbstract(type.getModifiers())) {
 			return info;
 		}
-		return NESTED_DOCUMENT;
 
+		if (!type.equals(source.getClass())) {
+			return info;
+		}
+
+		return NESTED_DOCUMENT;
 	}
 
 	/* 
@@ -211,7 +209,7 @@ public class UpdateMapper extends QueryMapper {
 		 */
 		@Override
 		protected Converter<MongoPersistentProperty, String> getPropertyConverter() {
-			return new UpdatePropertyConverter(key);
+			return new PositionParameterRetainingPropertyKeyConverter(key);
 		}
 
 		/*
@@ -223,99 +221,6 @@ public class UpdateMapper extends QueryMapper {
 			return new UpdateAssociationConverter(getAssociation(), key);
 		}
 
-		/**
-		 * Special mapper handling positional parameter {@literal $} within property names.
-		 * 
-		 * @author Christoph Strobl
-		 * @since 1.7
-		 */
-		private static class UpdateKeyMapper {
-
-			private final Iterator<String> iterator;
-
-			protected UpdateKeyMapper(String rawKey) {
-
-				Assert.hasText(rawKey, "Key must not be null or empty!");
-
-				this.iterator = Arrays.asList(rawKey.split("\\.")).iterator();
-				this.iterator.next();
-			}
-
-			/**
-			 * Maps the property name while retaining potential positional operator {@literal $}.
-			 * 
-			 * @param property
-			 * @return
-			 */
-			protected String mapPropertyName(MongoPersistentProperty property) {
-
-				String mappedName = PropertyToFieldNameConverter.INSTANCE.convert(property);
-
-				boolean inspect = iterator.hasNext();
-				while (inspect) {
-
-					String partial = iterator.next();
-
-					boolean isPositional = isPositionalParameter(partial);
-					if (isPositional) {
-						mappedName += "." + partial;
-					}
-
-					inspect = isPositional && iterator.hasNext();
-				}
-
-				return mappedName;
-			}
-
-			boolean isPositionalParameter(String partial) {
-
-				if (partial.equals("$")) {
-					return true;
-				}
-
-				try {
-					Long.valueOf(partial);
-					return true;
-				} catch (NumberFormatException e) {
-					return false;
-				}
-			}
-
-		}
-
-		/**
-		 * Special {@link Converter} for {@link MongoPersistentProperty} instances that will concatenate the {@literal $}
-		 * contained in the source update key.
-		 * 
-		 * @author Oliver Gierke
-		 * @author Christoph Strobl
-		 */
-		private static class UpdatePropertyConverter implements Converter<MongoPersistentProperty, String> {
-
-			private final UpdateKeyMapper mapper;
-
-			/**
-			 * Creates a new {@link UpdatePropertyConverter} with the given update key.
-			 * 
-			 * @param updateKey must not be {@literal null} or empty.
-			 */
-			public UpdatePropertyConverter(String updateKey) {
-
-				Assert.hasText(updateKey, "Update key must not be null or empty!");
-
-				this.mapper = new UpdateKeyMapper(updateKey);
-			}
-
-			/* 
-			 * (non-Javadoc)
-			 * @see org.springframework.core.convert.converter.Converter#convert(java.lang.Object)
-			 */
-			@Override
-			public String convert(MongoPersistentProperty property) {
-				return mapper.mapPropertyName(property);
-			}
-		}
-
 		/**
 		 * {@link Converter} retaining positional parameter {@literal $} for {@link Association}s.
 		 * 
@@ -323,7 +228,7 @@ public class UpdateMapper extends QueryMapper {
 		 */
 		protected static class UpdateAssociationConverter extends AssociationConverter {
 
-			private final UpdateKeyMapper mapper;
+			private final KeyMapper mapper;
 
 			/**
 			 * Creates a new {@link AssociationConverter} for the given {@link Association}.
@@ -333,7 +238,7 @@ public class UpdateMapper extends QueryMapper {
 			public UpdateAssociationConverter(Association<MongoPersistentProperty> association, String key) {
 
 				super(association);
-				this.mapper = new UpdateKeyMapper(key);
+				this.mapper = new KeyMapper(key);
 			}
 
 			/* 

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/index/Index.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2014 the original author or authors.
+ * Copyright 2010-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.
@@ -17,6 +17,7 @@ package org.springframework.data.mongodb.core.index;
 
 import java.util.LinkedHashMap;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.concurrent.TimeUnit;
 
 import org.springframework.data.domain.Sort.Direction;
@@ -44,7 +45,7 @@ public class Index implements IndexDefinition {
 		 * 
 		 * @deprecated since 1.7.
 		 */
-		@Deprecated//
+		@Deprecated //
 		DROP
 	}
 
@@ -175,11 +176,18 @@ public class Index implements IndexDefinition {
 		return unique();
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.index.IndexDefinition#getIndexKeys()
+	 */
 	public DBObject getIndexKeys() {
+
 		DBObject dbo = new BasicDBObject();
-		for (String k : fieldSpec.keySet()) {
-			dbo.put(k, fieldSpec.get(k).equals(Direction.ASC) ? 1 : -1);
+
+		for (Entry<String, Direction> entry : fieldSpec.entrySet()) {
+			dbo.put(entry.getKey(), Direction.ASC.equals(entry.getValue()) ? 1 : -1);
 		}
+
 		return dbo;
 	}
 

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/index/Indexed.java

@@ -29,8 +29,9 @@ import java.lang.annotation.Target;
  * @author Johno Crawford
  * @author Thomas Darimont
  * @author Christoph Strobl
+ * @author Jordi Llach
  */
-@Target(ElementType.FIELD)
+@Target({ElementType.ANNOTATION_TYPE, ElementType.FIELD})
 @Retention(RetentionPolicy.RUNTIME)
 public @interface Indexed {
 

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/index/MongoPersistentEntityIndexCreator.java

@@ -21,6 +21,7 @@ import java.util.concurrent.ConcurrentHashMap;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.context.ApplicationListener;
+import org.springframework.dao.DataIntegrityViolationException;
 import org.springframework.data.mapping.PersistentEntity;
 import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.data.mapping.context.MappingContextEvent;
@@ -29,7 +30,12 @@ import org.springframework.data.mongodb.core.index.MongoPersistentEntityIndexRes
 import org.springframework.data.mongodb.core.mapping.Document;
 import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
+import org.springframework.data.mongodb.util.MongoDbErrorCodes;
 import org.springframework.util.Assert;
+import org.springframework.util.ObjectUtils;
+
+import com.mongodb.DBObject;
+import com.mongodb.MongoException;
 
 /**
  * Component that inspects {@link MongoPersistentEntity} instances contained in the given {@link MongoMappingContext}
@@ -129,9 +135,34 @@ public class MongoPersistentEntityIndexCreator implements ApplicationListener<Ma
 		}
 	}
 
-	private void createIndex(IndexDefinitionHolder indexDefinition) {
-		mongoDbFactory.getDb().getCollection(indexDefinition.getCollection()).createIndex(indexDefinition.getIndexKeys(),
-				indexDefinition.getIndexOptions());
+	void createIndex(IndexDefinitionHolder indexDefinition) {
+
+		try {
+
+			mongoDbFactory.getDb().getCollection(indexDefinition.getCollection()).createIndex(indexDefinition.getIndexKeys(),
+					indexDefinition.getIndexOptions());
+
+		} catch (MongoException ex) {
+
+			if (MongoDbErrorCodes.isDataIntegrityViolationCode(ex.getCode())) {
+
+				DBObject existingIndex = fetchIndexInformation(indexDefinition);
+				String message = "Cannot create index for '%s' in collection '%s' with keys '%s' and options '%s'.";
+
+				if (existingIndex != null) {
+					message += " Index already defined as '%s'.";
+				}
+
+				throw new DataIntegrityViolationException(
+						String.format(message, indexDefinition.getPath(), indexDefinition.getCollection(),
+								indexDefinition.getIndexKeys(), indexDefinition.getIndexOptions(), existingIndex),
+						ex);
+			}
+
+			RuntimeException exceptionToThrow = mongoDbFactory.getExceptionTranslator().translateExceptionIfPossible(ex);
+
+			throw exceptionToThrow != null ? exceptionToThrow : ex;
+		}
 	}
 
 	/**
@@ -143,4 +174,28 @@ public class MongoPersistentEntityIndexCreator implements ApplicationListener<Ma
 	public boolean isIndexCreatorFor(MappingContext<?, ?> context) {
 		return this.mappingContext.equals(context);
 	}
+
+	private DBObject fetchIndexInformation(IndexDefinitionHolder indexDefinition) {
+
+		if (indexDefinition == null) {
+			return null;
+		}
+
+		try {
+
+			Object indexNameToLookUp = indexDefinition.getIndexOptions().get("name");
+
+			for (DBObject index : mongoDbFactory.getDb().getCollection(indexDefinition.getCollection()).getIndexInfo()) {
+				if (ObjectUtils.nullSafeEquals(indexNameToLookUp, index.get("name"))) {
+					return index;
+				}
+			}
+
+		} catch (Exception e) {
+			LOGGER.debug(
+					String.format("Failed to load index information for collection '%s'.", indexDefinition.getCollection()), e);
+		}
+
+		return null;
+	}
 }

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/index/MongoPersistentEntityIndexResolver.java

@@ -27,7 +27,10 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.dao.InvalidDataAccessApiUsageException;
 import org.springframework.data.domain.Sort;
+import org.springframework.data.mapping.Association;
+import org.springframework.data.mapping.AssociationHandler;
 import org.springframework.data.mapping.PropertyHandler;
+import org.springframework.data.mapping.model.MappingException;
 import org.springframework.data.mongodb.core.index.Index.Duplicates;
 import org.springframework.data.mongodb.core.index.MongoPersistentEntityIndexResolver.TextIndexIncludeOptions.IncludeStrategy;
 import org.springframework.data.mongodb.core.index.TextIndexDefinition.TextIndexDefinitionBuilder;
@@ -108,7 +111,7 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver {
 
 				try {
 					if (persistentProperty.isEntity()) {
-						indexInformation.addAll(resolveIndexForClass(persistentProperty.getActualType(),
+						indexInformation.addAll(resolveIndexForClass(persistentProperty.getTypeInformation().getActualType(),
 								persistentProperty.getFieldName(), root.getCollection(), guard));
 					}
 
@@ -123,6 +126,8 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver {
 			}
 		});
 
+		indexInformation.addAll(resolveIndexesForDbrefs("", root.getCollection(), root));
+
 		return indexInformation;
 	}
 
@@ -135,7 +140,7 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver {
 	 * @return List of {@link IndexDefinitionHolder} representing indexes for given type and its referenced property
 	 *         types. Will never be {@code null}.
 	 */
-	private List<IndexDefinitionHolder> resolveIndexForClass(final Class<?> type, final String path,
+	private List<IndexDefinitionHolder> resolveIndexForClass(final TypeInformation<?> type, final String path,
 			final String collection, final CycleGuard guard) {
 
 		MongoPersistentEntity<?> entity = mappingContext.getPersistentEntity(type);
@@ -153,8 +158,8 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver {
 
 				if (persistentProperty.isEntity()) {
 					try {
-						indexInformation.addAll(resolveIndexForClass(persistentProperty.getActualType(), propertyDotPath,
-								collection, guard));
+						indexInformation.addAll(resolveIndexForClass(persistentProperty.getTypeInformation().getActualType(),
+								propertyDotPath, collection, guard));
 					} catch (CyclicPropertyReferenceException e) {
 						LOGGER.info(e.getMessage());
 					}
@@ -168,6 +173,8 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver {
 			}
 		});
 
+		indexInformation.addAll(resolveIndexesForDbrefs(path, collection, entity));
+
 		return indexInformation;
 	}
 
@@ -193,18 +200,19 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver {
 		return createCompoundIndexDefinitions(dotPath, collection, entity);
 	}
 
-	private Collection<? extends IndexDefinitionHolder> potentiallyCreateTextIndexDefinition(MongoPersistentEntity<?> root) {
+	private Collection<? extends IndexDefinitionHolder> potentiallyCreateTextIndexDefinition(
+			MongoPersistentEntity<?> root) {
 
-		TextIndexDefinitionBuilder indexDefinitionBuilder = new TextIndexDefinitionBuilder().named(root.getType()
-				.getSimpleName() + "_TextIndex");
+		TextIndexDefinitionBuilder indexDefinitionBuilder = new TextIndexDefinitionBuilder()
+				.named(root.getType().getSimpleName() + "_TextIndex");
 
 		if (StringUtils.hasText(root.getLanguage())) {
 			indexDefinitionBuilder.withDefaultLanguage(root.getLanguage());
 		}
 
 		try {
-			appendTextIndexInformation("", indexDefinitionBuilder, root,
-					new TextIndexIncludeOptions(IncludeStrategy.DEFAULT), new CycleGuard());
+			appendTextIndexInformation("", indexDefinitionBuilder, root, new TextIndexIncludeOptions(IncludeStrategy.DEFAULT),
+					new CycleGuard());
 		} catch (CyclicPropertyReferenceException e) {
 			LOGGER.info(e.getMessage());
 		}
@@ -220,9 +228,8 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver {
 
 	}
 
-	private void appendTextIndexInformation(final String dotPath,
-			final TextIndexDefinitionBuilder indexDefinitionBuilder, final MongoPersistentEntity<?> entity,
-			final TextIndexIncludeOptions includeOptions, final CycleGuard guard) {
+	private void appendTextIndexInformation(final String dotPath, final TextIndexDefinitionBuilder indexDefinitionBuilder,
+			final MongoPersistentEntity<?> entity, final TextIndexIncludeOptions includeOptions, final CycleGuard guard) {
 
 		entity.doWithProperties(new PropertyHandler<MongoPersistentProperty>() {
 
@@ -249,8 +256,8 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver {
 
 						TextIndexIncludeOptions optionsForNestedType = includeOptions;
 						if (!IncludeStrategy.FORCE.equals(includeOptions.getStrategy()) && indexed != null) {
-							optionsForNestedType = new TextIndexIncludeOptions(IncludeStrategy.FORCE, new TextIndexedFieldSpec(
-									propertyDotPath, weight));
+							optionsForNestedType = new TextIndexIncludeOptions(IncludeStrategy.FORCE,
+									new TextIndexedFieldSpec(propertyDotPath, weight));
 						}
 
 						try {
@@ -259,9 +266,8 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver {
 						} catch (CyclicPropertyReferenceException e) {
 							LOGGER.info(e.getMessage(), e);
 						} catch (InvalidDataAccessApiUsageException e) {
-							LOGGER.info(
-									String.format("Potentially invald index structure discovered. Breaking operation for %s.",
-											entity.getName()), e);
+							LOGGER.info(String.format("Potentially invalid index structure discovered. Breaking operation for %s.",
+									entity.getName()), e);
 						}
 					} else if (includeOptions.isForce() || indexed != null) {
 						indexDefinitionBuilder.onField(propertyDotPath, weight);
@@ -306,8 +312,8 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver {
 	protected IndexDefinitionHolder createCompoundIndexDefinition(String dotPath, String fallbackCollection,
 			CompoundIndex index, MongoPersistentEntity<?> entity) {
 
-		CompoundIndexDefinition indexDefinition = new CompoundIndexDefinition(resolveCompoundIndexKeyFromStringDefinition(
-				dotPath, index.def()));
+		CompoundIndexDefinition indexDefinition = new CompoundIndexDefinition(
+				resolveCompoundIndexKeyFromStringDefinition(dotPath, index.def()));
 
 		if (!index.useGeneratedName()) {
 			indexDefinition.named(pathAwareIndexName(index.name(), dotPath, null));
@@ -431,13 +437,45 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver {
 
 		if (StringUtils.hasText(dotPath)) {
 
-			nameToUse = StringUtils.hasText(nameToUse) ? (property != null ? dotPath.replace("." + property.getFieldName(),
-					"") : dotPath) + "." + nameToUse : dotPath;
+			nameToUse = StringUtils.hasText(nameToUse)
+					? (property != null ? dotPath.replace("." + property.getFieldName(), "") : dotPath) + "." + nameToUse
+					: dotPath;
 		}
 		return nameToUse;
 
 	}
 
+	private List<IndexDefinitionHolder> resolveIndexesForDbrefs(final String path, final String collection,
+			MongoPersistentEntity<?> entity) {
+
+		final List<IndexDefinitionHolder> indexes = new ArrayList<IndexDefinitionHolder>(0);
+		entity.doWithAssociations(new AssociationHandler<MongoPersistentProperty>() {
+
+			@Override
+			public void doWithAssociation(Association<MongoPersistentProperty> association) {
+
+				MongoPersistentProperty property = association.getInverse();
+
+				String propertyDotPath = (StringUtils.hasText(path) ? path + "." : "") + property.getFieldName();
+
+				if (property.isAnnotationPresent(GeoSpatialIndexed.class) || property.isAnnotationPresent(TextIndexed.class)) {
+					throw new MappingException(
+							String.format("Cannot create geospatial-/text- index on DBRef in collection '%s' for path '%s'.",
+									collection, propertyDotPath));
+				}
+
+				IndexDefinitionHolder indexDefinitionHolder = createIndexDefinitionHolderForProperty(propertyDotPath,
+						collection, property);
+
+				if (indexDefinitionHolder != null) {
+					indexes.add(indexDefinitionHolder);
+				}
+			}
+		});
+
+		return indexes;
+	}
+
 	/**
 	 * {@link CycleGuard} holds information about properties and the paths for accessing those. This information is used
 	 * to detect potential cycles within the references.

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/mapping/BasicMongoPersistentEntity.java

@@ -16,6 +16,7 @@
 package org.springframework.data.mongodb.core.mapping;
 
 import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Map;
@@ -25,6 +26,7 @@ import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
 import org.springframework.context.expression.BeanFactoryAccessor;
 import org.springframework.context.expression.BeanFactoryResolver;
+import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.mapping.Association;
 import org.springframework.data.mapping.AssociationHandler;
@@ -76,7 +78,7 @@ public class BasicMongoPersistentEntity<T> extends BasicPersistentEntity<T, Mong
 		Class<?> rawType = typeInformation.getType();
 		String fallback = MongoCollectionUtils.getPreferredCollectionName(rawType);
 
-		Document document = rawType.getAnnotation(Document.class);
+		Document document = AnnotationUtils.findAnnotation(rawType, Document.class);
 
 		this.expression = detectExpression(document);
 		this.context = new StandardEvaluationContext();
@@ -305,28 +307,44 @@ public class BasicMongoPersistentEntity<T> extends BasicPersistentEntity<T, Mong
 	 */
 	private static class PropertyTypeAssertionHandler implements PropertyHandler<MongoPersistentProperty> {
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mapping.PropertyHandler#doWithPersistentProperty(org.springframework.data.mapping.PersistentProperty)
+		 */
 		@Override
 		public void doWithPersistentProperty(MongoPersistentProperty persistentProperty) {
 
 			potentiallyAssertTextScoreType(persistentProperty);
 			potentiallyAssertLanguageType(persistentProperty);
+			potentiallyAssertDBRefTargetType(persistentProperty);
 		}
 
-		private void potentiallyAssertLanguageType(MongoPersistentProperty persistentProperty) {
+		private static void potentiallyAssertLanguageType(MongoPersistentProperty persistentProperty) {
 
 			if (persistentProperty.isExplicitLanguageProperty()) {
 				assertPropertyType(persistentProperty, String.class);
 			}
 		}
 
-		private void potentiallyAssertTextScoreType(MongoPersistentProperty persistentProperty) {
+		private static void potentiallyAssertTextScoreType(MongoPersistentProperty persistentProperty) {
 
 			if (persistentProperty.isTextScoreProperty()) {
 				assertPropertyType(persistentProperty, Float.class, Double.class);
 			}
 		}
 
-		private void assertPropertyType(MongoPersistentProperty persistentProperty, Class<?>... validMatches) {
+		private static void potentiallyAssertDBRefTargetType(MongoPersistentProperty persistentProperty) {
+
+			if (persistentProperty.isDbReference() && persistentProperty.getDBRef().lazy()) {
+				if (persistentProperty.isArray() || Modifier.isFinal(persistentProperty.getActualType().getModifiers())) {
+					throw new MappingException(String.format(
+							"Invalid lazy DBRef property for %s. Found %s which must not be an array nor a final class.",
+							persistentProperty.getField(), persistentProperty.getActualType()));
+				}
+			}
+		}
+
+		private static void assertPropertyType(MongoPersistentProperty persistentProperty, Class<?>... validMatches) {
 
 			for (Class<?> potentialMatch : validMatches) {
 				if (ClassUtils.isAssignable(potentialMatch, persistentProperty.getActualType())) {
@@ -334,10 +352,9 @@ public class BasicMongoPersistentEntity<T> extends BasicPersistentEntity<T, Mong
 				}
 			}
 
-			throw new MappingException(String.format("Missmatching types for %s. Found %s expected one of %s.",
-					persistentProperty.getField(), persistentProperty.getActualType(),
-					StringUtils.arrayToCommaDelimitedString(validMatches)));
+			throw new MappingException(
+					String.format("Missmatching types for %s. Found %s expected one of %s.", persistentProperty.getField(),
+							persistentProperty.getActualType(), StringUtils.arrayToCommaDelimitedString(validMatches)));
 		}
 	}
-
 }

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/mapping/MongoPersistentProperty.java

@@ -45,7 +45,7 @@ public interface MongoPersistentProperty extends PersistentProperty<MongoPersist
 	int getFieldOrder();
 
 	/**
-	 * Returns whether the propert is a {@link com.mongodb.DBRef}. If this returns {@literal true} you can expect
+	 * Returns whether the property is a {@link com.mongodb.DBRef}. If this returns {@literal true} you can expect
 	 * {@link #getDBRef()} to return an non-{@literal null} value.
 	 * 
 	 * @return

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/mapping/event/AbstractDeleteEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013 by the original author(s).
+ * Copyright 2013-2015 by the original author(s).
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,6 +21,7 @@ import com.mongodb.DBObject;
  * Base class for delete events.
  * 
  * @author Martin Baumgartner
+ * @author Christoph Strobl
  */
 public abstract class AbstractDeleteEvent<T> extends MongoMappingEvent<DBObject> {
 
@@ -31,11 +32,25 @@ public abstract class AbstractDeleteEvent<T> extends MongoMappingEvent<DBObject>
 	 * Creates a new {@link AbstractDeleteEvent} for the given {@link DBObject} and type.
 	 * 
 	 * @param dbo must not be {@literal null}.
-	 * @param type , possibly be {@literal null}.
+	 * @param type can be {@literal null}.
+	 * @deprecated since 1.8. Please use {@link #AbstractDeleteEvent(DBObject, Class, String)}.
 	 */
+	@Deprecated
 	public AbstractDeleteEvent(DBObject dbo, Class<T> type) {
+		this(dbo, type, null);
+	}
 
-		super(dbo, dbo);
+	/**
+	 * Creates a new {@link AbstractDeleteEvent} for the given {@link DBObject} and type.
+	 * 
+	 * @param dbo must not be {@literal null}.
+	 * @param type can be {@literal null}.
+	 * @param collectionName can be {@literal null}.
+	 * @since 1.8
+	 */
+	public AbstractDeleteEvent(DBObject dbo, Class<T> type, String collectionName) {
+
+		super(dbo, dbo, collectionName);
 		this.type = type;
 	}
 

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/mapping/event/AbstractMongoEventListener.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2013 by the original author(s).
+ * Copyright 2011-2015 by the original author(s).
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -28,6 +28,7 @@ import com.mongodb.DBObject;
  * @author Jon Brisbin
  * @author Oliver Gierke
  * @author Martin Baumgartner
+ * @author Christoph Strobl
  */
 public abstract class AbstractMongoEventListener<E> implements ApplicationListener<MongoMappingEvent<?>> {
 
@@ -46,14 +47,14 @@ public abstract class AbstractMongoEventListener<E> implements ApplicationListen
 	 * (non-Javadoc)
 	 * @see org.springframework.context.ApplicationListener#onApplicationEvent(org.springframework.context.ApplicationEvent)
 	 */
-	@SuppressWarnings("rawtypes")
+	@SuppressWarnings({ "rawtypes", "unchecked" })
 	public void onApplicationEvent(MongoMappingEvent<?> event) {
 
 		if (event instanceof AfterLoadEvent) {
 			AfterLoadEvent<?> afterLoadEvent = (AfterLoadEvent<?>) event;
 
 			if (domainClass.isAssignableFrom(afterLoadEvent.getType())) {
-				onAfterLoad(event.getDBObject());
+				onAfterLoad((AfterLoadEvent<E>) event);
 			}
 
 			return;
@@ -65,18 +66,18 @@ public abstract class AbstractMongoEventListener<E> implements ApplicationListen
 
 			if (eventDomainType != null && domainClass.isAssignableFrom(eventDomainType)) {
 				if (event instanceof BeforeDeleteEvent) {
-					onBeforeDelete(event.getDBObject());
+					onBeforeDelete((BeforeDeleteEvent<E>) event);
 				}
 				if (event instanceof AfterDeleteEvent) {
-					onAfterDelete(event.getDBObject());
+					onAfterDelete((AfterDeleteEvent<E>) event);
 				}
 			}
 
 			return;
+
 		}
 
-		@SuppressWarnings("unchecked")
-		E source = (E) event.getSource();
+		Object source = event.getSource();
 
 		// Check for matching domain type and invoke callbacks
 		if (source != null && !domainClass.isAssignableFrom(source.getClass())) {
@@ -84,55 +85,185 @@ public abstract class AbstractMongoEventListener<E> implements ApplicationListen
 		}
 
 		if (event instanceof BeforeConvertEvent) {
-			onBeforeConvert(source);
+			onBeforeConvert((BeforeConvertEvent<E>) event);
 		} else if (event instanceof BeforeSaveEvent) {
-			onBeforeSave(source, event.getDBObject());
+			onBeforeSave((BeforeSaveEvent<E>) event);
 		} else if (event instanceof AfterSaveEvent) {
-			onAfterSave(source, event.getDBObject());
+			onAfterSave((AfterSaveEvent<E>) event);
 		} else if (event instanceof AfterConvertEvent) {
-			onAfterConvert(event.getDBObject(), source);
+			onAfterConvert((AfterConvertEvent<E>) event);
 		}
 	}
 
+	/**
+	 * Captures source element before conversion.
+	 * 
+	 * @param source will never be {@literal null}.
+	 * @deprecated since 1.8. Please use {@link #onBeforeConvert(BeforeConvertEvent)}.
+	 */
+	@Deprecated
 	public void onBeforeConvert(E source) {
+
 		if (LOG.isDebugEnabled()) {
 			LOG.debug("onBeforeConvert({})", source);
 		}
 	}
 
+	/**
+	 * Captures {@link BeforeConvertEvent}.
+	 * 
+	 * @param event never {@literal null}.
+	 * @since 1.8
+	 */
+	public void onBeforeConvert(BeforeConvertEvent<E> event) {
+		onBeforeConvert(event.getSource());
+	}
+
+	/**
+	 * Captures source element and {@link com.mongodb.DBObject} representation before save.
+	 * 
+	 * @param source will never be {@literal null}.
+	 * @param dbo can be {@literal null}.
+	 * @deprecated since 1.8. Please use {@link #onBeforeSave(BeforeSaveEvent)}.
+	 */
+	@Deprecated
 	public void onBeforeSave(E source, DBObject dbo) {
+
 		if (LOG.isDebugEnabled()) {
 			LOG.debug("onBeforeSave({}, {})", source, dbo);
 		}
 	}
 
+	/**
+	 * Captures {@link BeforeSaveEvent}.
+	 * 
+	 * @param event will never be {@literal null}.
+	 * @since 1.8
+	 */
+	public void onBeforeSave(BeforeSaveEvent<E> event) {
+		onBeforeSave(event.getSource(), event.getDBObject());
+	}
+
+	/**
+	 * Captures source element and {@link com.mongodb.DBObject} representation after save.
+	 * 
+	 * @param source will never be {@literal null}.
+	 * @param dbo can be {@literal null}.
+	 * @deprecated since 1.8. Please use {@link #onAfterSave(AfterSaveEvent)}.
+	 */
+	@Deprecated
 	public void onAfterSave(E source, DBObject dbo) {
+
 		if (LOG.isDebugEnabled()) {
 			LOG.debug("onAfterSave({}, {})", source, dbo);
 		}
 	}
 
+	/**
+	 * Captures {@link AfterSaveEvent}.
+	 * 
+	 * @param event will never be {@literal null}.
+	 * @since 1.8
+	 */
+	public void onAfterSave(AfterSaveEvent<E> event) {
+		onAfterSave(event.getSource(), event.getDBObject());
+	}
+
+	/**
+	 * Captures raw {@link com.mongodb.DBObject} when read from MongoDB.
+	 * 
+	 * @param dbo can be {@literal null}.
+	 * @deprecated since 1.8. Please use {@link #onAfterLoad(AfterLoadEvent)}.
+	 */
+	@Deprecated
 	public void onAfterLoad(DBObject dbo) {
+
 		if (LOG.isDebugEnabled()) {
 			LOG.debug("onAfterLoad({})", dbo);
 		}
 	}
 
+	/**
+	 * Captures {@link AfterLoadEvent}.
+	 * 
+	 * @param event will never be {@literal null}.
+	 * @since 1.8
+	 */
+	public void onAfterLoad(AfterLoadEvent<E> event) {
+		onAfterLoad(event.getDBObject());
+	}
+
+	/**
+	 * Captures raw {@link com.mongodb.DBObject} and converted domain type after conversion.
+	 * 
+	 * @param dbo can be {@literal null}.
+	 * @param source will never be {@literal null}.
+	 * @deprecated since 1.8. Please use {@link #onAfterConvert(AfterConvertEvent)}.
+	 */
+	@Deprecated
 	public void onAfterConvert(DBObject dbo, E source) {
+
 		if (LOG.isDebugEnabled()) {
 			LOG.debug("onAfterConvert({}, {})", dbo, source);
 		}
 	}
 
+	/**
+	 * Captures {@link AfterConvertEvent}.
+	 * 
+	 * @param event will never be {@literal null}.
+	 * @since 1.8
+	 */
+	public void onAfterConvert(AfterConvertEvent<E> event) {
+		onAfterConvert(event.getDBObject(), event.getSource());
+
+	}
+
+	/**
+	 * Captures {@link com.mongodb.DBObject} after delete.
+	 * 
+	 * @param dbo can be {@literal null}.
+	 * @deprecated since 1.8. Please use {@link #onAfterDelete(AfterDeleteEvent)}.
+	 */
+	@Deprecated
 	public void onAfterDelete(DBObject dbo) {
+
 		if (LOG.isDebugEnabled()) {
 			LOG.debug("onAfterDelete({})", dbo);
 		}
 	}
 
+	/**
+	 * Captures {@link AfterDeleteEvent}.
+	 * 
+	 * @param event will never be {@literal null}.
+	 * @since 1.8
+	 */
+	public void onAfterDelete(AfterDeleteEvent<E> event) {
+		onAfterDelete(event.getDBObject());
+	}
+
+	/**
+	 * Capture {@link com.mongodb.DBObject} before delete.
+	 * 
+	 * @param dbo can be {@literal null}.
+	 * @deprecated since 1.8. Please use {@link #onBeforeDelete(BeforeDeleteEvent)}.
+	 */
+	@Deprecated
 	public void onBeforeDelete(DBObject dbo) {
+
 		if (LOG.isDebugEnabled()) {
 			LOG.debug("onBeforeDelete({})", dbo);
 		}
 	}
+
+	/**
+	 * Capture {@link BeforeDeleteEvent}.
+	 * 
+	 * @param event will never be {@literal null}.
+	 * @since 1.8
+	 */
+	public void onBeforeDelete(BeforeDeleteEvent<E> event) {
+		onBeforeDelete(event.getDBObject());
+	}
 }

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/mapping/event/AfterConvertEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011 by the original author(s).
+ * Copyright (c) 2011-2015 by the original author(s).
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,20 +13,42 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 package org.springframework.data.mongodb.core.mapping.event;
 
 import com.mongodb.DBObject;
 
 /**
+ * {@link MongoMappingEvent} thrown after convert of a document.
+ * 
  * @author Jon Brisbin <jbrisbin@vmware.com>
+ * @author Christoph Strobl
  */
 public class AfterConvertEvent<E> extends MongoMappingEvent<E> {
 
 	private static final long serialVersionUID = 1L;
 
+	/**
+	 * Creates new {@link AfterConvertEvent}.
+	 * 
+	 * @param dbo can be {@literal null}.
+	 * @param source must not be {@literal null}.
+	 * @deprecated since 1.8. Please use {@link #AfterConvertEvent(DBObject, Object, String)}.
+	 */
+	@Deprecated
 	public AfterConvertEvent(DBObject dbo, E source) {
-		super(source, dbo);
+		this(dbo, source, null);
+	}
+
+	/**
+	 * Creates new {@link AfterConvertEvent}.
+	 * 
+	 * @param dbo can be {@literal null}.
+	 * @param source must not be {@literal null}.
+	 * @param collectionName can be {@literal null}.
+	 * @since 1.8
+	 */
+	public AfterConvertEvent(DBObject dbo, E source, String collectionName) {
+		super(source, dbo, collectionName);
 	}
 
 }

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/mapping/event/AfterDeleteEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013 by the original author(s).
+ * Copyright 2013-2015 by the original author(s).
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,6 +22,7 @@ import com.mongodb.DBObject;
  * will be the query document <em>after</am> it has been mapped onto the domain type handled.
  * 
  * @author Martin Baumgartner
+ * @author Christoph Strobl
  */
 public class AfterDeleteEvent<T> extends AbstractDeleteEvent<T> {
 
@@ -32,8 +33,22 @@ public class AfterDeleteEvent<T> extends AbstractDeleteEvent<T> {
 	 * 
 	 * @param dbo must not be {@literal null}.
 	 * @param type can be {@literal null}.
+	 * @deprecated since 1.8. Please use {@link #AfterDeleteEvent(DBObject, Class, String)}.
 	 */
+	@Deprecated
 	public AfterDeleteEvent(DBObject dbo, Class<T> type) {
-		super(dbo, type);
+		this(dbo, type, null);
+	}
+
+	/**
+	 * Creates a new {@link AfterDeleteEvent} for the given {@link DBObject}, type and collectionName.
+	 * 
+	 * @param dbo must not be {@literal null}.
+	 * @param type can be {@literal null}.
+	 * @param collectionName can be {@literal null}.
+	 * @since 1.8
+	 */
+	public AfterDeleteEvent(DBObject dbo, Class<T> type, String collectionName) {
+		super(dbo, type, collectionName);
 	}
 }

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/mapping/event/AfterLoadEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011 by the original author(s).
+ * Copyright (c) 2011-2015 by the original author(s).
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,6 +26,7 @@ import com.mongodb.DBObject;
  * @author Oliver Gierke
  * @author Jon Brisbin
  * @author Christoph Leiter
+ * @author Christoph Strobl
  */
 public class AfterLoadEvent<T> extends MongoMappingEvent<DBObject> {
 
@@ -36,11 +37,25 @@ public class AfterLoadEvent<T> extends MongoMappingEvent<DBObject> {
 	 * Creates a new {@link AfterLoadEvent} for the given {@link DBObject} and type.
 	 * 
 	 * @param dbo must not be {@literal null}.
-	 * @param type must not be {@literal null}.
+	 * @param type can be {@literal null}.
+	 * @deprecated since 1.8. Please use {@link #AfterLoadEvent(DBObject, Class, String)}.
 	 */
+	@Deprecated
 	public AfterLoadEvent(DBObject dbo, Class<T> type) {
+		this(dbo, type, null);
+	}
 
-		super(dbo, dbo);
+	/**
+	 * Creates a new {@link AfterLoadEvent} for the given {@link DBObject}, type and collectionName.
+	 * 
+	 * @param dbo must not be {@literal null}.
+	 * @param type must not be {@literal null}.
+	 * @param collectionName can be {@literal null}.
+	 * @since 1.8
+	 */
+	public AfterLoadEvent(DBObject dbo, Class<T> type, String collectionName) {
+
+		super(dbo, dbo, collectionName);
 
 		Assert.notNull(type, "Type must not be null!");
 		this.type = type;

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/mapping/event/AfterSaveEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011 by the original author(s).
+ * Copyright (c) 2011-2015 by the original author(s).
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,14 +19,37 @@ package org.springframework.data.mongodb.core.mapping.event;
 import com.mongodb.DBObject;
 
 /**
+ * {@link MongoMappingEvent} triggered after save of a document.
+ * 
  * @author Jon Brisbin <jbrisbin@vmware.com>
+ * @author Christoph Strobl
  */
 public class AfterSaveEvent<E> extends MongoMappingEvent<E> {
 
 	private static final long serialVersionUID = 1L;
 
+	/**
+	 * Creates new {@link AfterSaveEvent}
+	 * 
+	 * @param source must not be {@literal null}.
+	 * @param dbo can be {@literal null}.
+	 * @deprecated since 1.8. Please use {@link #AfterSaveEvent(Object, DBObject, String)}.
+	 */
+	@Deprecated
 	public AfterSaveEvent(E source, DBObject dbo) {
 		super(source, dbo);
 	}
 
+	/**
+	 * Creates new {@link AfterSaveEvent}.
+	 * 
+	 * @param source must not be {@literal null}.
+	 * @param dbo can be {@literal null}.
+	 * @param collectionName can be {@literal null}.
+	 * @since 1.8
+	 */
+	public AfterSaveEvent(E source, DBObject dbo, String collectionName) {
+		super(source, dbo, collectionName);
+	}
+
 }

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/mapping/event/BeforeConvertEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2012 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.
@@ -20,12 +20,31 @@ package org.springframework.data.mongodb.core.mapping.event;
  * 
  * @author Jon Brisbin
  * @author Oliver Gierke
+ * @author Christoph Strobl
  */
 public class BeforeConvertEvent<T> extends MongoMappingEvent<T> {
 
 	private static final long serialVersionUID = 252614269008845243L;
 
+	/**
+	 * Creates new {@link BeforeConvertEvent}.
+	 * 
+	 * @param source must not be {@literal null}.
+	 * @deprecated since 1.8. Please use {@link #BeforeConvertEvent(Object, String)}.
+	 */
+	@Deprecated
 	public BeforeConvertEvent(T source) {
-		super(source, null);
+		this(source, null);
+	}
+
+	/**
+	 * Creates new {@link BeforeConvertEvent}.
+	 * 
+	 * @param source must not be {@literal null}.
+	 * @param collectionName can be {@literal null}.
+	 * @since 1.8
+	 */
+	public BeforeConvertEvent(T source, String collectionName) {
+		super(source, null, collectionName);
 	}
 }

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/mapping/event/BeforeDeleteEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013 by the original author(s).
+ * Copyright 2013-2015 by the original author(s).
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,6 +22,7 @@ import com.mongodb.DBObject;
  * document <em>before</em> being mapped based on the domain class handled.
  * 
  * @author Martin Baumgartner
+ * @author Christoph Strobl
  */
 public class BeforeDeleteEvent<T> extends AbstractDeleteEvent<T> {
 
@@ -32,8 +33,22 @@ public class BeforeDeleteEvent<T> extends AbstractDeleteEvent<T> {
 	 * 
 	 * @param dbo must not be {@literal null}.
 	 * @param type can be {@literal null}.
+	 * @deprecated since 1.8. Please use {@link #BeforeDeleteEvent(DBObject, Class, String)}.
 	 */
+	@Deprecated
 	public BeforeDeleteEvent(DBObject dbo, Class<T> type) {
-		super(dbo, type);
+		this(dbo, type, null);
+	}
+
+	/**
+	 * Creates a new {@link BeforeDeleteEvent} for the given {@link DBObject}, type and collectionName.
+	 * 
+	 * @param dbo must not be {@literal null}.
+	 * @param type can be {@literal null}.
+	 * @param collectionName can be {@literal null}.
+	 * @since 1.8
+	 */
+	public BeforeDeleteEvent(DBObject dbo, Class<T> type, String collectionName) {
+		super(dbo, type, collectionName);
 	}
 }

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/mapping/event/BeforeSaveEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011 by the original author(s).
+ * Copyright (c) 2011-2015 by the original author(s).
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,14 +19,37 @@ package org.springframework.data.mongodb.core.mapping.event;
 import com.mongodb.DBObject;
 
 /**
+ * {@link MongoMappingEvent} triggered before save of a document.
+ * 
  * @author Jon Brisbin <jbrisbin@vmware.com>
+ * @author Christoph Strobl
  */
 public class BeforeSaveEvent<E> extends MongoMappingEvent<E> {
 
 	private static final long serialVersionUID = 1L;
 
+	/**
+	 * Creates new {@link BeforeSaveEvent}.
+	 * 
+	 * @param source must not be {@literal null}.
+	 * @param dbo can be {@literal null}.
+	 * @deprecated since 1.8. Please use {@link #BeforeSaveEvent(Object, DBObject, String)}.
+	 */
+	@Deprecated
 	public BeforeSaveEvent(E source, DBObject dbo) {
 		super(source, dbo);
 	}
 
+	/**
+	 * Creates new {@link BeforeSaveEvent}.
+	 * 
+	 * @param source must not be {@literal null}.
+	 * @param dbo can be {@literal null}.
+	 * @param collectionName can be {@literal null}.
+	 * @since 1.8
+	 */
+	public BeforeSaveEvent(E source, DBObject dbo, String collectionName) {
+		super(source, dbo, collectionName);
+	}
+
 }

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/mapping/event/MongoMappingEvent.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011 by the original author(s).
+ * Copyright (c) 2011-2015 by the original author(s).
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,26 +16,69 @@
 
 package org.springframework.data.mongodb.core.mapping.event;
 
-import com.mongodb.DBObject;
 import org.springframework.context.ApplicationEvent;
 
+import com.mongodb.DBObject;
+
 /**
+ * Base {@link ApplicationEvent} triggered by Spring Data MongoDB.
+ * 
  * @author Jon Brisbin <jbrisbin@vmware.com>
+ * @author Christoph Strobl
  */
 public class MongoMappingEvent<T> extends ApplicationEvent {
 
 	private static final long serialVersionUID = 1L;
 	private final DBObject dbo;
+	private final String collectionName;
 
+	/**
+	 * Creates new {@link MongoMappingEvent}.
+	 * 
+	 * @param source must not be {@literal null}.
+	 * @param dbo can be {@literal null}.
+	 * @deprecated since 1.8. Please use {@link #MongoMappingEvent(Object, DBObject, String)}.
+	 */
+	@Deprecated
 	public MongoMappingEvent(T source, DBObject dbo) {
-		super(source);
-		this.dbo = dbo;
+		this(source, dbo, null);
 	}
 
+	/**
+	 * Creates new {@link MongoMappingEvent}.
+	 * 
+	 * @param source must not be {@literal null}.
+	 * @param dbo can be {@literal null}.
+	 * @param collectionName can be {@literal null}.
+	 */
+	public MongoMappingEvent(T source, DBObject dbo, String collectionName) {
+
+		super(source);
+		this.dbo = dbo;
+		this.collectionName = collectionName;
+	}
+
+	/**
+	 * @return {@literal null} if not set.
+	 */
 	public DBObject getDBObject() {
 		return dbo;
 	}
 
+	/**
+	 * Get the collection the event refers to.
+	 * 
+	 * @return {@literal null} if not set.
+	 * @since 1.8
+	 */
+	public String getCollectionName() {
+		return collectionName;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see java.util.EventObject#getSource()
+	 */
 	@SuppressWarnings({ "unchecked" })
 	@Override
 	public T getSource() {

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/mapreduce/MapReduceOptions.java

@@ -45,6 +45,8 @@ public class MapReduceOptions {
 
 	private Boolean verbose = true;
 
+	private Integer limit;
+
 	private Map<String, Object> extraOptions = new HashMap<String, Object>();
 
 	/**
@@ -64,6 +66,8 @@ public class MapReduceOptions {
 	 * @return MapReduceOptions so that methods can be chained in a fluent API style
 	 */
 	public MapReduceOptions limit(int limit) {
+
+		this.limit = limit;
 		return this;
 	}
 
@@ -247,6 +251,15 @@ public class MapReduceOptions {
 		return this.scopeVariables;
 	}
 
+	/**
+	 * Get the maximum number of documents for the input into the map function.
+	 * 
+	 * @return {@literal null} if not set.
+	 */
+	public Integer getLimit() {
+		return limit;
+	}
+
 	public DBObject getOptionsObject() {
 		BasicDBObject cmd = new BasicDBObject();
 
@@ -264,6 +277,10 @@ public class MapReduceOptions {
 			cmd.put("scope", scopeVariables);
 		}
 
+		if (limit != null) {
+			cmd.put("limit", limit);
+		}
+
 		if (!extraOptions.keySet().isEmpty()) {
 			cmd.putAll(extraOptions);
 		}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/mapreduce/MapReduceTiming.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2011 the original author or authors.
+ * Copyright 2010-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.
@@ -17,13 +17,10 @@ package org.springframework.data.mongodb.core.mapreduce;
 
 public class MapReduceTiming {
 
-	private long mapTime;
-
-	private long emitLoopTime;
-
-	private long totalTime;
+	private long mapTime, emitLoopTime, totalTime;
 
 	public MapReduceTiming(long mapTime, long emitLoopTime, long totalTime) {
+
 		this.mapTime = mapTime;
 		this.emitLoopTime = emitLoopTime;
 		this.totalTime = totalTime;
@@ -41,37 +38,52 @@ public class MapReduceTiming {
 		return totalTime;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see java.lang.Object#toString()
+	 */
 	@Override
 	public String toString() {
 		return "MapReduceTiming [mapTime=" + mapTime + ", emitLoopTime=" + emitLoopTime + ", totalTime=" + totalTime + "]";
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see java.lang.Object#hashCode()
+	 */
 	@Override
 	public int hashCode() {
+
 		final int prime = 31;
 		int result = 1;
+
 		result = prime * result + (int) (emitLoopTime ^ (emitLoopTime >>> 32));
 		result = prime * result + (int) (mapTime ^ (mapTime >>> 32));
 		result = prime * result + (int) (totalTime ^ (totalTime >>> 32));
+
 		return result;
 	}
 
+	/*
+	 * 
+	 * (non-Javadoc)
+	 * @see java.lang.Object#equals(java.lang.Object)
+	 */
 	@Override
 	public boolean equals(Object obj) {
-		if (this == obj)
-			return true;
-		if (obj == null)
-			return false;
-		if (getClass() != obj.getClass())
-			return false;
-		MapReduceTiming other = (MapReduceTiming) obj;
-		if (emitLoopTime != other.emitLoopTime)
-			return false;
-		if (mapTime != other.mapTime)
-			return false;
-		if (totalTime != other.totalTime)
-			return false;
-		return true;
-	}
 
+		if (this == obj) {
+			return true;
+		}
+
+		if (!(obj instanceof MapReduceTiming)) {
+			return false;
+		}
+
+		MapReduceTiming that = (MapReduceTiming) obj;
+
+		return this.emitLoopTime == that.emitLoopTime && //
+				this.mapTime == that.mapTime && //
+				this.totalTime == that.totalTime;
+	}
 }

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/Criteria.java

@@ -22,6 +22,7 @@ import java.util.Arrays;
 import java.util.Collection;
 import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map.Entry;
 import java.util.regex.Pattern;
 
 import org.bson.BSON;
@@ -118,7 +119,7 @@ public class Criteria implements CriteriaDefinition {
 	}
 
 	private boolean lastOperatorWasNot() {
-		return this.criteria.size() > 0 && "$not".equals(this.criteria.keySet().toArray()[this.criteria.size() - 1]);
+		return !this.criteria.isEmpty() && "$not".equals(this.criteria.keySet().toArray()[this.criteria.size() - 1]);
 	}
 
 	/**
@@ -581,9 +582,10 @@ public class Criteria implements CriteriaDefinition {
 		DBObject dbo = new BasicDBObject();
 		boolean not = false;
 
-		for (String k : this.criteria.keySet()) {
+		for (Entry<String, Object> entry : criteria.entrySet()) {
 
-			Object value = this.criteria.get(k);
+			String key = entry.getKey();
+			Object value = entry.getValue();
 
 			if (requiresGeoJsonFormat(value)) {
 				value = new BasicDBObject("$geometry", value);
@@ -591,14 +593,14 @@ public class Criteria implements CriteriaDefinition {
 
 			if (not) {
 				DBObject notDbo = new BasicDBObject();
-				notDbo.put(k, value);
+				notDbo.put(key, value);
 				dbo.put("$not", notDbo);
 				not = false;
 			} else {
-				if ("$not".equals(k) && value == null) {
+				if ("$not".equals(key) && value == null) {
 					not = true;
 				} else {
-					dbo.put(k, value);
+					dbo.put(key, value);
 				}
 			}
 		}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/Field.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2013 the original author or authors.
+ * Copyright 2010-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.
@@ -83,14 +83,10 @@ public class Field {
 
 	public DBObject getFieldsObject() {
 
-		DBObject dbo = new BasicDBObject();
+		DBObject dbo = new BasicDBObject(criteria);
 
-		for (String k : criteria.keySet()) {
-			dbo.put(k, criteria.get(k));
-		}
-
-		for (String k : slices.keySet()) {
-			dbo.put(k, new BasicDBObject("$slice", slices.get(k)));
+		for (Entry<String, Object> entry : slices.entrySet()) {
+			dbo.put(entry.getKey(), new BasicDBObject("$slice", entry.getValue()));
 		}
 
 		for (Entry<String, Criteria> entry : elemMatchs.entrySet()) {
@@ -134,8 +130,8 @@ public class Field {
 			return false;
 		}
 
-		boolean samePositionKey = this.postionKey == null ? that.postionKey == null : this.postionKey
-				.equals(that.postionKey);
+		boolean samePositionKey = this.postionKey == null ? that.postionKey == null
+				: this.postionKey.equals(that.postionKey);
 		boolean samePositionValue = this.positionValue == that.positionValue;
 
 		return samePositionKey && samePositionValue;

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/Query.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2014 the original author or authors.
+ * Copyright 2010-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.
@@ -94,9 +94,9 @@ public class Query {
 		if (existing == null) {
 			this.criteria.put(key, criteriaDefinition);
 		} else {
-			throw new InvalidMongoDbApiUsageException("Due to limitations of the com.mongodb.BasicDBObject, "
-					+ "you can't add a second '" + key + "' criteria. " + "Query already contains '"
-					+ existing.getCriteriaObject() + "'.");
+			throw new InvalidMongoDbApiUsageException(
+					"Due to limitations of the com.mongodb.BasicDBObject, " + "you can't add a second '" + key + "' criteria. "
+							+ "Query already contains '" + existing.getCriteriaObject() + "'.");
 		}
 
 		return this;
@@ -176,7 +176,7 @@ public class Query {
 
 		for (Order order : sort) {
 			if (order.isIgnoreCase()) {
-				throw new IllegalArgumentException(String.format("Gven sort contained an Order for %s with ignore case! "
+				throw new IllegalArgumentException(String.format("Given sort contained an Order for %s with ignore case! "
 						+ "MongoDB does not support sorting ignoreing case currently!", order.getProperty()));
 			}
 		}
@@ -221,10 +221,8 @@ public class Query {
 
 		DBObject dbo = new BasicDBObject();
 
-		for (String k : criteria.keySet()) {
-			CriteriaDefinition c = criteria.get(k);
-			DBObject cl = c.getCriteriaObject();
-			dbo.putAll(cl);
+		for (CriteriaDefinition definition : criteria.values()) {
+			dbo.putAll(definition.getCriteriaObject());
 		}
 
 		if (!restrictedTypes.isEmpty()) {

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/TextCriteria.java

@@ -63,7 +63,7 @@ public class TextCriteria implements CriteriaDefinition {
 	}
 
 	/**
-	 * For a full list of supported languages see the mongdodb reference manual for <a
+	 * For a full list of supported languages see the mongodb reference manual for <a
 	 * href="http://docs.mongodb.org/manual/reference/text-search-languages/">Text Search Languages</a>.
 	 * 
 	 * @param language

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/Update.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2014 the original author or authors.
+ * Copyright 2010-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.
@@ -64,7 +64,7 @@ public class Update {
 	}
 
 	/**
-	 * Creates an {@link Update} instance from the given {@link DBObject}. Allows to explicitly exlude fields from making
+	 * Creates an {@link Update} instance from the given {@link DBObject}. Allows to explicitly exclude fields from making
 	 * it into the created {@link Update} object. Note, that this will set attributes directly and <em>not</em> use
 	 * {@literal $set}. This means fields not given in the {@link DBObject} will be nulled when executing the update. To
 	 * create an only-updating {@link Update} instance of a {@link DBObject}, call {@link #set(String, Object)} for each
@@ -254,7 +254,7 @@ public class Update {
 	 * @return
 	 */
 	public Update pullAll(String key, Object[] values) {
-		addFieldOperation("$pullAll", key, Arrays.copyOf(values, values.length));
+		addMultiFieldOperation("$pullAll", key, Arrays.copyOf(values, values.length));
 		return this;
 	}
 
@@ -327,17 +327,22 @@ public class Update {
 	}
 
 	public DBObject getUpdateObject() {
-
-		DBObject dbo = new BasicDBObject();
-		for (String k : modifierOps.keySet()) {
-			dbo.put(k, modifierOps.get(k));
-		}
-		return dbo;
+		return new BasicDBObject(modifierOps);
 	}
 
+	/**
+	 * This method is not called anymore rather override {@link #addMultiFieldOperation(String, String, Object)}.
+	 * 
+	 * @param operator
+	 * @param key
+	 * @param value
+	 * @deprectaed Use {@link #addMultiFieldOperation(String, String, Object)} instead.
+	 */
+	@Deprecated
 	protected void addFieldOperation(String operator, String key, Object value) {
 
 		Assert.hasText(key, "Key/Path for update must not be null or blank.");
+
 		modifierOps.put(operator, new BasicDBObject(key, value));
 		this.keysToUpdate.add(key);
 	}
@@ -355,8 +360,8 @@ public class Update {
 			if (existingValue instanceof BasicDBObject) {
 				keyValueMap = (BasicDBObject) existingValue;
 			} else {
-				throw new InvalidDataAccessApiUsageException("Modifier Operations should be a LinkedHashMap but was "
-						+ existingValue.getClass());
+				throw new InvalidDataAccessApiUsageException(
+						"Modifier Operations should be a LinkedHashMap but was " + existingValue.getClass());
 			}
 		}
 

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/monitor/AbstractMonitor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2012 the original author or authors.
+ * Copyright 2002-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.
@@ -29,6 +29,7 @@ import com.mongodb.MongoException;
  * Base class to encapsulate common configuration settings when connecting to a database
  * 
  * @author Mark Pollack
+ * @author Oliver Gierke
  */
 public abstract class AbstractMonitor {
 

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

@@ -38,7 +38,7 @@ import org.springframework.data.annotation.QueryAnnotation;
 public @interface Query {
 
 	/**
-	 * Takes a MongoDB JSON string to define the actual query to be executed. This one will take precendece over the
+	 * Takes a MongoDB JSON string to define the actual query to be executed. This one will take precedence over the
 	 * method name then.
 	 * 
 	 * @return

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/config/EnableMongoRepositories.java

@@ -47,7 +47,7 @@ public @interface EnableMongoRepositories {
 
 	/**
 	 * Alias for the {@link #basePackages()} attribute. Allows for more concise annotation declarations e.g.:
-	 * {@code @EnableJpaRepositories("org.my.pkg")} instead of {@code @EnableJpaRepositories(basePackages="org.my.pkg")}.
+	 * {@code @EnableMongoRepositories("org.my.pkg")} instead of {@code @EnableMongoRepositories(basePackages="org.my.pkg")}.
 	 */
 	String[] value() default {};
 

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/AbstractMongoQuery.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2015 the original author or authors.
+ * Copyright 2010-2016 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.
@@ -15,31 +15,25 @@
  */
 package org.springframework.data.mongodb.repository.query;
 
-import java.util.Collections;
-import java.util.List;
-
-import org.springframework.data.domain.PageImpl;
-import org.springframework.data.domain.Pageable;
-import org.springframework.data.domain.Range;
-import org.springframework.data.domain.Slice;
-import org.springframework.data.domain.SliceImpl;
-import org.springframework.data.geo.Distance;
-import org.springframework.data.geo.GeoPage;
-import org.springframework.data.geo.GeoResult;
-import org.springframework.data.geo.GeoResults;
-import org.springframework.data.geo.Point;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.data.convert.EntityInstantiators;
 import org.springframework.data.mongodb.core.MongoOperations;
-import org.springframework.data.mongodb.core.query.NearQuery;
 import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.mongodb.repository.query.MongoQueryExecution.CollectionExecution;
+import org.springframework.data.mongodb.repository.query.MongoQueryExecution.DeleteExecution;
+import org.springframework.data.mongodb.repository.query.MongoQueryExecution.GeoNearExecution;
+import org.springframework.data.mongodb.repository.query.MongoQueryExecution.PagedExecution;
+import org.springframework.data.mongodb.repository.query.MongoQueryExecution.PagingGeoNearExecution;
+import org.springframework.data.mongodb.repository.query.MongoQueryExecution.ResultProcessingConverter;
+import org.springframework.data.mongodb.repository.query.MongoQueryExecution.ResultProcessingExecution;
+import org.springframework.data.mongodb.repository.query.MongoQueryExecution.SingleEntityExecution;
+import org.springframework.data.mongodb.repository.query.MongoQueryExecution.SlicedExecution;
+import org.springframework.data.mongodb.repository.query.MongoQueryExecution.StreamExecution;
 import org.springframework.data.repository.query.ParameterAccessor;
 import org.springframework.data.repository.query.RepositoryQuery;
-import org.springframework.data.util.CloseableIterator;
-import org.springframework.data.util.StreamUtils;
-import org.springframework.data.util.TypeInformation;
+import org.springframework.data.repository.query.ResultProcessor;
 import org.springframework.util.Assert;
 
-import com.mongodb.WriteResult;
-
 /**
  * Base class for {@link RepositoryQuery} implementations for Mongo.
  * 
@@ -51,6 +45,7 @@ public abstract class AbstractMongoQuery implements RepositoryQuery {
 
 	private final MongoQueryMethod method;
 	private final MongoOperations operations;
+	private final EntityInstantiators instantiators;
 
 	/**
 	 * Creates a new {@link AbstractMongoQuery} from the given {@link MongoQueryMethod} and {@link MongoOperations}.
@@ -65,6 +60,7 @@ public abstract class AbstractMongoQuery implements RepositoryQuery {
 
 		this.method = method;
 		this.operations = operations;
+		this.instantiators = new EntityInstantiators();
 	}
 
 	/* 
@@ -86,30 +82,53 @@ public abstract class AbstractMongoQuery implements RepositoryQuery {
 
 		applyQueryMetaAttributesWhenPresent(query);
 
+		ResultProcessor processor = method.getResultProcessor().withDynamicProjection(accessor);
+		String collection = method.getEntityInformation().getCollectionName();
+
+		MongoQueryExecution execution = getExecution(query, accessor,
+				new ResultProcessingConverter(processor, operations, instantiators));
+
+		return execution.execute(query, processor.getReturnedType().getDomainType(), collection);
+	}
+
+	/**
+	 * Returns the execution instance to use.
+	 * 
+	 * @param query must not be {@literal null}.
+	 * @param parameters must not be {@literal null}.
+	 * @param accessor must not be {@literal null}.
+	 * @return
+	 */
+	private MongoQueryExecution getExecution(Query query, MongoParameterAccessor accessor,
+			Converter<Object, Object> resultProcessing) {
+
 		if (method.isStreamQuery()) {
-			return new StreamExecution().execute(query);
-		} else if (isDeleteQuery()) {
-			return new DeleteExecution().execute(query);
+			return new StreamExecution(operations, resultProcessing);
+		}
+
+		return new ResultProcessingExecution(getExecutionToWrap(query, accessor), resultProcessing);
+	}
+
+	private MongoQueryExecution getExecutionToWrap(Query query, MongoParameterAccessor accessor) {
+
+		if (isDeleteQuery()) {
+			return new DeleteExecution(operations, method);
 		} else if (method.isGeoNearQuery() && method.isPageQuery()) {
-
-			MongoParameterAccessor countAccessor = new MongoParametersParameterAccessor(method, parameters);
-			Query countQuery = createCountQuery(new ConvertingParameterAccessor(operations.getConverter(), countAccessor));
-
-			return new GeoNearExecution(accessor).execute(query, countQuery);
+			return new PagingGeoNearExecution(operations, accessor, method.getReturnType(), this);
 		} else if (method.isGeoNearQuery()) {
-			return new GeoNearExecution(accessor).execute(query);
+			return new GeoNearExecution(operations, accessor, method.getReturnType());
 		} else if (method.isSliceQuery()) {
-			return new SlicedExecution(accessor.getPageable()).execute(query);
+			return new SlicedExecution(operations, accessor.getPageable());
 		} else if (method.isCollectionQuery()) {
-			return new CollectionExecution(accessor.getPageable()).execute(query);
+			return new CollectionExecution(operations, accessor.getPageable());
 		} else if (method.isPageQuery()) {
-			return new PagedExecution(accessor.getPageable()).execute(query);
+			return new PagedExecution(operations, accessor.getPageable());
 		} else {
-			return new SingleEntityExecution(isCountQuery()).execute(query);
+			return new SingleEntityExecution(operations, isCountQuery());
 		}
 	}
 
-	private Query applyQueryMetaAttributesWhenPresent(Query query) {
+	Query applyQueryMetaAttributesWhenPresent(Query query) {
 
 		if (method.hasQueryMetaAttributes()) {
 			query.setMeta(method.getQueryMetaAttributes());
@@ -127,12 +146,7 @@ public abstract class AbstractMongoQuery implements RepositoryQuery {
 	 * @return
 	 */
 	protected Query createCountQuery(ConvertingParameterAccessor accessor) {
-
-		Query query = createQuery(accessor);
-
-		applyQueryMetaAttributesWhenPresent(query);
-
-		return query;
+		return applyQueryMetaAttributesWhenPresent(createQuery(accessor));
 	}
 
 	/**
@@ -157,292 +171,4 @@ public abstract class AbstractMongoQuery implements RepositoryQuery {
 	 * @since 1.5
 	 */
 	protected abstract boolean isDeleteQuery();
-
-	private abstract class Execution {
-
-		abstract Object execute(Query query);
-
-		protected List<?> readCollection(Query query) {
-
-			MongoEntityMetadata<?> metadata = method.getEntityInformation();
-
-			String collectionName = metadata.getCollectionName();
-			return operations.find(query, metadata.getJavaType(), collectionName);
-		}
-	}
-
-	/**
-	 * {@link Execution} for collection returning queries.
-	 * 
-	 * @author Oliver Gierke
-	 */
-	final class CollectionExecution extends Execution {
-
-		private final Pageable pageable;
-
-		CollectionExecution(Pageable pageable) {
-			this.pageable = pageable;
-		}
-
-		/*
-		 * (non-Javadoc)
-		 * @see org.springframework.data.mongodb.repository.query.AbstractMongoQuery.Execution#execute(org.springframework.data.mongodb.core.query.Query)
-		 */
-		@Override
-		public Object execute(Query query) {
-			return readCollection(query.with(pageable));
-		}
-	}
-
-	/**
-	 * {@link Execution} for {@link Slice} query methods.
-	 * 
-	 * @author Oliver Gierke
-	 * @author Christoph Strobl
-	 * @since 1.5
-	 */
-
-	final class SlicedExecution extends Execution {
-
-		private final Pageable pageable;
-
-		SlicedExecution(Pageable pageable) {
-			this.pageable = pageable;
-		}
-
-		/*
-		 * (non-Javadoc)
-		 * @see org.springframework.data.mongodb.repository.query.AbstractMongoQuery.Execution#execute(org.springframework.data.mongodb.core.query.Query)
-		 */
-		@Override
-		@SuppressWarnings({ "unchecked", "rawtypes" })
-		Object execute(Query query) {
-
-			MongoEntityMetadata<?> metadata = method.getEntityInformation();
-			int pageSize = pageable.getPageSize();
-
-			// Apply Pageable but tweak limit to peek into next page
-			Query modifiedQuery = query.with(pageable).limit(pageSize + 1);
-
-			List result = operations.find(modifiedQuery, metadata.getJavaType(), metadata.getCollectionName());
-
-			boolean hasNext = result.size() > pageSize;
-
-			return new SliceImpl<Object>(hasNext ? result.subList(0, pageSize) : result, pageable, hasNext);
-		}
-	}
-
-	/**
-	 * {@link Execution} for pagination queries.
-	 * 
-	 * @author Oliver Gierke
-	 */
-	final class PagedExecution extends Execution {
-
-		private final Pageable pageable;
-
-		/**
-		 * Creates a new {@link PagedExecution}.
-		 * 
-		 * @param pageable
-		 */
-		public PagedExecution(Pageable pageable) {
-
-			Assert.notNull(pageable);
-			this.pageable = pageable;
-		}
-
-		/*
-		 * (non-Javadoc)
-		 * @see org.springframework.data.mongodb.repository.AbstractMongoQuery.Execution#execute(org.springframework.data.mongodb.core.query.Query)
-		 */
-		@Override
-		@SuppressWarnings({ "rawtypes", "unchecked" })
-		Object execute(Query query) {
-
-			MongoEntityMetadata<?> metadata = method.getEntityInformation();
-			String collectionName = metadata.getCollectionName();
-			Class<?> type = metadata.getJavaType();
-
-			int overallLimit = query.getLimit();
-			long count = operations.count(query, type, collectionName);
-			count = overallLimit != 0 ? Math.min(count, query.getLimit()) : count;
-
-			boolean pageableOutOfScope = pageable.getOffset() > count;
-
-			if (pageableOutOfScope) {
-				return new PageImpl<Object>(Collections.emptyList(), pageable, count);
-			}
-
-			// Apply raw pagination
-			query = query.with(pageable);
-
-			// Adjust limit if page would exceed the overall limit
-			if (overallLimit != 0 && pageable.getOffset() + pageable.getPageSize() > overallLimit) {
-				query.limit(overallLimit - pageable.getOffset());
-			}
-
-			List<?> result = operations.find(query, type, collectionName);
-			return new PageImpl(result, pageable, count);
-		}
-	}
-
-	/**
-	 * {@link Execution} to return a single entity.
-	 * 
-	 * @author Oliver Gierke
-	 */
-	final class SingleEntityExecution extends Execution {
-
-		private final boolean countProjection;
-
-		private SingleEntityExecution(boolean countProjection) {
-			this.countProjection = countProjection;
-		}
-
-		/*
-		 * (non-Javadoc)
-		 * @see org.springframework.data.mongodb.repository.AbstractMongoQuery.Execution#execute(org.springframework.data.mongodb.core.core.query.Query)
-		 */
-		@Override
-		Object execute(Query query) {
-
-			MongoEntityMetadata<?> metadata = method.getEntityInformation();
-			return countProjection ? operations.count(query, metadata.getJavaType())
-					: operations.findOne(query, metadata.getJavaType(), metadata.getCollectionName());
-		}
-	}
-
-	/**
-	 * {@link Execution} to execute geo-near queries.
-	 * 
-	 * @author Oliver Gierke
-	 */
-	final class GeoNearExecution extends Execution {
-
-		private final MongoParameterAccessor accessor;
-
-		public GeoNearExecution(MongoParameterAccessor accessor) {
-			this.accessor = accessor;
-		}
-
-		/*
-		 * (non-Javadoc)
-		 * @see org.springframework.data.mongodb.repository.AbstractMongoQuery.Execution#execute(org.springframework.data.mongodb.core.query.Query)
-		 */
-		@Override
-		Object execute(Query query) {
-
-			GeoResults<?> results = doExecuteQuery(query);
-			return isListOfGeoResult() ? results.getContent() : results;
-		}
-
-		/**
-		 * Executes the given {@link Query} to return a page.
-		 * 
-		 * @param query must not be {@literal null}.
-		 * @param countQuery must not be {@literal null}.
-		 * @return
-		 */
-		Object execute(Query query, Query countQuery) {
-
-			MongoEntityMetadata<?> metadata = method.getEntityInformation();
-			long count = operations.count(countQuery, metadata.getCollectionName());
-
-			return new GeoPage<Object>(doExecuteQuery(query), accessor.getPageable(), count);
-		}
-
-		@SuppressWarnings("unchecked")
-		private GeoResults<Object> doExecuteQuery(Query query) {
-
-			Point nearLocation = accessor.getGeoNearLocation();
-			NearQuery nearQuery = NearQuery.near(nearLocation);
-
-			if (query != null) {
-				nearQuery.query(query);
-			}
-
-			Range<Distance> distances = accessor.getDistanceRange();
-			Distance maxDistance = distances.getUpperBound();
-
-			if (maxDistance != null) {
-				nearQuery.maxDistance(maxDistance).in(maxDistance.getMetric());
-			}
-
-			Distance minDistance = distances.getLowerBound();
-
-			if (minDistance != null) {
-				nearQuery.minDistance(minDistance).in(minDistance.getMetric());
-			}
-
-			Pageable pageable = accessor.getPageable();
-			if (pageable != null) {
-				nearQuery.with(pageable);
-			}
-
-			MongoEntityMetadata<?> metadata = method.getEntityInformation();
-			return (GeoResults<Object>) operations.geoNear(nearQuery, metadata.getJavaType(), metadata.getCollectionName());
-		}
-
-		private boolean isListOfGeoResult() {
-
-			TypeInformation<?> returnType = method.getReturnType();
-
-			if (!returnType.getType().equals(List.class)) {
-				return false;
-			}
-
-			TypeInformation<?> componentType = returnType.getComponentType();
-			return componentType == null ? false : GeoResult.class.equals(componentType.getType());
-		}
-	}
-
-	/**
-	 * {@link Execution} removing documents matching the query.
-	 * 
-	 * @since 1.5
-	 */
-	final class DeleteExecution extends Execution {
-
-		/*
-		 * (non-Javadoc)
-		 * @see org.springframework.data.mongodb.repository.query.AbstractMongoQuery.Execution#execute(org.springframework.data.mongodb.core.query.Query)
-		 */
-		@Override
-		Object execute(Query query) {
-
-			MongoEntityMetadata<?> metadata = method.getEntityInformation();
-			return deleteAndConvertResult(query, metadata);
-		}
-
-		private Object deleteAndConvertResult(Query query, MongoEntityMetadata<?> metadata) {
-
-			if (method.isCollectionQuery()) {
-				return operations.findAllAndRemove(query, metadata.getJavaType(), metadata.getCollectionName());
-			}
-
-			WriteResult writeResult = operations.remove(query, metadata.getJavaType(), metadata.getCollectionName());
-			return writeResult != null ? writeResult.getN() : 0L;
-		}
-	}
-
-	/**
-	 * @author Thomas Darimont
-	 * @since 1.7
-	 */
-	final class StreamExecution extends Execution {
-
-		/* 
-		 * (non-Javadoc)
-		 * @see org.springframework.data.mongodb.repository.query.AbstractMongoQuery.Execution#execute(org.springframework.data.mongodb.core.query.Query)
-		 */
-		@Override
-		@SuppressWarnings("unchecked")
-		Object execute(Query query) {
-
-			Class<?> entityType = getQueryMethod().getEntityInformation().getJavaType();
-
-			return StreamUtils.createStreamFromIterator((CloseableIterator<Object>) operations.stream(query, entityType));
-		}
-	}
 }

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/ConvertingParameterAccessor.java

@@ -90,6 +90,15 @@ public class ConvertingParameterAccessor implements MongoParameterAccessor {
 		return delegate.getSort();
 	}
 
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.repository.query.ParameterAccessor#getDynamicProjection()
+	 */
+	@Override
+	public Class<?> getDynamicProjection() {
+		return delegate.getDynamicProjection();
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.repository.query.ParameterAccessor#getBindableValue(int)

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/DtoInstantiatingConverter.java

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2015-2016 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.query;
+
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.data.convert.EntityInstantiator;
+import org.springframework.data.convert.EntityInstantiators;
+import org.springframework.data.mapping.PersistentEntity;
+import org.springframework.data.mapping.PersistentProperty;
+import org.springframework.data.mapping.PersistentPropertyAccessor;
+import org.springframework.data.mapping.PreferredConstructor;
+import org.springframework.data.mapping.PreferredConstructor.Parameter;
+import org.springframework.data.mapping.SimplePropertyHandler;
+import org.springframework.data.mapping.context.MappingContext;
+import org.springframework.data.mapping.model.ParameterValueProvider;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
+import org.springframework.util.Assert;
+
+/**
+ * {@link Converter} to instantiate DTOs from fully equipped domain objects.
+ *
+ * @author Oliver Gierke
+ */
+class DtoInstantiatingConverter implements Converter<Object, Object> {
+
+	private final Class<?> targetType;
+	private final MappingContext<? extends PersistentEntity<?, ?>, ? extends PersistentProperty<?>> context;
+	private final EntityInstantiator instantiator;
+
+	/**
+	 * Creates a new {@link Converter} to instantiate DTOs.
+	 * 
+	 * @param dtoType must not be {@literal null}.
+	 * @param context must not be {@literal null}.
+	 * @param instantiators must not be {@literal null}.
+	 */
+	public DtoInstantiatingConverter(Class<?> dtoType,
+			MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> context,
+			EntityInstantiators instantiator) {
+
+		Assert.notNull(dtoType, "DTO type must not be null!");
+		Assert.notNull(context, "MappingContext must not be null!");
+		Assert.notNull(instantiator, "EntityInstantiators must not be null!");
+
+		this.targetType = dtoType;
+		this.context = context;
+		this.instantiator = instantiator.getInstantiatorFor(context.getPersistentEntity(dtoType));
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.core.convert.converter.Converter#convert(java.lang.Object)
+	 */
+	@Override
+	public Object convert(Object source) {
+
+		if (targetType.isInterface()) {
+			return source;
+		}
+
+		final PersistentEntity<?, ?> sourceEntity = context.getPersistentEntity(source.getClass());
+		final PersistentPropertyAccessor sourceAccessor = sourceEntity.getPropertyAccessor(source);
+		final PersistentEntity<?, ?> targetEntity = context.getPersistentEntity(targetType);
+		final PreferredConstructor<?, ? extends PersistentProperty<?>> constructor = targetEntity
+				.getPersistenceConstructor();
+
+		@SuppressWarnings({ "rawtypes", "unchecked" })
+		Object dto = instantiator.createInstance(targetEntity, new ParameterValueProvider() {
+
+			@Override
+			public Object getParameterValue(Parameter parameter) {
+				return sourceAccessor.getProperty(sourceEntity.getPersistentProperty(parameter.getName()));
+			}
+		});
+
+		final PersistentPropertyAccessor dtoAccessor = targetEntity.getPropertyAccessor(dto);
+
+		targetEntity.doWithProperties(new SimplePropertyHandler() {
+
+			@Override
+			public void doWithPersistentProperty(PersistentProperty<?> property) {
+
+				if (constructor.isConstructorParameter(property)) {
+					return;
+				}
+
+				dtoAccessor.setProperty(property,
+						sourceAccessor.getProperty(sourceEntity.getPersistentProperty(property.getName())));
+			}
+		});
+
+		return dto;
+	}
+}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/ExpressionEvaluatingParameterBinder.java

@@ -0,0 +1,231 @@
+/*
+ * 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.mongodb.repository.query;
+
+import java.util.Collections;
+import java.util.List;
+
+import javax.xml.bind.DatatypeConverter;
+
+import org.bson.BSON;
+import org.springframework.data.mongodb.repository.query.StringBasedMongoQuery.ParameterBinding;
+import org.springframework.data.repository.query.EvaluationContextProvider;
+import org.springframework.expression.EvaluationContext;
+import org.springframework.expression.Expression;
+import org.springframework.expression.spel.standard.SpelExpressionParser;
+import org.springframework.util.Assert;
+import org.springframework.util.CollectionUtils;
+import org.springframework.util.StringUtils;
+
+import com.mongodb.util.JSON;
+
+/**
+ * {@link ExpressionEvaluatingParameterBinder} allows to evaluate, convert and bind parameters to placholders within a
+ * {@link String}.
+ * 
+ * @author Christoph Strobl
+ * @author Thomas Darimont
+ * @author Oliver Gierke
+ * @since 1.9
+ */
+class ExpressionEvaluatingParameterBinder {
+
+	private final SpelExpressionParser expressionParser;
+	private final EvaluationContextProvider evaluationContextProvider;
+
+	/**
+	 * Creates new {@link ExpressionEvaluatingParameterBinder}
+	 * 
+	 * @param expressionParser must not be {@literal null}.
+	 * @param evaluationContextProvider must not be {@literal null}.
+	 */
+	public ExpressionEvaluatingParameterBinder(SpelExpressionParser expressionParser,
+			EvaluationContextProvider evaluationContextProvider) {
+
+		Assert.notNull(expressionParser, "ExpressionParser must not be null!");
+		Assert.notNull(evaluationContextProvider, "EvaluationContextProvider must not be null!");
+
+		this.expressionParser = expressionParser;
+		this.evaluationContextProvider = evaluationContextProvider;
+	}
+
+	/**
+	 * Bind values provided by {@link MongoParameterAccessor} to placeholders in {@literal raw} while considering
+	 * potential conversions and parameter types.
+	 * 
+	 * @param raw can be {@literal null} or empty.
+	 * @param accessor must not be {@literal null}.
+	 * @param bindingContext must not be {@literal null}.
+	 * @return {@literal null} if given {@code raw} value is empty.
+	 */
+	public String bind(String raw, MongoParameterAccessor accessor, BindingContext bindingContext) {
+
+		if (!StringUtils.hasText(raw)) {
+			return null;
+		}
+
+		return replacePlaceholders(raw, accessor, bindingContext);
+	}
+
+	/**
+	 * Replaced the parameter placeholders with the actual parameter values from the given {@link ParameterBinding}s.
+	 * 
+	 * @param input must not be {@literal null} or empty.
+	 * @param accessor must not be {@literal null}.
+	 * @param bindings must not be {@literal null}.
+	 * @return
+	 */
+	private String replacePlaceholders(String input, MongoParameterAccessor accessor, BindingContext bindingContext) {
+
+		if (!bindingContext.hasBindings()) {
+			return input;
+		}
+
+		boolean isCompletlyParameterizedQuery = input.matches("^\\?\\d+$");
+		StringBuilder result = new StringBuilder(input);
+
+		for (ParameterBinding binding : bindingContext.getBindings()) {
+
+			String parameter = binding.getParameter();
+			int idx = result.indexOf(parameter);
+
+			if (idx == -1) {
+				continue;
+			}
+
+			String valueForBinding = getParameterValueForBinding(accessor, bindingContext.getParameters(), binding);
+
+			int start = idx;
+			int end = idx + parameter.length();
+
+			// If the value to bind is an object literal we need to remove the quoting around the expression insertion point.
+			if (valueForBinding.startsWith("{") && !isCompletlyParameterizedQuery) {
+
+				// Is the insertion point actually surrounded by quotes?
+				char beforeStart = result.charAt(start - 1);
+				char afterEnd = result.charAt(end);
+
+				if ((beforeStart == '\'' || beforeStart == '"') && (afterEnd == '\'' || afterEnd == '"')) {
+
+					// Skip preceding and following quote
+					start -= 1;
+					end += 1;
+				}
+			}
+
+			result.replace(start, end, valueForBinding);
+		}
+
+		return result.toString();
+	}
+
+	/**
+	 * Returns the serialized value to be used for the given {@link ParameterBinding}.
+	 * 
+	 * @param accessor must not be {@literal null}.
+	 * @param parameters
+	 * @param binding must not be {@literal null}.
+	 * @return
+	 */
+	private String getParameterValueForBinding(MongoParameterAccessor accessor, MongoParameters parameters,
+			ParameterBinding binding) {
+
+		Object value = binding.isExpression()
+				? evaluateExpression(binding.getExpression(), parameters, accessor.getValues())
+				: accessor.getBindableValue(binding.getParameterIndex());
+
+		if (value instanceof String && binding.isQuoted()) {
+			return (String) value;
+		}
+
+		if (value instanceof byte[]) {
+
+			String base64representation = DatatypeConverter.printBase64Binary((byte[]) value);
+
+			if (!binding.isQuoted()) {
+				return "{ '$binary' : '" + base64representation + "', '$type' : " + BSON.B_GENERAL + "}";
+			}
+
+			return base64representation;
+		}
+
+		return JSON.serialize(value);
+	}
+
+	/**
+	 * Evaluates the given {@code expressionString}.
+	 * 
+	 * @param expressionString must not be {@literal null} or empty.
+	 * @param parameters must not be {@literal null}.
+	 * @param parameterValues must not be {@literal null}.
+	 * @return
+	 */
+	private Object evaluateExpression(String expressionString, MongoParameters parameters, Object[] parameterValues) {
+
+		EvaluationContext evaluationContext = evaluationContextProvider.getEvaluationContext(parameters, parameterValues);
+		Expression expression = expressionParser.parseExpression(expressionString);
+
+		return expression.getValue(evaluationContext, Object.class);
+	}
+
+	/**
+	 * @author Christoph Strobl
+	 * @since 1.9
+	 */
+	static class BindingContext {
+
+		final MongoParameters parameters;
+		final List<ParameterBinding> bindings;
+
+		/**
+		 * Creates new {@link BindingContext}.
+		 * 
+		 * @param parameters
+		 * @param bindings
+		 */
+		public BindingContext(MongoParameters parameters, List<ParameterBinding> bindings) {
+
+			this.parameters = parameters;
+			this.bindings = bindings;
+		}
+
+		/**
+		 * @return {@literal true} when list of bindings is not empty.
+		 */
+		boolean hasBindings() {
+			return !CollectionUtils.isEmpty(bindings);
+		}
+
+		/**
+		 * Get unmodifiable list of {@link ParameterBinding}s.
+		 * 
+		 * @return never {@literal null}.
+		 */
+		public List<ParameterBinding> getBindings() {
+			return Collections.unmodifiableList(bindings);
+		}
+
+		/**
+		 * Get the associated {@link MongoParameters}.
+		 * 
+		 * @return
+		 */
+		public MongoParameters getParameters() {
+			return parameters;
+		}
+
+	}
+}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/MongoParametersParameterAccessor.java

@@ -15,6 +15,9 @@
  */
 package org.springframework.data.mongodb.repository.query;
 
+import java.util.Arrays;
+import java.util.List;
+
 import org.springframework.data.domain.Range;
 import org.springframework.data.geo.Distance;
 import org.springframework.data.geo.Point;
@@ -34,7 +37,7 @@ import org.springframework.util.ClassUtils;
 public class MongoParametersParameterAccessor extends ParametersParameterAccessor implements MongoParameterAccessor {
 
 	private final MongoQueryMethod method;
-	private final Object[] values;
+	private final List<Object> values;
 
 	/**
 	 * Creates a new {@link MongoParametersParameterAccessor}.
@@ -43,9 +46,11 @@ public class MongoParametersParameterAccessor extends ParametersParameterAccesso
 	 * @param values must not be {@literal null}.
 	 */
 	public MongoParametersParameterAccessor(MongoQueryMethod method, Object[] values) {
+
 		super(method.getParameters(), values);
+
 		this.method = method;
-		this.values = values;
+		this.values = Arrays.asList(values);
 	}
 
 	public Range<Distance> getDistanceRange() {
@@ -131,6 +136,6 @@ public class MongoParametersParameterAccessor extends ParametersParameterAccesso
 	 */
 	@Override
 	public Object[] getValues() {
-		return values;
+		return values.toArray();
 	}
 }

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/MongoQueryCreator.java

@@ -20,6 +20,7 @@ import static org.springframework.data.mongodb.core.query.Criteria.*;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Iterator;
+import java.util.regex.Pattern;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -29,6 +30,7 @@ import org.springframework.data.geo.Distance;
 import org.springframework.data.geo.Metrics;
 import org.springframework.data.geo.Point;
 import org.springframework.data.geo.Shape;
+import org.springframework.data.mapping.PropertyPath;
 import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.data.mapping.context.PersistentPropertyPath;
 import org.springframework.data.mongodb.core.index.GeoSpatialIndexType;
@@ -44,6 +46,7 @@ import org.springframework.data.repository.query.parser.Part.IgnoreCaseType;
 import org.springframework.data.repository.query.parser.Part.Type;
 import org.springframework.data.repository.query.parser.PartTree;
 import org.springframework.util.Assert;
+import org.springframework.util.ObjectUtils;
 
 /**
  * Custom query creator to create Mongo criterias.
@@ -55,6 +58,7 @@ import org.springframework.util.Assert;
 class MongoQueryCreator extends AbstractQueryCreator<Query, Criteria> {
 
 	private static final Logger LOG = LoggerFactory.getLogger(MongoQueryCreator.class);
+	private static final Pattern PUNCTATION_PATTERN = Pattern.compile("\\p{Punct}");
 	private final MongoParameterAccessor accessor;
 	private final boolean isGeoNearQuery;
 
@@ -165,32 +169,31 @@ class MongoQueryCreator extends AbstractQueryCreator<Query, Criteria> {
 	 * @param parameters
 	 * @return
 	 */
-	private Criteria from(Part part, MongoPersistentProperty property, Criteria criteria,
-			PotentiallyConvertingIterator parameters) {
+	private Criteria from(Part part, MongoPersistentProperty property, Criteria criteria, Iterator<Object> parameters) {
 
 		Type type = part.getType();
 
 		switch (type) {
 			case AFTER:
 			case GREATER_THAN:
-				return criteria.gt(parameters.nextConverted(property));
+				return criteria.gt(parameters.next());
 			case GREATER_THAN_EQUAL:
-				return criteria.gte(parameters.nextConverted(property));
+				return criteria.gte(parameters.next());
 			case BEFORE:
 			case LESS_THAN:
-				return criteria.lt(parameters.nextConverted(property));
+				return criteria.lt(parameters.next());
 			case LESS_THAN_EQUAL:
-				return criteria.lte(parameters.nextConverted(property));
+				return criteria.lte(parameters.next());
 			case BETWEEN:
-				return criteria.gt(parameters.nextConverted(property)).lt(parameters.nextConverted(property));
+				return criteria.gt(parameters.next()).lt(parameters.next());
 			case IS_NOT_NULL:
 				return criteria.ne(null);
 			case IS_NULL:
 				return criteria.is(null);
 			case NOT_IN:
-				return criteria.nin(nextAsArray(parameters, property));
+				return criteria.nin(nextAsArray(parameters));
 			case IN:
-				return criteria.in(nextAsArray(parameters, property));
+				return criteria.in(nextAsArray(parameters));
 			case LIKE:
 			case STARTING_WITH:
 			case ENDING_WITH:
@@ -237,12 +240,12 @@ class MongoQueryCreator extends AbstractQueryCreator<Query, Criteria> {
 				return criteria.within((Shape) parameter);
 			case SIMPLE_PROPERTY:
 
-				return isSimpleComparisionPossible(part) ? criteria.is(parameters.nextConverted(property))
+				return isSimpleComparisionPossible(part) ? criteria.is(parameters.next())
 						: createLikeRegexCriteriaOrThrow(part, property, criteria, parameters, false);
 
 			case NEGATING_SIMPLE_PROPERTY:
 
-				return isSimpleComparisionPossible(part) ? criteria.ne(parameters.nextConverted(property))
+				return isSimpleComparisionPossible(part) ? criteria.ne(parameters.next())
 						: createLikeRegexCriteriaOrThrow(part, property, criteria, parameters, true);
 			default:
 				throw new IllegalArgumentException("Unsupported keyword!");
@@ -274,22 +277,26 @@ class MongoQueryCreator extends AbstractQueryCreator<Query, Criteria> {
 	 * @return the criteria extended with the like-regex.
 	 */
 	private Criteria createLikeRegexCriteriaOrThrow(Part part, MongoPersistentProperty property, Criteria criteria,
-			PotentiallyConvertingIterator parameters, boolean shouldNegateExpression) {
+			Iterator<Object> parameters, boolean shouldNegateExpression) {
+
+		PropertyPath path = part.getProperty().getLeafProperty();
 
 		switch (part.shouldIgnoreCase()) {
 
 			case ALWAYS:
-				if (part.getProperty().getType() != String.class) {
-					throw new IllegalArgumentException(String.format("part %s must be of type String but was %s",
-							part.getProperty(), part.getType()));
+				if (path.getType() != String.class) {
+					throw new IllegalArgumentException(
+							String.format("Part %s must be of type String but was %s", path, path.getType()));
 				}
 				// fall-through
 
 			case WHEN_POSSIBLE:
+
 				if (shouldNegateExpression) {
 					criteria = criteria.not();
 				}
-				return addAppropriateLikeRegexTo(criteria, part, parameters.nextConverted(property).toString());
+
+				return addAppropriateLikeRegexTo(criteria, part, parameters.next().toString());
 
 			case NEVER:
 				// intentional no-op
@@ -311,10 +318,10 @@ class MongoQueryCreator extends AbstractQueryCreator<Query, Criteria> {
 	 * @return
 	 */
 	private Criteria createContainingCriteria(Part part, MongoPersistentProperty property, Criteria criteria,
-			PotentiallyConvertingIterator parameters) {
+			Iterator<Object> parameters) {
 
 		if (property.isCollectionLike()) {
-			return criteria.in(nextAsArray(parameters, property));
+			return criteria.in(nextAsArray(parameters));
 		}
 
 		return addAppropriateLikeRegexTo(criteria, part, parameters.next().toString());
@@ -365,16 +372,17 @@ class MongoQueryCreator extends AbstractQueryCreator<Query, Criteria> {
 			return (T) parameter;
 		}
 
-		throw new IllegalArgumentException(String.format("Expected parameter type of %s but got %s!", type,
-				parameter.getClass()));
+		throw new IllegalArgumentException(
+				String.format("Expected parameter type of %s but got %s!", type, parameter.getClass()));
 	}
 
-	private Object[] nextAsArray(PotentiallyConvertingIterator iterator, MongoPersistentProperty property) {
-		Object next = iterator.nextConverted(property);
+	private Object[] nextAsArray(Iterator<Object> iterator) {
+
+		Object next = iterator.next();
 
 		if (next instanceof Collection) {
 			return ((Collection<?>) next).toArray();
-		} else if (next.getClass().isArray()) {
+		} else if (next != null && next.getClass().isArray()) {
 			return (Object[]) next;
 		}
 
@@ -384,25 +392,59 @@ class MongoQueryCreator extends AbstractQueryCreator<Query, Criteria> {
 	private String toLikeRegex(String source, Part part) {
 
 		Type type = part.getType();
+		String regex = prepareAndEscapeStringBeforeApplyingLikeRegex(source, part);
 
 		switch (type) {
 			case STARTING_WITH:
-				source = "^" + source;
+				regex = "^" + regex;
 				break;
 			case ENDING_WITH:
-				source = source + "$";
+				regex = regex + "$";
 				break;
 			case CONTAINING:
 			case NOT_CONTAINING:
-				source = "*" + source + "*";
+				regex = ".*" + regex + ".*";
 				break;
 			case SIMPLE_PROPERTY:
 			case NEGATING_SIMPLE_PROPERTY:
-				source = "^" + source + "$";
+				regex = "^" + regex + "$";
 			default:
 		}
 
-		return source.replaceAll("\\*", ".*");
+		return regex;
+	}
+
+	private String prepareAndEscapeStringBeforeApplyingLikeRegex(String source, Part qpart) {
+
+		if (!ObjectUtils.nullSafeEquals(Type.LIKE, qpart.getType())) {
+			return PUNCTATION_PATTERN.matcher(source).find() ? Pattern.quote(source) : source;
+		}
+
+		if ("*".equals(source)) {
+			return ".*";
+		}
+
+		StringBuilder sb = new StringBuilder();
+
+		boolean leadingWildcard = source.startsWith("*");
+		boolean trailingWildcard = source.endsWith("*");
+
+		String valueToUse = source.substring(leadingWildcard ? 1 : 0,
+				trailingWildcard ? source.length() - 1 : source.length());
+
+		if (PUNCTATION_PATTERN.matcher(valueToUse).find()) {
+			valueToUse = Pattern.quote(valueToUse);
+		}
+
+		if (leadingWildcard) {
+			sb.append(".*");
+		}
+		sb.append(valueToUse);
+		if (trailingWildcard) {
+			sb.append(".*");
+		}
+
+		return sb.toString();
 	}
 
 	private boolean isSpherical(MongoPersistentProperty property) {

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/MongoQueryExecution.java

@@ -0,0 +1,381 @@
+/*
+ * Copyright 2016 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.query;
+
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Function;
+
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.data.convert.EntityInstantiators;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Range;
+import org.springframework.data.domain.Slice;
+import org.springframework.data.domain.SliceImpl;
+import org.springframework.data.geo.Distance;
+import org.springframework.data.geo.GeoPage;
+import org.springframework.data.geo.GeoResult;
+import org.springframework.data.geo.GeoResults;
+import org.springframework.data.geo.Point;
+import org.springframework.data.mongodb.core.MongoOperations;
+import org.springframework.data.mongodb.core.query.NearQuery;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.repository.query.ResultProcessor;
+import org.springframework.data.repository.query.ReturnedType;
+import org.springframework.data.util.CloseableIterator;
+import org.springframework.data.util.StreamUtils;
+import org.springframework.data.util.TypeInformation;
+import org.springframework.util.ClassUtils;
+
+import com.mongodb.WriteResult;
+
+interface MongoQueryExecution {
+
+	Object execute(Query query, Class<?> type, String collection);
+
+	/**
+	 * {@link MongoQueryExecution} for collection returning queries.
+	 * 
+	 * @author Oliver Gierke
+	 */
+	@RequiredArgsConstructor
+	static final class CollectionExecution implements MongoQueryExecution {
+
+		private final @NonNull MongoOperations operations;
+		private final Pageable pageable;
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.repository.query.AbstractMongoQuery.Execution#execute(org.springframework.data.mongodb.core.query.Query, java.lang.Class, java.lang.String)
+		 */
+		@Override
+		public Object execute(Query query, Class<?> type, String collection) {
+			return operations.find(query.with(pageable), type, collection);
+		}
+	}
+
+	/**
+	 * {@link MongoQueryExecution} for {@link Slice} query methods.
+	 * 
+	 * @author Oliver Gierke
+	 * @author Christoph Strobl
+	 * @since 1.5
+	 */
+	@RequiredArgsConstructor
+	static final class SlicedExecution implements MongoQueryExecution {
+
+		private final @NonNull MongoOperations operations;
+		private final @NonNull Pageable pageable;
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.repository.query.AbstractMongoQuery.Execution#execute(org.springframework.data.mongodb.core.query.Query, java.lang.Class, java.lang.String)
+		 */
+		@Override
+		@SuppressWarnings({ "unchecked", "rawtypes" })
+		public Object execute(Query query, Class<?> type, String collection) {
+
+			int pageSize = pageable.getPageSize();
+
+			// Apply Pageable but tweak limit to peek into next page
+			Query modifiedQuery = query.with(pageable).limit(pageSize + 1);
+			List result = operations.find(modifiedQuery, type, collection);
+
+			boolean hasNext = result.size() > pageSize;
+
+			return new SliceImpl<Object>(hasNext ? result.subList(0, pageSize) : result, pageable, hasNext);
+		}
+	}
+
+	/**
+	 * {@link MongoQueryExecution} for pagination queries.
+	 * 
+	 * @author Oliver Gierke
+	 */
+	@RequiredArgsConstructor
+	static final class PagedExecution implements MongoQueryExecution {
+
+		private final @NonNull MongoOperations operations;
+		private final @NonNull Pageable pageable;
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.repository.query.AbstractMongoQuery.Execution#execute(org.springframework.data.mongodb.core.query.Query, java.lang.Class, java.lang.String)
+		 */
+		@Override
+		@SuppressWarnings({ "rawtypes", "unchecked" })
+		public Object execute(Query query, Class<?> type, String collection) {
+
+			int overallLimit = query.getLimit();
+			long count = operations.count(query, type, collection);
+			count = overallLimit != 0 ? Math.min(count, query.getLimit()) : count;
+
+			boolean pageableOutOfScope = pageable.getOffset() > count;
+
+			if (pageableOutOfScope) {
+				return new PageImpl<Object>(Collections.emptyList(), pageable, count);
+			}
+
+			// Apply raw pagination
+			query = query.with(pageable);
+
+			// Adjust limit if page would exceed the overall limit
+			if (overallLimit != 0 && pageable.getOffset() + pageable.getPageSize() > overallLimit) {
+				query.limit(overallLimit - pageable.getOffset());
+			}
+
+			List<?> result = operations.find(query, type, collection);
+			return new PageImpl(result, pageable, count);
+		}
+	}
+
+	/**
+	 * {@link MongoQueryExecution} to return a single entity.
+	 * 
+	 * @author Oliver Gierke
+	 */
+	@RequiredArgsConstructor
+	static final class SingleEntityExecution implements MongoQueryExecution {
+
+		private final MongoOperations operations;
+		private final boolean countProjection;
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.repository.query.AbstractMongoQuery.Execution#execute(org.springframework.data.mongodb.core.query.Query, java.lang.Class, java.lang.String)
+		 */
+		@Override
+		public Object execute(Query query, Class<?> type, String collection) {
+			return countProjection ? operations.count(query, type, collection) : operations.findOne(query, type, collection);
+		}
+	}
+
+	/**
+	 * {@link MongoQueryExecution} to execute geo-near queries.
+	 * 
+	 * @author Oliver Gierke
+	 */
+	@RequiredArgsConstructor
+	static class GeoNearExecution implements MongoQueryExecution {
+
+		private final MongoOperations operations;
+		private final MongoParameterAccessor accessor;
+		private final TypeInformation<?> returnType;
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.repository.query.AbstractMongoQuery.Execution#execute(org.springframework.data.mongodb.core.query.Query, java.lang.Class, java.lang.String)
+		 */
+		@Override
+		public Object execute(Query query, Class<?> type, String collection) {
+
+			GeoResults<?> results = doExecuteQuery(query, type, collection);
+			return isListOfGeoResult() ? results.getContent() : results;
+		}
+
+		@SuppressWarnings("unchecked")
+		protected GeoResults<Object> doExecuteQuery(Query query, Class<?> type, String collection) {
+
+			Point nearLocation = accessor.getGeoNearLocation();
+			NearQuery nearQuery = NearQuery.near(nearLocation);
+
+			if (query != null) {
+				nearQuery.query(query);
+			}
+
+			Range<Distance> distances = accessor.getDistanceRange();
+			Distance maxDistance = distances.getUpperBound();
+
+			if (maxDistance != null) {
+				nearQuery.maxDistance(maxDistance).in(maxDistance.getMetric());
+			}
+
+			Distance minDistance = distances.getLowerBound();
+
+			if (minDistance != null) {
+				nearQuery.minDistance(minDistance).in(minDistance.getMetric());
+			}
+
+			Pageable pageable = accessor.getPageable();
+
+			if (pageable != null) {
+				nearQuery.with(pageable);
+			}
+
+			return (GeoResults<Object>) operations.geoNear(nearQuery, type, collection);
+		}
+
+		private boolean isListOfGeoResult() {
+
+			if (!returnType.getType().equals(List.class)) {
+				return false;
+			}
+
+			TypeInformation<?> componentType = returnType.getComponentType();
+			return componentType == null ? false : GeoResult.class.equals(componentType.getType());
+		}
+	}
+
+	static final class PagingGeoNearExecution extends GeoNearExecution {
+
+		private final MongoOperations operations;
+		private final MongoParameterAccessor accessor;
+		private final AbstractMongoQuery mongoQuery;
+
+		public PagingGeoNearExecution(MongoOperations operations, MongoParameterAccessor accessor,
+				TypeInformation<?> returnType, AbstractMongoQuery query) {
+
+			super(operations, accessor, returnType);
+
+			this.accessor = accessor;
+			this.operations = operations;
+			this.mongoQuery = query;
+		}
+
+		/**
+		 * Executes the given {@link Query} to return a page.
+		 * 
+		 * @param query must not be {@literal null}.
+		 * @param countQuery must not be {@literal null}.
+		 * @return
+		 */
+		@Override
+		public Object execute(Query query, Class<?> type, String collection) {
+
+			ConvertingParameterAccessor parameterAccessor = new ConvertingParameterAccessor(operations.getConverter(),
+					accessor);
+			Query countQuery = mongoQuery.applyQueryMetaAttributesWhenPresent(mongoQuery.createCountQuery(parameterAccessor));
+			long count = operations.count(countQuery, collection);
+
+			return new GeoPage<Object>(doExecuteQuery(query, type, collection), accessor.getPageable(), count);
+		}
+	}
+
+	/**
+	 * {@link MongoQueryExecution} removing documents matching the query.
+	 * 
+	 * @since 1.5
+	 */
+	@RequiredArgsConstructor
+	static final class DeleteExecution implements MongoQueryExecution {
+
+		private final MongoOperations operations;
+		private final MongoQueryMethod method;
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.repository.query.AbstractMongoQuery.Execution#execute(org.springframework.data.mongodb.core.query.Query, java.lang.Class, java.lang.String)
+		 */
+		@Override
+		public Object execute(Query query, Class<?> type, String collection) {
+
+			if (method.isCollectionQuery()) {
+				return operations.findAllAndRemove(query, type, collection);
+			}
+
+			WriteResult writeResult = operations.remove(query, type, collection);
+			return writeResult != null ? writeResult.getN() : 0L;
+		}
+	}
+
+	/**
+	 * @author Thomas Darimont
+	 * @since 1.7
+	 */
+	@RequiredArgsConstructor
+	static final class StreamExecution implements MongoQueryExecution {
+
+		private final @NonNull MongoOperations operations;
+		private final @NonNull Converter<Object, Object> resultProcessing;
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.repository.query.AbstractMongoQuery.Execution#execute(org.springframework.data.mongodb.core.query.Query, java.lang.Class, java.lang.String)
+		 */
+		@Override
+		@SuppressWarnings("unchecked")
+		public Object execute(Query query, Class<?> type, String collection) {
+
+			return StreamUtils.createStreamFromIterator((CloseableIterator<Object>) operations.stream(query, type))
+					.map(new Function<Object, Object>() {
+
+						@Override
+						public Object apply(Object t) {
+							return resultProcessing.convert(t);
+						}
+					});
+		}
+	}
+
+	/**
+	 * An {@link MongoQueryExecution} that wraps the results of the given delegate with the given result processing.
+	 *
+	 * @author Oliver Gierke
+	 * @since 1.9
+	 */
+	@RequiredArgsConstructor
+	static final class ResultProcessingExecution implements MongoQueryExecution {
+
+		private final @NonNull MongoQueryExecution delegate;
+		private final @NonNull Converter<Object, Object> converter;
+
+		/* 
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.repository.query.AbstractMongoQuery.Execution#execute(org.springframework.data.mongodb.core.query.Query, java.lang.Class, java.lang.String)
+		 */
+		@Override
+		public Object execute(Query query, Class<?> type, String collection) {
+			return converter.convert(delegate.execute(query, type, collection));
+		}
+	}
+
+	/**
+	 * A {@link Converter} to post-process all source objects using the given {@link ResultProcessor}.
+	 *
+	 * @author Oliver Gierke
+	 * @since 1.9
+	 */
+	@RequiredArgsConstructor
+	static final class ResultProcessingConverter implements Converter<Object, Object> {
+
+		private final @NonNull ResultProcessor processor;
+		private final @NonNull MongoOperations operations;
+		private final @NonNull EntityInstantiators instantiators;
+
+		/* 
+		 * (non-Javadoc)
+		 * @see org.springframework.core.convert.converter.Converter#convert(java.lang.Object)
+		 */
+		@Override
+		public Object convert(Object source) {
+
+			ReturnedType returnedType = processor.getReturnedType();
+
+			if (ClassUtils.isPrimitiveOrWrapper(returnedType.getReturnedType())) {
+				return source;
+			}
+
+			Converter<Object, Object> converter = new DtoInstantiatingConverter(returnedType.getReturnedType(),
+					operations.getConverter().getMappingContext(), instantiators);
+
+			return processor.processResult(source, converter);
+		}
+	}
+}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/MongoQueryMethod.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.
@@ -29,11 +29,13 @@ import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
 import org.springframework.data.mongodb.repository.Meta;
 import org.springframework.data.mongodb.repository.Query;
+import org.springframework.data.projection.ProjectionFactory;
 import org.springframework.data.repository.core.RepositoryMetadata;
 import org.springframework.data.repository.query.QueryMethod;
 import org.springframework.data.util.ClassTypeInformation;
 import org.springframework.data.util.TypeInformation;
 import org.springframework.util.Assert;
+import org.springframework.util.ClassUtils;
 import org.springframework.util.StringUtils;
 
 /**
@@ -55,12 +57,15 @@ public class MongoQueryMethod extends QueryMethod {
 	/**
 	 * Creates a new {@link MongoQueryMethod} from the given {@link Method}.
 	 * 
-	 * @param method
+	 * @param method must not be {@literal null}.
+	 * @param metadata must not be {@literal null}.
+	 * @param projectionFactory must not be {@literal null}.
+	 * @param mappingContext must not be {@literal null}.
 	 */
-	public MongoQueryMethod(Method method, RepositoryMetadata metadata,
+	public MongoQueryMethod(Method method, RepositoryMetadata metadata, ProjectionFactory projectionFactory,
 			MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext) {
 
-		super(method, metadata);
+		super(method, metadata, projectionFactory);
 
 		Assert.notNull(mappingContext, "MappingContext must not be null!");
 
@@ -122,13 +127,23 @@ public class MongoQueryMethod extends QueryMethod {
 			Class<?> returnedObjectType = getReturnedObjectType();
 			Class<?> domainClass = getDomainClass();
 
-			MongoPersistentEntity<?> returnedEntity = mappingContext.getPersistentEntity(getReturnedObjectType());
-			MongoPersistentEntity<?> managedEntity = mappingContext.getPersistentEntity(domainClass);
-			returnedEntity = returnedEntity == null ? managedEntity : returnedEntity;
-			MongoPersistentEntity<?> collectionEntity = domainClass.isAssignableFrom(returnedObjectType) ? returnedEntity
-					: managedEntity;
+			if (ClassUtils.isPrimitiveOrWrapper(returnedObjectType)) {
 
-			this.metadata = new SimpleMongoEntityMetadata<Object>((Class<Object>) returnedEntity.getType(), collectionEntity);
+				this.metadata = new SimpleMongoEntityMetadata<Object>((Class<Object>) domainClass,
+						mappingContext.getPersistentEntity(domainClass));
+
+			} else {
+
+				MongoPersistentEntity<?> returnedEntity = mappingContext.getPersistentEntity(returnedObjectType);
+				MongoPersistentEntity<?> managedEntity = mappingContext.getPersistentEntity(domainClass);
+				returnedEntity = returnedEntity == null || returnedEntity.getType().isInterface() ? managedEntity
+						: returnedEntity;
+				MongoPersistentEntity<?> collectionEntity = domainClass.isAssignableFrom(returnedObjectType) ? returnedEntity
+						: managedEntity;
+
+				this.metadata = new SimpleMongoEntityMetadata<Object>((Class<Object>) returnedEntity.getType(),
+						collectionEntity);
+			}
 		}
 
 		return this.metadata;

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/PartTreeMongoQuery.java

@@ -20,10 +20,13 @@ import org.springframework.data.mongodb.core.MongoOperations;
 import org.springframework.data.mongodb.core.MongoTemplate;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
 import org.springframework.data.mongodb.core.query.BasicQuery;
+import org.springframework.data.mongodb.core.query.Field;
 import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.data.mongodb.core.query.TextCriteria;
 import org.springframework.data.repository.query.QueryMethod;
 import org.springframework.data.repository.query.RepositoryQuery;
+import org.springframework.data.repository.query.ResultProcessor;
+import org.springframework.data.repository.query.ReturnedType;
 import org.springframework.data.repository.query.parser.PartTree;
 import org.springframework.util.StringUtils;
 
@@ -41,6 +44,7 @@ public class PartTreeMongoQuery extends AbstractMongoQuery {
 	private final PartTree tree;
 	private final boolean isGeoNearQuery;
 	private final MappingContext<?, MongoPersistentProperty> context;
+	private final ResultProcessor processor;
 
 	/**
 	 * Creates a new {@link PartTreeMongoQuery} from the given {@link QueryMethod} and {@link MongoTemplate}.
@@ -51,7 +55,9 @@ public class PartTreeMongoQuery extends AbstractMongoQuery {
 	public PartTreeMongoQuery(MongoQueryMethod method, MongoOperations mongoOperations) {
 
 		super(method, mongoOperations);
-		this.tree = new PartTree(method.getName(), method.getEntityInformation().getJavaType());
+
+		this.processor = method.getResultProcessor();
+		this.tree = new PartTree(method.getName(), processor.getReturnedType().getDomainType());
 		this.isGeoNearQuery = method.isGeoNearQuery();
 		this.context = mongoOperations.getConverter().getMappingContext();
 	}
@@ -87,6 +93,18 @@ public class PartTreeMongoQuery extends AbstractMongoQuery {
 		String fieldSpec = this.getQueryMethod().getFieldSpecification();
 
 		if (!StringUtils.hasText(fieldSpec)) {
+
+			ReturnedType returnedType = processor.withDynamicProjection(accessor).getReturnedType();
+
+			if (returnedType.isProjecting()) {
+
+				Field fields = query.fields();
+
+				for (String field : returnedType.getInputProperties()) {
+					fields.include(field);
+				}
+			}
+
 			return query;
 		}
 

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/StringBasedMongoQuery.java

@@ -26,9 +26,8 @@ import org.slf4j.LoggerFactory;
 import org.springframework.data.mongodb.core.MongoOperations;
 import org.springframework.data.mongodb.core.query.BasicQuery;
 import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.mongodb.repository.query.ExpressionEvaluatingParameterBinder.BindingContext;
 import org.springframework.data.repository.query.EvaluationContextProvider;
-import org.springframework.expression.EvaluationContext;
-import org.springframework.expression.Expression;
 import org.springframework.expression.spel.standard.SpelExpressionParser;
 import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
@@ -56,8 +55,7 @@ public class StringBasedMongoQuery extends AbstractMongoQuery {
 	private final boolean isDeleteQuery;
 	private final List<ParameterBinding> queryParameterBindings;
 	private final List<ParameterBinding> fieldSpecParameterBindings;
-	private final SpelExpressionParser expressionParser;
-	private final EvaluationContextProvider evaluationContextProvider;
+	private final ExpressionEvaluatingParameterBinder parameterBinder;
 
 	/**
 	 * Creates a new {@link StringBasedMongoQuery} for the given {@link MongoQueryMethod} and {@link MongoOperations}.
@@ -89,9 +87,6 @@ public class StringBasedMongoQuery extends AbstractMongoQuery {
 		Assert.notNull(query, "Query must not be null!");
 		Assert.notNull(expressionParser, "SpelExpressionParser must not be null!");
 
-		this.expressionParser = expressionParser;
-		this.evaluationContextProvider = evaluationContextProvider;
-
 		this.queryParameterBindings = new ArrayList<ParameterBinding>();
 		this.query = BINDING_PARSER.parseAndCollectParameterBindingsFromQueryIntoBindings(query,
 				this.queryParameterBindings);
@@ -106,6 +101,8 @@ public class StringBasedMongoQuery extends AbstractMongoQuery {
 		if (isCountQuery && isDeleteQuery) {
 			throw new IllegalArgumentException(String.format(COUND_AND_DELETE, method));
 		}
+
+		this.parameterBinder = new ExpressionEvaluatingParameterBinder(expressionParser, evaluationContextProvider);
 	}
 
 	/*
@@ -115,21 +112,15 @@ public class StringBasedMongoQuery extends AbstractMongoQuery {
 	@Override
 	protected Query createQuery(ConvertingParameterAccessor accessor) {
 
-		String queryString = replacePlaceholders(query, accessor, queryParameterBindings);
+		String queryString = parameterBinder.bind(this.query, accessor, new BindingContext(getQueryMethod()
+				.getParameters(), queryParameterBindings));
+		String fieldsString = parameterBinder.bind(this.fieldSpec, accessor, new BindingContext(getQueryMethod()
+				.getParameters(), fieldSpecParameterBindings));
 
-		Query query = null;
-
-		if (fieldSpec != null) {
-			String fieldString = replacePlaceholders(fieldSpec, accessor, fieldSpecParameterBindings);
-			query = new BasicQuery(queryString, fieldString);
-		} else {
-			query = new BasicQuery(queryString);
-		}
-
-		query.with(accessor.getSort());
+		Query query = new BasicQuery(queryString, fieldsString).with(accessor.getSort());
 
 		if (LOG.isDebugEnabled()) {
-			LOG.debug(String.format("Created query %s", query.getQueryObject()));
+			LOG.debug(String.format("Created query %s for %s fields.", query.getQueryObject(), query.getFieldsObject()));
 		}
 
 		return query;
@@ -153,70 +144,6 @@ public class StringBasedMongoQuery extends AbstractMongoQuery {
 		return this.isDeleteQuery;
 	}
 
-	/**
-	 * Replaced the parameter place-holders with the actual parameter values from the given {@link ParameterBinding}s.
-	 * 
-	 * @param input
-	 * @param accessor
-	 * @param bindings
-	 * @return
-	 */
-	private String replacePlaceholders(String input, ConvertingParameterAccessor accessor,
-			List<ParameterBinding> bindings) {
-
-		if (bindings.isEmpty()) {
-			return input;
-		}
-
-		StringBuilder result = new StringBuilder(input);
-
-		for (ParameterBinding binding : bindings) {
-
-			String parameter = binding.getParameter();
-			int idx = result.indexOf(parameter);
-
-			if (idx != -1) {
-				result.replace(idx, idx + parameter.length(), getParameterValueForBinding(accessor, binding));
-			}
-		}
-
-		return result.toString();
-	}
-
-	/**
-	 * Returns the serialized value to be used for the given {@link ParameterBinding}.
-	 * 
-	 * @param accessor
-	 * @param binding
-	 * @return
-	 */
-	private String getParameterValueForBinding(ConvertingParameterAccessor accessor, ParameterBinding binding) {
-
-		Object value = binding.isExpression() ? evaluateExpression(binding.getExpression(), accessor.getValues())
-				: accessor.getBindableValue(binding.getParameterIndex());
-
-		if (value instanceof String && binding.isQuoted()) {
-			return (String) value;
-		}
-
-		return JSON.serialize(value);
-	}
-
-	/**
-	 * Evaluates the given {@code expressionString}.
-	 * 
-	 * @param expressionString
-	 * @param parameterValues
-	 * @return
-	 */
-	private Object evaluateExpression(String expressionString, Object[] parameterValues) {
-
-		EvaluationContext evaluationContext = evaluationContextProvider
-				.getEvaluationContext(getQueryMethod().getParameters(), parameterValues);
-		Expression expression = expressionParser.parseExpression(expressionString);
-		return expression.getValue(evaluationContext, Object.class);
-	}
-
 	/**
 	 * A parser that extracts the parameter bindings from a given query string.
 	 * 
@@ -226,11 +153,16 @@ public class StringBasedMongoQuery extends AbstractMongoQuery {
 
 		INSTANCE;
 
+		private static final String EXPRESSION_PARAM_QUOTE = "'";
+		private static final String EXPRESSION_PARAM_PREFIX = "?expr";
+		private static final String INDEX_BASED_EXPRESSION_PARAM_START = "?#{";
+		private static final String NAME_BASED_EXPRESSION_PARAM_START = ":#{";
+		private static final char CURRLY_BRACE_OPEN = '{';
+		private static final char CURRLY_BRACE_CLOSE = '}';
 		private static final String PARAMETER_PREFIX = "_param_";
 		private static final String PARSEABLE_PARAMETER = "\"" + PARAMETER_PREFIX + "$1\"";
 		private static final Pattern PARAMETER_BINDING_PATTERN = Pattern.compile("\\?(\\d+)");
 		private static final Pattern PARSEABLE_BINDING_PATTERN = Pattern.compile("\"?" + PARAMETER_PREFIX + "(\\d+)\"?");
-		private static final Pattern PARAMETER_EXPRESSION_PATTERN = Pattern.compile("((:|\\?)#\\{([^}]+)\\})");
 
 		private final static int PARAMETER_INDEX_GROUP = 1;
 
@@ -258,44 +190,64 @@ public class StringBasedMongoQuery extends AbstractMongoQuery {
 			return transformedInput;
 		}
 
-		private String transformQueryAndCollectExpressionParametersIntoBindings(String input,
+		private static String transformQueryAndCollectExpressionParametersIntoBindings(String input,
 				List<ParameterBinding> bindings) {
 
-			Matcher matcher = PARAMETER_EXPRESSION_PATTERN.matcher(input);
-
 			StringBuilder result = new StringBuilder();
 
-			int lastPos = 0;
+			int startIndex = 0;
+			int currentPos = 0;
 			int exprIndex = 0;
 
-			while (matcher.find()) {
+			while (currentPos < input.length()) {
 
-				int startOffSet = matcher.start();
+				int indexOfExpressionParameter = getIndexOfExpressionParameter(input, currentPos);
 
-				result.append(input.subSequence(lastPos, startOffSet));
-				result.append("'?expr").append(exprIndex).append("'");
+				// no expression parameter found
+				if (indexOfExpressionParameter < 0) {
+					break;
+				}
 
-				lastPos = matcher.end();
+				int exprStart = indexOfExpressionParameter + 3;
+				currentPos = exprStart;
 
-				bindings.add(new ParameterBinding(exprIndex, true, matcher.group(3)));
+				// eat parameter expression
+				int curlyBraceOpenCnt = 1;
+
+				while (curlyBraceOpenCnt > 0) {
+					switch (input.charAt(currentPos++)) {
+						case CURRLY_BRACE_OPEN:
+							curlyBraceOpenCnt++;
+							break;
+						case CURRLY_BRACE_CLOSE:
+							curlyBraceOpenCnt--;
+							break;
+						default:
+					}
+				}
+
+				result.append(input.subSequence(startIndex, indexOfExpressionParameter));
+				result.append(EXPRESSION_PARAM_QUOTE).append(EXPRESSION_PARAM_PREFIX);
+				result.append(exprIndex);
+				result.append(EXPRESSION_PARAM_QUOTE);
+
+				bindings.add(new ParameterBinding(exprIndex, true, input.substring(exprStart, currentPos - 1)));
+
+				startIndex = currentPos;
 
 				exprIndex++;
 			}
 
-			result.append(input.subSequence(lastPos, input.length()));
-
-			return result.toString();
+			return result.append(input.subSequence(currentPos, input.length())).toString();
 		}
 
-		private String makeParameterReferencesParseable(String input) {
+		private static String makeParameterReferencesParseable(String input) {
 
 			Matcher matcher = PARAMETER_BINDING_PATTERN.matcher(input);
-			String parseableInput = matcher.replaceAll(PARSEABLE_PARAMETER);
-
-			return parseableInput;
+			return matcher.replaceAll(PARSEABLE_PARAMETER);
 		}
 
-		private void collectParameterReferencesIntoBindings(List<ParameterBinding> bindings, Object value) {
+		private static void collectParameterReferencesIntoBindings(List<ParameterBinding> bindings, Object value) {
 
 			if (value instanceof String) {
 
@@ -338,7 +290,7 @@ public class StringBasedMongoQuery extends AbstractMongoQuery {
 			}
 		}
 
-		private void potentiallyAddBinding(String source, List<ParameterBinding> bindings) {
+		private static void potentiallyAddBinding(String source, List<ParameterBinding> bindings) {
 
 			Matcher valueMatcher = PARSEABLE_BINDING_PATTERN.matcher(source);
 
@@ -351,6 +303,14 @@ public class StringBasedMongoQuery extends AbstractMongoQuery {
 				bindings.add(new ParameterBinding(paramIndex, quoted));
 			}
 		}
+
+		private static int getIndexOfExpressionParameter(String input, int position) {
+
+			int indexOfExpressionParameter = input.indexOf(INDEX_BASED_EXPRESSION_PARAM_START, position);
+
+			return indexOfExpressionParameter < 0 ? input.indexOf(NAME_BASED_EXPRESSION_PARAM_START, position)
+					: indexOfExpressionParameter;
+		}
 	}
 
 	/**
@@ -358,7 +318,7 @@ public class StringBasedMongoQuery extends AbstractMongoQuery {
 	 * 
 	 * @author Thomas Darimont
 	 */
-	private static class ParameterBinding {
+	static class ParameterBinding {
 
 		private final int parameterIndex;
 		private final boolean quoted;

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

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011 by the original author(s).
+ * Copyright 2011-2015 by the original author(s).
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,6 +17,7 @@ package org.springframework.data.mongodb.repository.support;
 
 import java.io.Serializable;
 
+import org.bson.types.ObjectId;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
 import org.springframework.data.mongodb.repository.query.MongoEntityInformation;
 import org.springframework.data.repository.core.support.PersistentEntityInformation;
@@ -27,12 +28,14 @@ import org.springframework.data.repository.core.support.PersistentEntityInformat
  * {@link MongoPersistentEntity} if given.
  * 
  * @author Oliver Gierke
+ * @author Christoph Strobl
  */
 public class MappingMongoEntityInformation<T, ID extends Serializable> extends PersistentEntityInformation<T, ID>
 		implements MongoEntityInformation<T, ID> {
 
 	private final MongoPersistentEntity<T> entityMetadata;
 	private final String customCollectionName;
+	private final Class<ID> fallbackIdType;
 
 	/**
 	 * Creates a new {@link MappingMongoEntityInformation} for the given {@link MongoPersistentEntity}.
@@ -40,7 +43,18 @@ public class MappingMongoEntityInformation<T, ID extends Serializable> extends P
 	 * @param entity must not be {@literal null}.
 	 */
 	public MappingMongoEntityInformation(MongoPersistentEntity<T> entity) {
-		this(entity, null);
+		this(entity, null, null);
+	}
+
+	/**
+	 * Creates a new {@link MappingMongoEntityInformation} for the given {@link MongoPersistentEntity} and fallback
+	 * identifier type.
+	 * 
+	 * @param entity must not be {@literal null}.
+	 * @param fallbackIdType can be {@literal null}.
+	 */
+	public MappingMongoEntityInformation(MongoPersistentEntity<T> entity, Class<ID> fallbackIdType) {
+		this(entity, (String) null, fallbackIdType);
 	}
 
 	/**
@@ -51,11 +65,26 @@ public class MappingMongoEntityInformation<T, ID extends Serializable> extends P
 	 * @param customCollectionName can be {@literal null}.
 	 */
 	public MappingMongoEntityInformation(MongoPersistentEntity<T> entity, String customCollectionName) {
+		this(entity, customCollectionName, null);
+	}
+
+	/**
+	 * Creates a new {@link MappingMongoEntityInformation} for the given {@link MongoPersistentEntity}, collection name
+	 * and identifier type.
+	 * 
+	 * @param entity must not be {@literal null}.
+	 * @param customCollectionName can be {@literal null}.
+	 * @param idType can be {@literal null}.
+	 */
+	@SuppressWarnings("unchecked")
+	private MappingMongoEntityInformation(MongoPersistentEntity<T> entity, String customCollectionName,
+			Class<ID> idType) {
 
 		super(entity);
 
 		this.entityMetadata = entity;
 		this.customCollectionName = customCollectionName;
+		this.fallbackIdType = idType != null ? idType : (Class<ID>) ObjectId.class;
 	}
 
 	/* (non-Javadoc)
@@ -71,4 +100,19 @@ public class MappingMongoEntityInformation<T, ID extends Serializable> extends P
 	public String getIdAttribute() {
 		return entityMetadata.getIdProperty().getName();
 	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.repository.core.support.PersistentEntityInformation#getIdType()
+	 */
+	@Override
+	@SuppressWarnings("unchecked")
+	public Class<ID> getIdType() {
+
+		if (this.entityMetadata.hasIdProperty()) {
+			return super.getIdType();
+		}
+
+		return fallbackIdType != null ? fallbackIdType : (Class<ID>) ObjectId.class;
+	}
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2013 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.
@@ -25,17 +25,17 @@ import javax.tools.Diagnostic;
 
 import org.springframework.data.mongodb.core.mapping.Document;
 
-import com.mysema.query.annotations.QueryEmbeddable;
-import com.mysema.query.annotations.QueryEmbedded;
-import com.mysema.query.annotations.QueryEntities;
-import com.mysema.query.annotations.QuerySupertype;
-import com.mysema.query.annotations.QueryTransient;
-import com.mysema.query.apt.AbstractQuerydslProcessor;
-import com.mysema.query.apt.Configuration;
-import com.mysema.query.apt.DefaultConfiguration;
+import com.querydsl.apt.AbstractQuerydslProcessor;
+import com.querydsl.apt.Configuration;
+import com.querydsl.apt.DefaultConfiguration;
+import com.querydsl.core.annotations.QueryEmbeddable;
+import com.querydsl.core.annotations.QueryEmbedded;
+import com.querydsl.core.annotations.QueryEntities;
+import com.querydsl.core.annotations.QuerySupertype;
+import com.querydsl.core.annotations.QueryTransient;
 
 /**
- * Annotation processor to create Querydsl query types for QueryDsl annoated classes.
+ * Annotation processor to create Querydsl query types for QueryDsl annotated classes.
  * 
  * @author Oliver Gierke
  */

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

@@ -30,6 +30,7 @@ import org.springframework.data.mongodb.repository.query.MongoEntityInformation;
 import org.springframework.data.mongodb.repository.query.MongoQueryMethod;
 import org.springframework.data.mongodb.repository.query.PartTreeMongoQuery;
 import org.springframework.data.mongodb.repository.query.StringBasedMongoQuery;
+import org.springframework.data.projection.ProjectionFactory;
 import org.springframework.data.querydsl.QueryDslPredicateExecutor;
 import org.springframework.data.repository.core.NamedQueries;
 import org.springframework.data.repository.core.RepositoryInformation;
@@ -47,12 +48,13 @@ import org.springframework.util.Assert;
  * 
  * @author Oliver Gierke
  * @author Thomas Darimont
+ * @author Christoph Strobl
  */
 public class MongoRepositoryFactory extends RepositoryFactorySupport {
 
 	private static final SpelExpressionParser EXPRESSION_PARSER = new SpelExpressionParser();
 
-	private final MongoOperations mongoOperations;
+	private final MongoOperations operations;
 	private final MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext;
 
 	/**
@@ -64,7 +66,7 @@ public class MongoRepositoryFactory extends RepositoryFactorySupport {
 
 		Assert.notNull(mongoOperations);
 
-		this.mongoOperations = mongoOperations;
+		this.operations = mongoOperations;
 		this.mappingContext = mongoOperations.getConverter().getMappingContext();
 	}
 
@@ -88,8 +90,9 @@ public class MongoRepositoryFactory extends RepositoryFactorySupport {
 	@Override
 	protected Object getTargetRepository(RepositoryInformation information) {
 
-		MongoEntityInformation<?, Serializable> entityInformation = getEntityInformation(information.getDomainType());
-		return getTargetRepositoryViaReflection(information, entityInformation, mongoOperations);
+		MongoEntityInformation<?, Serializable> entityInformation = getEntityInformation(information.getDomainType(),
+				information);
+		return getTargetRepositoryViaReflection(information, entityInformation, operations);
 	}
 
 	/* 
@@ -98,16 +101,20 @@ public class MongoRepositoryFactory extends RepositoryFactorySupport {
 	 */
 	@Override
 	protected QueryLookupStrategy getQueryLookupStrategy(Key key, EvaluationContextProvider evaluationContextProvider) {
-		return new MongoQueryLookupStrategy(evaluationContextProvider);
+		return new MongoQueryLookupStrategy(operations, evaluationContextProvider, mappingContext);
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.repository.core.support.RepositoryFactorySupport#getEntityInformation(java.lang.Class)
 	 */
-	@Override
-	@SuppressWarnings("unchecked")
 	public <T, ID extends Serializable> MongoEntityInformation<T, ID> getEntityInformation(Class<T> domainClass) {
+		return getEntityInformation(domainClass, null);
+	}
+
+	@SuppressWarnings("unchecked")
+	private <T, ID extends Serializable> MongoEntityInformation<T, ID> getEntityInformation(Class<T> domainClass,
+			RepositoryInformation information) {
 
 		MongoPersistentEntity<?> entity = mappingContext.getPersistentEntity(domainClass);
 
@@ -116,7 +123,8 @@ public class MongoRepositoryFactory extends RepositoryFactorySupport {
 					String.format("Could not lookup mapping metadata for domain class %s!", domainClass.getName()));
 		}
 
-		return new MappingMongoEntityInformation<T, ID>((MongoPersistentEntity<T>) entity);
+		return new MappingMongoEntityInformation<T, ID>((MongoPersistentEntity<T>) entity,
+				information != null ? (Class<ID>) information.getIdType() : null);
 	}
 
 	/**
@@ -125,31 +133,39 @@ public class MongoRepositoryFactory extends RepositoryFactorySupport {
 	 * @author Oliver Gierke
 	 * @author Thomas Darimont
 	 */
-	private class MongoQueryLookupStrategy implements QueryLookupStrategy {
+	private static class MongoQueryLookupStrategy implements QueryLookupStrategy {
 
+		private final MongoOperations operations;
 		private final EvaluationContextProvider evaluationContextProvider;
+		MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext;
 
-		public MongoQueryLookupStrategy(EvaluationContextProvider evaluationContextProvider) {
+		public MongoQueryLookupStrategy(MongoOperations operations, EvaluationContextProvider evaluationContextProvider,
+				MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext) {
+
+			this.operations = operations;
 			this.evaluationContextProvider = evaluationContextProvider;
+			this.mappingContext = mappingContext;
 		}
 
-		/*
+		/* 
 		 * (non-Javadoc)
-		 * @see org.springframework.data.repository.query.QueryLookupStrategy#resolveQuery(java.lang.reflect.Method, org.springframework.data.repository.core.RepositoryMetadata, org.springframework.data.repository.core.NamedQueries)
+		 * @see org.springframework.data.repository.query.QueryLookupStrategy#resolveQuery(java.lang.reflect.Method, org.springframework.data.repository.core.RepositoryMetadata, org.springframework.data.projection.ProjectionFactory, org.springframework.data.repository.core.NamedQueries)
 		 */
-		public RepositoryQuery resolveQuery(Method method, RepositoryMetadata metadata, NamedQueries namedQueries) {
+		@Override
+		public RepositoryQuery resolveQuery(Method method, RepositoryMetadata metadata, ProjectionFactory factory,
+				NamedQueries namedQueries) {
 
-			MongoQueryMethod queryMethod = new MongoQueryMethod(method, metadata, mappingContext);
+			MongoQueryMethod queryMethod = new MongoQueryMethod(method, metadata, factory, mappingContext);
 			String namedQueryName = queryMethod.getNamedQueryName();
 
 			if (namedQueries.hasQuery(namedQueryName)) {
 				String namedQuery = namedQueries.getQuery(namedQueryName);
-				return new StringBasedMongoQuery(namedQuery, queryMethod, mongoOperations, EXPRESSION_PARSER,
+				return new StringBasedMongoQuery(namedQuery, queryMethod, operations, EXPRESSION_PARSER,
 						evaluationContextProvider);
 			} else if (queryMethod.hasAnnotatedQuery()) {
-				return new StringBasedMongoQuery(queryMethod, mongoOperations, EXPRESSION_PARSER, evaluationContextProvider);
+				return new StringBasedMongoQuery(queryMethod, operations, EXPRESSION_PARSER, evaluationContextProvider);
 			} else {
-				return new PartTreeMongoQuery(queryMethod, mongoOperations);
+				return new PartTreeMongoQuery(queryMethod, operations);
 			}
 		}
 	}

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

@@ -34,12 +34,12 @@ import org.springframework.data.repository.core.EntityInformation;
 import org.springframework.data.repository.core.EntityMetadata;
 import org.springframework.util.Assert;
 
-import com.mysema.query.mongodb.MongodbQuery;
-import com.mysema.query.types.EntityPath;
-import com.mysema.query.types.Expression;
-import com.mysema.query.types.OrderSpecifier;
-import com.mysema.query.types.Predicate;
-import com.mysema.query.types.path.PathBuilder;
+import com.querydsl.core.types.EntityPath;
+import com.querydsl.core.types.Expression;
+import com.querydsl.core.types.OrderSpecifier;
+import com.querydsl.core.types.Predicate;
+import com.querydsl.core.types.dsl.PathBuilder;
+import com.querydsl.mongodb.AbstractMongodbQuery;
 
 /**
  * Special QueryDsl based repository implementation that allows execution {@link Predicate}s in various forms.
@@ -47,8 +47,8 @@ import com.mysema.query.types.path.PathBuilder;
  * @author Oliver Gierke
  * @author Thomas Darimont
  */
-public class QueryDslMongoRepository<T, ID extends Serializable> extends SimpleMongoRepository<T, ID> implements
-		QueryDslPredicateExecutor<T> {
+public class QueryDslMongoRepository<T, ID extends Serializable> extends SimpleMongoRepository<T, ID>
+		implements QueryDslPredicateExecutor<T> {
 
 	private final PathBuilder<T> builder;
 	private final EntityInformation<T, ID> entityInformation;
@@ -92,7 +92,7 @@ public class QueryDslMongoRepository<T, ID extends Serializable> extends SimpleM
 	 */
 	@Override
 	public T findOne(Predicate predicate) {
-		return createQueryFor(predicate).uniqueResult();
+		return createQueryFor(predicate).fetchOne();
 	}
 
 	/*
@@ -101,7 +101,7 @@ public class QueryDslMongoRepository<T, ID extends Serializable> extends SimpleM
 	 */
 	@Override
 	public List<T> findAll(Predicate predicate) {
-		return createQueryFor(predicate).list();
+		return createQueryFor(predicate).fetchResults().getResults();
 	}
 
 	/*
@@ -110,7 +110,7 @@ public class QueryDslMongoRepository<T, ID extends Serializable> extends SimpleM
 	 */
 	@Override
 	public List<T> findAll(Predicate predicate, OrderSpecifier<?>... orders) {
-		return createQueryFor(predicate).orderBy(orders).list();
+		return createQueryFor(predicate).orderBy(orders).fetchResults().getResults();
 	}
 
 	/*
@@ -119,7 +119,7 @@ public class QueryDslMongoRepository<T, ID extends Serializable> extends SimpleM
 	 */
 	@Override
 	public List<T> findAll(Predicate predicate, Sort sort) {
-		return applySorting(createQueryFor(predicate), sort).list();
+		return applySorting(createQueryFor(predicate), sort).fetchResults().getResults();
 	}
 
 	/* 
@@ -128,7 +128,7 @@ public class QueryDslMongoRepository<T, ID extends Serializable> extends SimpleM
 	 */
 	@Override
 	public Iterable<T> findAll(OrderSpecifier<?>... orders) {
-		return createQuery().orderBy(orders).list();
+		return createQuery().orderBy(orders).fetchResults().getResults();
 	}
 
 	/*
@@ -138,10 +138,11 @@ public class QueryDslMongoRepository<T, ID extends Serializable> extends SimpleM
 	@Override
 	public Page<T> findAll(Predicate predicate, Pageable pageable) {
 
-		MongodbQuery<T> countQuery = createQueryFor(predicate);
-		MongodbQuery<T> query = createQueryFor(predicate);
+		AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> countQuery = createQueryFor(predicate);
+		AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> query = createQueryFor(predicate);
 
-		return new PageImpl<T>(applyPagination(query, pageable).list(), pageable, countQuery.count());
+		return new PageImpl<T>(applyPagination(query, pageable).fetchResults().getResults(), pageable,
+				countQuery.fetchCount());
 	}
 
 	/*
@@ -151,10 +152,11 @@ public class QueryDslMongoRepository<T, ID extends Serializable> extends SimpleM
 	@Override
 	public Page<T> findAll(Pageable pageable) {
 
-		MongodbQuery<T> countQuery = createQuery();
-		MongodbQuery<T> query = createQuery();
+		AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> countQuery = createQuery();
+		AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> query = createQuery();
 
-		return new PageImpl<T>(applyPagination(query, pageable).list(), pageable, countQuery.count());
+		return new PageImpl<T>(applyPagination(query, pageable).fetchResults().getResults(), pageable,
+				countQuery.fetchCount());
 	}
 
 	/*
@@ -163,7 +165,7 @@ public class QueryDslMongoRepository<T, ID extends Serializable> extends SimpleM
 	 */
 	@Override
 	public List<T> findAll(Sort sort) {
-		return applySorting(createQuery(), sort).list();
+		return applySorting(createQuery(), sort).fetchResults().getResults();
 	}
 
 	/*
@@ -172,7 +174,7 @@ public class QueryDslMongoRepository<T, ID extends Serializable> extends SimpleM
 	 */
 	@Override
 	public long count(Predicate predicate) {
-		return createQueryFor(predicate).count();
+		return createQueryFor(predicate).fetchCount();
 	}
 
 	/* 
@@ -181,7 +183,7 @@ public class QueryDslMongoRepository<T, ID extends Serializable> extends SimpleM
 	 */
 	@Override
 	public boolean exists(Predicate predicate) {
-		return createQueryFor(predicate).exists();
+		return createQueryFor(predicate).fetchCount() > 0;
 	}
 
 	/**
@@ -190,7 +192,7 @@ public class QueryDslMongoRepository<T, ID extends Serializable> extends SimpleM
 	 * @param predicate
 	 * @return
 	 */
-	private MongodbQuery<T> createQueryFor(Predicate predicate) {
+	private AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> createQueryFor(Predicate predicate) {
 		return createQuery().where(predicate);
 	}
 
@@ -199,7 +201,7 @@ public class QueryDslMongoRepository<T, ID extends Serializable> extends SimpleM
 	 * 
 	 * @return
 	 */
-	private MongodbQuery<T> createQuery() {
+	private AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> createQuery() {
 		return new SpringDataMongodbQuery<T>(mongoOperations, entityInformation.getJavaType());
 	}
 
@@ -210,7 +212,8 @@ public class QueryDslMongoRepository<T, ID extends Serializable> extends SimpleM
 	 * @param pageable
 	 * @return
 	 */
-	private MongodbQuery<T> applyPagination(MongodbQuery<T> query, Pageable pageable) {
+	private AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> applyPagination(
+			AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> query, Pageable pageable) {
 
 		if (pageable == null) {
 			return query;
@@ -227,7 +230,8 @@ public class QueryDslMongoRepository<T, ID extends Serializable> extends SimpleM
 	 * @param sort
 	 * @return
 	 */
-	private MongodbQuery<T> applySorting(MongodbQuery<T> query, Sort sort) {
+	private AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> applySorting(
+			AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> query, Sort sort) {
 
 		if (sort == null) {
 			return query;
@@ -260,7 +264,7 @@ public class QueryDslMongoRepository<T, ID extends Serializable> extends SimpleM
 
 		Expression<Object> property = builder.get(order.getProperty());
 
-		return new OrderSpecifier(order.isAscending() ? com.mysema.query.types.Order.ASC
-				: com.mysema.query.types.Order.DESC, property);
+		return new OrderSpecifier(
+				order.isAscending() ? com.querydsl.core.types.Order.ASC : com.querydsl.core.types.Order.DESC, property);
 	}
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2012 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.
@@ -20,8 +20,8 @@ import org.springframework.data.mongodb.core.MongoOperations;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
 import org.springframework.util.Assert;
 
-import com.mysema.query.mongodb.MongodbQuery;
-import com.mysema.query.types.EntityPath;
+import com.querydsl.core.types.EntityPath;
+import com.querydsl.mongodb.AbstractMongodbQuery;
 
 /**
  * Base class to create repository implementations based on Querydsl.
@@ -36,7 +36,7 @@ public abstract class QuerydslRepositorySupport {
 	/**
 	 * Creates a new {@link QuerydslRepositorySupport} for the given {@link MongoOperations}.
 	 * 
-	 * @param operations must not be {@literal null}
+	 * @param operations must not be {@literal null}.
 	 */
 	public QuerydslRepositorySupport(MongoOperations operations) {
 
@@ -53,7 +53,7 @@ public abstract class QuerydslRepositorySupport {
 	 * @param path
 	 * @return
 	 */
-	protected <T> MongodbQuery<T> from(final EntityPath<T> path) {
+	protected <T> AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> from(final EntityPath<T> path) {
 		Assert.notNull(path);
 		MongoPersistentEntity<?> entity = context.getPersistentEntity(path.getType());
 		return from(path, entity.getCollection());
@@ -66,7 +66,7 @@ public abstract class QuerydslRepositorySupport {
 	 * @param collection must not be blank or {@literal null}
 	 * @return
 	 */
-	protected <T> MongodbQuery<T> from(final EntityPath<T> path, String collection) {
+	protected <T> AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> from(final EntityPath<T> path, String collection) {
 
 		Assert.notNull(path);
 		Assert.hasText(collection);

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012 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.
@@ -20,14 +20,14 @@ import org.springframework.data.mongodb.core.MongoOperations;
 import com.google.common.base.Function;
 import com.mongodb.DBCollection;
 import com.mongodb.DBObject;
-import com.mysema.query.mongodb.MongodbQuery;
+import com.querydsl.mongodb.AbstractMongodbQuery;
 
 /**
- * Spring Data specfic {@link MongodbQuery} implementation.
+ * Spring Data specific {@link MongodbQuery} implementation.
  * 
  * @author Oliver Gierke
  */
-class SpringDataMongodbQuery<T> extends MongodbQuery<T> {
+class SpringDataMongodbQuery<T> extends AbstractMongodbQuery<T, SpringDataMongodbQuery<T>> {
 
 	private final MongoOperations operations;
 
@@ -48,7 +48,8 @@ class SpringDataMongodbQuery<T> extends MongodbQuery<T> {
 	 * @param type must not be {@literal null}.
 	 * @param collectionName must not be {@literal null} or empty.
 	 */
-	public SpringDataMongodbQuery(final MongoOperations operations, final Class<? extends T> type, String collectionName) {
+	public SpringDataMongodbQuery(final MongoOperations operations, final Class<? extends T> type,
+			String collectionName) {
 
 		super(operations.getCollection(collectionName), new Function<DBObject, T>() {
 			public T apply(DBObject input) {
@@ -61,7 +62,7 @@ class SpringDataMongodbQuery<T> extends MongodbQuery<T> {
 
 	/*
 	 * (non-Javadoc)
-	 * @see com.mysema.query.mongodb.MongodbQuery#getCollection(java.lang.Class)
+	 * @see com.querydsl.mongodb.AbstractMongodbQuery#getCollection(java.lang.Class)
 	 */
 	@Override
 	protected DBCollection getCollection(Class<?> type) {

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/SpringDataMongodbSerializer.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.
@@ -29,12 +29,10 @@ import org.springframework.util.Assert;
 
 import com.mongodb.DBObject;
 import com.mongodb.DBRef;
-import com.mysema.query.mongodb.MongodbSerializer;
-import com.mysema.query.types.Constant;
-import com.mysema.query.types.Operation;
-import com.mysema.query.types.Path;
-import com.mysema.query.types.PathMetadata;
-import com.mysema.query.types.PathType;
+import com.querydsl.core.types.Path;
+import com.querydsl.core.types.PathMetadata;
+import com.querydsl.core.types.PathType;
+import com.querydsl.mongodb.MongodbSerializer;
 
 /**
  * Custom {@link MongodbSerializer} to take mapping information into account when building keys for constraints.
@@ -76,10 +74,10 @@ class SpringDataMongodbSerializer extends MongodbSerializer {
 
 	/*
 	 * (non-Javadoc)
-	 * @see com.mysema.query.mongodb.MongodbSerializer#getKeyForPath(com.mysema.query.types.Path, com.mysema.query.types.PathMetadata)
+	 * @see com.querydsl.mongodb.MongodbSerializer#getKeyForPath(com.querydsl.core.types.Path, com.querydsl.core.types.PathMetadata)
 	 */
 	@Override
-	protected String getKeyForPath(Path<?> expr, PathMetadata<?> metadata) {
+	protected String getKeyForPath(Path<?> expr, PathMetadata metadata) {
 
 		if (!metadata.getPathType().equals(PathType.PROPERTY)) {
 			return super.getKeyForPath(expr, metadata);
@@ -94,7 +92,7 @@ class SpringDataMongodbSerializer extends MongodbSerializer {
 
 	/*
 	 * (non-Javadoc)
-	 * @see com.mysema.query.mongodb.MongodbSerializer#asDBObject(java.lang.String, java.lang.Object)
+	 * @see com.querydsl.mongodb.MongodbSerializer#asDBObject(java.lang.String, java.lang.Object)
 	 */
 	@Override
 	protected DBObject asDBObject(String key, Object value) {
@@ -108,7 +106,7 @@ class SpringDataMongodbSerializer extends MongodbSerializer {
 
 	/*
 	 * (non-Javadoc)
-	 * @see com.mysema.query.mongodb.MongodbSerializer#isReference(com.mysema.query.types.Path)
+	 * @see com.querydsl.mongodb.MongodbSerializer#isReference(com.querydsl.core.types.Path)
 	 */
 	@Override
 	protected boolean isReference(Path<?> path) {
@@ -119,34 +117,13 @@ class SpringDataMongodbSerializer extends MongodbSerializer {
 
 	/*
 	 * (non-Javadoc)
-	 * @see com.mysema.query.mongodb.MongodbSerializer#asReference(java.lang.Object)
+	 * @see com.querydsl.mongodb.MongodbSerializer#asReference(java.lang.Object)
 	 */
 	@Override
 	protected DBRef asReference(Object constant) {
 		return converter.toDBRef(constant, null);
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * @see com.mysema.query.mongodb.MongodbSerializer#asReference(com.mysema.query.types.Operation, int)
-	 */
-	@Override
-	protected DBRef asReference(Operation<?> expr, int constIndex) {
-
-		for (Object arg : expr.getArgs()) {
-
-			if (arg instanceof Path) {
-
-				MongoPersistentProperty property = getPropertyFor((Path<?>) arg);
-				Object constant = ((Constant<?>) expr.getArg(constIndex)).getConstant();
-
-				return converter.toDBRef(constant, property);
-			}
-		}
-
-		return super.asReference(expr, constIndex);
-	}
-
 	private MongoPersistentProperty getPropertyFor(Path<?> path) {
 
 		Path<?> parent = path.getMetadata().getParent();

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/util/MongoDbErrorCodes.java

@@ -0,0 +1,140 @@
+/*
+ * 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.mongodb.util;
+
+import java.util.HashMap;
+
+/**
+ * {@link MongoDbErrorCodes} holds MongoDB specific error codes outlined in {@literal mongo/base/error_codes.err}.
+ * 
+ * @author Christoph Strobl
+ * @since 1.8
+ */
+public final class MongoDbErrorCodes {
+
+	static HashMap<Integer, String> dataAccessResourceFailureCodes;
+	static HashMap<Integer, String> dataIntegrityViolationCodes;
+	static HashMap<Integer, String> duplicateKeyCodes;
+	static HashMap<Integer, String> invalidDataAccessApiUsageExeption;
+	static HashMap<Integer, String> permissionDeniedCodes;
+
+	static HashMap<Integer, String> errorCodes;
+
+	static {
+
+		dataAccessResourceFailureCodes = new HashMap<Integer, String>(10);
+		dataAccessResourceFailureCodes.put(6, "HostUnreachable");
+		dataAccessResourceFailureCodes.put(7, "HostNotFound");
+		dataAccessResourceFailureCodes.put(89, "NetworkTimeout");
+		dataAccessResourceFailureCodes.put(91, "ShutdownInProgress");
+		dataAccessResourceFailureCodes.put(12000, "SlaveDelayDifferential");
+		dataAccessResourceFailureCodes.put(10084, "CannotFindMapFile64Bit");
+		dataAccessResourceFailureCodes.put(10085, "CannotFindMapFile");
+		dataAccessResourceFailureCodes.put(10357, "ShutdownInProgress");
+		dataAccessResourceFailureCodes.put(10359, "Header==0");
+		dataAccessResourceFailureCodes.put(13440, "BadOffsetInFile");
+		dataAccessResourceFailureCodes.put(13441, "BadOffsetInFile");
+		dataAccessResourceFailureCodes.put(13640, "DataFileHeaderCorrupt");
+
+		dataIntegrityViolationCodes = new HashMap<Integer, String>(6);
+		dataIntegrityViolationCodes.put(67, "CannotCreateIndex");
+		dataIntegrityViolationCodes.put(68, "IndexAlreadyExists");
+		dataIntegrityViolationCodes.put(85, "IndexOptionsConflict");
+		dataIntegrityViolationCodes.put(86, "IndexKeySpecsConflict");
+		dataIntegrityViolationCodes.put(112, "WriteConflict");
+		dataIntegrityViolationCodes.put(117, "ConflictingOperationInProgress");
+
+		duplicateKeyCodes = new HashMap<Integer, String>(3);
+		duplicateKeyCodes.put(3, "OBSOLETE_DuplicateKey");
+		duplicateKeyCodes.put(84, "DuplicateKeyValue");
+		duplicateKeyCodes.put(11000, "DuplicateKey");
+		duplicateKeyCodes.put(11001, "DuplicateKey");
+
+		invalidDataAccessApiUsageExeption = new HashMap<Integer, String>();
+		invalidDataAccessApiUsageExeption.put(5, "GraphContainsCycle");
+		invalidDataAccessApiUsageExeption.put(9, "FailedToParse");
+		invalidDataAccessApiUsageExeption.put(14, "TypeMismatch");
+		invalidDataAccessApiUsageExeption.put(15, "Overflow");
+		invalidDataAccessApiUsageExeption.put(16, "InvalidLength");
+		invalidDataAccessApiUsageExeption.put(20, "IllegalOperation");
+		invalidDataAccessApiUsageExeption.put(21, "EmptyArrayOperation");
+		invalidDataAccessApiUsageExeption.put(22, "InvalidBSON");
+		invalidDataAccessApiUsageExeption.put(23, "AlreadyInitialized");
+		invalidDataAccessApiUsageExeption.put(29, "NonExistentPath");
+		invalidDataAccessApiUsageExeption.put(30, "InvalidPath");
+		invalidDataAccessApiUsageExeption.put(40, "ConflictingUpdateOperators");
+		invalidDataAccessApiUsageExeption.put(45, "UserDataInconsistent");
+		invalidDataAccessApiUsageExeption.put(30, "DollarPrefixedFieldName");
+		invalidDataAccessApiUsageExeption.put(52, "InvalidPath");
+		invalidDataAccessApiUsageExeption.put(53, "InvalidIdField");
+		invalidDataAccessApiUsageExeption.put(54, "NotSingleValueField");
+		invalidDataAccessApiUsageExeption.put(55, "InvalidDBRef");
+		invalidDataAccessApiUsageExeption.put(56, "EmptyFieldName");
+		invalidDataAccessApiUsageExeption.put(57, "DottedFieldName");
+		invalidDataAccessApiUsageExeption.put(59, "CommandNotFound");
+		invalidDataAccessApiUsageExeption.put(60, "DatabaseNotFound");
+		invalidDataAccessApiUsageExeption.put(61, "ShardKeyNotFound");
+		invalidDataAccessApiUsageExeption.put(62, "OplogOperationUnsupported");
+		invalidDataAccessApiUsageExeption.put(66, "ImmutableField");
+		invalidDataAccessApiUsageExeption.put(72, "InvalidOptions");
+		invalidDataAccessApiUsageExeption.put(115, "CommandNotSupported");
+		invalidDataAccessApiUsageExeption.put(116, "DocTooLargeForCapped");
+		invalidDataAccessApiUsageExeption.put(130, "SymbolNotFound");
+		invalidDataAccessApiUsageExeption.put(17280, "KeyTooLong");
+		invalidDataAccessApiUsageExeption.put(13334, "ShardKeyTooBig");
+
+		permissionDeniedCodes = new HashMap<Integer, String>();
+		permissionDeniedCodes.put(11, "UserNotFound");
+		permissionDeniedCodes.put(18, "AuthenticationFailed");
+		permissionDeniedCodes.put(31, "RoleNotFound");
+		permissionDeniedCodes.put(32, "RolesNotRelated");
+		permissionDeniedCodes.put(33, "PrvilegeNotFound");
+		permissionDeniedCodes.put(15847, "CannotAuthenticate");
+		permissionDeniedCodes.put(16704, "CannotAuthenticateToAdminDB");
+		permissionDeniedCodes.put(16705, "CannotAuthenticateToAdminDB");
+
+		errorCodes = new HashMap<Integer, String>();
+		errorCodes.putAll(dataAccessResourceFailureCodes);
+		errorCodes.putAll(dataIntegrityViolationCodes);
+		errorCodes.putAll(duplicateKeyCodes);
+		errorCodes.putAll(invalidDataAccessApiUsageExeption);
+		errorCodes.putAll(permissionDeniedCodes);
+	}
+
+	public static boolean isDataIntegrityViolationCode(Integer errorCode) {
+		return errorCode == null ? false : dataIntegrityViolationCodes.containsKey(errorCode);
+	}
+
+	public static boolean isDataAccessResourceFailureCode(Integer errorCode) {
+		return errorCode == null ? false : dataAccessResourceFailureCodes.containsKey(errorCode);
+	}
+
+	public static boolean isDuplicateKeyCode(Integer errorCode) {
+		return errorCode == null ? false : duplicateKeyCodes.containsKey(errorCode);
+	}
+
+	public static boolean isPermissionDeniedCode(Integer errorCode) {
+		return errorCode == null ? false : permissionDeniedCodes.containsKey(errorCode);
+	}
+
+	public static boolean isInvalidDataAccessApiUsageCode(Integer errorCode) {
+		return errorCode == null ? false : invalidDataAccessApiUsageExeption.containsKey(errorCode);
+	}
+
+	public static String getErrorDescription(Integer errorCode) {
+		return errorCode == null ? null : errorCodes.get(errorCode);
+	}
+}

spring-data-mongodb/src/main/resources/org/springframework/data/mongodb/config/spring-mongo-1.7.xsd

@@ -601,7 +601,7 @@ The comma delimited list of host:port entries to use for replica set/pairs.
 		<xsd:attribute name="credentials" type="xsd:string" use="optional">
 			<xsd:annotation>
 				<xsd:documentation><![CDATA[
-The comma delimited list of username:password@database entries to use for authentication. Appending ?uri.authMechanism allows to specify the authentication challenge mechanism.
+The comma delimited list of username:password@database entries to use for authentication. Appending ?uri.authMechanism allows to specify the authentication challenge mechanism. If the credential you're trying to pass contains a comma itself, quote it with single quotes: '…'.
 							]]></xsd:documentation>
 			</xsd:annotation>
 		</xsd:attribute>

spring-data-mongodb/src/main/resources/org/springframework/data/mongodb/config/spring-mongo-1.8.xsd

@@ -607,7 +607,7 @@ The comma delimited list of host:port entries to use for replica set/pairs.
 		<xsd:attribute name="credentials" type="xsd:string" use="optional">
 			<xsd:annotation>
 				<xsd:documentation><![CDATA[
-The comma delimited list of username:password@database entries to use for authentication. Appending ?uri.authMechanism allows to specify the authentication challenge mechanism.
+The comma delimited list of username:password@database entries to use for authentication. Appending ?uri.authMechanism allows to specify the authentication challenge mechanism. If the credential you're trying to pass contains a comma itself, quote it with single quotes: '…'.
 							]]></xsd:documentation>
 			</xsd:annotation>
 		</xsd:attribute>

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/AuditingIntegrationTests.java

@@ -47,7 +47,7 @@ public class AuditingIntegrationTests {
 		mappingContext.getPersistentEntity(Entity.class);
 
 		Entity entity = new Entity();
-		BeforeConvertEvent<Entity> event = new BeforeConvertEvent<Entity>(entity);
+		BeforeConvertEvent<Entity> event = new BeforeConvertEvent<Entity>(entity, "collection-1");
 		context.publishEvent(event);
 
 		assertThat(entity.created, is(notNullValue()));
@@ -55,7 +55,7 @@ public class AuditingIntegrationTests {
 
 		Thread.sleep(10);
 		entity.id = 1L;
-		event = new BeforeConvertEvent<Entity>(entity);
+		event = new BeforeConvertEvent<Entity>(entity, "collection-1");
 		context.publishEvent(event);
 
 		assertThat(entity.created, is(notNullValue()));

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MongoCredentialPropertyEditorUnitTests.java

@@ -43,6 +43,9 @@ public class MongoCredentialPropertyEditorUnitTests {
 	static final String USER_2_PWD = "warg";
 	static final String USER_2_DB = "snow";
 
+	static final String USER_3_NAME = "CN=myName,OU=myOrgUnit,O=myOrg,L=myLocality,ST=myState,C=myCountry";
+	static final String USER_3_DB = "stark";
+
 	static final String USER_1_AUTH_STRING = USER_1_NAME + ":" + USER_1_PWD + "@" + USER_1_DB;
 	static final String USER_1_AUTH_STRING_WITH_PLAIN_AUTH_MECHANISM = USER_1_AUTH_STRING + "?uri.authMechanism=PLAIN";
 
@@ -50,6 +53,9 @@ public class MongoCredentialPropertyEditorUnitTests {
 	static final String USER_2_AUTH_STRING_WITH_MONGODB_CR_AUTH_MECHANISM = USER_2_AUTH_STRING
 			+ "?uri.authMechanism=MONGODB-CR";
 
+	static final String USER_3_AUTH_STRING_WITH_X509_AUTH_MECHANISM = "'" + USER_3_NAME + "@" + USER_3_DB
+			+ "?uri.authMechanism=MONGODB-X509'";
+
 	static final MongoCredential USER_1_CREDENTIALS = MongoCredential.createCredential(USER_1_NAME, USER_1_DB,
 			USER_1_PWD.toCharArray());
 	static final MongoCredential USER_1_CREDENTIALS_PLAIN_AUTH = MongoCredential.createPlainCredential(USER_1_NAME,
@@ -60,6 +66,8 @@ public class MongoCredentialPropertyEditorUnitTests {
 	static final MongoCredential USER_2_CREDENTIALS_CR_AUTH = MongoCredential.createMongoCRCredential(USER_2_NAME,
 			USER_2_DB, USER_2_PWD.toCharArray());
 
+	static final MongoCredential USER_3_CREDENTIALS_X509_AUTH = MongoCredential.createMongoX509Credential(USER_3_NAME);
+
 	MongoCredentialPropertyEditor editor;
 
 	@Before
@@ -168,4 +176,75 @@ public class MongoCredentialPropertyEditorUnitTests {
 
 		assertThat((List<MongoCredential>) editor.getValue(), contains(USER_1_CREDENTIALS_PLAIN_AUTH, USER_2_CREDENTIALS));
 	}
+
+	/**
+	 * @see DATAMONGO-1257
+	 */
+	@Test
+	@SuppressWarnings("unchecked")
+	public void shouldReturnCredentialsValueCorrectlyWhenGivenMultipleQuotedUserNamePasswordStringWithDatabaseAndNoOptions() {
+
+		editor.setAsText(StringUtils.collectionToCommaDelimitedString(Arrays.asList("'" + USER_1_AUTH_STRING + "'", "'"
+				+ USER_2_AUTH_STRING + "'")));
+
+		assertThat((List<MongoCredential>) editor.getValue(), contains(USER_1_CREDENTIALS, USER_2_CREDENTIALS));
+	}
+
+	/**
+	 * @see DATAMONGO-1257
+	 */
+	@Test
+	@SuppressWarnings("unchecked")
+	public void shouldReturnCredentialsValueCorrectlyWhenGivenSingleQuotedUserNamePasswordStringWithDatabaseAndNoOptions() {
+
+		editor.setAsText("'" + USER_1_AUTH_STRING + "'");
+
+		assertThat((List<MongoCredential>) editor.getValue(), contains(USER_1_CREDENTIALS));
+	}
+
+	/**
+	 * @see DATAMONGO-1257
+	 */
+	@Test
+	@SuppressWarnings("unchecked")
+	public void shouldReturnX509CredentialsCorrectly() {
+
+		editor.setAsText(USER_3_AUTH_STRING_WITH_X509_AUTH_MECHANISM);
+
+		assertThat((List<MongoCredential>) editor.getValue(), contains(USER_3_CREDENTIALS_X509_AUTH));
+	}
+
+	/**
+	 * @see DATAMONGO-1257
+	 */
+	@Test
+	@SuppressWarnings("unchecked")
+	public void shouldReturnX509CredentialsCorrectlyWhenNoDbSpecified() {
+
+		editor.setAsText("tyrion?uri.authMechanism=MONGODB-X509");
+
+		assertThat((List<MongoCredential>) editor.getValue(), contains(MongoCredential.createMongoX509Credential("tyrion")));
+	}
+
+	/**
+	 * @see DATAMONGO-1257
+	 */
+	@Test(expected = IllegalArgumentException.class)
+	public void shouldThrowExceptionWhenNoDbSpecifiedForMongodbCR() {
+
+		editor.setAsText("tyrion?uri.authMechanism=MONGODB-CR");
+
+		editor.getValue();
+	}
+
+	/**
+	 * @see DATAMONGO-1257
+	 */
+	@Test(expected = IllegalArgumentException.class)
+	public void shouldThrowExceptionWhenDbIsEmptyForMongodbCR() {
+
+		editor.setAsText("tyrion@?uri.authMechanism=MONGODB-CR");
+
+		editor.getValue();
+	}
 }

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MongoDbFactoryParserIntegrationTests.java

@@ -50,6 +50,7 @@ import com.mongodb.WriteConcern;
  * 
  * @author Oliver Gierke
  * @author Christoph Strobl
+ * @author Viktor Khoroshko
  */
 public class MongoDbFactoryParserIntegrationTests {
 
@@ -198,6 +199,52 @@ public class MongoDbFactoryParserIntegrationTests {
 		reader.loadBeanDefinitions(new ClassPathResource("namespace/mongo-client-uri-and-details.xml"));
 	}
 
+	/**
+	 * @see DATAMONGO-1293
+	 */
+	@Test
+	public void setsUpClientUriWithId() {
+
+		reader.loadBeanDefinitions(new ClassPathResource("namespace/mongo-client-uri-and-id.xml"));
+		BeanDefinition definition = factory.getBeanDefinition("testMongo");
+		ConstructorArgumentValues constructorArguments = definition.getConstructorArgumentValues();
+
+		assertThat(constructorArguments.getArgumentCount(), is(1));
+		ValueHolder argument = constructorArguments.getArgumentValue(0, MongoClientURI.class);
+		assertThat(argument, is(notNullValue()));
+	}
+
+	/**
+	 * @see DATAMONGO-1293
+	 */
+	@Test
+	public void setsUpUriWithId() {
+
+		reader.loadBeanDefinitions(new ClassPathResource("namespace/mongo-uri-and-id.xml"));
+		BeanDefinition definition = factory.getBeanDefinition("testMongo");
+		ConstructorArgumentValues constructorArguments = definition.getConstructorArgumentValues();
+
+		assertThat(constructorArguments.getArgumentCount(), is(1));
+		ValueHolder argument = constructorArguments.getArgumentValue(0, MongoClientURI.class);
+		assertThat(argument, is(notNullValue()));
+	}
+
+	/**
+	 * @see DATAMONGO-1293
+	 */
+	@Test(expected = BeanDefinitionParsingException.class)
+	public void rejectsClientUriPlusDetailedConfigurationAndWriteConcern() {
+		reader.loadBeanDefinitions(new ClassPathResource("namespace/mongo-client-uri-write-concern-and-details.xml"));
+	}
+
+	/**
+	 * @see DATAMONGO-1293
+	 */
+	@Test(expected = BeanDefinitionParsingException.class)
+	public void rejectsUriPlusDetailedConfigurationAndWriteConcern() {
+		reader.loadBeanDefinitions(new ClassPathResource("namespace/mongo-client-uri-write-concern-and-details.xml"));
+	}
+
 	private static void assertWriteConcern(ClassPathXmlApplicationContext ctx, WriteConcern expectedWriteConcern) {
 
 		SimpleMongoDbFactory dbFactory = ctx.getBean("first", SimpleMongoDbFactory.class);

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/CloseableIterableCursorAdapterUnitTests.java

@@ -0,0 +1,83 @@
+/*
+ * 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.mongodb.core;
+
+import static org.mockito.Mockito.*;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+import org.springframework.dao.support.PersistenceExceptionTranslator;
+import org.springframework.data.mongodb.core.MongoTemplate.CloseableIterableCursorAdapter;
+import org.springframework.data.mongodb.core.MongoTemplate.DbObjectCallback;
+import org.springframework.data.util.CloseableIterator;
+
+import com.mongodb.Cursor;
+
+/**
+ * Unit tests for {@link CloseableIterableCursorAdapter}.
+ * 
+ * @author Oliver Gierke
+ * @see DATAMONGO-1276
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class CloseableIterableCursorAdapterUnitTests {
+
+	@Mock PersistenceExceptionTranslator exceptionTranslator;
+	@Mock DbObjectCallback<Object> callback;
+
+	Cursor cursor;
+	CloseableIterator<Object> adapter;
+
+	@Before
+	public void setUp() {
+
+		this.cursor = doThrow(IllegalArgumentException.class).when(mock(Cursor.class));
+		this.adapter = new CloseableIterableCursorAdapter<Object>(cursor, exceptionTranslator, callback);
+	}
+
+	/**
+	 * @see DATAMONGO-1276
+	 */
+	@Test(expected = IllegalArgumentException.class)
+	public void propagatesOriginalExceptionFromAdapterDotNext() {
+
+		cursor.next();
+		adapter.next();
+	}
+
+	/**
+	 * @see DATAMONGO-1276
+	 */
+	@Test(expected = IllegalArgumentException.class)
+	public void propagatesOriginalExceptionFromAdapterDotHasNext() {
+
+		cursor.hasNext();
+		adapter.hasNext();
+	}
+
+	/**
+	 * @see DATAMONGO-1276
+	 */
+	@Test(expected = IllegalArgumentException.class)
+	public void propagatesOriginalExceptionFromAdapterDotClose() {
+
+		cursor.close();
+		adapter.close();
+	}
+}

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/DefaultBulkOperationsIntegrationTests.java

@@ -0,0 +1,343 @@
+/*
+ * 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.mongodb.core;
+
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.BulkOperationException;
+import org.springframework.data.mongodb.core.BulkOperations.BulkMode;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.mongodb.core.query.Update;
+import org.springframework.data.util.Tuple;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.mongodb.BasicDBObject;
+import com.mongodb.BulkWriteResult;
+import com.mongodb.DBCollection;
+import com.mongodb.DBObject;
+import com.mongodb.WriteConcern;
+
+/**
+ * Integration tests for {@link DefaultBulkOperations}.
+ * 
+ * @author Tobias Trelle
+ * @author Oliver Gierke
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration("classpath:infrastructure.xml")
+public class DefaultBulkOperationsIntegrationTests {
+
+	static final String COLLECTION_NAME = "bulk_ops";
+
+	@Autowired MongoOperations operations;
+
+	DBCollection collection;
+
+	@Before
+	public void setUp() {
+
+		this.collection = this.operations.getCollection(COLLECTION_NAME);
+		this.collection.remove(new BasicDBObject());
+	}
+
+	/**
+	 * @see DATAMONGO-934
+	 */
+	@Test(expected = IllegalArgumentException.class)
+	public void rejectsNullMongoOperations() {
+		new DefaultBulkOperations(null, null, COLLECTION_NAME, null);
+	}
+
+	/**
+	 * @see DATAMONGO-934
+	 */
+	@Test(expected = IllegalArgumentException.class)
+	public void rejectsNullCollectionName() {
+		new DefaultBulkOperations(operations, null, null, null);
+	}
+
+	/**
+	 * @see DATAMONGO-934
+	 */
+	@Test(expected = IllegalArgumentException.class)
+	public void rejectsEmptyCollectionName() {
+		new DefaultBulkOperations(operations, null, "", null);
+	}
+
+	/**
+	 * @see DATAMONGO-934
+	 */
+	@Test
+	public void insertOrdered() {
+
+		List<BaseDoc> documents = Arrays.asList(newDoc("1"), newDoc("2"));
+
+		assertThat(createBulkOps(BulkMode.ORDERED).insert(documents).execute().getInsertedCount(), is(2));
+	}
+
+	/**
+	 * @see DATAMONGO-934
+	 */
+	@Test
+	public void insertOrderedFails() {
+
+		List<BaseDoc> documents = Arrays.asList(newDoc("1"), newDoc("1"), newDoc("2"));
+
+		try {
+			createBulkOps(BulkMode.ORDERED).insert(documents).execute();
+			fail();
+		} catch (BulkOperationException e) {
+			assertThat(e.getResult().getInsertedCount(), is(1)); // fails after first error
+			assertThat(e.getErrors(), notNullValue());
+			assertThat(e.getErrors().size(), is(1));
+		}
+	}
+
+	/**
+	 * @see DATAMONGO-934
+	 */
+	@Test
+	public void insertUnOrdered() {
+
+		List<BaseDoc> documents = Arrays.asList(newDoc("1"), newDoc("2"));
+
+		assertThat(createBulkOps(BulkMode.UNORDERED).insert(documents).execute().getInsertedCount(), is(2));
+	}
+
+	/**
+	 * @see DATAMONGO-934
+	 */
+	@Test
+	public void insertUnOrderedContinuesOnError() {
+
+		List<BaseDoc> documents = Arrays.asList(newDoc("1"), newDoc("1"), newDoc("2"));
+
+		try {
+			createBulkOps(BulkMode.UNORDERED).insert(documents).execute();
+			fail();
+		} catch (BulkOperationException e) {
+			assertThat(e.getResult().getInsertedCount(), is(2)); // two docs were inserted
+			assertThat(e.getErrors(), notNullValue());
+			assertThat(e.getErrors().size(), is(1));
+		}
+	}
+
+	/**
+	 * @see DATAMONGO-934
+	 */
+	@Test
+	public void upsertDoesUpdate() {
+
+		insertSomeDocuments();
+
+		BulkWriteResult result = createBulkOps(BulkMode.ORDERED).//
+				upsert(where("value", "value1"), set("value", "value2")).//
+				execute();
+
+		assertThat(result, notNullValue());
+		assertThat(result.getMatchedCount(), is(2));
+		assertThat(result.getModifiedCount(), is(2));
+		assertThat(result.getInsertedCount(), is(0));
+		assertThat(result.getUpserts(), is(notNullValue()));
+		assertThat(result.getUpserts().size(), is(0));
+	}
+
+	/**
+	 * @see DATAMONGO-934
+	 */
+	@Test
+	public void upsertDoesInsert() {
+
+		BulkWriteResult result = createBulkOps(BulkMode.ORDERED).//
+				upsert(where("_id", "1"), set("value", "v1")).//
+				execute();
+
+		assertThat(result, notNullValue());
+		assertThat(result.getMatchedCount(), is(0));
+		assertThat(result.getModifiedCount(), is(0));
+		assertThat(result.getUpserts(), is(notNullValue()));
+		assertThat(result.getUpserts().size(), is(1));
+	}
+
+	/**
+	 * @see DATAMONGO-934
+	 */
+	@Test
+	public void updateOneOrdered() {
+		testUpdate(BulkMode.ORDERED, false, 2);
+	}
+
+	/**
+	 * @see DATAMONGO-934
+	 */
+	@Test
+	public void updateMultiOrdered() {
+		testUpdate(BulkMode.ORDERED, true, 4);
+	}
+
+	/**
+	 * @see DATAMONGO-934
+	 */
+	@Test
+	public void updateOneUnOrdered() {
+		testUpdate(BulkMode.UNORDERED, false, 2);
+	}
+
+	/**
+	 * @see DATAMONGO-934
+	 */
+	@Test
+	public void updateMultiUnOrdered() {
+		testUpdate(BulkMode.UNORDERED, true, 4);
+	}
+
+	/**
+	 * @see DATAMONGO-934
+	 */
+	@Test
+	public void removeOrdered() {
+		testRemove(BulkMode.ORDERED);
+	}
+
+	/**
+	 * @see DATAMONGO-934
+	 */
+	@Test
+	public void removeUnordered() {
+		testRemove(BulkMode.UNORDERED);
+	}
+
+	/**
+	 * If working on the same set of documents, only an ordered bulk operation will yield predictable results.
+	 * 
+	 * @see DATAMONGO-934
+	 */
+	@Test
+	public void mixedBulkOrdered() {
+
+		BulkWriteResult result = createBulkOps(BulkMode.ORDERED).insert(newDoc("1", "v1")).//
+				updateOne(where("_id", "1"), set("value", "v2")).//
+				remove(where("value", "v2")).//
+				execute();
+
+		assertThat(result, notNullValue());
+		assertThat(result.getInsertedCount(), is(1));
+		assertThat(result.getModifiedCount(), is(1));
+		assertThat(result.getRemovedCount(), is(1));
+	}
+
+	/**
+	 * If working on the same set of documents, only an ordered bulk operation will yield predictable results.
+	 */
+	@Test
+	@SuppressWarnings("unchecked")
+	public void mixedBulkOrderedWithList() {
+
+		List<BaseDoc> inserts = Arrays.asList(newDoc("1", "v1"), newDoc("2", "v2"), newDoc("3", "v2"));
+		List<Tuple<Query, Update>> updates = Arrays.asList(Tuple.of(where("value", "v2"), set("value", "v3")));
+		List<Query> removes = Arrays.asList(where("_id", "1"));
+
+		BulkWriteResult result = createBulkOps(BulkMode.ORDERED).insert(inserts).updateMulti(updates).remove(removes)
+				.execute();
+
+		assertThat(result, notNullValue());
+		assertThat(result.getInsertedCount(), is(3));
+		assertThat(result.getModifiedCount(), is(2));
+		assertThat(result.getRemovedCount(), is(1));
+	}
+
+	private void testUpdate(BulkMode mode, boolean multi, int expectedUpdates) {
+
+		BulkOperations bulkOps = createBulkOps(mode);
+
+		insertSomeDocuments();
+
+		List<Tuple<Query, Update>> updates = new ArrayList<Tuple<Query, Update>>();
+		updates.add(Tuple.of(where("value", "value1"), set("value", "value3")));
+		updates.add(Tuple.of(where("value", "value2"), set("value", "value4")));
+
+		int modifiedCount = multi ? bulkOps.updateMulti(updates).execute().getModifiedCount()
+				: bulkOps.updateOne(updates).execute().getModifiedCount();
+
+		assertThat(modifiedCount, is(expectedUpdates));
+	}
+
+	private void testRemove(BulkMode mode) {
+
+		insertSomeDocuments();
+
+		List<Query> removes = Arrays.asList(where("_id", "1"), where("value", "value2"));
+
+		assertThat(createBulkOps(mode).remove(removes).execute().getRemovedCount(), is(3));
+	}
+
+	private BulkOperations createBulkOps(BulkMode mode) {
+
+		DefaultBulkOperations operations = new DefaultBulkOperations(this.operations, mode, COLLECTION_NAME, null);
+		operations.setDefaultWriteConcern(WriteConcern.ACKNOWLEDGED);
+
+		return operations;
+	}
+
+	private void insertSomeDocuments() {
+
+		final DBCollection coll = operations.getCollection(COLLECTION_NAME);
+
+		coll.insert(rawDoc("1", "value1"));
+		coll.insert(rawDoc("2", "value1"));
+		coll.insert(rawDoc("3", "value2"));
+		coll.insert(rawDoc("4", "value2"));
+	}
+
+	private static BaseDoc newDoc(String id) {
+
+		BaseDoc doc = new BaseDoc();
+		doc.id = id;
+
+		return doc;
+	}
+
+	private static BaseDoc newDoc(String id, String value) {
+
+		BaseDoc doc = newDoc(id);
+		doc.value = value;
+
+		return doc;
+	}
+
+	private static Query where(String field, String value) {
+		return new Query().addCriteria(Criteria.where(field).is(value));
+	}
+
+	private static Update set(String field, String value) {
+		return new Update().set(field, value);
+	}
+
+	private static DBObject rawDoc(String id, String value) {
+		return new BasicDBObject("_id", id).append("value", value);
+	}
+}

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/GeoCommandStatisticsUnitTests.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2016 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.core;
+
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import com.mongodb.BasicDBObject;
+
+/**
+ * Unit tests for {@link GeoCommandStatistics}.
+ * 
+ * @author Oliver Gierke
+ * @soundtrack Fruitcake - Jeff Coffin (The Inside of the Outside)
+ */
+public class GeoCommandStatisticsUnitTests {
+
+	/**
+	 * @see DATAMONGO-1361
+	 */
+	@Test(expected = IllegalArgumentException.class)
+	public void rejectsNullCommandResult() {
+		GeoCommandStatistics.from(null);
+	}
+
+	/**
+	 * @see DATAMONGO-1361
+	 */
+	@Test
+	public void fallsBackToNanIfNoAverageDistanceIsAvailable() {
+
+		GeoCommandStatistics statistics = GeoCommandStatistics.from(new BasicDBObject("stats", null));
+		assertThat(statistics.getAverageDistance(), is(Double.NaN));
+
+		statistics = GeoCommandStatistics.from(new BasicDBObject("stats", new BasicDBObject()));
+		assertThat(statistics.getAverageDistance(), is(Double.NaN));
+	}
+
+	/**
+	 * @see DATAMONGO-1361
+	 */
+	@Test
+	public void returnsAverageDistanceIfPresent() {
+
+		GeoCommandStatistics statistics = GeoCommandStatistics
+				.from(new BasicDBObject("stats", new BasicDBObject("avgDistance", 1.5)));
+
+		assertThat(statistics.getAverageDistance(), is(1.5));
+	}
+}

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/MongoAdminIntegrationTests.java

@@ -36,7 +36,7 @@ import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 @ContextConfiguration("classpath:infrastructure.xml")
 public class MongoAdminIntegrationTests {
 
-	private static Log logger = LogFactory.getLog(MongoAdminIntegrationTests.class);
+	private static final Log logger = LogFactory.getLog(MongoAdminIntegrationTests.class);
 
 	@SuppressWarnings("unused")
 	private DB testAdminDb;

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/MongoTemplateTests.java

@@ -3035,7 +3035,7 @@ public class MongoTemplateTests {
 	 */
 	@Test
 	public void takesLimitIntoAccountWhenStreaming() {
-		
+
 		Person youngestPerson = new Person("John", 20);
 		Person oldestPerson = new Person("Jane", 42);
 
@@ -3049,6 +3049,100 @@ public class MongoTemplateTests {
 		assertThat(stream.hasNext(), is(false));
 	}
 
+	/**
+	 * @see DATAMONGO-1204
+	 */
+	@Test
+	public void resolvesCyclicDBRefCorrectly() {
+
+		SomeMessage message = new SomeMessage();
+		SomeContent content = new SomeContent();
+
+		template.save(message);
+		template.save(content);
+
+		message.dbrefContent = content;
+		content.dbrefMessage = message;
+
+		template.save(message);
+		template.save(content);
+
+		SomeMessage messageLoaded = template.findOne(query(where("id").is(message.id)), SomeMessage.class);
+		SomeContent contentLoaded = template.findOne(query(where("id").is(content.id)), SomeContent.class);
+
+		assertThat(messageLoaded.dbrefContent.id, is(contentLoaded.id));
+		assertThat(contentLoaded.dbrefMessage.id, is(messageLoaded.id));
+	}
+
+	/**
+	 * @see DATAMONGO-1287
+	 */
+	@Test
+	public void shouldReuseAlreadyResolvedLazyLoadedDBRefWhenUsedAsPersistenceConstrcutorArgument() {
+
+		Document docInCtor = new Document();
+		docInCtor.id = "doc-in-ctor";
+		template.save(docInCtor);
+
+		DocumentWithLazyDBrefUsedInPresistenceConstructor source = new DocumentWithLazyDBrefUsedInPresistenceConstructor(
+				docInCtor);
+
+		template.save(source);
+
+		DocumentWithLazyDBrefUsedInPresistenceConstructor loaded = template.findOne(query(where("id").is(source.id)),
+				DocumentWithLazyDBrefUsedInPresistenceConstructor.class);
+		assertThat(loaded.refToDocUsedInCtor, not(instanceOf(LazyLoadingProxy.class)));
+		assertThat(loaded.refToDocNotUsedInCtor, nullValue());
+	}
+
+	/**
+	 * @see DATAMONGO-1287
+	 */
+	@Test
+	public void shouldNotReuseLazyLoadedDBRefWhenTypeUsedInPersistenceConstrcutorButValueRefersToAnotherProperty() {
+
+		Document docNotUsedInCtor = new Document();
+		docNotUsedInCtor.id = "doc-but-not-used-in-ctor";
+		template.save(docNotUsedInCtor);
+
+		DocumentWithLazyDBrefUsedInPresistenceConstructor source = new DocumentWithLazyDBrefUsedInPresistenceConstructor(
+				null);
+		source.refToDocNotUsedInCtor = docNotUsedInCtor;
+
+		template.save(source);
+
+		DocumentWithLazyDBrefUsedInPresistenceConstructor loaded = template.findOne(query(where("id").is(source.id)),
+				DocumentWithLazyDBrefUsedInPresistenceConstructor.class);
+		assertThat(loaded.refToDocNotUsedInCtor, instanceOf(LazyLoadingProxy.class));
+		assertThat(loaded.refToDocUsedInCtor, nullValue());
+	}
+
+	/**
+	 * @see DATAMONGO-1287
+	 */
+	@Test
+	public void shouldRespectParamterValueWhenAttemptingToReuseLazyLoadedDBRefUsedInPersistenceConstrcutor() {
+
+		Document docInCtor = new Document();
+		docInCtor.id = "doc-in-ctor";
+		template.save(docInCtor);
+
+		Document docNotUsedInCtor = new Document();
+		docNotUsedInCtor.id = "doc-but-not-used-in-ctor";
+		template.save(docNotUsedInCtor);
+
+		DocumentWithLazyDBrefUsedInPresistenceConstructor source = new DocumentWithLazyDBrefUsedInPresistenceConstructor(
+				docInCtor);
+		source.refToDocNotUsedInCtor = docNotUsedInCtor;
+
+		template.save(source);
+
+		DocumentWithLazyDBrefUsedInPresistenceConstructor loaded = template.findOne(query(where("id").is(source.id)),
+				DocumentWithLazyDBrefUsedInPresistenceConstructor.class);
+		assertThat(loaded.refToDocUsedInCtor, not(instanceOf(LazyLoadingProxy.class)));
+		assertThat(loaded.refToDocNotUsedInCtor, instanceOf(LazyLoadingProxy.class));
+	}
+
 	static class DoucmentWithNamedIdField {
 
 		@Id String someIdKey;
@@ -3351,6 +3445,7 @@ public class MongoTemplateTests {
 		String id;
 		String text;
 		String name;
+		@org.springframework.data.mongodb.core.mapping.DBRef SomeMessage dbrefMessage;
 
 		public String getName() {
 			return name;
@@ -3375,4 +3470,18 @@ public class MongoTemplateTests {
 		@org.springframework.data.mongodb.core.mapping.DBRef SomeContent dbrefContent;
 		SomeContent normalContent;
 	}
+
+	static class DocumentWithLazyDBrefUsedInPresistenceConstructor {
+
+		@Id String id;
+		@org.springframework.data.mongodb.core.mapping.DBRef(lazy = true) Document refToDocUsedInCtor;
+		@org.springframework.data.mongodb.core.mapping.DBRef(lazy = true) Document refToDocNotUsedInCtor;
+
+		@PersistenceConstructor
+		public DocumentWithLazyDBrefUsedInPresistenceConstructor(Document refToDocUsedInCtor) {
+			this.refToDocUsedInCtor = refToDocUsedInCtor;
+		}
+
+	}
+
 }

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/MongoTemplateUnitTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2014 the original author or authors.
+ * Copyright 2010-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.
@@ -43,27 +43,35 @@ import org.springframework.dao.InvalidDataAccessApiUsageException;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.annotation.Version;
 import org.springframework.data.domain.Sort;
+import org.springframework.data.geo.Point;
 import org.springframework.data.mongodb.MongoDbFactory;
+import org.springframework.data.mongodb.core.aggregation.Aggregation;
 import org.springframework.data.mongodb.core.convert.CustomConversions;
 import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver;
 import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
 import org.springframework.data.mongodb.core.convert.QueryMapper;
 import org.springframework.data.mongodb.core.index.MongoPersistentEntityIndexCreator;
 import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
+import org.springframework.data.mongodb.core.mapreduce.MapReduceOptions;
 import org.springframework.data.mongodb.core.query.BasicQuery;
 import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.NearQuery;
 import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.data.mongodb.core.query.Update;
 import org.springframework.test.util.ReflectionTestUtils;
 
 import com.mongodb.BasicDBObject;
 import com.mongodb.BasicDBObjectBuilder;
+import com.mongodb.CommandResult;
 import com.mongodb.DB;
 import com.mongodb.DBCollection;
 import com.mongodb.DBCursor;
 import com.mongodb.DBObject;
+import com.mongodb.MapReduceCommand;
+import com.mongodb.MapReduceOutput;
 import com.mongodb.Mongo;
 import com.mongodb.MongoException;
+import com.mongodb.ReadPreference;
 
 /**
  * Unit tests for {@link MongoTemplate}.
@@ -353,6 +361,176 @@ public class MongoTemplateUnitTests extends MongoOperationsUnitTests {
 		assertThat(captor.getValue(), equalTo(new BasicDBObjectBuilder().add("foo", 1).get()));
 	}
 
+	/**
+	 * @see DATAMONGO-1166
+	 */
+	@Test
+	public void aggregateShouldHonorReadPreferenceWhenSet() {
+
+		when(db.command(Mockito.any(DBObject.class), Mockito.any(ReadPreference.class))).thenReturn(
+				mock(CommandResult.class));
+		when(db.command(Mockito.any(DBObject.class))).thenReturn(mock(CommandResult.class));
+		template.setReadPreference(ReadPreference.secondary());
+
+		template.aggregate(Aggregation.newAggregation(Aggregation.unwind("foo")), "collection-1", Wrapper.class);
+
+		verify(this.db, times(1)).command(Mockito.any(DBObject.class), eq(ReadPreference.secondary()));
+	}
+
+	/**
+	 * @see DATAMONGO-1166
+	 */
+	@Test
+	public void aggregateShouldIgnoreReadPreferenceWhenNotSet() {
+
+		when(db.command(Mockito.any(DBObject.class), Mockito.any(ReadPreference.class))).thenReturn(
+				mock(CommandResult.class));
+		when(db.command(Mockito.any(DBObject.class))).thenReturn(mock(CommandResult.class));
+
+		template.aggregate(Aggregation.newAggregation(Aggregation.unwind("foo")), "collection-1", Wrapper.class);
+
+		verify(this.db, times(1)).command(Mockito.any(DBObject.class));
+	}
+
+	/**
+	 * @see DATAMONGO-1166
+	 */
+	@Test
+	public void geoNearShouldHonorReadPreferenceWhenSet() {
+
+		when(db.command(Mockito.any(DBObject.class), Mockito.any(ReadPreference.class))).thenReturn(
+				mock(CommandResult.class));
+		when(db.command(Mockito.any(DBObject.class))).thenReturn(mock(CommandResult.class));
+		template.setReadPreference(ReadPreference.secondary());
+
+		NearQuery query = NearQuery.near(new Point(1, 1));
+		template.geoNear(query, Wrapper.class);
+
+		verify(this.db, times(1)).command(Mockito.any(DBObject.class), eq(ReadPreference.secondary()));
+	}
+
+	/**
+	 * @see DATAMONGO-1166
+	 */
+	@Test
+	public void geoNearShouldIgnoreReadPreferenceWhenNotSet() {
+
+		when(db.command(Mockito.any(DBObject.class), Mockito.any(ReadPreference.class))).thenReturn(
+				mock(CommandResult.class));
+		when(db.command(Mockito.any(DBObject.class))).thenReturn(mock(CommandResult.class));
+
+		NearQuery query = NearQuery.near(new Point(1, 1));
+		template.geoNear(query, Wrapper.class);
+
+		verify(this.db, times(1)).command(Mockito.any(DBObject.class));
+	}
+
+	/**
+	 * @see DATAMONGO-1334
+	 */
+	@Test
+	public void mapReduceShouldUseZeroAsDefaultLimit() {
+
+		ArgumentCaptor<MapReduceCommand> captor = ArgumentCaptor.forClass(MapReduceCommand.class);
+
+		MapReduceOutput output = mock(MapReduceOutput.class);
+		when(output.results()).thenReturn(Collections.<DBObject> emptySet());
+		when(collection.mapReduce(Mockito.any(MapReduceCommand.class))).thenReturn(output);
+
+		Query query = new BasicQuery("{'foo':'bar'}");
+
+		template.mapReduce(query, "collection", "function(){}", "function(key,values){}", Wrapper.class);
+
+		verify(collection).mapReduce(captor.capture());
+
+		assertThat(captor.getValue().getLimit(), is(0));
+	}
+
+	/**
+	 * @see DATAMONGO-1334
+	 */
+	@Test
+	public void mapReduceShouldPickUpLimitFromQuery() {
+
+		ArgumentCaptor<MapReduceCommand> captor = ArgumentCaptor.forClass(MapReduceCommand.class);
+
+		MapReduceOutput output = mock(MapReduceOutput.class);
+		when(output.results()).thenReturn(Collections.<DBObject> emptySet());
+		when(collection.mapReduce(Mockito.any(MapReduceCommand.class))).thenReturn(output);
+
+		Query query = new BasicQuery("{'foo':'bar'}");
+		query.limit(100);
+
+		template.mapReduce(query, "collection", "function(){}", "function(key,values){}", Wrapper.class);
+
+		verify(collection).mapReduce(captor.capture());
+
+		assertThat(captor.getValue().getLimit(), is(100));
+	}
+
+	/**
+	 * @see DATAMONGO-1334
+	 */
+	@Test
+	public void mapReduceShouldPickUpLimitFromOptions() {
+
+		ArgumentCaptor<MapReduceCommand> captor = ArgumentCaptor.forClass(MapReduceCommand.class);
+
+		MapReduceOutput output = mock(MapReduceOutput.class);
+		when(output.results()).thenReturn(Collections.<DBObject> emptySet());
+		when(collection.mapReduce(Mockito.any(MapReduceCommand.class))).thenReturn(output);
+
+		Query query = new BasicQuery("{'foo':'bar'}");
+
+		template.mapReduce(query, "collection", "function(){}", "function(key,values){}",
+				new MapReduceOptions().limit(1000), Wrapper.class);
+
+		verify(collection).mapReduce(captor.capture());
+		assertThat(captor.getValue().getLimit(), is(1000));
+	}
+
+	/**
+	 * @see DATAMONGO-1334
+	 */
+	@Test
+	public void mapReduceShouldPickUpLimitFromOptionsWhenQueryIsNotPresent() {
+
+		ArgumentCaptor<MapReduceCommand> captor = ArgumentCaptor.forClass(MapReduceCommand.class);
+
+		MapReduceOutput output = mock(MapReduceOutput.class);
+		when(output.results()).thenReturn(Collections.<DBObject> emptySet());
+		when(collection.mapReduce(Mockito.any(MapReduceCommand.class))).thenReturn(output);
+
+		template.mapReduce("collection", "function(){}", "function(key,values){}", new MapReduceOptions().limit(1000),
+				Wrapper.class);
+
+		verify(collection).mapReduce(captor.capture());
+		assertThat(captor.getValue().getLimit(), is(1000));
+	}
+
+	/**
+	 * @see DATAMONGO-1334
+	 */
+	@Test
+	public void mapReduceShouldPickUpLimitFromOptionsEvenWhenQueryDefinesItDifferently() {
+
+		ArgumentCaptor<MapReduceCommand> captor = ArgumentCaptor.forClass(MapReduceCommand.class);
+
+		MapReduceOutput output = mock(MapReduceOutput.class);
+		when(output.results()).thenReturn(Collections.<DBObject> emptySet());
+		when(collection.mapReduce(Mockito.any(MapReduceCommand.class))).thenReturn(output);
+
+		Query query = new BasicQuery("{'foo':'bar'}");
+		query.limit(100);
+
+		template.mapReduce(query, "collection", "function(){}", "function(key,values){}",
+				new MapReduceOptions().limit(1000), Wrapper.class);
+
+		verify(collection).mapReduce(captor.capture());
+
+		assertThat(captor.getValue().getLimit(), is(1000));
+	}
+
 	class AutogenerateableId {
 
 		@Id BigInteger id;

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/NoExplicitIdTests.java

@@ -0,0 +1,131 @@
+/*
+ * 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.mongodb.core;
+
+import static org.hamcrest.core.Is.*;
+import static org.junit.Assert.*;
+import static org.springframework.data.mongodb.core.query.Criteria.*;
+import static org.springframework.data.mongodb.core.query.Query.*;
+
+import java.util.Map;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.mongodb.config.AbstractMongoConfiguration;
+import org.springframework.data.mongodb.repository.MongoRepository;
+import org.springframework.data.mongodb.repository.config.EnableMongoRepositories;
+import org.springframework.test.context.ContextConfiguration;
+import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
+
+import com.mongodb.Mongo;
+import com.mongodb.MongoClient;
+
+/**
+ * Integration tests for DATAMONGO-1289.
+ * 
+ * @author Christoph Strobl
+ */
+@RunWith(SpringJUnit4ClassRunner.class)
+@ContextConfiguration
+public class NoExplicitIdTests {
+
+	@Configuration
+	@EnableMongoRepositories(considerNestedRepositories = true)
+	static class Config extends AbstractMongoConfiguration {
+
+		@Override
+		protected String getDatabaseName() {
+			return "test";
+		}
+
+		@Override
+		public Mongo mongo() throws Exception {
+			return new MongoClient();
+		}
+	}
+
+	@Autowired MongoOperations mongoOps;
+	@Autowired TypeWithoutExplicitIdPropertyRepository repo;
+
+	@Before
+	public void setUp() {
+		mongoOps.dropCollection(TypeWithoutIdProperty.class);
+	}
+
+	/**
+	 * @see DATAMONGO-1289
+	 */
+	@Test
+	public void saveAndRetrieveTypeWithoutIdPorpertyViaTemplate() {
+
+		TypeWithoutIdProperty noid = new TypeWithoutIdProperty();
+		noid.someString = "o.O";
+
+		mongoOps.save(noid);
+
+		TypeWithoutIdProperty retrieved = mongoOps.findOne(query(where("someString").is(noid.someString)),
+				TypeWithoutIdProperty.class);
+
+		assertThat(retrieved.someString, is(noid.someString));
+	}
+
+	/**
+	 * @see DATAMONGO-1289
+	 */
+	@Test
+	public void saveAndRetrieveTypeWithoutIdPorpertyViaRepository() {
+
+		TypeWithoutIdProperty noid = new TypeWithoutIdProperty();
+		noid.someString = "o.O";
+
+		repo.save(noid);
+
+		TypeWithoutIdProperty retrieved = repo.findBySomeString(noid.someString);
+		assertThat(retrieved.someString, is(noid.someString));
+	}
+
+	/**
+	 * @see DATAMONGO-1289
+	 */
+	@Test
+	@SuppressWarnings("unchecked")
+	public void saveAndRetrieveTypeWithoutIdPorpertyViaRepositoryFindOne() {
+
+		TypeWithoutIdProperty noid = new TypeWithoutIdProperty();
+		noid.someString = "o.O";
+
+		repo.save(noid);
+
+		Map<String, Object> map = mongoOps.findOne(query(where("someString").is(noid.someString)), Map.class,
+				"typeWithoutIdProperty");
+
+		TypeWithoutIdProperty retrieved = repo.findOne(map.get("_id").toString());
+		assertThat(retrieved.someString, is(noid.someString));
+	}
+
+	static class TypeWithoutIdProperty {
+
+		String someString;
+	}
+
+	static interface TypeWithoutExplicitIdPropertyRepository extends MongoRepository<TypeWithoutIdProperty, String> {
+
+		TypeWithoutIdProperty findBySomeString(String someString);
+	}
+}

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/SimpleMongoDbFactoryUnitTests.java

@@ -22,10 +22,13 @@ import static org.springframework.test.util.ReflectionTestUtils.*;
 
 import java.net.UnknownHostException;
 
+import org.junit.Rule;
 import org.junit.Test;
+import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
+import org.springframework.dao.InvalidDataAccessApiUsageException;
 import org.springframework.data.authentication.UserCredentials;
 import org.springframework.data.mongodb.MongoDbFactory;
 
@@ -43,6 +46,7 @@ import com.mongodb.MongoURI;
 @RunWith(MockitoJUnitRunner.class)
 public class SimpleMongoDbFactoryUnitTests {
 
+	public @Rule ExpectedException expectedException = ExpectedException.none();
 	@Mock Mongo mongo;
 
 	/**
@@ -115,6 +119,46 @@ public class SimpleMongoDbFactoryUnitTests {
 		assertThat(getField(factory, "authenticationDatabaseName").toString(), is("FooBar"));
 	}
 
+	/**
+	 * @see DATAMONGO-1260
+	 */
+	@Test
+	public void rejectsMongoClientWithUserCredentials() {
+
+		expectedException.expect(InvalidDataAccessApiUsageException.class);
+		expectedException.expectMessage("use 'MongoCredential' for 'MongoClient'");
+
+		new SimpleMongoDbFactory(mock(MongoClient.class), "cairhienin", new UserCredentials("moiraine", "sedai"));
+	}
+
+	/**
+	 * @see DATAMONGO-1260
+	 */
+	@Test
+	public void rejectsMongoClientWithUserCredentialsAndAuthDb() {
+
+		expectedException.expect(InvalidDataAccessApiUsageException.class);
+		expectedException.expectMessage("use 'MongoCredential' for 'MongoClient'");
+
+		new SimpleMongoDbFactory(mock(MongoClient.class), "malkieri", new UserCredentials("lan", "mandragoran"), "authdb");
+	}
+
+	/**
+	 * @see DATAMONGO-1260
+	 */
+	@Test
+	public void shouldNotRejectMongoClientWithNoCredentials() {
+		new SimpleMongoDbFactory(mock(MongoClient.class), "andoran", UserCredentials.NO_CREDENTIALS);
+	}
+
+	/**
+	 * @see DATAMONGO-1260
+	 */
+	@Test
+	public void shouldNotRejectMongoClientWithEmptyUserCredentials() {
+		new SimpleMongoDbFactory(mock(MongoClient.class), "shangtai", new UserCredentials("", ""));
+	}
+
 	@SuppressWarnings("deprecation")
 	private void rejectsDatabaseName(String databaseName) {
 

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/UnwrapAndReadDbObjectCallbackUnitTests.java

@@ -50,7 +50,7 @@ public class UnwrapAndReadDbObjectCallbackUnitTests {
 		MappingMongoConverter converter = new MappingMongoConverter(new DefaultDbRefResolver(factory),
 				new MongoMappingContext());
 
-		this.callback = template.new UnwrapAndReadDbObjectCallback<Target>(converter, Target.class);
+		this.callback = template.new UnwrapAndReadDbObjectCallback<Target>(converter, Target.class, "collection-1");
 	}
 
 	@Test

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/Venue.java

@@ -17,6 +17,7 @@ package org.springframework.data.mongodb.core;
 
 import java.util.Arrays;
 
+import org.joda.time.LocalDate;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.annotation.PersistenceConstructor;
 import org.springframework.data.mongodb.core.mapping.Document;
@@ -24,10 +25,10 @@ import org.springframework.data.mongodb.core.mapping.Document;
 @Document(collection = "newyork")
 public class Venue {
 
-	@Id
-	private String id;
+	@Id private String id;
 	private String name;
 	private double[] location;
+	private LocalDate openingDate;
 
 	@PersistenceConstructor
 	Venue(String name, double[] location) {
@@ -50,6 +51,14 @@ public class Venue {
 		return location;
 	}
 
+	public LocalDate getOpeningDate() {
+		return openingDate;
+	}
+
+	public void setOpeningDate(LocalDate openingDate) {
+		this.openingDate = openingDate;
+	}
+
 	@Override
 	public String toString() {
 		return "Venue [id=" + id + ", name=" + name + ", location=" + Arrays.toString(location) + "]";

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/aggregation/AggregationUnitTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2014 the original author or authors.
+ * Copyright 2013-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.
@@ -30,6 +30,7 @@ import org.junit.rules.ExpectedException;
 import org.springframework.data.domain.Sort.Direction;
 
 import com.mongodb.BasicDBObject;
+import com.mongodb.BasicDBObjectBuilder;
 import com.mongodb.DBObject;
 
 /**
@@ -37,6 +38,7 @@ import com.mongodb.DBObject;
  * 
  * @author Oliver Gierke
  * @author Thomas Darimont
+ * @author Christoph Strobl
  */
 public class AggregationUnitTests {
 
@@ -283,6 +285,40 @@ public class AggregationUnitTests {
 				is((DBObject) new BasicDBObject("_id", "$someKey").append("doc", new BasicDBObject("$first", "$$ROOT"))));
 	}
 
+	/**
+	 * @see DATAMONGO-1254
+	 */
+	@Test
+	public void shouldExposeAliasedFieldnameForProjectionsIncludingOperationsDownThePipeline() {
+
+		DBObject agg = Aggregation.newAggregation(//
+				project("date") //
+						.and("tags").minus(10).as("tags_count")//
+				, group("date")//
+						.sum("tags_count").as("count")//
+				).toDbObject("foo", Aggregation.DEFAULT_CONTEXT);
+
+		DBObject group = extractPipelineElement(agg, 1, "$group");
+		assertThat(getAsDBObject(group, "count"), is(new BasicDBObjectBuilder().add("$sum", "$tags_count").get()));
+	}
+
+	/**
+	 * @see DATAMONGO-1254
+	 */
+	@Test
+	public void shouldUseAliasedFieldnameForProjectionsIncludingOperationsDownThePipelineWhenUsingSpEL() {
+
+		DBObject agg = Aggregation.newAggregation(//
+				project("date") //
+						.andExpression("tags-10")//
+				, group("date")//
+						.sum("tags_count").as("count")//
+				).toDbObject("foo", Aggregation.DEFAULT_CONTEXT);
+
+		DBObject group = extractPipelineElement(agg, 1, "$group");
+		assertThat(getAsDBObject(group, "count"), is(new BasicDBObjectBuilder().add("$sum", "$tags_count").get()));
+	}
+
 	private DBObject extractPipelineElement(DBObject agg, int index, String operation) {
 
 		List<DBObject> pipeline = (List<DBObject>) agg.get("pipeline");