DATAMONGO-2033 - Release version 2.1 RC2 (Lovelace).

Original pull request: #603.

.travis.yml

@@ -3,34 +3,33 @@ language: java
 jdk:
   - oraclejdk8
 
-before_script:
-  - mongod --version
-
-services:
-  - mongodb
+before_install:
+  - mkdir -p downloads
+  - mkdir -p var/db var/log
+  - if [[ ! -d downloads/mongodb-linux-x86_64-ubuntu1604-${MONGO_VERSION} ]] ; then cd downloads && wget https://fastdl.mongodb.org/linux/mongodb-linux-x86_64-ubuntu1604-${MONGO_VERSION}.tgz && tar xzf mongodb-linux-x86_64-ubuntu1604-${MONGO_VERSION}.tgz && cd ..; fi
+  - downloads/mongodb-linux-x86_64-ubuntu1604-${MONGO_VERSION}/bin/mongod --version
+  - downloads/mongodb-linux-x86_64-ubuntu1604-${MONGO_VERSION}/bin/mongod --dbpath var/db --replSet rs0 --fork --logpath var/log/mongod.log
+  - sleep 10
+  - |-
+    downloads/mongodb-linux-x86_64-ubuntu1604-${MONGO_VERSION}/bin/mongo --eval "rs.initiate({_id: 'rs0', members:[{_id: 0, host: '127.0.0.1:27017'}]});"
+    sleep 15
 
 env:
   matrix:
     - PROFILE=ci
-    - PROFILE=mongo36-next
+  global:
+    - MONGO_VERSION=4.0.0
 
-# Current MongoDB version is 2.4.2 as of 2016-04, see https://github.com/travis-ci/travis-ci/issues/3694
-# apt-get starts a MongoDB instance so it's not started using before_script
 addons:
   apt:
-    sources:
-      - mongodb-3.4-precise
     packages:
-    - mongodb-org-server
-    - mongodb-org-shell
-    - oracle-java8-installer
+      - oracle-java8-installer
 
 sudo: false
 
 cache:
   directories:
     - $HOME/.m2
-
-install: true
+    - downloads
 
 script: "mvn clean dependency:list test -P${PROFILE} -Dsort"

README.md

@@ -83,7 +83,7 @@ You can have Spring automatically create a proxy for the interface by using the
 class ApplicationConfig extends AbstractMongoConfiguration {
 
   @Override
-  public Mongo mongo() throws Exception {
+  public MongoClient mongoClient() throws Exception {
     return new MongoClient();
   }
 
@@ -138,6 +138,42 @@ public class MyService {
 }
 ```
 
+### MongoDB 4.0 Transactions
+
+As of version 4 MongoDB supports [Transactions](https://www.mongodb.com/transactions). Transactions are built on top of
+ `ClientSessions` and therefore require an active session.
+
+`MongoTransactionManager` is the gateway to the well known Spring transaction support. It allows applications to use 
+[managed transaction features of Spring](http://docs.spring.io/spring/docs/current/spring-framework-reference/html/transaction.html).
+The `MongoTransactionManager` binds a `ClientSession` to the thread. `MongoTemplate` automatically detects those and operates on them accordingly.
+
+```java
+@Configuration
+static class Config extends AbstractMongoConfiguration {
+
+	@Bean
+	MongoTransactionManager transactionManager(MongoDbFactory dbFactory) {
+		return new MongoTransactionManager(dbFactory);
+	}
+
+	// ...
+}
+
+@Component
+public class StateService {
+
+	@Transactional
+	void someBusinessFunction(Step step) {
+
+		template.insert(step);
+
+		process(step);
+
+		template.update(Step.class).apply(Update.set("state", // ...
+	};
+});
+```
+
 ## Contributing to Spring Data
 
 Here are some ways for you to get involved in the community:

pom.xml

@@ -5,7 +5,7 @@
 
 	<groupId>org.springframework.data</groupId>
 	<artifactId>spring-data-mongodb-parent</artifactId>
-	<version>2.0.0.RELEASE</version>
+	<version>2.1.0.RC2</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>2.0.0.RELEASE</version>
+		<version>2.1.0.RC2</version>
 	</parent>
 
 	<modules>
@@ -27,9 +27,9 @@
 	<properties>
 		<project.type>multi</project.type>
 		<dist.id>spring-data-mongodb</dist.id>
-		<springdata.commons>2.0.0.RELEASE</springdata.commons>
-		<mongo>3.5.0</mongo>
-		<mongo.reactivestreams>1.6.0</mongo.reactivestreams>
+		<springdata.commons>2.1.0.RC2</springdata.commons>
+		<mongo>3.8.0</mongo>
+		<mongo.reactivestreams>1.9.0</mongo.reactivestreams>
 		<jmh.version>1.19</jmh.version>
 	</properties>
 
@@ -115,38 +115,6 @@
 
 	<profiles>
 
-		<!-- not-yet available profile>
-
-			<id>mongo35-next</id>
-			<properties>
-				<mongo>3.5.1-SNAPSHOT</mongo>
-			</properties>
-
-			<repositories>
-				<repository>
-					<id>mongo-snapshots</id>
-					<url>https://oss.sonatype.org/content/repositories/snapshots</url>
-				</repository>
-			</repositories>
-
-		</profile -->
-
-		<profile>
-
-			<id>mongo36-next</id>
-			<properties>
-				<mongo>3.6.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>
@@ -183,8 +151,8 @@
 
 	<repositories>
 		<repository>
-			<id>spring-libs-release</id>
-			<url>https://repo.spring.io/libs-release</url>
+			<id>spring-libs-milestone</id>
+			<url>https://repo.spring.io/libs-milestone</url>
 		</repository>
 	</repositories>
 
@@ -193,6 +161,11 @@
 			<id>spring-plugins-release</id>
 			<url>https://repo.spring.io/plugins-release</url>
 		</pluginRepository>
+		<pluginRepository>
+			<id>spring-libs-milestone</id>
+			<url>https://repo.spring.io/libs-milestone</url>
+		</pluginRepository>
+
 	</pluginRepositories>
 
 </project>

spring-data-mongodb-benchmarks/pom.xml

@@ -7,7 +7,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>2.0.0.RELEASE</version>
+		<version>2.1.0.RC2</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 the original author or authors.
+ * Copyright 2017-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 the original author or authors.
+ * Copyright 2017-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 the original author or authors.
+ * Copyright 2017-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

spring-data-mongodb-benchmarks/src/main/java/org/springframework/data/mongodb/microbenchmark/AbstractMicrobenchmark.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 the original author or authors.
+ * Copyright 2017-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

spring-data-mongodb-benchmarks/src/main/java/org/springframework/data/mongodb/microbenchmark/HttpResultsWriter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 the original author or authors.
+ * Copyright 2017-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

spring-data-mongodb-benchmarks/src/main/java/org/springframework/data/mongodb/microbenchmark/MongoResultsWriter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 the original author or authors.
+ * Copyright 2017-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

spring-data-mongodb-benchmarks/src/main/java/org/springframework/data/mongodb/microbenchmark/ResultsWriter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 the original author or authors.
+ * Copyright 2017-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

@@ -6,7 +6,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>2.0.0.RELEASE</version>
+		<version>2.1.0.RC2</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 
@@ -17,6 +17,7 @@
 		<jpa>2.1.1</jpa>
 		<hibernate>5.2.1.Final</hibernate>
 		<java-module-name>spring.data.mongodb.cross.store</java-module-name>
+		<project.root>${basedir}/..</project.root>
 	</properties>
 
 	<dependencies>
@@ -49,7 +50,7 @@
 		<dependency>
 			<groupId>org.springframework.data</groupId>
 			<artifactId>spring-data-mongodb</artifactId>
-			<version>2.0.0.RELEASE</version>
+			<version>2.1.0.RC2</version>
 		</dependency>
 
 		<!-- reactive -->

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2017 the original author or authors.
+ * Copyright 2011-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

@@ -1,214 +1,214 @@
-/*
- * Copyright 2011-2017 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.crossstore;
-
-import javax.persistence.EntityManagerFactory;
-
-import org.bson.Document;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.dao.DataAccessException;
-import org.springframework.dao.DataAccessResourceFailureException;
-import org.springframework.dao.DataIntegrityViolationException;
-import org.springframework.data.crossstore.ChangeSet;
-import org.springframework.data.crossstore.ChangeSetBacked;
-import org.springframework.data.crossstore.ChangeSetPersister;
-import org.springframework.data.mongodb.core.CollectionCallback;
-import org.springframework.data.mongodb.core.MongoTemplate;
-import org.springframework.util.ClassUtils;
-
-import com.mongodb.MongoException;
-import com.mongodb.client.MongoCollection;
-import com.mongodb.client.model.Filters;
-import com.mongodb.client.result.DeleteResult;
-
-/**
- * @author Thomas Risberg
- * @author Oliver Gierke
- * @author Alex Vengrovsk
- * @author Mark Paluch
- * @deprecated will be removed without replacement.
- */
-@Deprecated
-public class MongoChangeSetPersister implements ChangeSetPersister<Object> {
-
-	private static final String ENTITY_CLASS = "_entity_class";
-	private static final String ENTITY_ID = "_entity_id";
-	private static final String ENTITY_FIELD_NAME = "_entity_field_name";
-	private static final String ENTITY_FIELD_CLASS = "_entity_field_class";
-
-	private final Logger log = LoggerFactory.getLogger(getClass());
-
-	private MongoTemplate mongoTemplate;
-	private EntityManagerFactory entityManagerFactory;
-
-	public void setMongoTemplate(MongoTemplate mongoTemplate) {
-		this.mongoTemplate = mongoTemplate;
-	}
-
-	public void setEntityManagerFactory(EntityManagerFactory entityManagerFactory) {
-		this.entityManagerFactory = entityManagerFactory;
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.crossstore.ChangeSetPersister#getPersistentState(java.lang.Class, java.lang.Object, org.springframework.data.crossstore.ChangeSet)
-	 */
-	public void getPersistentState(Class<? extends ChangeSetBacked> entityClass, Object id, final ChangeSet changeSet)
-			throws DataAccessException, NotFoundException {
-
-		if (id == null) {
-			log.debug("Unable to load MongoDB data for null id");
-			return;
-		}
-
-		String collName = getCollectionNameForEntity(entityClass);
-
-		final Document dbk = new Document();
-		dbk.put(ENTITY_ID, id);
-		dbk.put(ENTITY_CLASS, entityClass.getName());
-		if (log.isDebugEnabled()) {
-			log.debug("Loading MongoDB data for {}", dbk);
-		}
-		mongoTemplate.execute(collName, new CollectionCallback<Object>() {
-			public Object doInCollection(MongoCollection<Document> collection) throws MongoException, DataAccessException {
-				for (Document dbo : collection.find(dbk)) {
-					String key = (String) dbo.get(ENTITY_FIELD_NAME);
-					if (log.isDebugEnabled()) {
-						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");
-						}
-						Class<?> clazz = ClassUtils.resolveClassName(className, ClassUtils.getDefaultClassLoader());
-						Object value = mongoTemplate.getConverter().read(clazz, dbo);
-						if (log.isDebugEnabled()) {
-							log.debug("Adding to ChangeSet: {}", key);
-						}
-						changeSet.set(key, value);
-					}
-				}
-				return null;
-			}
-		});
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @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 {
-		if (log.isDebugEnabled()) {
-			log.debug("getPersistentId called on {}", entity);
-		}
-		if (entityManagerFactory == null) {
-			throw new DataAccessResourceFailureException("EntityManagerFactory cannot be null");
-		}
-
-		return entityManagerFactory.getPersistenceUnitUtil().getIdentifier(entity);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.crossstore.ChangeSetPersister#persistState(org.springframework.data.crossstore.ChangeSetBacked, org.springframework.data.crossstore.ChangeSet)
-	 */
-	public Object persistState(ChangeSetBacked entity, ChangeSet cs) throws DataAccessException {
-		if (cs == null) {
-			log.debug("Flush: changeset was null, nothing to flush.");
-			return 0L;
-		}
-
-		if (log.isDebugEnabled()) {
-			log.debug("Flush: changeset: {}", cs.getValues());
-		}
-
-		String collName = getCollectionNameForEntity(entity.getClass());
-		if (mongoTemplate.getCollection(collName) == null) {
-			mongoTemplate.createCollection(collName);
-		}
-
-		for (String key : cs.getValues().keySet()) {
-			if (key != null && !key.startsWith("_") && !key.equals(ChangeSetPersister.ID_KEY)) {
-				Object value = cs.getValues().get(key);
-				final Document dbQuery = new Document();
-				dbQuery.put(ENTITY_ID, getPersistentId(entity, cs));
-				dbQuery.put(ENTITY_CLASS, entity.getClass().getName());
-				dbQuery.put(ENTITY_FIELD_NAME, key);
-				final Document dbId = mongoTemplate.execute(collName, new CollectionCallback<Document>() {
-					public Document doInCollection(MongoCollection<Document> collection)
-							throws MongoException, DataAccessException {
-						Document id = collection.find(dbQuery).first();
-						return id;
-					}
-				});
-
-				if (value == null) {
-					if (log.isDebugEnabled()) {
-						log.debug("Flush: removing: {}", dbQuery);
-					}
-					mongoTemplate.execute(collName, new CollectionCallback<Object>() {
-						public Object doInCollection(MongoCollection<Document> collection)
-								throws MongoException, DataAccessException {
-							DeleteResult dr = collection.deleteMany(dbQuery);
-							return null;
-						}
-					});
-				} else {
-					final Document dbDoc = new Document();
-					dbDoc.putAll(dbQuery);
-					if (log.isDebugEnabled()) {
-						log.debug("Flush: saving: {}", dbQuery);
-					}
-					mongoTemplate.getConverter().write(value, dbDoc);
-					dbDoc.put(ENTITY_FIELD_CLASS, value.getClass().getName());
-					if (dbId != null) {
-						dbDoc.put("_id", dbId.get("_id"));
-					}
-					mongoTemplate.execute(collName, new CollectionCallback<Object>() {
-						public Object doInCollection(MongoCollection<Document> collection)
-								throws MongoException, DataAccessException {
-
-							if (dbId != null) {
-								collection.replaceOne(Filters.eq("_id", dbId.get("_id")), dbDoc);
-							} else {
-
-								if (dbDoc.containsKey("_id") && dbDoc.get("_id") == null) {
-									dbDoc.remove("_id");
-								}
-								collection.insertOne(dbDoc);
-							}
-							return null;
-						}
-					});
-				}
-			}
-		}
-		return 0L;
-	}
-
-	/**
-	 * Returns the collection the given entity type shall be persisted to.
-	 * 
-	 * @param entityClass must not be {@literal null}.
-	 * @return
-	 */
-	private String getCollectionNameForEntity(Class<? extends ChangeSetBacked> entityClass) {
-		return mongoTemplate.getCollectionName(entityClass);
-	}
-}
+/*
+ * Copyright 2011-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.crossstore;
+
+import javax.persistence.EntityManagerFactory;
+
+import org.bson.Document;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.dao.DataAccessException;
+import org.springframework.dao.DataAccessResourceFailureException;
+import org.springframework.dao.DataIntegrityViolationException;
+import org.springframework.data.crossstore.ChangeSet;
+import org.springframework.data.crossstore.ChangeSetBacked;
+import org.springframework.data.crossstore.ChangeSetPersister;
+import org.springframework.data.mongodb.core.CollectionCallback;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.util.ClassUtils;
+
+import com.mongodb.MongoException;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.model.Filters;
+import com.mongodb.client.result.DeleteResult;
+
+/**
+ * @author Thomas Risberg
+ * @author Oliver Gierke
+ * @author Alex Vengrovsk
+ * @author Mark Paluch
+ * @deprecated will be removed without replacement.
+ */
+@Deprecated
+public class MongoChangeSetPersister implements ChangeSetPersister<Object> {
+
+	private static final String ENTITY_CLASS = "_entity_class";
+	private static final String ENTITY_ID = "_entity_id";
+	private static final String ENTITY_FIELD_NAME = "_entity_field_name";
+	private static final String ENTITY_FIELD_CLASS = "_entity_field_class";
+
+	private final Logger log = LoggerFactory.getLogger(getClass());
+
+	private MongoTemplate mongoTemplate;
+	private EntityManagerFactory entityManagerFactory;
+
+	public void setMongoTemplate(MongoTemplate mongoTemplate) {
+		this.mongoTemplate = mongoTemplate;
+	}
+
+	public void setEntityManagerFactory(EntityManagerFactory entityManagerFactory) {
+		this.entityManagerFactory = entityManagerFactory;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.crossstore.ChangeSetPersister#getPersistentState(java.lang.Class, java.lang.Object, org.springframework.data.crossstore.ChangeSet)
+	 */
+	public void getPersistentState(Class<? extends ChangeSetBacked> entityClass, Object id, final ChangeSet changeSet)
+			throws DataAccessException, NotFoundException {
+
+		if (id == null) {
+			log.debug("Unable to load MongoDB data for null id");
+			return;
+		}
+
+		String collName = getCollectionNameForEntity(entityClass);
+
+		final Document dbk = new Document();
+		dbk.put(ENTITY_ID, id);
+		dbk.put(ENTITY_CLASS, entityClass.getName());
+		if (log.isDebugEnabled()) {
+			log.debug("Loading MongoDB data for {}", dbk);
+		}
+		mongoTemplate.execute(collName, new CollectionCallback<Object>() {
+			public Object doInCollection(MongoCollection<Document> collection) throws MongoException, DataAccessException {
+				for (Document dbo : collection.find(dbk)) {
+					String key = (String) dbo.get(ENTITY_FIELD_NAME);
+					if (log.isDebugEnabled()) {
+						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");
+						}
+						Class<?> clazz = ClassUtils.resolveClassName(className, ClassUtils.getDefaultClassLoader());
+						Object value = mongoTemplate.getConverter().read(clazz, dbo);
+						if (log.isDebugEnabled()) {
+							log.debug("Adding to ChangeSet: {}", key);
+						}
+						changeSet.set(key, value);
+					}
+				}
+				return null;
+			}
+		});
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @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 {
+		if (log.isDebugEnabled()) {
+			log.debug("getPersistentId called on {}", entity);
+		}
+		if (entityManagerFactory == null) {
+			throw new DataAccessResourceFailureException("EntityManagerFactory cannot be null");
+		}
+
+		return entityManagerFactory.getPersistenceUnitUtil().getIdentifier(entity);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.crossstore.ChangeSetPersister#persistState(org.springframework.data.crossstore.ChangeSetBacked, org.springframework.data.crossstore.ChangeSet)
+	 */
+	public Object persistState(ChangeSetBacked entity, ChangeSet cs) throws DataAccessException {
+		if (cs == null) {
+			log.debug("Flush: changeset was null, nothing to flush.");
+			return 0L;
+		}
+
+		if (log.isDebugEnabled()) {
+			log.debug("Flush: changeset: {}", cs.getValues());
+		}
+
+		String collName = getCollectionNameForEntity(entity.getClass());
+		if (mongoTemplate.getCollection(collName) == null) {
+			mongoTemplate.createCollection(collName);
+		}
+
+		for (String key : cs.getValues().keySet()) {
+			if (key != null && !key.startsWith("_") && !key.equals(ChangeSetPersister.ID_KEY)) {
+				Object value = cs.getValues().get(key);
+				final Document dbQuery = new Document();
+				dbQuery.put(ENTITY_ID, getPersistentId(entity, cs));
+				dbQuery.put(ENTITY_CLASS, entity.getClass().getName());
+				dbQuery.put(ENTITY_FIELD_NAME, key);
+				final Document dbId = mongoTemplate.execute(collName, new CollectionCallback<Document>() {
+					public Document doInCollection(MongoCollection<Document> collection)
+							throws MongoException, DataAccessException {
+						Document id = collection.find(dbQuery).first();
+						return id;
+					}
+				});
+
+				if (value == null) {
+					if (log.isDebugEnabled()) {
+						log.debug("Flush: removing: {}", dbQuery);
+					}
+					mongoTemplate.execute(collName, new CollectionCallback<Object>() {
+						public Object doInCollection(MongoCollection<Document> collection)
+								throws MongoException, DataAccessException {
+							DeleteResult dr = collection.deleteMany(dbQuery);
+							return null;
+						}
+					});
+				} else {
+					final Document dbDoc = new Document();
+					dbDoc.putAll(dbQuery);
+					if (log.isDebugEnabled()) {
+						log.debug("Flush: saving: {}", dbQuery);
+					}
+					mongoTemplate.getConverter().write(value, dbDoc);
+					dbDoc.put(ENTITY_FIELD_CLASS, value.getClass().getName());
+					if (dbId != null) {
+						dbDoc.put("_id", dbId.get("_id"));
+					}
+					mongoTemplate.execute(collName, new CollectionCallback<Object>() {
+						public Object doInCollection(MongoCollection<Document> collection)
+								throws MongoException, DataAccessException {
+
+							if (dbId != null) {
+								collection.replaceOne(Filters.eq("_id", dbId.get("_id")), dbDoc);
+							} else {
+
+								if (dbDoc.containsKey("_id") && dbDoc.get("_id") == null) {
+									dbDoc.remove("_id");
+								}
+								collection.insertOne(dbDoc);
+							}
+							return null;
+						}
+					});
+				}
+			}
+		}
+		return 0L;
+	}
+
+	/**
+	 * Returns the collection the given entity type shall be persisted to.
+	 *
+	 * @param entityClass must not be {@literal null}.
+	 * @return
+	 */
+	private String getCollectionNameForEntity(Class<? extends ChangeSetBacked> entityClass) {
+		return mongoTemplate.getCollectionName(entityClass);
+	}
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2017 the original author or authors.
+ * Copyright 2011-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

spring-data-mongodb-cross-store/src/test/java/org/springframework/data/mongodb/crossstore/CrossStoreMongoTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2013 the original author or authors.
+ * Copyright 2011-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -39,7 +39,7 @@ import org.springframework.transaction.support.TransactionTemplate;
 
 /**
  * Integration tests for MongoDB cross-store persistence (mainly {@link MongoChangeSetPersister}).
- * 
+ *
  * @author Thomas Risberg
  * @author Oliver Gierke
  */

spring-data-mongodb-cross-store/src/test/java/org/springframework/data/mongodb/crossstore/test/Address.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011 the original author or authors.
+ * Copyright 2011-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

spring-data-mongodb-cross-store/src/test/java/org/springframework/data/mongodb/crossstore/test/Person.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011 the original author or authors.
+ * Copyright 2011-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

spring-data-mongodb-cross-store/src/test/java/org/springframework/data/mongodb/crossstore/test/Resume.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011 the original author or authors.
+ * Copyright 2011-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

spring-data-mongodb-distribution/pom.xml

@@ -13,7 +13,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>2.0.0.RELEASE</version>
+		<version>2.1.0.RC2</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 

spring-data-mongodb/pom.xml

@@ -11,7 +11,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>2.0.0.RELEASE</version>
+		<version>2.1.0.RC2</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 
@@ -19,6 +19,8 @@
 		<objenesis>1.3</objenesis>
 		<equalsverifier>1.7.8</equalsverifier>
 		<java-module-name>spring.data.mongodb</java-module-name>
+		<project.root>${basedir}/..</project.root>
+		<multithreadedtc>1.01</multithreadedtc>
 	</properties>
 
 	<dependencies>
@@ -145,7 +147,7 @@
 			<version>1.0.1</version>
 			<scope>test</scope>
 		</dependency>
-		
+
 		<dependency>
 			<groupId>javax.interceptor</groupId>
 			<artifactId>javax.interceptor-api</artifactId>
@@ -214,7 +216,6 @@
 		<dependency>
 			<groupId>com.fasterxml.jackson.core</groupId>
 			<artifactId>jackson-databind</artifactId>
-			<version>${jackson}</version>
 			<optional>true</optional>
 		</dependency>
 
@@ -245,6 +246,20 @@
 			<scope>test</scope>
 		</dependency>
 
+		<dependency>
+			<groupId>edu.umd.cs.mtc</groupId>
+			<artifactId>multithreadedtc</artifactId>
+			<version>${multithreadedtc}</version>
+			<scope>test</scope>
+		</dependency>
+
+		<dependency>
+			<groupId>javax.transaction</groupId>
+			<artifactId>jta</artifactId>
+			<version>1.1</version>
+			<scope>test</scope>
+		</dependency>
+
 		<!-- Kotlin extension -->
 		<dependency>
 			<groupId>org.jetbrains.kotlin</groupId>
@@ -288,74 +303,9 @@
 	</dependencies>
 
 	<build>
+
 		<plugins>
 
-			<plugin>
-				<artifactId>kotlin-maven-plugin</artifactId>
-				<groupId>org.jetbrains.kotlin</groupId>
-				<version>${kotlin}</version>
-				<configuration>
-					<jvmTarget>${source.level}</jvmTarget>
-				</configuration>
-				<executions>
-					<execution>
-						<id>compile</id>
-						<phase>compile</phase>
-						<goals>
-							<goal>compile</goal>
-						</goals>
-						<configuration>
-							<sourceDirs>
-								<sourceDir>${project.basedir}/src/main/kotlin</sourceDir>
-								<sourceDir>${project.basedir}/src/main/java</sourceDir>
-							</sourceDirs>
-						</configuration>
-					</execution>
-					<execution>
-						<id>test-compile</id>
-						<phase>test-compile</phase>
-						<goals>
-							<goal>test-compile</goal>
-						</goals>
-						<configuration>
-							<sourceDirs>
-								<sourceDir>${project.basedir}/src/test/kotlin</sourceDir>
-								<sourceDir>${project.basedir}/src/test/java</sourceDir>
-							</sourceDirs>
-						</configuration>
-					</execution>
-				</executions>
-			</plugin>
-
-			<plugin>
-				<groupId>org.apache.maven.plugins</groupId>
-				<artifactId>maven-compiler-plugin</artifactId>
-				<executions>
-					<execution>
-						<id>default-compile</id>
-						<phase>none</phase>
-					</execution>
-					<execution>
-						<id>default-testCompile</id>
-						<phase>none</phase>
-					</execution>
-					<execution>
-						<id>java-compile</id>
-						<phase>compile</phase>
-						<goals>
-							<goal>compile</goal>
-						</goals>
-					</execution>
-					<execution>
-						<id>java-test-compile</id>
-						<phase>test-compile</phase>
-						<goals>
-							<goal>testCompile</goal>
-						</goals>
-					</execution>
-				</executions>
-			</plugin>
-
 			<plugin>
 				<groupId>com.mysema.maven</groupId>
 				<artifactId>apt-maven-plugin</artifactId>
@@ -384,7 +334,6 @@
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-surefire-plugin</artifactId>
-				<version>2.12</version>
 				<configuration>
 					<useFile>false</useFile>
 					<includes>
@@ -406,6 +355,8 @@
 					</properties>
 				</configuration>
 			</plugin>
+
 		</plugins>
+
 	</build>
 </project>

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015 the original author or authors.
+ * Copyright 2015-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,7 +25,7 @@ import com.mongodb.BulkWriteResult;
 
 /**
  * Is thrown when errors occur during bulk operations.
- * 
+ *
  * @author Tobias Trelle
  * @author Oliver Gierke
  * @since 1.9
@@ -39,7 +39,7 @@ public class BulkOperationException extends DataAccessException {
 
 	/**
 	 * 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}.
 	 */

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2017 the original author or authors.
+ * Copyright 2010-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb;
+
+import org.springframework.dao.NonTransientDataAccessException;
+import org.springframework.lang.Nullable;
+
+/**
+ * {@link NonTransientDataAccessException} specific to MongoDB {@link com.mongodb.session.ClientSession} related data
+ * access failures such as reading data using an already closed session.
+ *
+ * @author Christoph Strobl
+ * @since 2.1
+ */
+public class ClientSessionException extends NonTransientDataAccessException {
+
+	/**
+	 * Constructor for {@link ClientSessionException}.
+	 *
+	 * @param msg the detail message. Must not be {@literal null}.
+	 */
+	public ClientSessionException(String msg) {
+		super(msg);
+	}
+
+	/**
+	 * Constructor for {@link ClientSessionException}.
+	 *
+	 * @param msg the detail message. Can be {@literal null}.
+	 * @param cause the root cause. Can be {@literal null}.
+	 */
+	public ClientSessionException(@Nullable String msg, @Nullable Throwable cause) {
+		super(msg, cause);
+	}
+}

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

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2017-2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb;
+
+import java.util.Optional;
+
+import org.bson.codecs.Codec;
+import org.bson.codecs.configuration.CodecConfigurationException;
+import org.bson.codecs.configuration.CodecRegistry;
+import org.springframework.util.Assert;
+
+/**
+ * Provider interface to obtain {@link CodecRegistry} from the underlying MongoDB Java driver.
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @since 2.1
+ */
+@FunctionalInterface
+public interface CodecRegistryProvider {
+
+	/**
+	 * Get the underlying {@link CodecRegistry} used by the MongoDB Java driver.
+	 *
+	 * @return never {@literal null}.
+	 * @throws IllegalStateException if {@link CodecRegistry} cannot be obtained.
+	 */
+	CodecRegistry getCodecRegistry();
+
+	/**
+	 * Checks if a {@link Codec} is registered for a given type.
+	 *
+	 * @param type must not be {@literal null}.
+	 * @return true if {@link #getCodecRegistry()} holds a {@link Codec} for given type.
+	 * @throws IllegalStateException if {@link CodecRegistry} cannot be obtained.
+	 */
+	default boolean hasCodecFor(Class<?> type) {
+		return getCodecFor(type).isPresent();
+	}
+
+	/**
+	 * Get the {@link Codec} registered for the given {@literal type} or an {@link Optional#empty() empty Optional}
+	 * instead.
+	 *
+	 * @param type must not be {@literal null}.
+	 * @param <T>
+	 * @return never {@literal null}.
+	 * @throws IllegalArgumentException if {@literal type} is {@literal null}.
+	 */
+	default <T> Optional<Codec<T>> getCodecFor(Class<T> type) {
+
+		Assert.notNull(type, "Type must not be null!");
+
+		try {
+			return Optional.of(getCodecRegistry().get(type));
+		} catch (CodecConfigurationException e) {
+			// ignore
+		}
+		return Optional.empty();
+	}
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2011 the original author or authors.
+ * Copyright 2010-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013 the original author or authors.
+ * Copyright 2013-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011 the original author or authors.
+ * Copyright 2011-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,7 +23,7 @@ import org.springframework.util.StringUtils;
  * <p/>
  * <p/>
  * Mainly intended for internal use within the framework.
- * 
+ *
  * @author Thomas Risberg
  * @since 1.0
  */
@@ -38,7 +38,7 @@ public abstract class MongoCollectionUtils {
 
 	/**
 	 * Obtains the collection name to use for the provided class
-	 * 
+	 *
 	 * @param entityClass The class to determine the preferred collection name for
 	 * @return The preferred collection name
 	 */

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

@@ -0,0 +1,230 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb;
+
+import org.springframework.lang.Nullable;
+import org.springframework.transaction.support.ResourceHolderSynchronization;
+import org.springframework.transaction.support.TransactionSynchronization;
+import org.springframework.transaction.support.TransactionSynchronizationManager;
+import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
+
+import com.mongodb.ClientSessionOptions;
+import com.mongodb.client.ClientSession;
+import com.mongodb.client.MongoDatabase;
+
+/**
+ * Helper class for managing a {@link MongoDatabase} instances via {@link MongoDbFactory}. Used for obtaining
+ * {@link ClientSession session bound} resources, such as {@link MongoDatabase} and
+ * {@link com.mongodb.client.MongoCollection} suitable for transactional usage.
+ * <p />
+ * <strong>Note:</strong> Intended for internal usage only.
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @currentRead Shadow's Edge - Brent Weeks
+ * @since 2.1
+ */
+public class MongoDatabaseUtils {
+
+	/**
+	 * Obtain the default {@link MongoDatabase database} form the given {@link MongoDbFactory factory} using
+	 * {@link SessionSynchronization#ON_ACTUAL_TRANSACTION native session synchronization}.
+	 * <p />
+	 * Registers a {@link MongoSessionSynchronization MongoDB specific transaction synchronization} within the current
+	 * {@link Thread} if {@link TransactionSynchronizationManager#isSynchronizationActive() synchronization is active}.
+	 *
+	 * @param factory the {@link MongoDbFactory} to get the {@link MongoDatabase} from.
+	 * @return the {@link MongoDatabase} that is potentially associated with a transactional {@link ClientSession}.
+	 */
+	public static MongoDatabase getDatabase(MongoDbFactory factory) {
+		return doGetMongoDatabase(null, factory, SessionSynchronization.ON_ACTUAL_TRANSACTION);
+	}
+
+	/**
+	 * Obtain the default {@link MongoDatabase database} form the given {@link MongoDbFactory factory}.
+	 * <p />
+	 * Registers a {@link MongoSessionSynchronization MongoDB specific transaction synchronization} within the current
+	 * {@link Thread} if {@link TransactionSynchronizationManager#isSynchronizationActive() synchronization is active}.
+	 *
+	 * @param factory the {@link MongoDbFactory} to get the {@link MongoDatabase} from.
+	 * @param sessionSynchronization the synchronization to use. Must not be {@literal null}.
+	 * @return the {@link MongoDatabase} that is potentially associated with a transactional {@link ClientSession}.
+	 */
+	public static MongoDatabase getDatabase(MongoDbFactory factory, SessionSynchronization sessionSynchronization) {
+		return doGetMongoDatabase(null, factory, sessionSynchronization);
+	}
+
+	/**
+	 * Obtain the {@link MongoDatabase database} with given name form the given {@link MongoDbFactory factory} using
+	 * {@link SessionSynchronization#ON_ACTUAL_TRANSACTION native session synchronization}.
+	 * <p />
+	 * Registers a {@link MongoSessionSynchronization MongoDB specific transaction synchronization} within the current
+	 * {@link Thread} if {@link TransactionSynchronizationManager#isSynchronizationActive() synchronization is active}.
+	 *
+	 * @param dbName the name of the {@link MongoDatabase} to get.
+	 * @param factory the {@link MongoDbFactory} to get the {@link MongoDatabase} from.
+	 * @return the {@link MongoDatabase} that is potentially associated with a transactional {@link ClientSession}.
+	 */
+	public static MongoDatabase getDatabase(String dbName, MongoDbFactory factory) {
+		return doGetMongoDatabase(dbName, factory, SessionSynchronization.ON_ACTUAL_TRANSACTION);
+	}
+
+	/**
+	 * Obtain the {@link MongoDatabase database} with given name form the given {@link MongoDbFactory factory}.
+	 * <p />
+	 * Registers a {@link MongoSessionSynchronization MongoDB specific transaction synchronization} within the current
+	 * {@link Thread} if {@link TransactionSynchronizationManager#isSynchronizationActive() synchronization is active}.
+	 * 
+	 * @param dbName the name of the {@link MongoDatabase} to get.
+	 * @param factory the {@link MongoDbFactory} to get the {@link MongoDatabase} from.
+	 * @param sessionSynchronization the synchronization to use. Must not be {@literal null}.
+	 * @return the {@link MongoDatabase} that is potentially associated with a transactional {@link ClientSession}.
+	 */
+	public static MongoDatabase getDatabase(String dbName, MongoDbFactory factory,
+			SessionSynchronization sessionSynchronization) {
+		return doGetMongoDatabase(dbName, factory, sessionSynchronization);
+	}
+
+	private static MongoDatabase doGetMongoDatabase(@Nullable String dbName, MongoDbFactory factory,
+			SessionSynchronization sessionSynchronization) {
+
+		Assert.notNull(factory, "Factory must not be null!");
+
+		if (!TransactionSynchronizationManager.isSynchronizationActive()) {
+			return StringUtils.hasText(dbName) ? factory.getDb(dbName) : factory.getDb();
+		}
+
+		ClientSession session = doGetSession(factory, sessionSynchronization);
+
+		if(session == null) {
+			return StringUtils.hasText(dbName) ? factory.getDb(dbName) : factory.getDb();
+		}
+
+		MongoDbFactory factoryToUse = factory.withSession(session);
+		return StringUtils.hasText(dbName) ? factoryToUse.getDb(dbName) : factoryToUse.getDb();
+	}
+
+	@Nullable
+	private static ClientSession doGetSession(MongoDbFactory dbFactory, SessionSynchronization sessionSynchronization) {
+
+		MongoResourceHolder resourceHolder = (MongoResourceHolder) TransactionSynchronizationManager.getResource(dbFactory);
+
+		// check for native MongoDB transaction
+		if (resourceHolder != null && (resourceHolder.hasSession() || resourceHolder.isSynchronizedWithTransaction())) {
+
+			if (!resourceHolder.hasSession()) {
+				resourceHolder.setSession(createClientSession(dbFactory));
+			}
+
+			return resourceHolder.getSession();
+		}
+
+		if (SessionSynchronization.ON_ACTUAL_TRANSACTION.equals(sessionSynchronization)) {
+			return null;
+		}
+
+		// init a non native MongoDB transaction by registering a MongoSessionSynchronization
+
+		resourceHolder = new MongoResourceHolder(createClientSession(dbFactory), dbFactory);
+		resourceHolder.getSession().startTransaction();
+
+		TransactionSynchronizationManager
+				.registerSynchronization(new MongoSessionSynchronization(resourceHolder, dbFactory));
+		resourceHolder.setSynchronizedWithTransaction(true);
+		TransactionSynchronizationManager.bindResource(dbFactory, resourceHolder);
+
+		return resourceHolder.getSession();
+	}
+
+	private static ClientSession createClientSession(MongoDbFactory dbFactory) {
+		return dbFactory.getSession(ClientSessionOptions.builder().causallyConsistent(true).build());
+	}
+
+	/**
+	 * MongoDB specific {@link ResourceHolderSynchronization} for resource cleanup at the end of a transaction when
+	 * participating in a non-native MongoDB transaction, such as a Jta or JDBC transaction.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	private static class MongoSessionSynchronization extends ResourceHolderSynchronization<MongoResourceHolder, Object> {
+
+		private final MongoResourceHolder resourceHolder;
+
+		MongoSessionSynchronization(MongoResourceHolder resourceHolder, MongoDbFactory dbFactory) {
+
+			super(resourceHolder, dbFactory);
+			this.resourceHolder = resourceHolder;
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.transaction.support.ResourceHolderSynchronization#shouldReleaseBeforeCompletion()
+		 */
+		@Override
+		protected boolean shouldReleaseBeforeCompletion() {
+			return false;
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.transaction.support.ResourceHolderSynchronization#processResourceAfterCommit(java.lang.Object)
+		 */
+		@Override
+		protected void processResourceAfterCommit(MongoResourceHolder resourceHolder) {
+
+			if (isTransactionActive(resourceHolder)) {
+				resourceHolder.getSession().commitTransaction();
+			}
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.transaction.support.ResourceHolderSynchronization#afterCompletion(int)
+		 */
+		@Override
+		public void afterCompletion(int status) {
+
+			if (status == TransactionSynchronization.STATUS_ROLLED_BACK && isTransactionActive(this.resourceHolder)) {
+				resourceHolder.getSession().abortTransaction();
+			}
+
+			super.afterCompletion(status);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.transaction.support.ResourceHolderSynchronization#releaseResource(java.lang.Object, java.lang.Object)
+		 */
+		@Override
+		protected void releaseResource(MongoResourceHolder resourceHolder, Object resourceKey) {
+
+			if (resourceHolder.hasActiveSession()) {
+				resourceHolder.getSession().close();
+			}
+		}
+
+		private boolean isTransactionActive(MongoResourceHolder resourceHolder) {
+
+			if (!resourceHolder.hasSession()) {
+				return false;
+			}
+
+			return resourceHolder.getSession().hasActiveTransaction();
+		}
+	}
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2013 the original author or authors.
+ * Copyright 2011-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,24 +15,28 @@
  */
 package org.springframework.data.mongodb;
 
+import org.bson.codecs.configuration.CodecRegistry;
 import org.springframework.dao.DataAccessException;
 import org.springframework.dao.support.PersistenceExceptionTranslator;
 import org.springframework.data.mongodb.core.MongoExceptionTranslator;
 
+import com.mongodb.ClientSessionOptions;
 import com.mongodb.DB;
+import com.mongodb.client.ClientSession;
 import com.mongodb.client.MongoDatabase;
 
 /**
- * Interface for factories creating {@link DB} instances.
- * 
+ * Interface for factories creating {@link MongoDatabase} instances.
+ *
  * @author Mark Pollack
  * @author Thomas Darimont
+ * @author Christoph Strobl
  */
-public interface MongoDbFactory {
+public interface MongoDbFactory extends CodecRegistryProvider, MongoSessionProvider {
 
 	/**
-	 * Creates a default {@link DB} instance.
-	 * 
+	 * Creates a default {@link MongoDatabase} instance.
+	 *
 	 * @return
 	 * @throws DataAccessException
 	 */
@@ -40,7 +44,7 @@ public interface MongoDbFactory {
 
 	/**
 	 * Creates a {@link DB} instance to access the database with the given name.
-	 * 
+	 *
 	 * @param dbName must not be {@literal null} or empty.
 	 * @return
 	 * @throws DataAccessException
@@ -49,10 +53,59 @@ public interface MongoDbFactory {
 
 	/**
 	 * Exposes a shared {@link MongoExceptionTranslator}.
-	 * 
+	 *
 	 * @return will never be {@literal null}.
 	 */
 	PersistenceExceptionTranslator getExceptionTranslator();
 
+	/**
+	 * Get the legacy database entry point. Please consider {@link #getDb()} instead.
+	 *
+	 * @return
+	 * @deprecated since 2.1, use {@link #getDb()}. This method will be removed with a future version as it works only
+	 *             with the legacy MongoDB driver.
+	 */
+	@Deprecated
 	DB getLegacyDb();
+
+	/**
+	 * Get the underlying {@link CodecRegistry} used by the MongoDB Java driver.
+	 *
+	 * @return never {@literal null}.
+	 */
+	@Override
+	default CodecRegistry getCodecRegistry() {
+		return getDb().getCodecRegistry();
+	}
+
+	/**
+	 * Obtain a {@link ClientSession} for given ClientSessionOptions.
+	 *
+	 * @param options must not be {@literal null}.
+	 * @return never {@literal null}.
+	 * @since 2.1
+	 */
+	ClientSession getSession(ClientSessionOptions options);
+
+	/**
+	 * Obtain a {@link ClientSession} bound instance of {@link MongoDbFactory} returning {@link MongoDatabase} instances
+	 * that are aware and bound to a new session with given {@link ClientSessionOptions options}.
+	 *
+	 * @param options must not be {@literal null}.
+	 * @return never {@literal null}.
+	 * @since 2.1
+	 */
+	default MongoDbFactory withSession(ClientSessionOptions options) {
+		return withSession(getSession(options));
+	}
+
+	/**
+	 * Obtain a {@link ClientSession} bound instance of {@link MongoDbFactory} returning {@link MongoDatabase} instances
+	 * that are aware and bound to the given session.
+	 *
+	 * @param session must not be {@literal null}.
+	 * @return never {@literal null}.
+	 * @since 2.1
+	 */
+	MongoDbFactory withSession(ClientSession session);
 }

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

@@ -0,0 +1,122 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb;
+
+import org.springframework.lang.Nullable;
+import org.springframework.transaction.TransactionDefinition;
+import org.springframework.transaction.support.ResourceHolderSupport;
+
+import com.mongodb.client.ClientSession;
+
+/**
+ * MongoDB specific {@link ResourceHolderSupport resource holder}, wrapping a {@link ClientSession}.
+ * {@link MongoTransactionManager} binds instances of this class to the thread.
+ * <p />
+ * <strong>Note:</strong> Intended for internal usage only.
+ *
+ * @author Christoph Strobl
+ * @since 2.1
+ * @see MongoTransactionManager
+ * @see org.springframework.data.mongodb.core.MongoTemplate
+ */
+class MongoResourceHolder extends ResourceHolderSupport {
+
+	private @Nullable ClientSession session;
+	private MongoDbFactory dbFactory;
+
+	/**
+	 * Create a new {@link MongoResourceHolder} for a given {@link ClientSession session}.
+	 *
+	 * @param session the associated {@link ClientSession}. Can be {@literal null}.
+	 * @param dbFactory the associated {@link MongoDbFactory}. must not be {@literal null}.
+	 */
+	MongoResourceHolder(@Nullable ClientSession session, MongoDbFactory dbFactory) {
+
+		this.session = session;
+		this.dbFactory = dbFactory;
+	}
+
+	/**
+	 * @return the associated {@link ClientSession}. Can be {@literal null}.
+	 */
+	@Nullable
+	ClientSession getSession() {
+		return session;
+	}
+
+	/**
+	 * @return the associated {@link MongoDbFactory}.
+	 */
+	public MongoDbFactory getDbFactory() {
+		return dbFactory;
+	}
+
+	/**
+	 * Set the {@link ClientSession} to guard.
+	 *
+	 * @param session can be {@literal null}.
+	 */
+	public void setSession(@Nullable ClientSession session) {
+		this.session = session;
+	}
+
+	/**
+	 * Only set the timeout if it does not match the {@link TransactionDefinition#TIMEOUT_DEFAULT default timeout}.
+	 *
+	 * @param seconds
+	 */
+	void setTimeoutIfNotDefaulted(int seconds) {
+
+		if (seconds != TransactionDefinition.TIMEOUT_DEFAULT) {
+			setTimeoutInSeconds(seconds);
+		}
+	}
+
+	/**
+	 * @return {@literal true} if session is not {@literal null}.
+	 */
+	boolean hasSession() {
+		return session != null;
+	}
+
+	/**
+	 * @return {@literal true} if the session is active and has not been closed.
+	 */
+	boolean hasActiveSession() {
+
+		if (!hasSession()) {
+			return false;
+		}
+
+		return hasServerSession() && !getSession().getServerSession().isClosed();
+	}
+
+	/**
+	 * @return {@literal true} if the {@link ClientSession} has a {@link com.mongodb.session.ServerSession} associated
+	 *         that is accessible via {@link ClientSession#getServerSession()}.
+	 */
+	boolean hasServerSession() {
+
+		try {
+			return getSession().getServerSession() != null;
+		} catch (IllegalStateException serverSessionClosed) {
+			// ignore
+		}
+
+		return false;
+	}
+
+}

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

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb;
+
+import com.mongodb.ClientSessionOptions;
+import com.mongodb.client.ClientSession;
+
+/**
+ * A simple interface for obtaining a {@link ClientSession} to be consumed by
+ * {@link org.springframework.data.mongodb.core.MongoOperations} and MongoDB native operations that support causal
+ * consistency and transactions.
+ *
+ * @author Christoph Strobl
+ * @currentRead Shadow's Edge - Brent Weeks
+ * @since 2.1
+ */
+@FunctionalInterface
+public interface MongoSessionProvider {
+
+	/**
+	 * Obtain a {@link ClientSession} with with given options.
+	 *
+	 * @param options must not be {@literal null}.
+	 * @return never {@literal null}.
+	 * @throws org.springframework.dao.DataAccessException
+	 */
+	ClientSession getSession(ClientSessionOptions options);
+}

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

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb;
+
+import org.springframework.lang.Nullable;
+
+/**
+ * A specific {@link ClientSessionException} related to issues with a transaction such as aborted or non existing
+ * transactions.
+ *
+ * @author Christoph Strobl
+ * @since 2.1
+ */
+public class MongoTransactionException extends ClientSessionException {
+
+	/**
+	 * Constructor for {@link MongoTransactionException}.
+	 *
+	 * @param msg the detail message. Must not be {@literal null}.
+	 */
+	public MongoTransactionException(String msg) {
+		super(msg);
+	}
+
+	/**
+	 * Constructor for {@link ClientSessionException}.
+	 *
+	 * @param msg the detail message. Can be {@literal null}.
+	 * @param cause the root cause. Can be {@literal null}.
+	 */
+	public MongoTransactionException(@Nullable String msg, @Nullable Throwable cause) {
+		super(msg, cause);
+	}
+}

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

@@ -0,0 +1,490 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb;
+
+import org.springframework.beans.factory.InitializingBean;
+import org.springframework.lang.Nullable;
+import org.springframework.transaction.TransactionDefinition;
+import org.springframework.transaction.TransactionException;
+import org.springframework.transaction.TransactionSystemException;
+import org.springframework.transaction.support.AbstractPlatformTransactionManager;
+import org.springframework.transaction.support.DefaultTransactionStatus;
+import org.springframework.transaction.support.ResourceTransactionManager;
+import org.springframework.transaction.support.SmartTransactionObject;
+import org.springframework.transaction.support.TransactionSynchronizationManager;
+import org.springframework.transaction.support.TransactionSynchronizationUtils;
+import org.springframework.util.Assert;
+import org.springframework.util.ClassUtils;
+
+import com.mongodb.ClientSessionOptions;
+import com.mongodb.MongoException;
+import com.mongodb.TransactionOptions;
+import com.mongodb.client.ClientSession;
+
+/**
+ * A {@link org.springframework.transaction.PlatformTransactionManager} implementation that manages
+ * {@link ClientSession} based transactions for a single {@link MongoDbFactory}.
+ * <p />
+ * Binds a {@link ClientSession} from the specified {@link MongoDbFactory} to the thread.
+ * <p />
+ * {@link TransactionDefinition#isReadOnly() Readonly} transactions operate on a {@link ClientSession} and enable causal
+ * consistency, and also {@link ClientSession#startTransaction() start}, {@link ClientSession#commitTransaction()
+ * commit} or {@link ClientSession#abortTransaction() abort} a transaction.
+ * <p />
+ * Application code is required to retrieve the {@link com.mongodb.client.MongoDatabase} via
+ * {@link MongoDatabaseUtils#getDatabase(MongoDbFactory)} instead of a standard {@link MongoDbFactory#getDb()} call.
+ * Spring classes such as {@link org.springframework.data.mongodb.core.MongoTemplate} use this strategy implicitly.
+ * 
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @currentRead Shadow's Edge - Brent Weeks
+ * @since 2.1
+ * @see <a href="https://www.mongodb.com/transactions">MongoDB Transaction Documentation</a>
+ * @see MongoDatabaseUtils#getDatabase(MongoDbFactory, SessionSynchronization) 
+ */
+public class MongoTransactionManager extends AbstractPlatformTransactionManager
+		implements ResourceTransactionManager, InitializingBean {
+
+	private @Nullable MongoDbFactory dbFactory;
+	private @Nullable TransactionOptions options;
+
+	/**
+	 * Create a new {@link MongoTransactionManager} for bean-style usage.
+	 * <p />
+	 * <strong>Note:</strong>The {@link MongoDbFactory db factory} has to be {@link #setDbFactory(MongoDbFactory) set}
+	 * before using the instance. Use this constructor to prepare a {@link MongoTransactionManager} via a
+	 * {@link org.springframework.beans.factory.BeanFactory}.
+	 * <p />
+	 * Optionally it is possible to set default {@link TransactionOptions transaction options} defining
+	 * {@link com.mongodb.ReadConcern} and {@link com.mongodb.WriteConcern}.
+	 * 
+	 * @see #setDbFactory(MongoDbFactory)
+	 * @see #setTransactionSynchronization(int)
+	 */
+	public MongoTransactionManager() {}
+
+	/**
+	 * Create a new {@link MongoTransactionManager} obtaining sessions from the given {@link MongoDbFactory}.
+	 *
+	 * @param dbFactory must not be {@literal null}.
+	 */
+	public MongoTransactionManager(MongoDbFactory dbFactory) {
+		this(dbFactory, null);
+	}
+
+	/**
+	 * Create a new {@link MongoTransactionManager} obtaining sessions from the given {@link MongoDbFactory} applying the
+	 * given {@link TransactionOptions options}, if present, when starting a new transaction.
+	 *
+	 * @param dbFactory must not be {@literal null}.
+	 * @param options can be {@literal null}.
+	 */
+	public MongoTransactionManager(MongoDbFactory dbFactory, @Nullable TransactionOptions options) {
+
+		Assert.notNull(dbFactory, "DbFactory must not be null!");
+
+		this.dbFactory = dbFactory;
+		this.options = options;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * org.springframework.transaction.support.AbstractPlatformTransactionManager#doGetTransaction()
+	 */
+	@Override
+	protected Object doGetTransaction() throws TransactionException {
+
+		MongoResourceHolder resourceHolder = (MongoResourceHolder) TransactionSynchronizationManager
+				.getResource(getRequiredDbFactory());
+		return new MongoTransactionObject(resourceHolder);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * org.springframework.transaction.support.AbstractPlatformTransactionManager#isExistingTransaction(java.lang.Object)
+	 */
+	@Override
+	protected boolean isExistingTransaction(Object transaction) throws TransactionException {
+		return extractMongoTransaction(transaction).hasResourceHolder();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * org.springframework.transaction.support.AbstractPlatformTransactionManager#doBegin(java.lang.Object, org.springframework.transaction.TransactionDefinition)
+	 */
+	@Override
+	protected void doBegin(Object transaction, TransactionDefinition definition) throws TransactionException {
+
+		MongoTransactionObject mongoTransactionObject = extractMongoTransaction(transaction);
+
+		MongoResourceHolder resourceHolder = newResourceHolder(definition,
+				ClientSessionOptions.builder().causallyConsistent(true).build());
+		mongoTransactionObject.setResourceHolder(resourceHolder);
+
+		if (logger.isDebugEnabled()) {
+			logger
+					.debug(String.format("About to start transaction for session %s.", debugString(resourceHolder.getSession())));
+		}
+
+		try {
+			mongoTransactionObject.startTransaction(options);
+		} catch (MongoException ex) {
+			throw new TransactionSystemException(String.format("Could not start Mongo transaction for session %s.",
+					debugString(mongoTransactionObject.getSession())), ex);
+		}
+
+		if (logger.isDebugEnabled()) {
+			logger.debug(String.format("Started transaction for session %s.", debugString(resourceHolder.getSession())));
+		}
+
+		resourceHolder.setSynchronizedWithTransaction(true);
+		TransactionSynchronizationManager.bindResource(getRequiredDbFactory(), resourceHolder);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * org.springframework.transaction.support.AbstractPlatformTransactionManager#doSuspend(java.lang.Object)
+	 */
+	@Override
+	protected Object doSuspend(Object transaction) throws TransactionException {
+
+		MongoTransactionObject mongoTransactionObject = extractMongoTransaction(transaction);
+		mongoTransactionObject.setResourceHolder(null);
+
+		return TransactionSynchronizationManager.unbindResource(getRequiredDbFactory());
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * org.springframework.transaction.support.AbstractPlatformTransactionManager#doResume(java.lang.Object, java.lang.Object)
+	 */
+	@Override
+	protected void doResume(@Nullable Object transaction, Object suspendedResources) {
+		TransactionSynchronizationManager.bindResource(getRequiredDbFactory(), suspendedResources);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * org.springframework.transaction.support.AbstractPlatformTransactionManager#doCommit(org.springframework.transaction.support.DefaultTransactionStatus)
+	 */
+	@Override
+	protected void doCommit(DefaultTransactionStatus status) throws TransactionException {
+
+		MongoTransactionObject mongoTransactionObject = extractMongoTransaction(status);
+
+		if (logger.isDebugEnabled()) {
+			logger.debug(String.format("About to commit transaction for session %s.",
+					debugString(mongoTransactionObject.getSession())));
+		}
+
+		try {
+			mongoTransactionObject.commitTransaction();
+		} catch (MongoException ex) {
+
+			throw new TransactionSystemException(String.format("Could not commit Mongo transaction for session %s.",
+					debugString(mongoTransactionObject.getSession())), ex);
+		}
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * org.springframework.transaction.support.AbstractPlatformTransactionManager#doRollback(org.springframework.transaction.support.DefaultTransactionStatus)
+	 */
+	@Override
+	protected void doRollback(DefaultTransactionStatus status) throws TransactionException {
+
+		MongoTransactionObject mongoTransactionObject = extractMongoTransaction(status);
+
+		if (logger.isDebugEnabled()) {
+			logger.debug(String.format("About to abort transaction for session %s.",
+					debugString(mongoTransactionObject.getSession())));
+		}
+
+		try {
+			mongoTransactionObject.abortTransaction();
+		} catch (MongoException ex) {
+
+			throw new TransactionSystemException(String.format("Could not abort Mongo transaction for session %s.",
+					debugString(mongoTransactionObject.getSession())), ex);
+		}
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * org.springframework.transaction.support.AbstractPlatformTransactionManager#doSetRollbackOnly(org.springframework.transaction.support.DefaultTransactionStatus)
+	 */
+	@Override
+	protected void doSetRollbackOnly(DefaultTransactionStatus status) throws TransactionException {
+
+		MongoTransactionObject transactionObject = extractMongoTransaction(status);
+		transactionObject.getRequiredResourceHolder().setRollbackOnly();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * org.springframework.transaction.support.AbstractPlatformTransactionManager#doCleanupAfterCompletion(java.lang.Object)
+	 */
+	@Override
+	protected void doCleanupAfterCompletion(Object transaction) {
+
+		Assert.isInstanceOf(MongoTransactionObject.class, transaction,
+				() -> String.format("Expected to find a %s but it turned out to be %s.", MongoTransactionObject.class,
+						transaction.getClass()));
+
+		MongoTransactionObject mongoTransactionObject = (MongoTransactionObject) transaction;
+
+		// Remove the connection holder from the thread.
+		TransactionSynchronizationManager.unbindResource(getRequiredDbFactory());
+		mongoTransactionObject.getRequiredResourceHolder().clear();
+
+		if (logger.isDebugEnabled()) {
+			logger.debug(String.format("About to release Session %s after transaction.",
+					debugString(mongoTransactionObject.getSession())));
+		}
+
+		mongoTransactionObject.closeSession();
+	}
+
+	/**
+	 * Set the {@link MongoDbFactory} that this instance should manage transactions for.
+	 *
+	 * @param dbFactory must not be {@literal null}.
+	 */
+	public void setDbFactory(MongoDbFactory dbFactory) {
+
+		Assert.notNull(dbFactory, "DbFactory must not be null!");
+		this.dbFactory = dbFactory;
+	}
+
+	/**
+	 * Set the {@link TransactionOptions} to be applied when starting transactions.
+	 *
+	 * @param options can be {@literal null}.
+	 */
+	public void setOptions(@Nullable TransactionOptions options) {
+		this.options = options;
+	}
+
+	/**
+	 * Get the {@link MongoDbFactory} that this instance manages transactions for.
+	 *
+	 * @return can be {@literal null}.
+	 */
+	@Nullable
+	public MongoDbFactory getDbFactory() {
+		return dbFactory;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.transaction.support.ResourceTransactionManager#getResourceFactory()
+	 */
+	@Override
+	public MongoDbFactory getResourceFactory() {
+		return getRequiredDbFactory();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
+	 */
+	@Override
+	public void afterPropertiesSet() {
+		getRequiredDbFactory();
+	}
+
+	private MongoResourceHolder newResourceHolder(TransactionDefinition definition, ClientSessionOptions options) {
+
+		MongoDbFactory dbFactory = getResourceFactory();
+
+		MongoResourceHolder resourceHolder = new MongoResourceHolder(dbFactory.getSession(options), dbFactory);
+		resourceHolder.setTimeoutIfNotDefaulted(determineTimeout(definition));
+
+		return resourceHolder;
+	}
+
+	/**
+	 * @throws IllegalStateException if {@link #dbFactory} is {@literal null}.
+	 */
+	private MongoDbFactory getRequiredDbFactory() {
+
+		Assert.state(dbFactory != null,
+				"MongoTransactionManager operates upon a MongoDbFactory. Did you forget to provide one? It's required.");
+
+		return dbFactory;
+	}
+
+	private static MongoTransactionObject extractMongoTransaction(Object transaction) {
+
+		Assert.isInstanceOf(MongoTransactionObject.class, transaction,
+				() -> String.format("Expected to find a %s but it turned out to be %s.", MongoTransactionObject.class,
+						transaction.getClass()));
+
+		return (MongoTransactionObject) transaction;
+	}
+
+	private static MongoTransactionObject extractMongoTransaction(DefaultTransactionStatus status) {
+
+		Assert.isInstanceOf(MongoTransactionObject.class, status.getTransaction(),
+				() -> String.format("Expected to find a %s but it turned out to be %s.", MongoTransactionObject.class,
+						status.getTransaction().getClass()));
+
+		return (MongoTransactionObject) status.getTransaction();
+	}
+
+	private static String debugString(@Nullable ClientSession session) {
+
+		if (session == null) {
+			return "null";
+		}
+
+		String debugString = String.format("[%s@%s ", ClassUtils.getShortName(session.getClass()),
+				Integer.toHexString(session.hashCode()));
+
+		try {
+			if (session.getServerSession() != null) {
+				debugString += String.format("id = %s, ", session.getServerSession().getIdentifier());
+				debugString += String.format("causallyConsistent = %s, ", session.isCausallyConsistent());
+				debugString += String.format("txActive = %s, ", session.hasActiveTransaction());
+				debugString += String.format("txNumber = %d, ", session.getServerSession().getTransactionNumber());
+				debugString += String.format("closed = %d, ", session.getServerSession().isClosed());
+				debugString += String.format("clusterTime = %s", session.getClusterTime());
+			} else {
+				debugString += "id = n/a";
+				debugString += String.format("causallyConsistent = %s, ", session.isCausallyConsistent());
+				debugString += String.format("txActive = %s, ", session.hasActiveTransaction());
+				debugString += String.format("clusterTime = %s", session.getClusterTime());
+			}
+		} catch (RuntimeException e) {
+			debugString += String.format("error = %s", e.getMessage());
+		}
+
+		debugString += "]";
+
+		return debugString;
+	}
+
+	/**
+	 * MongoDB specific transaction object, representing a {@link MongoResourceHolder}. Used as transaction object by
+	 * {@link MongoTransactionManager}.
+	 *
+	 * @author Christoph Strobl
+	 * @author Mark Paluch
+	 * @since 2.1
+	 * @see MongoResourceHolder
+	 */
+	static class MongoTransactionObject implements SmartTransactionObject {
+
+		private @Nullable MongoResourceHolder resourceHolder;
+
+		MongoTransactionObject(@Nullable MongoResourceHolder resourceHolder) {
+			this.resourceHolder = resourceHolder;
+		}
+
+		/**
+		 * Set the {@link MongoResourceHolder}.
+		 *
+		 * @param resourceHolder can be {@literal null}.
+		 */
+		void setResourceHolder(@Nullable MongoResourceHolder resourceHolder) {
+			this.resourceHolder = resourceHolder;
+		}
+
+		/**
+		 * @return {@literal true} if a {@link MongoResourceHolder} is set.
+		 */
+		boolean hasResourceHolder() {
+			return resourceHolder != null;
+		}
+
+		/**
+		 * Start a MongoDB transaction optionally given {@link TransactionOptions}.
+		 *
+		 * @param options can be {@literal null}
+		 */
+		void startTransaction(@Nullable TransactionOptions options) {
+
+			ClientSession session = getRequiredSession();
+			if (options != null) {
+				session.startTransaction(options);
+			} else {
+				session.startTransaction();
+			}
+		}
+
+		/**
+		 * Commit the transaction.
+		 */
+		void commitTransaction() {
+			getRequiredSession().commitTransaction();
+		}
+
+		/**
+		 * Rollback (abort) the transaction.
+		 */
+		void abortTransaction() {
+			getRequiredSession().abortTransaction();
+		}
+
+		/**
+		 * Close a {@link ClientSession} without regard to its transactional state.
+		 */
+		void closeSession() {
+
+			ClientSession session = getRequiredSession();
+			if (session.getServerSession() != null && !session.getServerSession().isClosed()) {
+				session.close();
+			}
+		}
+
+		@Nullable
+		ClientSession getSession() {
+			return resourceHolder != null ? resourceHolder.getSession() : null;
+		}
+
+		private MongoResourceHolder getRequiredResourceHolder() {
+
+			Assert.state(resourceHolder != null, "MongoResourceHolder is required but not present. o_O");
+			return resourceHolder;
+		}
+
+		private ClientSession getRequiredSession() {
+
+			ClientSession session = getSession();
+			Assert.state(session != null, "A Session is required but it turned out to be null.");
+			return session;
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see  org.springframework.transaction.support.SmartTransactionObject#isRollbackOnly()
+		 */
+		@Override
+		public boolean isRollbackOnly() {
+			return this.resourceHolder != null && this.resourceHolder.isRollbackOnly();
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see  org.springframework.transaction.support.SmartTransactionObject#flush()
+		 */
+		@Override
+		public void flush() {
+			TransactionSynchronizationUtils.triggerFlush();
+		}
+
+	}
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016 the original author or authors.
+ * Copyright 2016-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,19 +16,25 @@
 
 package org.springframework.data.mongodb;
 
+import reactor.core.publisher.Mono;
+
+import org.bson.codecs.configuration.CodecRegistry;
 import org.springframework.dao.DataAccessException;
 import org.springframework.dao.support.PersistenceExceptionTranslator;
 import org.springframework.data.mongodb.core.MongoExceptionTranslator;
 
+import com.mongodb.ClientSessionOptions;
+import com.mongodb.reactivestreams.client.ClientSession;
 import com.mongodb.reactivestreams.client.MongoDatabase;
 
 /**
  * Interface for factories creating reactive {@link MongoDatabase} instances.
  *
  * @author Mark Paluch
+ * @author Christoph Strobl
  * @since 2.0
  */
-public interface ReactiveMongoDatabaseFactory {
+public interface ReactiveMongoDatabaseFactory extends CodecRegistryProvider {
 
 	/**
 	 * Creates a default {@link MongoDatabase} instance.
@@ -53,4 +59,33 @@ public interface ReactiveMongoDatabaseFactory {
 	 * @return will never be {@literal null}.
 	 */
 	PersistenceExceptionTranslator getExceptionTranslator();
+
+	/**
+	 * Get the underlying {@link CodecRegistry} used by the reactive MongoDB Java driver.
+	 *
+	 * @return never {@literal null}.
+	 */
+	@Override
+	default CodecRegistry getCodecRegistry() {
+		return getMongoDatabase().getCodecRegistry();
+	}
+
+	/**
+	 * Obtain a {@link Mono} emitting a {@link ClientSession} for given {@link ClientSessionOptions options}.
+	 *
+	 * @param options must not be {@literal null}.
+	 * @return never {@literal null}.
+	 * @since 2.1
+	 */
+	Mono<ClientSession> getSession(ClientSessionOptions options);
+
+	/**
+	 * Obtain a {@link ClientSession} bound instance of {@link ReactiveMongoDatabaseFactory} returning
+	 * {@link MongoDatabase} instances that are aware and bound to the given session.
+	 *
+	 * @param session must not be {@literal null}.
+	 * @return never {@literal null}.
+	 * @since 2.1
+	 */
+	ReactiveMongoDatabaseFactory withSession(ClientSession session);
 }

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

@@ -0,0 +1,215 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+import java.util.Optional;
+import java.util.function.BiFunction;
+
+import org.aopalliance.intercept.MethodInterceptor;
+import org.aopalliance.intercept.MethodInvocation;
+import org.springframework.core.MethodClassKey;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+import org.springframework.util.ClassUtils;
+import org.springframework.util.ConcurrentReferenceHashMap;
+import org.springframework.util.ReflectionUtils;
+
+import com.mongodb.WriteConcern;
+import com.mongodb.session.ClientSession;
+
+/**
+ * {@link MethodInterceptor} implementation looking up and invoking an alternative target method having
+ * {@link ClientSession} as its first argument. This allows seamless integration with the existing code base.
+ * <p />
+ * The {@link MethodInterceptor} is aware of methods on {@code MongoCollection} that my return new instances of itself
+ * like (eg. {@link com.mongodb.reactivestreams.client.MongoCollection#withWriteConcern(WriteConcern)} and decorate them
+ * if not already proxied.
+ *
+ * @param <D> Type of the actual Mongo Database.
+ * @param <C> Type of the actual Mongo Collection.
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @since 2.1
+ */
+public class SessionAwareMethodInterceptor<D, C> implements MethodInterceptor {
+
+	private static final MethodCache METHOD_CACHE = new MethodCache();
+
+	private final ClientSession session;
+	private final ClientSessionOperator collectionDecorator;
+	private final ClientSessionOperator databaseDecorator;
+	private final Object target;
+	private final Class<?> targetType;
+	private final Class<?> collectionType;
+	private final Class<?> databaseType;
+	private final Class<? extends ClientSession> sessionType;
+
+	/**
+	 * Create a new SessionAwareMethodInterceptor for given target.
+	 *
+	 * @param session the {@link ClientSession} to be used on invocation.
+	 * @param target the original target object.
+	 * @param databaseType the MongoDB database type
+	 * @param databaseDecorator a {@link ClientSessionOperator} used to create the proxy for an imperative / reactive
+	 *          {@code MongoDatabase}.
+	 * @param collectionType the MongoDB collection type.
+	 * @param collectionDecorator a {@link ClientSessionOperator} used to create the proxy for an imperative / reactive
+	 *          {@code MongoCollection}.
+	 * @param <T> target object type.
+	 */
+	public <T> SessionAwareMethodInterceptor(ClientSession session, T target, Class<? extends ClientSession> sessionType,
+			Class<D> databaseType, ClientSessionOperator<D> databaseDecorator, Class<C> collectionType,
+			ClientSessionOperator<C> collectionDecorator) {
+
+		Assert.notNull(session, "ClientSession must not be null!");
+		Assert.notNull(target, "Target must not be null!");
+		Assert.notNull(sessionType, "SessionType must not be null!");
+		Assert.notNull(databaseType, "Database type must not be null!");
+		Assert.notNull(databaseDecorator, "Database ClientSessionOperator must not be null!");
+		Assert.notNull(collectionType, "Collection type must not be null!");
+		Assert.notNull(collectionDecorator, "Collection ClientSessionOperator must not be null!");
+
+		this.session = session;
+		this.target = target;
+		this.databaseType = ClassUtils.getUserClass(databaseType);
+		this.collectionType = ClassUtils.getUserClass(collectionType);
+		this.collectionDecorator = collectionDecorator;
+		this.databaseDecorator = databaseDecorator;
+
+		this.targetType = ClassUtils.isAssignable(databaseType, target.getClass()) ? databaseType : collectionType;
+		this.sessionType = sessionType;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.aopalliance.intercept.MethodInterceptor(org.aopalliance.intercept.MethodInvocation)
+	 */
+	@Nullable
+	@Override
+	public Object invoke(MethodInvocation methodInvocation) throws Throwable {
+
+		if (requiresDecoration(methodInvocation.getMethod())) {
+
+			Object target = methodInvocation.proceed();
+			if (target instanceof Proxy) {
+				return target;
+			}
+
+			return decorate(target);
+		}
+
+		if (!requiresSession(methodInvocation.getMethod())) {
+			return methodInvocation.proceed();
+		}
+
+		Optional<Method> targetMethod = METHOD_CACHE.lookup(methodInvocation.getMethod(), targetType, sessionType);
+
+		return !targetMethod.isPresent() ? methodInvocation.proceed()
+				: ReflectionUtils.invokeMethod(targetMethod.get(), target,
+						prependSessionToArguments(session, methodInvocation));
+	}
+
+	private boolean requiresDecoration(Method method) {
+
+		return ClassUtils.isAssignable(databaseType, method.getReturnType())
+				|| ClassUtils.isAssignable(collectionType, method.getReturnType());
+	}
+
+	@SuppressWarnings("unchecked")
+	protected Object decorate(Object target) {
+
+		return ClassUtils.isAssignable(databaseType, target.getClass()) ? databaseDecorator.apply(session, target)
+				: collectionDecorator.apply(session, target);
+	}
+
+	private static boolean requiresSession(Method method) {
+
+		if (method.getParameterCount() == 0
+				|| !ClassUtils.isAssignable(ClientSession.class, method.getParameterTypes()[0])) {
+			return true;
+		}
+
+		return false;
+	}
+
+	private static Object[] prependSessionToArguments(ClientSession session, MethodInvocation invocation) {
+
+		Object[] args = new Object[invocation.getArguments().length + 1];
+
+		args[0] = session;
+		System.arraycopy(invocation.getArguments(), 0, args, 1, invocation.getArguments().length);
+
+		return args;
+	}
+
+	/**
+	 * Simple {@link Method} to {@link Method} caching facility for {@link ClientSession} overloaded targets.
+	 *
+	 * @since 2.1
+	 * @author Christoph Strobl
+	 */
+	static class MethodCache {
+
+		private final ConcurrentReferenceHashMap<MethodClassKey, Optional<Method>> cache = new ConcurrentReferenceHashMap<>();
+
+		/**
+		 * Lookup the target {@link Method}.
+		 *
+		 * @param method
+		 * @param targetClass
+		 * @return
+		 */
+		Optional<Method> lookup(Method method, Class<?> targetClass, Class<? extends ClientSession> sessionType) {
+
+			return cache.computeIfAbsent(new MethodClassKey(method, targetClass),
+					val -> Optional.ofNullable(findTargetWithSession(method, targetClass, sessionType)));
+		}
+
+		@Nullable
+		private Method findTargetWithSession(Method sourceMethod, Class<?> targetType,
+				Class<? extends ClientSession> sessionType) {
+
+			Class<?>[] argTypes = sourceMethod.getParameterTypes();
+			Class<?>[] args = new Class<?>[argTypes.length + 1];
+			args[0] = sessionType;
+			System.arraycopy(argTypes, 0, args, 1, argTypes.length);
+
+			return ReflectionUtils.findMethod(targetType, sourceMethod.getName(), args);
+		}
+
+		/**
+		 * Check whether the cache contains an entry for {@link Method} and {@link Class}.
+		 *
+		 * @param method
+		 * @param targetClass
+		 * @return
+		 */
+		boolean contains(Method method, Class<?> targetClass) {
+			return cache.containsKey(new MethodClassKey(method, targetClass));
+		}
+	}
+
+	/**
+	 * Represents an operation upon two operands of the same type, producing a result of the same type as the operands
+	 * accepting {@link ClientSession}. This is a specialization of {@link BiFunction} for the case where the operands and
+	 * the result are all of the same type.
+	 *
+	 * @param <T> the type of the operands and result of the operator
+	 */
+	public interface ClientSessionOperator<T> extends BiFunction<ClientSession, T, T> {}
+}

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

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb;
+
+/**
+ * {@link SessionSynchronization} is used along with {@link org.springframework.data.mongodb.core.MongoTemplate} to
+ * define in which type of transactions to participate if any.
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @since 2.1
+ */
+public enum SessionSynchronization {
+
+	/**
+	 * Synchronize with any transaction even with empty transactions and initiate a MongoDB transaction when doing so by
+	 * registering a MongoDB specific {@link org.springframework.transaction.support.ResourceHolderSynchronization}.
+	 */
+	ALWAYS,
+
+	/**
+	 * Synchronize with native MongoDB transactions initiated via {@link MongoTransactionManager}.
+	 */
+	ON_ACTUAL_TRANSACTION;
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2011 the original author or authors.
+ * Copyright 2010-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.mongodb.MongoDbFactory;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.SimpleMongoClientDbFactory;
+import org.springframework.data.mongodb.core.SimpleMongoDbFactory;
+import org.springframework.data.mongodb.core.convert.DbRefResolver;
+import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver;
+import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
+import org.springframework.data.mongodb.core.mapping.Document;
+import org.springframework.lang.Nullable;
+
+import com.mongodb.client.MongoClient;
+
+/**
+ * Base class for Spring Data MongoDB configuration using JavaConfig with {@link com.mongodb.client.MongoClient}.
+ *
+ * @author Christoph Strobl
+ * @since 2.1
+ * @see MongoConfigurationSupport
+ * @see AbstractMongoConfiguration
+ */
+@Configuration
+public abstract class AbstractMongoClientConfiguration extends MongoConfigurationSupport {
+
+	/**
+	 * Return the {@link MongoClient} instance to connect to. Annotate with {@link Bean} in case you want to expose a
+	 * {@link MongoClient} instance to the {@link org.springframework.context.ApplicationContext}.
+	 *
+	 * @return
+	 */
+	public abstract MongoClient mongoClient();
+
+	/**
+	 * Creates a {@link MongoTemplate}.
+	 *
+	 * @return
+	 */
+	@Bean
+	public MongoTemplate mongoTemplate() throws Exception {
+		return new MongoTemplate(mongoDbFactory(), mappingMongoConverter());
+	}
+
+	/**
+	 * Creates a {@link SimpleMongoDbFactory} to be used by the {@link MongoTemplate}. Will use the {@link MongoClient}
+	 * instance configured in {@link #mongoClient()}.
+	 *
+	 * @see #mongoClient()
+	 * @see #mongoTemplate()
+	 * @return
+	 */
+	@Bean
+	public MongoDbFactory mongoDbFactory() {
+		return new SimpleMongoClientDbFactory(mongoClient(), getDatabaseName());
+	}
+
+	/**
+	 * Return the base package to scan for mapped {@link Document}s. Will return the package name of the configuration
+	 * class' (the concrete class, not this one here) by default. So if you have a {@code com.acme.AppConfig} extending
+	 * {@link AbstractMongoClientConfiguration} the base package will be considered {@code com.acme} unless the method is
+	 * overridden to implement alternate behavior.
+	 *
+	 * @return the base package to scan for mapped {@link Document} classes or {@literal null} to not enable scanning for
+	 *         entities.
+	 * @deprecated use {@link #getMappingBasePackages()} instead.
+	 */
+	@Deprecated
+	@Nullable
+	protected String getMappingBasePackage() {
+
+		Package mappingBasePackage = getClass().getPackage();
+		return mappingBasePackage == null ? null : mappingBasePackage.getName();
+	}
+
+	/**
+	 * Creates a {@link MappingMongoConverter} using the configured {@link #mongoDbFactory()} and
+	 * {@link #mongoMappingContext()}. Will get {@link #customConversions()} applied.
+	 *
+	 * @see #customConversions()
+	 * @see #mongoMappingContext()
+	 * @see #mongoDbFactory()
+	 * @return
+	 * @throws Exception
+	 */
+	@Bean
+	public MappingMongoConverter mappingMongoConverter() throws Exception {
+
+		DbRefResolver dbRefResolver = new DefaultDbRefResolver(mongoDbFactory());
+		MappingMongoConverter converter = new MappingMongoConverter(dbRefResolver, mongoMappingContext());
+		converter.setCustomConversions(customConversions());
+
+		return converter;
+	}
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2017 the original author or authors.
+ * Copyright 2011-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -29,7 +29,10 @@ import org.springframework.lang.Nullable;
 import com.mongodb.MongoClient;
 
 /**
- * Base class for Spring Data MongoDB configuration using JavaConfig.
+ * Base class for Spring Data MongoDB configuration using JavaConfig with {@link com.mongodb.MongoClient}.
+ * <p />
+ * <strong>INFO:</strong>In case you want to use {@link com.mongodb.client.MongoClients} for configuration please refer
+ * to {@link AbstractMongoClientConfiguration}.
  *
  * @author Mark Pollack
  * @author Oliver Gierke
@@ -38,10 +41,10 @@ import com.mongodb.MongoClient;
  * @author Christoph Strobl
  * @author Mark Paluch
  * @see MongoConfigurationSupport
+ * @see AbstractMongoClientConfiguration
  */
 @Configuration
-public abstract class
-AbstractMongoConfiguration extends MongoConfigurationSupport {
+public abstract class AbstractMongoConfiguration extends MongoConfigurationSupport {
 
 	/**
 	 * Return the {@link MongoClient} instance to connect to. Annotate with {@link Bean} in case you want to expose a
@@ -63,7 +66,7 @@ AbstractMongoConfiguration extends MongoConfigurationSupport {
 
 	/**
 	 * Creates a {@link SimpleMongoDbFactory} to be used by the {@link MongoTemplate}. Will use the {@link MongoClient}
-	 * instance configured in {@link #mongo()}.
+	 * instance configured in {@link #mongoClient()}.
 	 *
 	 * @see #mongoClient()
 	 * @see #mongoTemplate()
@@ -111,4 +114,5 @@ AbstractMongoConfiguration extends MongoConfigurationSupport {
 
 		return converter;
 	}
+
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2017 the original author or authors.
+ * Copyright 2016-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,6 +22,7 @@ import org.springframework.data.mongodb.core.ReactiveMongoOperations;
 import org.springframework.data.mongodb.core.ReactiveMongoTemplate;
 import org.springframework.data.mongodb.core.SimpleReactiveMongoDatabaseFactory;
 import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
+import org.springframework.data.mongodb.core.convert.NoOpDbRefResolver;
 
 import com.mongodb.reactivestreams.client.MongoClient;
 
@@ -80,8 +81,7 @@ public abstract class AbstractReactiveMongoConfiguration extends MongoConfigurat
 	@Bean
 	public MappingMongoConverter mappingMongoConverter() throws Exception {
 
-		MappingMongoConverter converter = new MappingMongoConverter(ReactiveMongoTemplate.NO_OP_REF_RESOLVER,
-				mongoMappingContext());
+		MappingMongoConverter converter = new MappingMongoConverter(NoOpDbRefResolver.INSTANCE, mongoMappingContext());
 		converter.setCustomConversions(customConversions());
 
 		return converter;

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2017 the original author or authors.
+ * Copyright 2011-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,7 +17,7 @@ package org.springframework.data.mongodb.config;
 
 /**
  * Constants to declare bean names used by the namespace configuration.
- * 
+ *
  * @author Jon Brisbin
  * @author Oliver Gierke
  * @author Martin Baumgartner

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013 the original author or authors.
+ * Copyright 2013-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -28,7 +28,7 @@ import org.springframework.data.domain.AuditorAware;
 
 /**
  * Annotation to enable auditing in MongoDB via annotation configuration.
- * 
+ *
  * @author Thomas Darimont
  * @author Oliver Gierke
  */
@@ -41,21 +41,21 @@ public @interface EnableMongoAuditing {
 
 	/**
 	 * Configures the {@link AuditorAware} bean to be used to lookup the current principal.
-	 * 
+	 *
 	 * @return
 	 */
 	String auditorAwareRef() default "";
 
 	/**
 	 * Configures whether the creation and modification dates are set. Defaults to {@literal true}.
-	 * 
+	 *
 	 * @return
 	 */
 	boolean setDates() default true;
 
 	/**
 	 * Configures whether the entity shall be marked as modified on creation. Defaults to {@literal true}.
-	 * 
+	 *
 	 * @return
 	 */
 	boolean modifyOnCreate() default true;
@@ -63,7 +63,7 @@ public @interface EnableMongoAuditing {
 	/**
 	 * Configures a {@link DateTimeProvider} bean name that allows customizing the {@link org.joda.time.DateTime} to be
 	 * used for setting creation and modification dates.
-	 * 
+	 *
 	 * @return
 	 */
 	String dateTimeProviderRef() default "";

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2017 the original author or authors.
+ * Copyright 2015-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,7 +21,7 @@ import org.springframework.data.web.config.SpringDataJacksonModules;
 
 /**
  * Configuration class to expose {@link GeoJsonModule} as a Spring bean.
- * 
+ *
  * @author Oliver Gierke
  * @author Jens Schauder
  */

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2014 the original author or authors.
+ * Copyright 2013-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -29,7 +29,7 @@ import org.w3c.dom.Element;
 
 /**
  * {@link BeanDefinitionParser} to parse {@code gridFsTemplate} elements into {@link BeanDefinition}s.
- * 
+ *
  * @author Martin Baumgartner
  */
 class GridFsTemplateParser extends AbstractBeanDefinitionParser {

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2017 the original author or authors.
+ * Copyright 2011-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2014 the original author or authors.
+ * Copyright 2012-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -33,12 +33,12 @@ import org.w3c.dom.Element;
 /**
  * {@link BeanDefinitionParser} to register a {@link AuditingEventListener} to transparently set auditing information on
  * an entity.
- * 
+ *
  * @author Oliver Gierke
  */
 public class MongoAuditingBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {
 
-	/* 
+	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser#getBeanClass(org.w3c.dom.Element)
 	 */
@@ -47,7 +47,7 @@ public class MongoAuditingBeanDefinitionParser extends AbstractSingleBeanDefinit
 		return AuditingEventListener.class;
 	}
 
-	/* 
+	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.beans.factory.xml.AbstractBeanDefinitionParser#shouldGenerateId()
 	 */
@@ -56,7 +56,7 @@ public class MongoAuditingBeanDefinitionParser extends AbstractSingleBeanDefinit
 		return true;
 	}
 
-	/* 
+	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser#doParse(org.w3c.dom.Element, org.springframework.beans.factory.xml.ParserContext, org.springframework.beans.factory.support.BeanDefinitionBuilder)
 	 */

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2016 the original author or authors.
+ * Copyright 2013-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -37,13 +37,13 @@ import org.springframework.util.Assert;
 
 /**
  * {@link ImportBeanDefinitionRegistrar} to enable {@link EnableMongoAuditing} annotation.
- * 
+ *
  * @author Thomas Darimont
  * @author Oliver Gierke
  */
 class MongoAuditingRegistrar extends AuditingBeanDefinitionRegistrarSupport {
 
-	/* 
+	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport#getAnnotation()
 	 */
@@ -52,7 +52,7 @@ class MongoAuditingRegistrar extends AuditingBeanDefinitionRegistrarSupport {
 		return EnableMongoAuditing.class;
 	}
 
-	/* 
+	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport#getAuditingHandlerBeanName()
 	 */
@@ -61,7 +61,7 @@ class MongoAuditingRegistrar extends AuditingBeanDefinitionRegistrarSupport {
 		return "mongoAuditingHandler";
 	}
 
-	/* 
+	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport#registerBeanDefinitions(org.springframework.core.type.AnnotationMetadata, org.springframework.beans.factory.support.BeanDefinitionRegistry)
 	 */
@@ -74,7 +74,7 @@ class MongoAuditingRegistrar extends AuditingBeanDefinitionRegistrarSupport {
 		super.registerBeanDefinitions(annotationMetadata, registry);
 	}
 
-	/* 
+	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport#getAuditHandlerBeanDefinitionBuilder(org.springframework.data.auditing.config.AuditingConfiguration)
 	 */
@@ -92,7 +92,7 @@ class MongoAuditingRegistrar extends AuditingBeanDefinitionRegistrarSupport {
 		return configureDefaultAuditHandlerAttributes(configuration, builder);
 	}
 
-	/* 
+	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport#registerAuditListener(org.springframework.beans.factory.config.BeanDefinition, org.springframework.beans.factory.support.BeanDefinitionRegistry)
 	 */
@@ -125,14 +125,14 @@ class MongoAuditingRegistrar extends AuditingBeanDefinitionRegistrarSupport {
 
 		/**
 		 * Creates a new {@link MongoMappingContextLookup} for the given {@link MappingMongoConverter}.
-		 * 
+		 *
 		 * @param converter must not be {@literal null}.
 		 */
 		public MongoMappingContextLookup(MappingMongoConverter converter) {
 			this.converter = converter;
 		}
 
-		/* 
+		/*
 		 * (non-Javadoc)
 		 * @see org.springframework.beans.factory.FactoryBean#getObject()
 		 */
@@ -141,7 +141,7 @@ class MongoAuditingRegistrar extends AuditingBeanDefinitionRegistrarSupport {
 			return converter.getMappingContext();
 		}
 
-		/* 
+		/*
 		 * (non-Javadoc)
 		 * @see org.springframework.beans.factory.FactoryBean#getObjectType()
 		 */
@@ -150,7 +150,7 @@ class MongoAuditingRegistrar extends AuditingBeanDefinitionRegistrarSupport {
 			return MappingContext.class;
 		}
 
-		/* 
+		/*
 		 * (non-Javadoc)
 		 * @see org.springframework.beans.factory.FactoryBean#isSingleton()
 		 */

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015 the original author or authors.
+ * Copyright 2015-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -29,13 +29,13 @@ import org.w3c.dom.Element;
 
 /**
  * Parser for {@code mongo-client} definitions.
- * 
+ *
  * @author Christoph Strobl
  * @since 1.7
  */
 public class MongoClientParser implements BeanDefinitionParser {
 
-	/* 
+	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.beans.factory.xml.BeanDefinitionParser#parse(org.w3c.dom.Element, org.springframework.beans.factory.xml.ParserContext)
 	 */

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2017 the original author or authors.
+ * Copyright 2016-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2017 the original author or authors.
+ * Copyright 2015-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -35,6 +35,8 @@ import com.mongodb.MongoCredential;
  *
  * @author Christoph Strobl
  * @author Oliver Gierke
+ * @author Stephen Tyler Conrad
+ * @author Mark Paluch
  * @since 1.7
  */
 public class MongoCredentialPropertyEditor extends PropertyEditorSupport {
@@ -98,6 +100,12 @@ public class MongoCredentialPropertyEditor extends PropertyEditorSupport {
 						verifyDatabasePresent(database);
 						credentials.add(MongoCredential.createScramSha1Credential(userNameAndPassword[0], database,
 								userNameAndPassword[1].toCharArray()));
+					} else if (MongoCredential.SCRAM_SHA_256_MECHANISM.equals(authMechanism)) {
+
+						verifyUsernameAndPasswordPresent(userNameAndPassword);
+						verifyDatabasePresent(database);
+						credentials.add(MongoCredential.createScramSha256Credential(userNameAndPassword[0], database,
+								userNameAndPassword[1].toCharArray()));
 					} else {
 						throw new IllegalArgumentException(
 								String.format("Cannot create MongoCredentials for unknown auth mechanism '%s'!", authMechanism));
@@ -164,7 +172,7 @@ public class MongoCredentialPropertyEditor extends PropertyEditorSupport {
 	private static Properties extractOptions(String text) {
 
 		int optionsSeparationIndex = text.lastIndexOf(OPTIONS_DELIMITER);
-		int dbSeparationIndex = text.lastIndexOf(OPTIONS_DELIMITER);
+		int dbSeparationIndex = text.lastIndexOf(DATABASE_DELIMITER);
 
 		if (optionsSeparationIndex == -1 || dbSeparationIndex > optionsSeparationIndex) {
 			return new Properties();
@@ -173,7 +181,13 @@ public class MongoCredentialPropertyEditor extends PropertyEditorSupport {
 		Properties properties = new Properties();
 
 		for (String option : text.substring(optionsSeparationIndex + 1).split(OPTION_VALUE_DELIMITER)) {
+
 			String[] optionArgs = option.split("=");
+
+			if (optionArgs.length == 1) {
+				throw new IllegalArgumentException(String.format("Query parameter '%s' has no value!", optionArgs[0]));
+			}
+
 			properties.put(optionArgs[0], optionArgs[1]);
 		}
 

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2017 the original author or authors.
+ * Copyright 2011-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2017 the original author or authors.
+ * Copyright 2011-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2017 the original author or authors.
+ * Copyright 2011-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,7 +19,7 @@ import org.springframework.beans.factory.xml.NamespaceHandlerSupport;
 
 /**
  * {@link org.springframework.beans.factory.xml.NamespaceHandler} for Mongo DB configuration.
- * 
+ *
  * @author Oliver Gierke
  * @author Martin Baumgartner
  * @author Christoph Strobl

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2017 the original author or authors.
+ * Copyright 2011-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -30,7 +30,7 @@ import org.w3c.dom.Element;
 
 /**
  * Utility methods for {@link BeanDefinitionParser} implementations for MongoDB.
- * 
+ *
  * @author Mark Pollack
  * @author Oliver Gierke
  * @author Thomas Darimont
@@ -43,7 +43,7 @@ abstract class MongoParsingUtils {
 
 	/**
 	 * Parses the mongo replica-set element.
-	 * 
+	 *
 	 * @param parserContext the parser context
 	 * @param element the mongo element
 	 * @param mongoBuilder the bean definition builder to populate
@@ -56,7 +56,7 @@ abstract class MongoParsingUtils {
 	/**
 	 * Parses the {@code mongo:client-options} sub-element. Populates the given attribute factory with the proper
 	 * attributes.
-	 * 
+	 *
 	 * @param element must not be {@literal null}.
 	 * @param mongoClientBuilder must not be {@literal null}.
 	 * @return
@@ -102,7 +102,7 @@ abstract class MongoParsingUtils {
 	/**
 	 * Returns the {@link BeanDefinitionBuilder} to build a {@link BeanDefinition} for a
 	 * {@link WriteConcernPropertyEditor}.
-	 * 
+	 *
 	 * @return
 	 */
 	static BeanDefinitionBuilder getWriteConcernPropertyEditorBuilder() {
@@ -135,7 +135,7 @@ abstract class MongoParsingUtils {
 	/**
 	 * Returns the {@link BeanDefinitionBuilder} to build a {@link BeanDefinition} for a
 	 * {@link ReadPreferencePropertyEditor}.
-	 * 
+	 *
 	 * @return
 	 * @since 1.7
 	 */
@@ -153,7 +153,7 @@ abstract class MongoParsingUtils {
 	/**
 	 * Returns the {@link BeanDefinitionBuilder} to build a {@link BeanDefinition} for a
 	 * {@link MongoCredentialPropertyEditor}.
-	 * 
+	 *
 	 * @return
 	 * @since 1.7
 	 */

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2014 the original author or authors.
+ * Copyright 2011-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -33,13 +33,13 @@ import org.w3c.dom.Element;
 
 /**
  * {@link BeanDefinitionParser} to parse {@code template} elements into {@link BeanDefinition}s.
- * 
+ *
  * @author Martin Baumgartner
  * @author Oliver Gierke
  */
 class MongoTemplateParser extends AbstractBeanDefinitionParser {
 
-	/* 
+	/*
 	 * (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)
 	 */

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2017 the original author or authors.
+ * Copyright 2015-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,7 +23,7 @@ import com.mongodb.ReadPreference;
 
 /**
  * Parse a {@link String} to a {@link ReadPreference}.
- * 
+ *
  * @author Christoph Strobl
  * @since 1.7
  */

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2017 the original author or authors.
+ * Copyright 2011-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012 the original author or authors.
+ * Copyright 2012-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,12 +21,12 @@ import com.mongodb.WriteConcern;
 
 /**
  * Converter to create {@link WriteConcern} instances from String representations.
- * 
+ *
  * @author Oliver Gierke
  */
 public class StringToWriteConcernConverter implements Converter<String, WriteConcern> {
 
-	/* 
+	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.core.convert.converter.Converter#convert(java.lang.Object)
 	 */

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2017 the original author or authors.
+ * Copyright 2011-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,7 +27,7 @@ import com.mongodb.WriteConcern;
  * {@link WriteConcern#valueOf(String)}, use the well known {@link WriteConcern} value, otherwise pass the string as is
  * to the constructor of the write concern. There is no support for other constructor signatures when parsing from a
  * string value.
- * 
+ *
  * @author Mark Pollack
  * @author Christoph Strobl
  */

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

@@ -0,0 +1,170 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import lombok.AllArgsConstructor;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+import org.bson.Document;
+import org.springframework.data.mapping.context.MappingContext;
+import org.springframework.data.mongodb.core.aggregation.Aggregation;
+import org.springframework.data.mongodb.core.aggregation.AggregationOperation;
+import org.springframework.data.mongodb.core.aggregation.AggregationOperationContext;
+import org.springframework.data.mongodb.core.aggregation.AggregationOptions;
+import org.springframework.data.mongodb.core.aggregation.CountOperation;
+import org.springframework.data.mongodb.core.aggregation.TypeBasedAggregationOperationContext;
+import org.springframework.data.mongodb.core.aggregation.TypedAggregation;
+import org.springframework.data.mongodb.core.convert.QueryMapper;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
+import org.springframework.data.mongodb.core.query.CriteriaDefinition;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+import org.springframework.util.ObjectUtils;
+
+/**
+ * Utility methods to map {@link org.springframework.data.mongodb.core.aggregation.Aggregation} pipeline definitions and
+ * create type-bound {@link AggregationOperationContext}.
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @since 2.1
+ */
+@AllArgsConstructor
+class AggregationUtil {
+
+	QueryMapper queryMapper;
+	MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext;
+
+	/**
+	 * Prepare the {@link AggregationOperationContext} for a given aggregation by either returning the context itself it
+	 * is not {@literal null}, create a {@link TypeBasedAggregationOperationContext} if the aggregation contains type
+	 * information (is a {@link TypedAggregation}) or use the {@link Aggregation#DEFAULT_CONTEXT}.
+	 *
+	 * @param aggregation must not be {@literal null}.
+	 * @param context can be {@literal null}.
+	 * @return the root {@link AggregationOperationContext} to use.
+	 */
+	AggregationOperationContext prepareAggregationContext(Aggregation aggregation,
+			@Nullable AggregationOperationContext context) {
+
+		if (context != null) {
+			return context;
+		}
+
+		if (aggregation instanceof TypedAggregation) {
+			return new TypeBasedAggregationOperationContext(((TypedAggregation) aggregation).getInputType(), mappingContext,
+					queryMapper);
+		}
+
+		return Aggregation.DEFAULT_CONTEXT;
+	}
+
+	/**
+	 * Extract and map the aggregation pipeline into a {@link List} of {@link Document}.
+	 *
+	 * @param aggregation
+	 * @param context
+	 * @return
+	 */
+	List<Document> createPipeline(Aggregation aggregation, AggregationOperationContext context) {
+
+		if (!ObjectUtils.nullSafeEquals(context, Aggregation.DEFAULT_CONTEXT)) {
+			return aggregation.toPipeline(context);
+		}
+
+		return mapAggregationPipeline(aggregation.toPipeline(context));
+	}
+
+	/**
+	 * Extract the command and map the aggregation pipeline.
+	 *
+	 * @param aggregation
+	 * @param context
+	 * @return
+	 */
+	Document createCommand(String collection, Aggregation aggregation, AggregationOperationContext context) {
+
+		Document command = aggregation.toDocument(collection, context);
+
+		if (!ObjectUtils.nullSafeEquals(context, Aggregation.DEFAULT_CONTEXT)) {
+			return command;
+		}
+
+		command.put("pipeline", mapAggregationPipeline(command.get("pipeline", List.class)));
+
+		return command;
+	}
+
+	/**
+	 * Create a {@code $count} aggregation for {@link Query} and optionally a {@link Class entity class}.
+	 *
+	 * @param query must not be {@literal null}.
+	 * @param entityClass can be {@literal null} if the {@link Query} object is empty.
+	 * @return the {@link Aggregation} pipeline definition to run a {@code $count} aggregation.
+	 */
+	Aggregation createCountAggregation(Query query, @Nullable Class<?> entityClass) {
+
+		List<AggregationOperation> pipeline = computeCountAggregationPipeline(query, entityClass);
+
+		Aggregation aggregation = entityClass != null ? Aggregation.newAggregation(entityClass, pipeline)
+				: Aggregation.newAggregation(pipeline);
+		aggregation.withOptions(AggregationOptions.builder().collation(query.getCollation().orElse(null)).build());
+
+		return aggregation;
+	}
+
+	private List<AggregationOperation> computeCountAggregationPipeline(Query query, @Nullable Class<?> entityType) {
+
+		CountOperation count = Aggregation.count().as("totalEntityCount");
+		if (query.getQueryObject().isEmpty()) {
+			return Collections.singletonList(count);
+		}
+
+		Assert.notNull(entityType, "Entity type must not be null!");
+
+		Document mappedQuery = queryMapper.getMappedObject(query.getQueryObject(),
+				mappingContext.getPersistentEntity(entityType));
+
+		CriteriaDefinition criteria = new CriteriaDefinition() {
+
+			@Override
+			public Document getCriteriaObject() {
+				return mappedQuery;
+			}
+
+			@Nullable
+			@Override
+			public String getKey() {
+				return null;
+			}
+		};
+
+		return Arrays.asList(Aggregation.match(criteria), count);
+	}
+
+	private List<Document> mapAggregationPipeline(List<Document> pipeline) {
+
+		return pipeline.stream().map(val -> queryMapper.getMappedObject(val, Optional.empty()))
+				.collect(Collectors.toList());
+	}
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2017 the original author or authors.
+ * Copyright 2015-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

@@ -0,0 +1,188 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import lombok.EqualsAndHashCode;
+
+import java.time.Instant;
+import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
+
+import org.bson.BsonValue;
+import org.bson.Document;
+import org.springframework.data.mongodb.core.convert.MongoConverter;
+import org.springframework.data.mongodb.core.messaging.Message;
+import org.springframework.lang.Nullable;
+import org.springframework.util.ClassUtils;
+
+import com.mongodb.client.model.changestream.ChangeStreamDocument;
+import com.mongodb.client.model.changestream.OperationType;
+
+/**
+ * {@link Message} implementation specific to MongoDB <a href="https://docs.mongodb.com/manual/changeStreams/">Change
+ * Streams</a>.
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @since 2.1
+ */
+@EqualsAndHashCode
+public class ChangeStreamEvent<T> {
+
+	@SuppressWarnings("rawtypes") //
+	private static final AtomicReferenceFieldUpdater<ChangeStreamEvent, Object> CONVERTED_UPDATER = AtomicReferenceFieldUpdater
+			.newUpdater(ChangeStreamEvent.class, Object.class, "converted");
+
+	private final @Nullable ChangeStreamDocument<Document> raw;
+
+	private final Class<T> targetType;
+	private final MongoConverter converter;
+
+	// accessed through CONVERTED_UPDATER.
+	private volatile @Nullable T converted;
+
+	/**
+	 * @param raw can be {@literal null}.
+	 * @param targetType must not be {@literal null}.
+	 * @param converter must not be {@literal null}.
+	 */
+	public ChangeStreamEvent(@Nullable ChangeStreamDocument<Document> raw, Class<T> targetType,
+			MongoConverter converter) {
+
+		this.raw = raw;
+		this.targetType = targetType;
+		this.converter = converter;
+	}
+
+	/**
+	 * Get the raw {@link ChangeStreamDocument} as emitted by the driver.
+	 *
+	 * @return can be {@literal null}.
+	 */
+	@Nullable
+	public ChangeStreamDocument<Document> getRaw() {
+		return raw;
+	}
+
+	/**
+	 * Get the {@link ChangeStreamDocument#getClusterTime() cluster time} as {@link Instant} the event was emitted at.
+	 *
+	 * @return can be {@literal null}.
+	 */
+	@Nullable
+	public Instant getTimestamp() {
+		return raw != null && raw.getClusterTime() != null ? Instant.ofEpochMilli(raw.getClusterTime().getValue()) : null;
+	}
+
+	/**
+	 * Get the {@link ChangeStreamDocument#getResumeToken() resume token} for this event.
+	 *
+	 * @return can be {@literal null}.
+	 */
+	@Nullable
+	public BsonValue getResumeToken() {
+		return raw != null ? raw.getResumeToken() : null;
+	}
+
+	/**
+	 * Get the {@link ChangeStreamDocument#getOperationType() operation type} for this event.
+	 *
+	 * @return can be {@literal null}.
+	 */
+	@Nullable
+	public OperationType getOperationType() {
+		return raw != null ? raw.getOperationType() : null;
+	}
+
+	/**
+	 * Get the database name the event was originated at.
+	 *
+	 * @return can be {@literal null}.
+	 */
+	@Nullable
+	public String getDatabaseName() {
+		return raw != null ? raw.getNamespace().getDatabaseName() : null;
+	}
+
+	/**
+	 * Get the collection name the event was originated at.
+	 *
+	 * @return can be {@literal null}.
+	 */
+	@Nullable
+	public String getCollectionName() {
+		return raw != null ? raw.getNamespace().getCollectionName() : null;
+	}
+
+	/**
+	 * Get the potentially converted {@link ChangeStreamDocument#getFullDocument()}.
+	 *
+	 * @return {@literal null} when {@link #getRaw()} or {@link ChangeStreamDocument#getFullDocument()} is
+	 *         {@literal null}.
+	 */
+	@Nullable
+	public T getBody() {
+
+		if (raw == null) {
+			return null;
+		}
+
+		Document fullDocument = raw.getFullDocument();
+
+		if (fullDocument == null) {
+			return targetType.cast(fullDocument);
+		}
+
+		return getConverted(fullDocument);
+	}
+
+	@SuppressWarnings("unchecked")
+	private T getConverted(Document fullDocument) {
+		return (T) doGetConverted(fullDocument);
+	}
+
+	private Object doGetConverted(Document fullDocument) {
+
+		Object result = CONVERTED_UPDATER.get(this);
+
+		if (result != null) {
+			return result;
+		}
+
+		if (ClassUtils.isAssignable(Document.class, fullDocument.getClass())) {
+
+			result = converter.read(targetType, fullDocument);
+			return CONVERTED_UPDATER.compareAndSet(this, null, result) ? result : CONVERTED_UPDATER.get(this);
+		}
+
+		if (converter.getConversionService().canConvert(fullDocument.getClass(), targetType)) {
+
+			result = converter.getConversionService().convert(fullDocument, targetType);
+			return CONVERTED_UPDATER.compareAndSet(this, null, result) ? result : CONVERTED_UPDATER.get(this);
+		}
+
+		throw new IllegalArgumentException(String.format("No converter found capable of converting %s to %s",
+				fullDocument.getClass(), targetType));
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see java.lang.Object#toString()
+	 */
+	@Override
+	public String toString() {
+		return "ChangeStreamEvent {" + "raw=" + raw + ", targetType=" + targetType + '}';
+	}
+}

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

@@ -0,0 +1,243 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import lombok.EqualsAndHashCode;
+
+import java.time.Instant;
+import java.util.Arrays;
+import java.util.Optional;
+
+import org.bson.BsonValue;
+import org.bson.Document;
+import org.springframework.data.mongodb.core.aggregation.Aggregation;
+import org.springframework.data.mongodb.core.query.Collation;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+
+import com.mongodb.client.model.changestream.ChangeStreamDocument;
+import com.mongodb.client.model.changestream.FullDocument;
+
+/**
+ * Options applicable to MongoDB <a href="https://docs.mongodb.com/manual/changeStreams/">Change Streams</a>. Intended
+ * to be used along with {@link org.springframework.data.mongodb.core.messaging.ChangeStreamRequest} in a sync world as
+ * well {@link ReactiveMongoOperations} if you prefer it that way.
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @since 2.1
+ */
+@EqualsAndHashCode
+public class ChangeStreamOptions {
+
+	private @Nullable Object filter;
+	private @Nullable BsonValue resumeToken;
+	private @Nullable FullDocument fullDocumentLookup;
+	private @Nullable Collation collation;
+	private @Nullable Instant resumeTimestamp;
+
+	protected ChangeStreamOptions() {}
+
+	/**
+	 * @return {@link Optional#empty()} if not set.
+	 */
+	public Optional<Object> getFilter() {
+		return Optional.ofNullable(filter);
+	}
+
+	/**
+	 * @return {@link Optional#empty()} if not set.
+	 */
+	public Optional<BsonValue> getResumeToken() {
+		return Optional.ofNullable(resumeToken);
+	}
+
+	/**
+	 * @return {@link Optional#empty()} if not set.
+	 */
+	public Optional<FullDocument> getFullDocumentLookup() {
+		return Optional.ofNullable(fullDocumentLookup);
+	}
+
+	/**
+	 * @return {@link Optional#empty()} if not set.
+	 */
+	public Optional<Collation> getCollation() {
+		return Optional.ofNullable(collation);
+	}
+
+	/**
+	 * @return {@link Optional#empty()} if not set.
+	 */
+	public Optional<Instant> getResumeTimestamp() {
+		return Optional.ofNullable(resumeTimestamp);
+	}
+
+	/**
+	 * @return empty {@link ChangeStreamOptions}.
+	 */
+	public static ChangeStreamOptions empty() {
+		return ChangeStreamOptions.builder().build();
+	}
+
+	/**
+	 * Obtain a shiny new {@link ChangeStreamOptionsBuilder} and start defining options in this fancy fluent way. Just
+	 * don't forget to call {@link ChangeStreamOptionsBuilder#build() build()} when your're done.
+	 *
+	 * @return new instance of {@link ChangeStreamOptionsBuilder}.
+	 */
+	public static ChangeStreamOptionsBuilder builder() {
+		return new ChangeStreamOptionsBuilder();
+	}
+
+	/**
+	 * Builder for creating {@link ChangeStreamOptions}.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	public static class ChangeStreamOptionsBuilder {
+
+		private @Nullable Object filter;
+		private @Nullable BsonValue resumeToken;
+		private @Nullable FullDocument fullDocumentLookup;
+		private @Nullable Collation collation;
+		private @Nullable Instant resumeTimestamp;
+
+		private ChangeStreamOptionsBuilder() {}
+
+		/**
+		 * Set the collation to use.
+		 *
+		 * @param collation must not be {@literal null} nor {@literal empty}.
+		 * @return this.
+		 */
+		public ChangeStreamOptionsBuilder collation(Collation collation) {
+
+			Assert.notNull(collation, "Collation must not be null nor empty!");
+
+			this.collation = collation;
+			return this;
+		}
+
+		/**
+		 * Set the filter to apply.
+		 * <p/>
+		 * Fields on aggregation expression root level are prefixed to map to fields contained in
+		 * {@link ChangeStreamDocument#getFullDocument() fullDocument}. However {@literal operationType}, {@literal ns},
+		 * {@literal documentKey} and {@literal fullDocument} are reserved words that will be omitted, and therefore taken
+		 * as given, during the mapping procedure. You may want to have a look at the
+		 * <a href="https://docs.mongodb.com/manual/reference/change-events/">structure of Change Events</a>.
+		 * <p/>
+		 * Use {@link org.springframework.data.mongodb.core.aggregation.TypedAggregation} to ensure filter expressions are
+		 * mapped to domain type fields.
+		 *
+		 * @param filter the {@link Aggregation Aggregation pipeline} to apply for filtering events. Must not be
+		 *          {@literal null}.
+		 * @return this.
+		 */
+		public ChangeStreamOptionsBuilder filter(Aggregation filter) {
+
+			Assert.notNull(filter, "Filter must not be null!");
+
+			this.filter = filter;
+			return this;
+		}
+
+		/**
+		 * Set the plain filter chain to apply.
+		 *
+		 * @param filter must not be {@literal null} nor contain {@literal null} values.
+		 * @return this.
+		 */
+		public ChangeStreamOptionsBuilder filter(Document... filter) {
+
+			Assert.noNullElements(filter, "Filter must not contain null values");
+
+			this.filter = Arrays.asList(filter);
+			return this;
+		}
+
+		/**
+		 * Set the resume token (typically a {@link org.bson.BsonDocument} containing a {@link org.bson.BsonBinary binary
+		 * token}) after which to start with listening.
+		 *
+		 * @param resumeToken must not be {@literal null}.
+		 * @return this.
+		 */
+		public ChangeStreamOptionsBuilder resumeToken(BsonValue resumeToken) {
+
+			Assert.notNull(resumeToken, "ResumeToken must not be null!");
+
+			this.resumeToken = resumeToken;
+			return this;
+		}
+
+		/**
+		 * Set the {@link FullDocument} lookup to {@link FullDocument#UPDATE_LOOKUP}.
+		 *
+		 * @return this.
+		 * @see #fullDocumentLookup(FullDocument)
+		 */
+		public ChangeStreamOptionsBuilder returnFullDocumentOnUpdate() {
+			return fullDocumentLookup(FullDocument.UPDATE_LOOKUP);
+		}
+
+		/**
+		 * Set the {@link FullDocument} lookup to use.
+		 *
+		 * @param lookup must not be {@literal null}.
+		 * @return this.
+		 */
+		public ChangeStreamOptionsBuilder fullDocumentLookup(FullDocument lookup) {
+
+			Assert.notNull(lookup, "Lookup must not be null!");
+
+			this.fullDocumentLookup = lookup;
+			return this;
+		}
+
+		/**
+		 * Set the cluster time to resume from.
+		 *
+		 * @param resumeTimestamp must not be {@literal null}.
+		 * @return this.
+		 */
+		public ChangeStreamOptionsBuilder resumeAt(Instant resumeTimestamp) {
+
+			Assert.notNull(resumeTimestamp, "ResumeTimestamp must not be null!");
+
+			this.resumeTimestamp = resumeTimestamp;
+			return this;
+		}
+
+		/**
+		 * @return the built {@link ChangeStreamOptions}
+		 */
+		public ChangeStreamOptions build() {
+
+			ChangeStreamOptions options = new ChangeStreamOptions();
+
+			options.filter = filter;
+			options.resumeToken = resumeToken;
+			options.fullDocumentLookup = fullDocumentLookup;
+			options.collation = collation;
+			options.resumeTimestamp = resumeTimestamp;
+
+			return options;
+		}
+	}
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2017 the original author or authors.
+ * Copyright 2010-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2017 the original author or authors.
+ * Copyright 2010-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,18 +15,27 @@
  */
 package org.springframework.data.mongodb.core;
 
+import lombok.RequiredArgsConstructor;
+
 import java.util.Optional;
 
 import org.springframework.data.mongodb.core.query.Collation;
+import org.springframework.data.mongodb.core.schema.MongoJsonSchema;
+import org.springframework.data.mongodb.core.validation.Validator;
+import org.springframework.data.util.Optionals;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
+import com.mongodb.client.model.ValidationAction;
+import com.mongodb.client.model.ValidationLevel;
+
 /**
  * Provides a simple wrapper to encapsulate the variety of settings you can use when creating a collection.
  *
  * @author Thomas Risberg
  * @author Christoph Strobl
  * @author Mark Paluch
+ * @author Andreas Zink
  */
 public class CollectionOptions {
 
@@ -34,6 +43,7 @@ public class CollectionOptions {
 	private @Nullable Long size;
 	private @Nullable Boolean capped;
 	private @Nullable Collation collation;
+	private ValidationOptions validationOptions;
 
 	/**
 	 * Constructs a new <code>CollectionOptions</code> instance.
@@ -46,16 +56,17 @@ public class CollectionOptions {
 	 */
 	@Deprecated
 	public CollectionOptions(@Nullable Long size, @Nullable Long maxDocuments, @Nullable Boolean capped) {
-		this(size, maxDocuments, capped, null);
+		this(size, maxDocuments, capped, null, ValidationOptions.none());
 	}
 
 	private CollectionOptions(@Nullable Long size, @Nullable Long maxDocuments, @Nullable Boolean capped,
-			@Nullable Collation collation) {
+			@Nullable Collation collation, ValidationOptions validationOptions) {
 
 		this.maxDocuments = maxDocuments;
 		this.size = size;
 		this.capped = capped;
 		this.collation = collation;
+		this.validationOptions = validationOptions;
 	}
 
 	/**
@@ -69,7 +80,7 @@ public class CollectionOptions {
 
 		Assert.notNull(collation, "Collation must not be null!");
 
-		return new CollectionOptions(null, null, null, collation);
+		return new CollectionOptions(null, null, null, collation, ValidationOptions.none());
 	}
 
 	/**
@@ -79,7 +90,7 @@ public class CollectionOptions {
 	 * @since 2.0
 	 */
 	public static CollectionOptions empty() {
-		return new CollectionOptions(null, null, null, null);
+		return new CollectionOptions(null, null, null, null, ValidationOptions.none());
 	}
 
 	/**
@@ -90,7 +101,7 @@ public class CollectionOptions {
 	 * @since 2.0
 	 */
 	public CollectionOptions capped() {
-		return new CollectionOptions(size, maxDocuments, true, collation);
+		return new CollectionOptions(size, maxDocuments, true, collation, validationOptions);
 	}
 
 	/**
@@ -101,7 +112,7 @@ public class CollectionOptions {
 	 * @since 2.0
 	 */
 	public CollectionOptions maxDocuments(long maxDocuments) {
-		return new CollectionOptions(size, maxDocuments, capped, collation);
+		return new CollectionOptions(size, maxDocuments, capped, collation, validationOptions);
 	}
 
 	/**
@@ -112,7 +123,7 @@ public class CollectionOptions {
 	 * @since 2.0
 	 */
 	public CollectionOptions size(long size) {
-		return new CollectionOptions(size, maxDocuments, capped, collation);
+		return new CollectionOptions(size, maxDocuments, capped, collation, validationOptions);
 	}
 
 	/**
@@ -123,7 +134,127 @@ public class CollectionOptions {
 	 * @since 2.0
 	 */
 	public CollectionOptions collation(@Nullable Collation collation) {
-		return new CollectionOptions(size, maxDocuments, capped, collation);
+		return new CollectionOptions(size, maxDocuments, capped, collation, validationOptions);
+	}
+
+	/**
+	 * Create new {@link CollectionOptions} with already given settings and {@code validationOptions} set to given
+	 * {@link MongoJsonSchema}.
+	 *
+	 * @param schema can be {@literal null}.
+	 * @return new {@link CollectionOptions}.
+	 * @since 2.1
+	 */
+	public CollectionOptions schema(@Nullable MongoJsonSchema schema) {
+		return validator(Validator.schema(schema));
+	}
+
+	/**
+	 * Create new {@link CollectionOptions} with already given settings and {@code validationOptions} set to given
+	 * {@link Validator}.
+	 *
+	 * @param validator can be {@literal null}.
+	 * @return new {@link CollectionOptions}.
+	 * @since 2.1
+	 */
+	public CollectionOptions validator(@Nullable Validator validator) {
+		return validation(validationOptions.validator(validator));
+	}
+
+	/**
+	 * Create new {@link CollectionOptions} with already given settings and {@code validationLevel} set to
+	 * {@link ValidationLevel#OFF}.
+	 *
+	 * @return new {@link CollectionOptions}.
+	 * @since 2.1
+	 */
+	public CollectionOptions disableValidation() {
+		return schemaValidationLevel(ValidationLevel.OFF);
+	}
+
+	/**
+	 * Create new {@link CollectionOptions} with already given settings and {@code validationLevel} set to
+	 * {@link ValidationLevel#STRICT}.
+	 *
+	 * @return new {@link CollectionOptions}.
+	 * @since 2.1
+	 */
+	public CollectionOptions strictValidation() {
+		return schemaValidationLevel(ValidationLevel.STRICT);
+	}
+
+	/**
+	 * Create new {@link CollectionOptions} with already given settings and {@code validationLevel} set to
+	 * {@link ValidationLevel#MODERATE}.
+	 *
+	 * @return new {@link CollectionOptions}.
+	 * @since 2.1
+	 */
+	public CollectionOptions moderateValidation() {
+		return schemaValidationLevel(ValidationLevel.MODERATE);
+	}
+
+	/**
+	 * Create new {@link CollectionOptions} with already given settings and {@code validationAction} set to
+	 * {@link ValidationAction#WARN}.
+	 *
+	 * @return new {@link CollectionOptions}.
+	 * @since 2.1
+	 */
+	public CollectionOptions warnOnValidationError() {
+		return schemaValidationAction(ValidationAction.WARN);
+	}
+
+	/**
+	 * Create new {@link CollectionOptions} with already given settings and {@code validationAction} set to
+	 * {@link ValidationAction#ERROR}.
+	 *
+	 * @return new {@link CollectionOptions}.
+	 * @since 2.1
+	 */
+	public CollectionOptions failOnValidationError() {
+		return schemaValidationAction(ValidationAction.ERROR);
+	}
+
+	/**
+	 * Create new {@link CollectionOptions} with already given settings and {@code validationLevel} set given
+	 * {@link ValidationLevel}.
+	 *
+	 * @param validationLevel must not be {@literal null}.
+	 * @return new {@link CollectionOptions}.
+	 * @since 2.1
+	 */
+	public CollectionOptions schemaValidationLevel(ValidationLevel validationLevel) {
+
+		Assert.notNull(validationLevel, "ValidationLevel must not be null!");
+		return validation(validationOptions.validationLevel(validationLevel));
+	}
+
+	/**
+	 * Create new {@link CollectionOptions} with already given settings and {@code validationAction} set given
+	 * {@link ValidationAction}.
+	 *
+	 * @param validationAction must not be {@literal null}.
+	 * @return new {@link CollectionOptions}.
+	 * @since 2.1
+	 */
+	public CollectionOptions schemaValidationAction(ValidationAction validationAction) {
+
+		Assert.notNull(validationAction, "ValidationAction must not be null!");
+		return validation(validationOptions.validationAction(validationAction));
+	}
+
+	/**
+	 * Create new {@link CollectionOptions} with the given {@link ValidationOptions}.
+	 *
+	 * @param validationOptions must not be {@literal null}. Use {@link ValidationOptions#none()} to remove validation.
+	 * @return new {@link CollectionOptions}.
+	 * @since 2.1
+	 */
+	public CollectionOptions validation(ValidationOptions validationOptions) {
+
+		Assert.notNull(validationOptions, "ValidationOptions must not be null!");
+		return new CollectionOptions(size, maxDocuments, capped, collation, validationOptions);
 	}
 
 	/**
@@ -163,4 +294,104 @@ public class CollectionOptions {
 	public Optional<Collation> getCollation() {
 		return Optional.ofNullable(collation);
 	}
+
+	/**
+	 * Get the {@link MongoJsonSchema} for the collection.
+	 *
+	 * @return {@link Optional#empty()} if not set.
+	 * @since 2.1
+	 */
+	public Optional<ValidationOptions> getValidationOptions() {
+		return validationOptions.isEmpty() ? Optional.empty() : Optional.of(validationOptions);
+	}
+
+	/**
+	 * Encapsulation of ValidationOptions options.
+	 *
+	 * @author Christoph Strobl
+	 * @author Andreas Zink
+	 * @since 2.1
+	 */
+	@RequiredArgsConstructor
+	public static class ValidationOptions {
+
+		private static final ValidationOptions NONE = new ValidationOptions(null, null, null);
+
+		private final @Nullable Validator validator;
+		private final @Nullable ValidationLevel validationLevel;
+		private final @Nullable ValidationAction validationAction;
+
+		/**
+		 * Create an empty {@link ValidationOptions}.
+		 *
+		 * @return never {@literal null}.
+		 */
+		public static ValidationOptions none() {
+			return NONE;
+		}
+
+		/**
+		 * Define the {@link Validator} to be used for document validation.
+		 *
+		 * @param validator can be {@literal null}.
+		 * @return new instance of {@link ValidationOptions}.
+		 */
+		public ValidationOptions validator(@Nullable Validator validator) {
+			return new ValidationOptions(validator, validationLevel, validationAction);
+		}
+
+		/**
+		 * Define the validation level to apply.
+		 *
+		 * @param validationLevel can be {@literal null}.
+		 * @return new instance of {@link ValidationOptions}.
+		 */
+		public ValidationOptions validationLevel(ValidationLevel validationLevel) {
+			return new ValidationOptions(validator, validationLevel, validationAction);
+		}
+
+		/**
+		 * Define the validation action to take.
+		 *
+		 * @param validationAction can be {@literal null}.
+		 * @return new instance of {@link ValidationOptions}.
+		 */
+		public ValidationOptions validationAction(ValidationAction validationAction) {
+			return new ValidationOptions(validator, validationLevel, validationAction);
+		}
+
+		/**
+		 * Get the {@link Validator} to use.
+		 *
+		 * @return never {@literal null}.
+		 */
+		public Optional<Validator> getValidator() {
+			return Optional.ofNullable(validator);
+		}
+
+		/**
+		 * Get the {@code validationLevel} to apply.
+		 *
+		 * @return {@link Optional#empty()} if not set.
+		 */
+		public Optional<ValidationLevel> getValidationLevel() {
+			return Optional.ofNullable(validationLevel);
+		}
+
+		/**
+		 * Get the {@code validationAction} to perform.
+		 *
+		 * @return @return {@link Optional#empty()} if not set.
+		 */
+		public Optional<ValidationAction> getValidationAction() {
+			return Optional.ofNullable(validationAction);
+		}
+
+		/**
+		 * @return {@literal true} if no arguments set.
+		 */
+		boolean isEmpty() {
+			return !Optionals.isAnyPresent(getValidator(), getValidationAction(), getValidationLevel());
+		}
+	}
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2016 the original author or authors.
+ * Copyright 2002-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,7 +21,7 @@ import com.mongodb.client.FindIterable;
 
 /**
  * Simple callback interface to allow customization of a {@link FindIterable}.
- * 
+ *
  * @author Oliver Gierke
  * @author Christoph Strobl
  */
@@ -29,7 +29,7 @@ interface CursorPreparer {
 
 	/**
 	 * Prepare the given cursor (apply limits, skips and so on). Returns the prepared cursor.
-	 * 
+	 *
 	 * @param cursor
 	 */
 	FindIterable<Document> prepare(FindIterable<Document> cursor);

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2017 the original author or authors.
+ * Copyright 2010-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2017 the original author or authors.
+ * Copyright 2015-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -274,19 +274,10 @@ class DefaultBulkOperations implements BulkOperations {
 	public com.mongodb.bulk.BulkWriteResult execute() {
 
 		try {
-
-			MongoCollection<Document> collection = mongoOperations.getCollection(collectionName);
-			if (defaultWriteConcern != null) {
-				collection = collection.withWriteConcern(defaultWriteConcern);
-			}
-
-			return collection.bulkWrite(models.stream().map(this::mapWriteModel).collect(Collectors.toList()), bulkOptions);
-
-		} catch (BulkWriteException o_O) {
-
-			DataAccessException toThrow = exceptionTranslator.translateExceptionIfPossible(o_O);
-			throw toThrow == null ? o_O : toThrow;
-
+			
+			return mongoOperations.execute(collectionName, collection -> {
+				return collection.bulkWrite(models.stream().map(this::mapWriteModel).collect(Collectors.toList()), bulkOptions);
+			});
 		} finally {
 			this.bulkOptions = getBulkWriteOptions(bulkOperationContext.getBulkMode());
 		}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2017 the original author or authors.
+ * Copyright 2011-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,8 +15,6 @@
  */
 package org.springframework.data.mongodb.core;
 
-import static org.springframework.data.mongodb.core.MongoTemplate.*;
-
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
@@ -50,18 +48,22 @@ public class DefaultIndexOperations implements IndexOperations {
 
 	private static final String PARTIAL_FILTER_EXPRESSION_KEY = "partialFilterExpression";
 
-	private final MongoDbFactory mongoDbFactory;
 	private final String collectionName;
 	private final QueryMapper mapper;
 	private final @Nullable Class<?> type;
 
+	private MongoOperations mongoOperations;
+
 	/**
 	 * Creates a new {@link DefaultIndexOperations}.
 	 *
 	 * @param mongoDbFactory must not be {@literal null}.
 	 * @param collectionName must not be {@literal null}.
 	 * @param queryMapper must not be {@literal null}.
+	 * @deprecated since 2.1. Please use
+	 *             {@link DefaultIndexOperations#DefaultIndexOperations(MongoOperations, String, Class)}.
 	 */
+	@Deprecated
 	public DefaultIndexOperations(MongoDbFactory mongoDbFactory, String collectionName, QueryMapper queryMapper) {
 		this(mongoDbFactory, collectionName, queryMapper, null);
 	}
@@ -74,7 +76,10 @@ public class DefaultIndexOperations implements IndexOperations {
 	 * @param queryMapper must not be {@literal null}.
 	 * @param type Type used for mapping potential partial index filter expression. Can be {@literal null}.
 	 * @since 1.10
+	 * @deprecated since 2.1. Please use
+	 *             {@link DefaultIndexOperations#DefaultIndexOperations(MongoOperations, String, Class)}.
 	 */
+	@Deprecated
 	public DefaultIndexOperations(MongoDbFactory mongoDbFactory, String collectionName, QueryMapper queryMapper,
 			@Nullable Class<?> type) {
 
@@ -82,10 +87,29 @@ public class DefaultIndexOperations implements IndexOperations {
 		Assert.notNull(collectionName, "Collection name can not be null!");
 		Assert.notNull(queryMapper, "QueryMapper must not be null!");
 
-		this.mongoDbFactory = mongoDbFactory;
 		this.collectionName = collectionName;
 		this.mapper = queryMapper;
 		this.type = type;
+		this.mongoOperations = new MongoTemplate(mongoDbFactory);
+	}
+
+	/**
+	 * Creates a new {@link DefaultIndexOperations}.
+	 *
+	 * @param mongoOperations must not be {@literal null}.
+	 * @param collectionName must not be {@literal null} or empty.
+	 * @param type can be {@literal null}.
+	 * @since 2.1
+	 */
+	public DefaultIndexOperations(MongoOperations mongoOperations, String collectionName, @Nullable Class<?> type) {
+
+		Assert.notNull(mongoOperations, "MongoOperations must not be null!");
+		Assert.hasText(collectionName, "Collection name must not be null or empty!");
+
+		this.mongoOperations = mongoOperations;
+		this.mapper = new QueryMapper(mongoOperations.getConverter());
+		this.collectionName = collectionName;
+		this.type = type;
 	}
 
 	/*
@@ -187,11 +211,10 @@ public class DefaultIndexOperations implements IndexOperations {
 
 		Assert.notNull(callback, "CollectionCallback must not be null!");
 
-		try {
-			MongoCollection<Document> collection = mongoDbFactory.getDb().getCollection(collectionName);
-			return callback.doInCollection(collection);
-		} catch (RuntimeException e) {
-			throw potentiallyConvertRuntimeException(e, mongoDbFactory.getExceptionTranslator());
+		if (type != null) {
+			return mongoOperations.execute(type, callback);
 		}
+
+		return mongoOperations.execute(collectionName, callback);
 	}
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2017 the original author or authors.
+ * Copyright 2016-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2017 the original author or authors.
+ * Copyright 2016-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2017 the original author or authors.
+ * Copyright 2014-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -43,9 +43,10 @@ import com.mongodb.client.MongoDatabase;
 
 /**
  * Default implementation of {@link ScriptOperations} capable of saving and executing {@link ServerSideJavaScript}.
- * 
+ *
  * @author Christoph Strobl
  * @author Oliver Gierke
+ * @author Mark Paluch
  * @since 1.7
  */
 class DefaultScriptOperations implements ScriptOperations {
@@ -141,7 +142,7 @@ class DefaultScriptOperations implements ScriptOperations {
 
 		Assert.hasText(scriptName, "ScriptName must not be null or empty!");
 
-		return mongoOperations.exists(query(where("name").is(scriptName)), NamedMongoScript.class, SCRIPT_COLLECTION_NAME);
+		return mongoOperations.exists(query(where("_id").is(scriptName)), NamedMongoScript.class, SCRIPT_COLLECTION_NAME);
 	}
 
 	/*
@@ -190,7 +191,7 @@ class DefaultScriptOperations implements ScriptOperations {
 	 * Generate a valid name for the {@literal JavaScript}. MongoDB requires an id of type String for scripts. Calling
 	 * scripts having {@link ObjectId} as id fails. Therefore we create a random UUID without {@code -} (as this won't
 	 * work) an prefix the result with {@link #SCRIPT_NAME_PREFIX}.
-	 * 
+	 *
 	 * @return
 	 */
 	private static String generateScriptName() {

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015 the original author or authors.
+ * Copyright 2015-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2016 the original author or authors.
+ * Copyright 2010-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,7 +26,7 @@ import com.mongodb.MongoException;
  * about exception handling. {@MongoException}s will be caught and translated by the calling MongoTemplate An
  * DocumentCallbackHandler is typically stateful: It keeps the result state within the object, to be available later for
  * later inspection.
- * 
+ *
  * @author Mark Pollack
  * @author Grame Rocher
  * @author Oliver Gierke

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

@@ -0,0 +1,655 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import lombok.AccessLevel;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+
+import java.util.Collection;
+import java.util.Map;
+
+import org.bson.Document;
+import org.springframework.core.convert.ConversionService;
+import org.springframework.dao.InvalidDataAccessApiUsageException;
+import org.springframework.data.mapping.IdentifierAccessor;
+import org.springframework.data.mapping.MappingException;
+import org.springframework.data.mapping.PersistentPropertyAccessor;
+import org.springframework.data.mapping.context.MappingContext;
+import org.springframework.data.mapping.model.ConvertingPropertyAccessor;
+import org.springframework.data.mongodb.core.convert.MongoWriter;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
+import org.springframework.data.mongodb.core.mapping.MongoSimpleTypes;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+import org.springframework.util.LinkedMultiValueMap;
+import org.springframework.util.MultiValueMap;
+
+import com.mongodb.util.JSONParseException;
+
+/**
+ * Common operations performed on an entity in the context of it's mapping metadata.
+ *
+ * @author Oliver Gierke
+ * @author Mark Paluch
+ * @since 2.1
+ * @see MongoTemplate
+ * @see ReactiveMongoTemplate
+ */
+@RequiredArgsConstructor
+class EntityOperations {
+
+	private static final String ID_FIELD = "_id";
+
+	private final @NonNull MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> context;
+
+	/**
+	 * Creates a new {@link Entity} for the given bean.
+	 *
+	 * @param entity must not be {@literal null}.
+	 * @return
+	 */
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	public <T> Entity<T> forEntity(T entity) {
+
+		Assert.notNull(entity, "Bean must not be null!");
+
+		if (entity instanceof String) {
+			return new UnmappedEntity(parse(entity.toString()));
+		}
+
+		if (entity instanceof Map) {
+			return new SimpleMappedEntity((Map<String, Object>) entity);
+		}
+
+		return MappedEntity.of(entity, context);
+	}
+
+	/**
+	 * Creates a new {@link AdaptibleEntity} for the given bean and {@link ConversionService}.
+	 *
+	 * @param entity must not be {@literal null}.
+	 * @param conversionService must not be {@literal null}.
+	 * @return
+	 */
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	public <T> AdaptibleEntity<T> forEntity(T entity, ConversionService conversionService) {
+
+		Assert.notNull(entity, "Bean must not be null!");
+		Assert.notNull(conversionService, "ConversionService must not be null!");
+
+		if (entity instanceof String) {
+			return new UnmappedEntity(parse(entity.toString()));
+		}
+
+		if (entity instanceof Map) {
+			return new SimpleMappedEntity((Map<String, Object>) entity);
+		}
+
+		return AdaptibleMappedEntity.of(entity, context, conversionService);
+	}
+
+	public String determineCollectionName(@Nullable Class<?> entityClass) {
+
+		if (entityClass == null) {
+			throw new InvalidDataAccessApiUsageException(
+					"No class parameter provided, entity collection can't be determined!");
+		}
+
+		return context.getRequiredPersistentEntity(entityClass).getCollection();
+	}
+
+	/**
+	 * Returns the collection name to be used for the given entity.
+	 *
+	 * @param obj can be {@literal null}.
+	 * @return
+	 */
+	@Nullable
+	public String determineEntityCollectionName(@Nullable Object obj) {
+		return null == obj ? null : determineCollectionName(obj.getClass());
+	}
+
+	public Query getByIdInQuery(Collection<?> entities) {
+
+		MultiValueMap<String, Object> byIds = new LinkedMultiValueMap<>();
+
+		entities.stream() //
+				.map(this::forEntity) //
+				.forEach(it -> byIds.add(it.getIdFieldName(), it.getId()));
+
+		Criteria[] criterias = byIds.entrySet().stream() //
+				.map(it -> Criteria.where(it.getKey()).in(it.getValue())) //
+				.toArray(Criteria[]::new);
+
+		return new Query(criterias.length == 1 ? criterias[0] : new Criteria().orOperator(criterias));
+	}
+
+	/**
+	 * Returns the name of the identifier property. Considers mapping information but falls back to the MongoDB default of
+	 * {@code _id} if no identifier property can be found.
+	 *
+	 * @param type must not be {@literal null}.
+	 * @return
+	 */
+	public String getIdPropertyName(Class<?> type) {
+
+		Assert.notNull(type, "Type must not be null!");
+
+		MongoPersistentEntity<?> persistentEntity = context.getPersistentEntity(type);
+
+		if (persistentEntity != null && persistentEntity.getIdProperty() != null) {
+			return persistentEntity.getRequiredIdProperty().getName();
+		}
+
+		return ID_FIELD;
+	}
+
+	private static Document parse(String source) {
+
+		try {
+			return Document.parse(source);
+		} catch (JSONParseException | org.bson.json.JsonParseException o_O) {
+			throw new MappingException("Could not parse given String to save into a JSON document!", o_O);
+		}
+	}
+
+	/**
+	 * A representation of information about an entity.
+	 *
+	 * @author Oliver Gierke
+	 * @since 2.1
+	 */
+	interface Entity<T> {
+
+		/**
+		 * Returns the field name of the identifier of the entity.
+		 *
+		 * @return
+		 */
+		String getIdFieldName();
+
+		/**
+		 * Returns the identifier of the entity.
+		 *
+		 * @return
+		 */
+		Object getId();
+
+		/**
+		 * Returns the {@link Query} to find the entity by its identifier.
+		 *
+		 * @return
+		 */
+		Query getByIdQuery();
+
+		/**
+		 * Returns the {@link Query} to find the entity in its current version.
+		 *
+		 * @return
+		 */
+		Query getQueryForVersion();
+
+		/**
+		 * Maps the backing entity into a {@link MappedDocument} using the given {@link MongoWriter}.
+		 *
+		 * @param writer must not be {@literal null}.
+		 * @return
+		 */
+		MappedDocument toMappedDocument(MongoWriter<? super T> writer);
+
+		/**
+		 * Asserts that the identifier type is updatable in case its not already set.
+		 */
+		default void assertUpdateableIdIfNotSet() {}
+
+		/**
+		 * Returns whether the entity is versioned, i.e. if it contains a version property.
+		 *
+		 * @return
+		 */
+		default boolean isVersionedEntity() {
+			return false;
+		}
+
+		/**
+		 * Returns the value of the version if the entity has a version property, {@literal null} otherwise.
+		 *
+		 * @return
+		 */
+		@Nullable
+		Object getVersion();
+
+		/**
+		 * Returns the underlying bean.
+		 *
+		 * @return
+		 */
+		T getBean();
+	}
+
+	/**
+	 * Information and commands on an entity.
+	 *
+	 * @author Oliver Gierke
+	 * @since 2.1
+	 */
+	interface AdaptibleEntity<T> extends Entity<T> {
+
+		/**
+		 * Populates the identifier of the backing entity if it has an identifier property and there's no identifier
+		 * currently present.
+		 *
+		 * @param id must not be {@literal null}.
+		 * @return
+		 */
+		@Nullable
+		T populateIdIfNecessary(@Nullable Object id);
+
+		/**
+		 * Initializes the version property of the of the current entity if available.
+		 *
+		 * @return the entity with the version property updated if available.
+		 */
+		T initializeVersionProperty();
+
+		/**
+		 * Increments the value of the version property if available.
+		 *
+		 * @return the entity with the version property incremented if available.
+		 */
+		T incrementVersion();
+
+		/**
+		 * Returns the current version value if the entity has a version property.
+		 *
+		 * @return the current version or {@literal null} in case it's uninitialized or the entity doesn't expose a version
+		 *         property.
+		 */
+		@Nullable
+		Number getVersion();
+	}
+
+	@RequiredArgsConstructor
+	private static class UnmappedEntity<T extends Map<String, Object>> implements AdaptibleEntity<T> {
+
+		private final T map;
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#getIdPropertyName()
+		 */
+		@Override
+		public String getIdFieldName() {
+			return ID_FIELD;
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#getId()
+		 */
+		@Override
+		public Object getId() {
+			return map.get(ID_FIELD);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#getByIdQuery()
+		 */
+		@Override
+		public Query getByIdQuery() {
+			return Query.query(Criteria.where(ID_FIELD).is(map.get(ID_FIELD)));
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.MutablePersistableSource#populateIdIfNecessary(java.lang.Object)
+		 */
+		@Nullable
+		@Override
+		public T populateIdIfNecessary(@Nullable Object id) {
+
+			map.put(ID_FIELD, id);
+
+			return map;
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#getQueryForVersion()
+		 */
+		@Override
+		public Query getQueryForVersion() {
+			throw new MappingException("Cannot query for version on plain Documents!");
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#toMappedDocument(org.springframework.data.mongodb.core.convert.MongoWriter)
+		 */
+		@Override
+		public MappedDocument toMappedDocument(MongoWriter<? super T> writer) {
+			return MappedDocument.of(map instanceof Document //
+					? (Document) map //
+					: new Document(map));
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.MutablePersistableSource#initializeVersionProperty()
+		 */
+		@Override
+		public T initializeVersionProperty() {
+			return map;
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.MutablePersistableSource#getVersion()
+		 */
+		@Override
+		@Nullable
+		public Number getVersion() {
+			return null;
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.MutablePersistableSource#incrementVersion()
+		 */
+		@Override
+		public T incrementVersion() {
+			return map;
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#getBean()
+		 */
+		@Override
+		public T getBean() {
+			return map;
+		}
+	}
+
+	private static class SimpleMappedEntity<T extends Map<String, Object>> extends UnmappedEntity<T> {
+
+		SimpleMappedEntity(T map) {
+			super(map);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#toMappedDocument(org.springframework.data.mongodb.core.convert.MongoWriter)
+		 */
+		@Override
+		@SuppressWarnings("unchecked")
+		public MappedDocument toMappedDocument(MongoWriter<? super T> writer) {
+
+			T bean = getBean();
+			bean = (T) (bean instanceof Document //
+					? (Document) bean //
+					: new Document(bean));
+			Document document = new Document();
+			writer.write(bean, document);
+
+			return MappedDocument.of(document);
+		}
+	}
+
+	@RequiredArgsConstructor(access = AccessLevel.PROTECTED)
+	private static class MappedEntity<T> implements Entity<T> {
+
+		private final @NonNull MongoPersistentEntity<?> entity;
+		private final @NonNull IdentifierAccessor idAccessor;
+		private final @NonNull PersistentPropertyAccessor<T> propertyAccessor;
+
+		private static <T> MappedEntity<T> of(T bean,
+				MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> context) {
+
+			MongoPersistentEntity<?> entity = context.getRequiredPersistentEntity(bean.getClass());
+			IdentifierAccessor identifierAccessor = entity.getIdentifierAccessor(bean);
+			PersistentPropertyAccessor<T> propertyAccessor = entity.getPropertyAccessor(bean);
+
+			return new MappedEntity<>(entity, identifierAccessor, propertyAccessor);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#getIdPropertyName()
+		 */
+		@Override
+		public String getIdFieldName() {
+			return entity.getRequiredIdProperty().getFieldName();
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#getId()
+		 */
+		@Override
+		public Object getId() {
+			return idAccessor.getRequiredIdentifier();
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#getByIdQuery()
+		 */
+		@Override
+		public Query getByIdQuery() {
+
+			if (!entity.hasIdProperty()) {
+				throw new MappingException("No id property found for object of type " + entity.getType() + "!");
+			}
+
+			MongoPersistentProperty idProperty = entity.getRequiredIdProperty();
+
+			return Query.query(Criteria.where(idProperty.getName()).is(getId()));
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#getQueryForVersion(java.lang.Object)
+		 */
+		@Override
+		public Query getQueryForVersion() {
+
+			MongoPersistentProperty idProperty = entity.getRequiredIdProperty();
+			MongoPersistentProperty property = entity.getRequiredVersionProperty();
+
+			return new Query(Criteria.where(idProperty.getName()).is(getId())//
+					.and(property.getName()).is(getVersion()));
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#toMappedDocument(org.springframework.data.mongodb.core.convert.MongoWriter)
+		 */
+		@Override
+		public MappedDocument toMappedDocument(MongoWriter<? super T> writer) {
+
+			T bean = propertyAccessor.getBean();
+
+			Document document = new Document();
+			writer.write(bean, document);
+
+			if (document.containsKey(ID_FIELD) && document.get(ID_FIELD) == null) {
+				document.remove(ID_FIELD);
+			}
+
+			return MappedDocument.of(document);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.Entity#assertUpdateableIdIfNotSet()
+		 */
+		public void assertUpdateableIdIfNotSet() {
+
+			if (!entity.hasIdProperty()) {
+				return;
+			}
+
+			MongoPersistentProperty property = entity.getRequiredIdProperty();
+			Object propertyValue = idAccessor.getIdentifier();
+
+			if (propertyValue != null) {
+				return;
+			}
+
+			if (!MongoSimpleTypes.AUTOGENERATED_ID_TYPES.contains(property.getType())) {
+				throw new InvalidDataAccessApiUsageException(
+						String.format("Cannot autogenerate id of type %s for entity of type %s!", property.getType().getName(),
+								entity.getType().getName()));
+			}
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#isVersionedEntity()
+		 */
+		@Override
+		public boolean isVersionedEntity() {
+			return entity.hasVersionProperty();
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#getVersion()
+		 */
+		@Override
+		@Nullable
+		public Object getVersion() {
+			return propertyAccessor.getProperty(entity.getRequiredVersionProperty());
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#getBean()
+		 */
+		@Override
+		public T getBean() {
+			return propertyAccessor.getBean();
+		}
+	}
+
+	private static class AdaptibleMappedEntity<T> extends MappedEntity<T> implements AdaptibleEntity<T> {
+
+		private final MongoPersistentEntity<?> entity;
+		private final ConvertingPropertyAccessor<T> propertyAccessor;
+		private final IdentifierAccessor identifierAccessor;
+
+		private AdaptibleMappedEntity(MongoPersistentEntity<?> entity, IdentifierAccessor identifierAccessor,
+				ConvertingPropertyAccessor<T> propertyAccessor) {
+
+			super(entity, identifierAccessor, propertyAccessor);
+
+			this.entity = entity;
+			this.propertyAccessor = propertyAccessor;
+			this.identifierAccessor = identifierAccessor;
+		}
+
+		private static <T> AdaptibleEntity<T> of(T bean,
+				MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> context,
+				ConversionService conversionService) {
+
+			MongoPersistentEntity<?> entity = context.getRequiredPersistentEntity(bean.getClass());
+			IdentifierAccessor identifierAccessor = entity.getIdentifierAccessor(bean);
+			PersistentPropertyAccessor<T> propertyAccessor = entity.getPropertyAccessor(bean);
+
+			return new AdaptibleMappedEntity<>(entity, identifierAccessor,
+					new ConvertingPropertyAccessor<>(propertyAccessor, conversionService));
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.AdaptibleEntity#populateIdIfNecessary(java.lang.Object)
+		 */
+		@Nullable
+		@Override
+		public T populateIdIfNecessary(@Nullable Object id) {
+
+			if (id == null) {
+				return null;
+			}
+
+			T bean = propertyAccessor.getBean();
+			MongoPersistentProperty idProperty = entity.getIdProperty();
+
+			if (idProperty == null) {
+				return bean;
+			}
+
+			if (identifierAccessor.getIdentifier() != null) {
+				return bean;
+			}
+
+			propertyAccessor.setProperty(idProperty, id);
+
+			return propertyAccessor.getBean();
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.MappedEntity#getVersion()
+		 */
+		@Override
+		@Nullable
+		public Number getVersion() {
+
+			MongoPersistentProperty versionProperty = entity.getRequiredVersionProperty();
+
+			return propertyAccessor.getProperty(versionProperty, Number.class);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.AdaptibleEntity#initializeVersionProperty()
+		 */
+		@Override
+		public T initializeVersionProperty() {
+
+			if (!entity.hasVersionProperty()) {
+				return propertyAccessor.getBean();
+			}
+
+			propertyAccessor.setProperty(entity.getRequiredVersionProperty(), 0);
+
+			return propertyAccessor.getBean();
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.AdaptibleEntity#incrementVersion()
+		 */
+		@Override
+		public T incrementVersion() {
+
+			MongoPersistentProperty versionProperty = entity.getRequiredVersionProperty();
+			Number version = getVersion();
+			Number nextVersion = version == null ? 0 : version.longValue() + 1;
+
+			propertyAccessor.setProperty(versionProperty, nextVersion);
+
+			return propertyAccessor.getBean();
+		}
+	}
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 the original author or authors.
+ * Copyright 2017-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 the original author or authors.
+ * Copyright 2017-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -35,22 +35,10 @@ import org.springframework.util.StringUtils;
  * @author Mark Paluch
  * @since 2.0
  */
+@RequiredArgsConstructor
 class ExecutableAggregationOperationSupport implements ExecutableAggregationOperation {
 
-	private final MongoTemplate template;
-
-	/**
-	 * Create new instance of {@link ExecutableAggregationOperationSupport}.
-	 *
-	 * @param template must not be {@literal null}.
-	 * @throws IllegalArgumentException if template is {@literal null}.
-	 */
-	ExecutableAggregationOperationSupport(MongoTemplate template) {
-
-		Assert.notNull(template, "Template must not be null!");
-
-		this.template = template;
-	}
+	private final @NonNull MongoTemplate template;
 
 	/*
 	 * (non-Javadoc)
@@ -131,11 +119,11 @@ class ExecutableAggregationOperationSupport implements ExecutableAggregationOper
 				TypedAggregation<?> typedAggregation = (TypedAggregation<?>) aggregation;
 
 				if (typedAggregation.getInputType() != null) {
-					return template.determineCollectionName(typedAggregation.getInputType());
+					return template.getCollectionName(typedAggregation.getInputType());
 				}
 			}
 
-			return template.determineCollectionName(domainType);
+			return template.getCollectionName(domainType);
 		}
 	}
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 the original author or authors.
+ * Copyright 2017-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,11 +19,14 @@ import java.util.List;
 import java.util.Optional;
 import java.util.stream.Stream;
 
+import org.springframework.dao.DataAccessException;
 import org.springframework.data.geo.GeoResults;
 import org.springframework.data.mongodb.core.query.NearQuery;
 import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.lang.Nullable;
 
+import com.mongodb.client.MongoCollection;
+
 /**
  * {@link ExecutableFindOperation} allows creation and execution of MongoDB find operations in a fluent API style.
  * <br />
@@ -202,7 +205,7 @@ public interface ExecutableFindOperation {
 	 * @author Christoph Strobl
 	 * @since 2.0
 	 */
-	interface FindWithProjection<T> extends FindWithQuery<T> {
+	interface FindWithProjection<T> extends FindWithQuery<T>, FindDistinct {
 
 		/**
 		 * Define the target type fields should be mapped to. <br />
@@ -214,6 +217,101 @@ public interface ExecutableFindOperation {
 		 * @throws IllegalArgumentException if resultType is {@literal null}.
 		 */
 		<R> FindWithQuery<R> as(Class<R> resultType);
+
+	}
+
+	/**
+	 * Distinct Find support.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	interface FindDistinct {
+
+		/**
+		 * Finds the distinct values for a specified {@literal field} across a single {@link MongoCollection} or view.
+		 *
+		 * @param field name of the field. Must not be {@literal null}.
+		 * @return new instance of {@link TerminatingDistinct}.
+		 * @throws IllegalArgumentException if field is {@literal null}.
+		 */
+		TerminatingDistinct<Object> distinct(String field);
+	}
+
+	/**
+	 * Result type override. Optional.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	interface DistinctWithProjection {
+
+		/**
+		 * Define the target type the result should be mapped to. <br />
+		 * Skip this step if you are anyway fine with the default conversion.
+		 * <dl>
+		 * <dt>{@link Object} (the default)</dt>
+		 * <dd>Result is mapped according to the {@link org.bson.BsonType} converting eg. {@link org.bson.BsonString} into
+		 * plain {@link String}, {@link org.bson.BsonInt64} to {@link Long}, etc. always picking the most concrete type with
+		 * respect to the domain types property.<br />
+		 * Any {@link org.bson.BsonType#DOCUMENT} is run through the {@link org.springframework.data.convert.EntityReader}
+		 * to obtain the domain type. <br />
+		 * Using {@link Object} also works for non strictly typed fields. Eg. a mixture different types like fields using
+		 * {@link String} in one {@link org.bson.Document} while {@link Long} in another.</dd>
+		 * <dt>Any Simple type like {@link String} or {@link Long}.</dt>
+		 * <dd>The result is mapped directly by the MongoDB Java driver and the {@link org.bson.codecs.CodeCodec Codecs} in
+		 * place. This works only for results where all documents considered for the operation use the very same type for
+		 * the field.</dd>
+		 * <dt>Any Domain type</dt>
+		 * <dd>Domain types can only be mapped if the if the result of the actual {@code distinct()} operation returns
+		 * {@link org.bson.BsonType#DOCUMENT}.</dd>
+		 * <dt>{@link org.bson.BsonValue}</dt>
+		 * <dd>Using {@link org.bson.BsonValue} allows retrieval of the raw driver specific format, which returns eg.
+		 * {@link org.bson.BsonString}.</dd>
+		 * </dl>
+		 *
+		 * @param resultType must not be {@literal null}.
+		 * @param <R> result type.
+		 * @return new instance of {@link TerminatingDistinct}.
+		 * @throws IllegalArgumentException if resultType is {@literal null}.
+		 */
+		<R> TerminatingDistinct<R> as(Class<R> resultType);
+	}
+
+	/**
+	 * Result restrictions. Optional.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	interface DistinctWithQuery<T> extends DistinctWithProjection {
+
+		/**
+		 * Set the filter query to be used.
+		 *
+		 * @param query must not be {@literal null}.
+		 * @return new instance of {@link TerminatingDistinct}.
+		 * @throws IllegalArgumentException if resultType is {@literal null}.
+		 */
+		TerminatingDistinct<T> matching(Query query);
+	}
+
+	/**
+	 * Terminating distinct find operations.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	interface TerminatingDistinct<T> extends DistinctWithQuery<T> {
+
+		/**
+		 * Get all matching distinct field values.
+		 *
+		 * @return empty {@link List} if not match found. Never {@literal null}.
+		 * @throws DataAccessException if eg. result cannot be converted correctly which may happen if the document contains
+		 *           {@link String} whereas the result type is specified as {@link Long}.
+		 */
+		List<T> all();
 	}
 
 	/**
@@ -222,5 +320,5 @@ public interface ExecutableFindOperation {
 	 * @author Christoph Strobl
 	 * @since 2.0
 	 */
-	interface ExecutableFind<T> extends FindWithCollection<T>, FindWithProjection<T> {}
+	interface ExecutableFind<T> extends FindWithCollection<T>, FindWithProjection<T>, FindDistinct {}
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 the original author or authors.
+ * Copyright 2017-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -45,24 +45,12 @@ import com.mongodb.client.FindIterable;
  * @author Mark Paluch
  * @since 2.0
  */
+@RequiredArgsConstructor
 class ExecutableFindOperationSupport implements ExecutableFindOperation {
 
 	private static final Query ALL_QUERY = new Query();
 
-	private final MongoTemplate template;
-
-	/**
-	 * Create new {@link ExecutableFindOperationSupport}.
-	 *
-	 * @param template must not be {@literal null}.
-	 * @throws IllegalArgumentException if template is {@literal null}.
-	 */
-	ExecutableFindOperationSupport(MongoTemplate template) {
-
-		Assert.notNull(template, "Template must not be null!");
-
-		this.template = template;
-	}
+	private final @NonNull MongoTemplate template;
 
 	/*
 	 * (non-Javadoc)
@@ -205,6 +193,19 @@ class ExecutableFindOperationSupport implements ExecutableFindOperation {
 			return template.exists(query, domainType, getCollectionName());
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.FindDistinct#distinct(java.lang.String)
+		 */
+		@SuppressWarnings("unchecked")
+		@Override
+		public TerminatingDistinct<Object> distinct(String field) {
+
+			Assert.notNull(field, "Field must not be null!");
+
+			return new DistinctOperationSupport(this, field);
+		}
+
 		private List<T> doFind(@Nullable CursorPreparer preparer) {
 
 			Document queryObject = query.getQueryObject();
@@ -214,6 +215,12 @@ class ExecutableFindOperationSupport implements ExecutableFindOperation {
 					getCursorPreparer(query, preparer));
 		}
 
+		private List<T> doFindDistinct(String field) {
+
+			return template.findDistinct(query, field, getCollectionName(), domainType,
+					returnType == domainType ? (Class<T>) Object.class : returnType);
+		}
+
 		private CloseableIterator<T> doStream() {
 			return template.doStream(query, domainType, getCollectionName(), returnType);
 		}
@@ -223,7 +230,7 @@ class ExecutableFindOperationSupport implements ExecutableFindOperation {
 		}
 
 		private String getCollectionName() {
-			return StringUtils.hasText(collection) ? collection : template.determineCollectionName(domainType);
+			return StringUtils.hasText(collection) ? collection : template.getCollectionName(domainType);
 		}
 
 		private String asString() {
@@ -261,4 +268,54 @@ class ExecutableFindOperationSupport implements ExecutableFindOperation {
 			return this;
 		}
 	}
+
+	/**
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	static class DistinctOperationSupport<T> implements TerminatingDistinct<T> {
+
+		private final String field;
+		private final ExecutableFindSupport<T> delegate;
+
+		public DistinctOperationSupport(ExecutableFindSupport<T> delegate, String field) {
+
+			this.delegate = delegate;
+			this.field = field;
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.DistinctWithProjection#as(java.lang.Class)
+		 */
+		@Override
+		@SuppressWarnings("unchecked")
+		public <R> TerminatingDistinct<R> as(Class<R> resultType) {
+
+			Assert.notNull(resultType, "ResultType must not be null!");
+
+			return new DistinctOperationSupport<>((ExecutableFindSupport) delegate.as(resultType), field);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.DistinctWithQuery#matching(org.springframework.data.mongodb.core.query.Query)
+		 */
+		@Override
+		public TerminatingDistinct<T> matching(Query query) {
+
+			Assert.notNull(query, "Query must not be null!");
+
+			return new DistinctOperationSupport<>((ExecutableFindSupport<T>) delegate.matching(query), field);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.TerminatingDistinct#all()
+		 */
+		@Override
+		public List<T> all() {
+			return delegate.doFindDistinct(field);
+		}
+	}
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 the original author or authors.
+ * Copyright 2017-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -63,17 +63,19 @@ public interface ExecutableInsertOperation {
 		 * Insert exactly one object.
 		 *
 		 * @param object must not be {@literal null}.
+		 * @return the inserted object.
 		 * @throws IllegalArgumentException if object is {@literal null}.
 		 */
-		void one(T object);
+		T one(T object);
 
 		/**
 		 * Insert a collection of objects.
 		 *
 		 * @param objects must not be {@literal null}.
+		 * @return the inserted objects.
 		 * @throws IllegalArgumentException if objects is {@literal null}.
 		 */
-		void all(Collection<? extends T> objects);
+		Collection<? extends T> all(Collection<? extends T> objects);
 	}
 
 	/**

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 the original author or authors.
+ * Copyright 2017-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -37,22 +37,10 @@ import com.mongodb.bulk.BulkWriteResult;
  * @author Mark Paluch
  * @since 2.0
  */
+@RequiredArgsConstructor
 class ExecutableInsertOperationSupport implements ExecutableInsertOperation {
 
-	private final MongoTemplate template;
-
-	/**
-	 * Create new {@link ExecutableInsertOperationSupport}.
-	 *
-	 * @param template must not be {@literal null}.
-	 * @throws IllegalArgumentException if template is {@literal null}.
-	 */
-	ExecutableInsertOperationSupport(MongoTemplate template) {
-
-		Assert.notNull(template, "Template must not be null!");
-
-		this.template = template;
-	}
+	private final @NonNull MongoTemplate template;
 
 	/*
 	 * (non-Javadoc)
@@ -84,11 +72,11 @@ class ExecutableInsertOperationSupport implements ExecutableInsertOperation {
 		 * @see org.springframework.data.mongodb.core.ExecutableInsertOperation.TerminatingInsert#insert(java.lang.Class)
 		 */
 		@Override
-		public void one(T object) {
+		public T one(T object) {
 
 			Assert.notNull(object, "Object must not be null!");
 
-			template.insert(object, getCollectionName());
+			return template.insert(object, getCollectionName());
 		}
 
 		/*
@@ -96,11 +84,11 @@ class ExecutableInsertOperationSupport implements ExecutableInsertOperation {
 		 * @see org.springframework.data.mongodb.core.ExecutableInsertOperation.TerminatingInsert#all(java.util.Collection)
 		 */
 		@Override
-		public void all(Collection<? extends T> objects) {
+		public Collection<T> all(Collection<? extends T> objects) {
 
 			Assert.notNull(objects, "Objects must not be null!");
 
-			template.insert(objects, getCollectionName());
+			return template.insert(objects, getCollectionName());
 		}
 
 		/*
@@ -141,7 +129,7 @@ class ExecutableInsertOperationSupport implements ExecutableInsertOperation {
 		}
 
 		private String getCollectionName() {
-			return StringUtils.hasText(collection) ? collection : template.determineCollectionName(domainType);
+			return StringUtils.hasText(collection) ? collection : template.getCollectionName(domainType);
 		}
 	}
 }

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

@@ -0,0 +1,199 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import java.util.List;
+
+import org.springframework.data.mongodb.core.ExecutableFindOperation.ExecutableFind;
+import org.springframework.data.mongodb.core.mapreduce.MapReduceOptions;
+import org.springframework.data.mongodb.core.query.Query;
+
+/**
+ * {@link ExecutableMapReduceOperation} allows creation and execution of MongoDB mapReduce operations in a fluent API
+ * style. The starting {@literal domainType} is used for mapping an optional {@link Query} provided via {@code matching}
+ * into the MongoDB specific representation. By default, the originating {@literal domainType} is also used for mapping
+ * back the results from the {@link org.bson.Document}. However, it is possible to define an different
+ * {@literal returnType} via {@code as} to mapping the result.<br />
+ * The collection to operate on is by default derived from the initial {@literal domainType} and can be defined there
+ * via {@link org.springframework.data.mongodb.core.mapping.Document}. Using {@code inCollection} allows to override the
+ * collection name for the execution.
+ * 
+ * <pre>
+ *     <code>
+ *         mapReduce(Human.class)
+ *             .map("function() { emit(this.id, this.firstname) }")
+ *             .reduce("function(id, name) { return sum(id, name); }")
+ *             .inCollection("star-wars")
+ *             .as(Jedi.class)
+ *             .matching(query(where("lastname").is("skywalker")))
+ *             .all();
+ *     </code>
+ * </pre>
+ *
+ * @author Christoph Strobl
+ * @since 2.1
+ */
+public interface ExecutableMapReduceOperation {
+
+	/**
+	 * Start creating a mapReduce operation for the given {@literal domainType}.
+	 *
+	 * @param domainType must not be {@literal null}.
+	 * @return new instance of {@link ExecutableFind}.
+	 * @throws IllegalArgumentException if domainType is {@literal null}.
+	 */
+	<T> MapReduceWithMapFunction<T> mapReduce(Class<T> domainType);
+
+	/**
+	 * Trigger mapReduce execution by calling one of the terminating methods.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	interface TerminatingMapReduce<T> {
+
+		/**
+		 * Get the mapReduce results.
+		 *
+		 * @return never {@literal null}.
+		 */
+		List<T> all();
+	}
+
+	/**
+	 * Provide the Javascript {@code function()} used to map matching documents.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	interface MapReduceWithMapFunction<T> {
+
+		/**
+		 * Set the Javascript map {@code function()}.
+		 *
+		 * @param mapFunction must not be {@literal null} nor empty.
+		 * @return new instance of {@link MapReduceWithReduceFunction}.
+		 * @throws IllegalArgumentException if {@literal mapFunction} is {@literal null} or empty.
+		 */
+		MapReduceWithReduceFunction<T> map(String mapFunction);
+
+	}
+
+	/**
+	 * Provide the Javascript {@code function()} used to reduce matching documents.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	interface MapReduceWithReduceFunction<T> {
+
+		/**
+		 * Set the Javascript map {@code function()}.
+		 *
+		 * @param reduceFunction must not be {@literal null} nor empty.
+		 * @return new instance of {@link ExecutableMapReduce}.
+		 * @throws IllegalArgumentException if {@literal reduceFunction} is {@literal null} or empty.
+		 */
+		ExecutableMapReduce<T> reduce(String reduceFunction);
+
+	}
+
+	/**
+	 * Collection override (Optional).
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	interface MapReduceWithCollection<T> extends MapReduceWithQuery<T> {
+
+		/**
+		 * Explicitly set the name of the collection to perform the mapReduce operation on. <br />
+		 * Skip this step to use the default collection derived from the domain type.
+		 *
+		 * @param collection must not be {@literal null} nor {@literal empty}.
+		 * @return new instance of {@link MapReduceWithProjection}.
+		 * @throws IllegalArgumentException if collection is {@literal null}.
+		 */
+		MapReduceWithProjection<T> inCollection(String collection);
+	}
+
+	/**
+	 * Input document filter query (Optional).
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	interface MapReduceWithQuery<T> extends TerminatingMapReduce<T> {
+
+		/**
+		 * Set the filter query to be used.
+		 *
+		 * @param query must not be {@literal null}.
+		 * @return new instance of {@link TerminatingMapReduce}.
+		 * @throws IllegalArgumentException if query is {@literal null}.
+		 */
+		TerminatingMapReduce<T> matching(Query query);
+	}
+
+	/**
+	 * Result type override (Optional).
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	interface MapReduceWithProjection<T> extends MapReduceWithQuery<T> {
+
+		/**
+		 * Define the target type fields should be mapped to. <br />
+		 * Skip this step if you are anyway only interested in the original domain type.
+		 *
+		 * @param resultType must not be {@literal null}.
+		 * @param <R> result type.
+		 * @return new instance of {@link TerminatingMapReduce}.
+		 * @throws IllegalArgumentException if resultType is {@literal null}.
+		 */
+		<R> MapReduceWithQuery<R> as(Class<R> resultType);
+	}
+
+	/**
+	 * Additional mapReduce options (Optional).
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	interface MapReduceWithOptions<T> {
+
+		/**
+		 * Set additional options to apply to the mapReduce operation.
+		 *
+		 * @param options must not be {@literal null}.
+		 * @return new instance of {@link ExecutableMapReduce}.
+		 * @throws IllegalArgumentException if options is {@literal null}.
+		 */
+		ExecutableMapReduce<T> with(MapReduceOptions options);
+	}
+
+	/**
+	 * {@link ExecutableMapReduce} provides methods for constructing mapReduce operations in a fluent way.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	interface ExecutableMapReduce<T> extends MapReduceWithMapFunction<T>, MapReduceWithReduceFunction<T>,
+			MapReduceWithCollection<T>, MapReduceWithProjection<T>, MapReduceWithOptions<T> {
+
+	}
+}

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

@@ -0,0 +1,177 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+
+import java.util.List;
+
+import org.springframework.data.mongodb.core.mapreduce.MapReduceOptions;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
+
+/**
+ * Implementation of {@link ExecutableMapReduceOperation}.
+ *
+ * @author Christoph Strobl
+ * @since 2.1
+ */
+@RequiredArgsConstructor
+class ExecutableMapReduceOperationSupport implements ExecutableMapReduceOperation {
+
+	private static final Query ALL_QUERY = new Query();
+
+	private final @NonNull MongoTemplate template;
+
+	/*
+	 * (non-Javascript)
+	 * @see in org.springframework.data.mongodb.core.ExecutableMapReduceOperation#mapReduce(java.lang.Class)
+	 */
+	@Override
+	public <T> ExecutableMapReduceSupport<T> mapReduce(Class<T> domainType) {
+
+		Assert.notNull(domainType, "DomainType must not be null!");
+
+		return new ExecutableMapReduceSupport<>(template, domainType, domainType, null, ALL_QUERY, null, null, null);
+	}
+
+	/**
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	static class ExecutableMapReduceSupport<T>
+			implements ExecutableMapReduce<T>, MapReduceWithOptions<T>, MapReduceWithCollection<T>,
+			MapReduceWithProjection<T>, MapReduceWithQuery<T>, MapReduceWithReduceFunction<T>, MapReduceWithMapFunction<T> {
+
+		private final MongoTemplate template;
+		private final Class<?> domainType;
+		private final Class<T> returnType;
+		private final @Nullable String collection;
+		private final Query query;
+		private final @Nullable String mapFunction;
+		private final @Nullable String reduceFunction;
+		private final @Nullable MapReduceOptions options;
+
+		ExecutableMapReduceSupport(MongoTemplate template, Class<?> domainType, Class<T> returnType,
+				@Nullable String collection, Query query, @Nullable String mapFunction, @Nullable String reduceFunction,
+				@Nullable MapReduceOptions options) {
+
+			this.template = template;
+			this.domainType = domainType;
+			this.returnType = returnType;
+			this.collection = collection;
+			this.query = query;
+			this.mapFunction = mapFunction;
+			this.reduceFunction = reduceFunction;
+			this.options = options;
+		}
+
+		/*
+		 * (non-Javascript)
+		 * @see in org.springframework.data.mongodb.core.ExecutableMapReduceOperation.TerminatingMapReduce#all()
+		 */
+		@Override
+		public List<T> all() {
+			return template.mapReduce(query, domainType, getCollectionName(), mapFunction, reduceFunction, options,
+					returnType);
+		}
+
+		/*
+		 * (non-Javascript)
+		 * @see in org.springframework.data.mongodb.core.ExecutableMapReduceOperation.MapReduceWithCollection#inCollection(java.lang.String)
+		 */
+		@Override
+		public MapReduceWithProjection<T> inCollection(String collection) {
+
+			Assert.hasText(collection, "Collection name must not be null nor empty!");
+
+			return new ExecutableMapReduceSupport<>(template, domainType, returnType, collection, query, mapFunction,
+					reduceFunction, options);
+		}
+
+		/*
+		 * (non-Javascript)
+		 * @see in org.springframework.data.mongodb.core.ExecutableMapReduceOperation.MapReduceWithQuery#query(org.springframework.data.mongodb.core.query.Query)
+		 */
+		@Override
+		public TerminatingMapReduce<T> matching(Query query) {
+
+			Assert.notNull(query, "Query must not be null!");
+
+			return new ExecutableMapReduceSupport<>(template, domainType, returnType, collection, query, mapFunction,
+					reduceFunction, options);
+		}
+
+		/*
+		 * (non-Javascript)
+		 * @see in org.springframework.data.mongodb.core.ExecutableMapReduceOperation.MapReduceWithProjection#as(java.lang.Class)
+		 */
+		@Override
+		public <R> MapReduceWithQuery<R> as(Class<R> resultType) {
+
+			Assert.notNull(resultType, "ResultType must not be null!");
+
+			return new ExecutableMapReduceSupport<>(template, domainType, resultType, collection, query, mapFunction,
+					reduceFunction, options);
+		}
+
+		/*
+		 * (non-Javascript)
+		 * @see in org.springframework.data.mongodb.core.ExecutableMapReduceOperation.MapReduceWithOptions#with(org.springframework.data.mongodb.core.mapreduce.MapReduceOptions)
+		 */
+		@Override
+		public ExecutableMapReduce<T> with(MapReduceOptions options) {
+
+			Assert.notNull(options, "Options must not be null! Please consider empty MapReduceOptions#options() instead.");
+
+			return new ExecutableMapReduceSupport<>(template, domainType, returnType, collection, query, mapFunction,
+					reduceFunction, options);
+		}
+
+		/*
+		 * (non-Javascript)
+		 * @see in org.springframework.data.mongodb.core.ExecutableMapReduceOperation.MapReduceWithMapFunction#map(java.lang.String)
+		 */
+		@Override
+		public MapReduceWithReduceFunction<T> map(String mapFunction) {
+
+			Assert.hasText(mapFunction, "MapFunction name must not be null nor empty!");
+
+			return new ExecutableMapReduceSupport<>(template, domainType, returnType, collection, query, mapFunction,
+					reduceFunction, options);
+		}
+
+		/*
+		 * (non-Javascript)
+		 * @see in org.springframework.data.mongodb.core.ExecutableMapReduceOperation.MapReduceWithReduceFunction#reduce(java.lang.String)
+		 */
+		@Override
+		public ExecutableMapReduce<T> reduce(String reduceFunction) {
+
+			Assert.hasText(reduceFunction, "ReduceFunction name must not be null nor empty!");
+
+			return new ExecutableMapReduceSupport<>(template, domainType, returnType, collection, query, mapFunction,
+					reduceFunction, options);
+		}
+
+		private String getCollectionName() {
+			return StringUtils.hasText(collection) ? collection : template.getCollectionName(domainType);
+		}
+	}
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 the original author or authors.
+ * Copyright 2017-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -53,6 +53,37 @@ public interface ExecutableRemoveOperation {
 	 */
 	<T> ExecutableRemove<T> remove(Class<T> domainType);
 
+	/**
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface TerminatingRemove<T> {
+
+		/**
+		 * Remove all documents matching.
+		 *
+		 * @return the {@link DeleteResult}. Never {@literal null}.
+		 */
+		DeleteResult all();
+
+		/**
+		 * Remove the first matching document.
+		 *
+		 * @return the {@link DeleteResult}. Never {@literal null}.
+		 */
+		DeleteResult one();
+
+		/**
+		 * Remove and return all matching documents. <br/>
+		 * <strong>NOTE</strong> The entire list of documents will be fetched before sending the actual delete commands.
+		 * Also, {@link org.springframework.context.ApplicationEvent}s will be published for each and every delete
+		 * operation.
+		 *
+		 * @return empty {@link List} if no match found. Never {@literal null}.
+		 */
+		List<T> findAndRemove();
+	}
+
 	/**
 	 * Collection override (optional).
 	 *
@@ -73,29 +104,6 @@ public interface ExecutableRemoveOperation {
 		RemoveWithQuery<T> inCollection(String collection);
 	}
 
-	/**
-	 * @author Christoph Strobl
-	 * @since 2.0
-	 */
-	interface TerminatingRemove<T> {
-
-		/**
-		 * Remove all documents matching.
-		 *
-		 * @return the {@link DeleteResult}. Never {@literal null}.
-		 */
-		DeleteResult all();
-
-		/**
-		 * Remove and return all matching documents. <br/>
-		 * <strong>NOTE</strong> The entire list of documents will be fetched before sending the actual delete commands.
-		 * Also, {@link org.springframework.context.ApplicationEvent}s will be published for each and every delete
-		 * operation.
-		 *
-		 * @return empty {@link List} if no match found. Never {@literal null}.
-		 */
-		List<T> findAndRemove();
-	}
 
 	/**
 	 * @author Christoph Strobl

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 the original author or authors.
+ * Copyright 2017-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -36,24 +36,12 @@ import com.mongodb.client.result.DeleteResult;
  * @author Mark Paluch
  * @since 2.0
  */
+@RequiredArgsConstructor
 class ExecutableRemoveOperationSupport implements ExecutableRemoveOperation {
 
 	private static final Query ALL_QUERY = new Query();
 
-	private final MongoTemplate tempate;
-
-	/**
-	 * Create new {@link ExecutableRemoveOperationSupport}.
-	 *
-	 * @param template must not be {@literal null}.
-	 * @throws IllegalArgumentException if template is {@literal null}.
-	 */
-	ExecutableRemoveOperationSupport(MongoTemplate template) {
-
-		Assert.notNull(template, "Template must not be null!");
-
-		this.tempate = template;
-	}
+	private final @NonNull MongoTemplate tempate;
 
 	/*
 	 * (non-Javadoc)
@@ -110,10 +98,16 @@ class ExecutableRemoveOperationSupport implements ExecutableRemoveOperation {
 		 */
 		@Override
 		public DeleteResult all() {
+			return template.doRemove(getCollectionName(), query, domainType, true);
+		}
 
-			String collectionName = getCollectionName();
-
-			return template.doRemove(collectionName, query, domainType);
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableRemoveOperation.TerminatingRemove#one()
+		 */
+		@Override
+		public DeleteResult one() {
+			return template.doRemove(getCollectionName(), query, domainType, false);
 		}
 
 		/*
@@ -129,7 +123,7 @@ class ExecutableRemoveOperationSupport implements ExecutableRemoveOperation {
 		}
 
 		private String getCollectionName() {
-			return StringUtils.hasText(collection) ? collection : template.determineCollectionName(domainType);
+			return StringUtils.hasText(collection) ? collection : template.getCollectionName(domainType);
 		}
 	}
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 the original author or authors.
+ * Copyright 2017-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,13 +19,13 @@ import java.util.Optional;
 
 import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.data.mongodb.core.query.Update;
-
-import com.mongodb.client.result.UpdateResult;
 import org.springframework.lang.Nullable;
 
+import com.mongodb.client.result.UpdateResult;
+
 /**
- * {@link ExecutableUpdateOperation} allows creation and execution of MongoDB update / findAndModify operations in a
- * fluent API style. <br />
+ * {@link ExecutableUpdateOperation} allows creation and execution of MongoDB update / findAndModify / findAndReplace
+ * operations in a fluent API style. <br />
  * The starting {@literal domainType} is used for mapping the {@link Query} provided via {@code matching}, as well as
  * the {@link Update} via {@code apply} into the MongoDB specific representations. The collection to operate on is by
  * default derived from the initial {@literal domainType} and can be defined there via
@@ -57,6 +57,91 @@ public interface ExecutableUpdateOperation {
 	 */
 	<T> ExecutableUpdate<T> update(Class<T> domainType);
 
+	/**
+	 * Trigger findAndModify execution by calling one of the terminating methods.
+	 *
+	 * @author Christoph Strobl
+	 * @author Mark Paluch
+	 * @since 2.0
+	 */
+	interface TerminatingFindAndModify<T> {
+
+		/**
+		 * Find, modify and return the first matching document.
+		 *
+		 * @return {@link Optional#empty()} if nothing found.
+		 */
+		default Optional<T> findAndModify() {
+			return Optional.ofNullable(findAndModifyValue());
+		}
+
+		/**
+		 * Find, modify and return the first matching document.
+		 *
+		 * @return {@literal null} if nothing found.
+		 */
+		@Nullable
+		T findAndModifyValue();
+	}
+
+	/**
+	 * Trigger
+	 * <a href="https://docs.mongodb.com/manual/reference/method/db.collection.findOneAndReplace/">findOneAndReplace<a/>
+	 * execution by calling one of the terminating methods.
+	 *
+	 * @author Mark Paluch
+	 * @since 2.1
+	 */
+	interface TerminatingFindAndReplace<T> {
+
+		/**
+		 * Find, replace and return the first matching document.
+		 *
+		 * @return {@link Optional#empty()} if nothing found.
+		 */
+		default Optional<T> findAndReplace() {
+			return Optional.ofNullable(findAndReplaceValue());
+		}
+
+		/**
+		 * Find, replace and return the first matching document.
+		 *
+		 * @return {@literal null} if nothing found.
+		 */
+		@Nullable
+		T findAndReplaceValue();
+	}
+
+	/**
+	 * Trigger update execution by calling one of the terminating methods.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface TerminatingUpdate<T> extends TerminatingFindAndModify<T>, FindAndModifyWithOptions<T> {
+
+		/**
+		 * Update all matching documents in the collection.
+		 *
+		 * @return never {@literal null}.
+		 */
+		UpdateResult all();
+
+		/**
+		 * Update the first document in the collection.
+		 *
+		 * @return never {@literal null}.
+		 */
+		UpdateResult first();
+
+		/**
+		 * Creates a new document if no documents match the filter query or updates the matching ones.
+		 *
+		 * @return never {@literal null}.
+		 */
+		UpdateResult upsert();
+	}
+
 	/**
 	 * Declare the {@link Update} to apply.
 	 *
@@ -73,6 +158,16 @@ public interface ExecutableUpdateOperation {
 		 * @throws IllegalArgumentException if update is {@literal null}.
 		 */
 		TerminatingUpdate<T> apply(Update update);
+
+		/**
+		 * Specify {@code replacement} object.
+		 *
+		 * @param replacement must not be {@literal null}.
+		 * @return new instance of {@link FindAndReplaceOptions}.
+		 * @throws IllegalArgumentException if options is {@literal null}.
+		 * @since 2.1
+		 */
+		FindAndReplaceWithProjection<T> replaceWith(T replacement);
 	}
 
 	/**
@@ -131,56 +226,43 @@ public interface ExecutableUpdateOperation {
 	}
 
 	/**
-	 * Trigger findAndModify execution by calling one of the terminating methods.
+	 * Define {@link FindAndReplaceOptions}.
+	 *
+	 * @author Mark Paluch
+	 * @author Christoph Strobl
+	 * @since 2.1
 	 */
-	interface TerminatingFindAndModify<T> {
+	interface FindAndReplaceWithOptions<T> extends TerminatingFindAndReplace<T> {
 
 		/**
-		 * Find, modify and return the first matching document.
+		 * Explicitly define {@link FindAndReplaceOptions} for the {@link Update}.
 		 *
-		 * @return {@link Optional#empty()} if nothing found.
+		 * @param options must not be {@literal null}.
+		 * @return new instance of {@link FindAndReplaceOptions}.
+		 * @throws IllegalArgumentException if options is {@literal null}.
 		 */
-		default Optional<T> findAndModify() {
-			return Optional.ofNullable(findAndModifyValue());
-		}
-
-		/**
-		 * Find, modify and return the first matching document.
-		 *
-		 * @return {@literal null} if nothing found.
-		 */
-		@Nullable
-		T findAndModifyValue();
+		FindAndReplaceWithProjection<T> withOptions(FindAndReplaceOptions options);
 	}
 
 	/**
-	 * Trigger update execution by calling one of the terminating methods.
+	 * Result type override (Optional).
 	 *
 	 * @author Christoph Strobl
-	 * @since 2.0
+	 * @since 2.1
 	 */
-	interface TerminatingUpdate<T> extends TerminatingFindAndModify<T>, FindAndModifyWithOptions<T> {
+	interface FindAndReplaceWithProjection<T> extends FindAndReplaceWithOptions<T> {
 
 		/**
-		 * Update all matching documents in the collection.
+		 * Define the target type fields should be mapped to. <br />
+		 * Skip this step if you are anyway only interested in the original domain type.
 		 *
-		 * @return never {@literal null}.
+		 * @param resultType must not be {@literal null}.
+		 * @param <R> result type.
+		 * @return new instance of {@link FindAndReplaceWithProjection}.
+		 * @throws IllegalArgumentException if resultType is {@literal null}.
 		 */
-		UpdateResult all();
+		<R> FindAndReplaceWithOptions<R> as(Class<R> resultType);
 
-		/**
-		 * Update the first document in the collection.
-		 *
-		 * @return never {@literal null}.
-		 */
-		UpdateResult first();
-
-		/**
-		 * Creates a new document if no documents match the filter query or updates the matching ones.
-		 *
-		 * @return never {@literal null}.
-		 */
-		UpdateResult upsert();
 	}
 
 	/**

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 the original author or authors.
+ * Copyright 2017-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -35,23 +35,12 @@ import com.mongodb.client.result.UpdateResult;
  * @author Mark Paluch
  * @since 2.0
  */
+@RequiredArgsConstructor
 class ExecutableUpdateOperationSupport implements ExecutableUpdateOperation {
 
 	private static final Query ALL_QUERY = new Query();
 
-	private final MongoTemplate template;
-
-	/**
-	 * Creates new {@link ExecutableUpdateOperationSupport}.
-	 *
-	 * @param template must not be {@literal null}.
-	 */
-	ExecutableUpdateOperationSupport(MongoTemplate template) {
-
-		Assert.notNull(template, "Template must not be null!");
-
-		this.template = template;
-	}
+	private final @NonNull MongoTemplate template;
 
 	/*
 	 * (non-Javadoc)
@@ -62,7 +51,7 @@ class ExecutableUpdateOperationSupport implements ExecutableUpdateOperation {
 
 		Assert.notNull(domainType, "DomainType must not be null!");
 
-		return new ExecutableUpdateSupport<>(template, domainType, ALL_QUERY, null, null, null);
+		return new ExecutableUpdateSupport<>(template, domainType, ALL_QUERY, null, null, null, null, null, domainType);
 	}
 
 	/**
@@ -72,14 +61,18 @@ class ExecutableUpdateOperationSupport implements ExecutableUpdateOperation {
 	@RequiredArgsConstructor
 	@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
 	static class ExecutableUpdateSupport<T>
-			implements ExecutableUpdate<T>, UpdateWithCollection<T>, UpdateWithQuery<T>, TerminatingUpdate<T> {
+			implements ExecutableUpdate<T>, UpdateWithCollection<T>, UpdateWithQuery<T>, TerminatingUpdate<T>,
+			FindAndReplaceWithOptions<T>, TerminatingFindAndReplace<T>, FindAndReplaceWithProjection<T> {
 
 		@NonNull MongoTemplate template;
-		@NonNull Class<T> domainType;
+		@NonNull Class domainType;
 		Query query;
 		@Nullable Update update;
 		@Nullable String collection;
-		@Nullable FindAndModifyOptions options;
+		@Nullable FindAndModifyOptions findAndModifyOptions;
+		@Nullable FindAndReplaceOptions findAndReplaceOptions;
+		@Nullable Object replacement;
+		@NonNull Class<T> targetType;
 
 		/*
 		 * (non-Javadoc)
@@ -90,7 +83,8 @@ class ExecutableUpdateOperationSupport implements ExecutableUpdateOperation {
 
 			Assert.notNull(update, "Update must not be null!");
 
-			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, options);
+			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
+					findAndReplaceOptions, replacement, targetType);
 		}
 
 		/*
@@ -102,7 +96,8 @@ class ExecutableUpdateOperationSupport implements ExecutableUpdateOperation {
 
 			Assert.hasText(collection, "Collection must not be null nor empty!");
 
-			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, options);
+			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
+					findAndReplaceOptions, replacement, targetType);
 		}
 
 		/*
@@ -114,7 +109,34 @@ class ExecutableUpdateOperationSupport implements ExecutableUpdateOperation {
 
 			Assert.notNull(options, "Options must not be null!");
 
-			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, options);
+			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, options,
+					findAndReplaceOptions, replacement, targetType);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableUpdateOperation.UpdateWithUpdate#replaceWith(Object)
+		 */
+		@Override
+		public FindAndReplaceWithProjection<T> replaceWith(T replacement) {
+
+			Assert.notNull(replacement, "Replacement must not be null!");
+
+			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
+					findAndReplaceOptions, replacement, targetType);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableUpdateOperation.FindAndReplaceWithOptions#withOptions(org.springframework.data.mongodb.core.FindAndReplaceOptions)
+		 */
+		@Override
+		public FindAndReplaceWithProjection<T> withOptions(FindAndReplaceOptions options) {
+
+			Assert.notNull(options, "Options must not be null!");
+
+			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
+					options, replacement, targetType);
 		}
 
 		/*
@@ -126,7 +148,21 @@ class ExecutableUpdateOperationSupport implements ExecutableUpdateOperation {
 
 			Assert.notNull(query, "Query must not be null!");
 
-			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, options);
+			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
+					findAndReplaceOptions, replacement, targetType);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveUpdateOperation.FindAndReplaceWithProjection#as(java.lang.Class)
+		 */
+		@Override
+		public <R> FindAndReplaceWithOptions<R> as(Class<R> resultType) {
+
+			Assert.notNull(resultType, "ResultType must not be null!");
+
+			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
+					findAndReplaceOptions, replacement, resultType);
 		}
 
 		/*
@@ -162,7 +198,22 @@ class ExecutableUpdateOperationSupport implements ExecutableUpdateOperation {
 		 */
 		@Override
 		public @Nullable T findAndModifyValue() {
-			return template.findAndModify(query, update, options != null ? options : new FindAndModifyOptions(), domainType, getCollectionName());
+
+			return template.findAndModify(query, update,
+					findAndModifyOptions != null ? findAndModifyOptions : new FindAndModifyOptions(), targetType,
+					getCollectionName());
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableUpdateOperation.TerminatingFindAndReplace#findAndReplaceValue()
+		 */
+		@Override
+		public @Nullable T findAndReplaceValue() {
+
+			return (T) template.findAndReplace(query, replacement,
+					findAndReplaceOptions != null ? findAndReplaceOptions : FindAndReplaceOptions.empty(), domainType,
+					getCollectionName(), targetType);
 		}
 
 		private UpdateResult doUpdate(boolean multi, boolean upsert) {
@@ -170,7 +221,7 @@ class ExecutableUpdateOperationSupport implements ExecutableUpdateOperation {
 		}
 
 		private String getCollectionName() {
-			return StringUtils.hasText(collection) ? collection : template.determineCollectionName(domainType);
+			return StringUtils.hasText(collection) ? collection : template.getCollectionName(domainType);
 		}
 	}
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2017 the original author or authors.
+ * Copyright 2010-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -36,15 +36,17 @@ public class FindAndModifyOptions {
 	/**
 	 * Static factory method to create a FindAndModifyOptions instance
 	 *
-	 * @return a new instance
+	 * @return new instance of {@link FindAndModifyOptions}.
 	 */
 	public static FindAndModifyOptions options() {
 		return new FindAndModifyOptions();
 	}
 
 	/**
-	 * @param options
-	 * @return
+	 * Create new {@link FindAndModifyOptions} based on option of given {@litearl source}.
+	 * 
+	 * @param source can be {@literal null}.
+	 * @return new instance of {@link FindAndModifyOptions}.
 	 * @since 2.0
 	 */
 	public static FindAndModifyOptions of(@Nullable FindAndModifyOptions source) {

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

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+/**
+ * Options for
+ * <a href="https://docs.mongodb.com/manual/reference/method/db.collection.findOneAndReplace/">findOneAndReplace<a/>.
+ * <br />
+ * Defaults to
+ * <dl>
+ * <dt>returnNew</dt>
+ * <dd>false</dd>
+ * <dt>upsert</dt>
+ * <dd>false</dd>
+ * </dl>
+ *
+ * @author Mark Paluch
+ * @author Christoph Strobl
+ * @since 2.1
+ */
+public class FindAndReplaceOptions {
+
+	private boolean returnNew;
+	private boolean upsert;
+
+	/**
+	 * Static factory method to create a {@link FindAndReplaceOptions} instance.
+	 * <dl>
+	 * <dt>returnNew</dt>
+	 * <dd>false</dd>
+	 * <dt>upsert</dt>
+	 * <dd>false</dd>
+	 * </dl>
+	 *
+	 * @return new instance of {@link FindAndReplaceOptions}.
+	 */
+	public static FindAndReplaceOptions options() {
+		return new FindAndReplaceOptions();
+	}
+
+	/**
+	 * Static factory method to create a {@link FindAndReplaceOptions} instance with
+	 * <dl>
+	 * <dt>returnNew</dt>
+	 * <dd>false</dd>
+	 * <dt>upsert</dt>
+	 * <dd>false</dd>
+	 * </dl>
+	 *
+	 * @return new instance of {@link FindAndReplaceOptions}.
+	 */
+	public static FindAndReplaceOptions empty() {
+		return new FindAndReplaceOptions();
+	}
+
+	/**
+	 * Return the replacement document.
+	 *
+	 * @return this.
+	 */
+	public FindAndReplaceOptions returnNew() {
+
+		this.returnNew = true;
+		return this;
+	}
+
+	/**
+	 * Insert a new document if not exists.
+	 *
+	 * @return this.
+	 */
+	public FindAndReplaceOptions upsert() {
+
+		this.upsert = true;
+		return this;
+	}
+
+	/**
+	 * Get the bit indicating to return the replacement document.
+	 *
+	 * @return
+	 */
+	public boolean isReturnNew() {
+		return returnNew;
+	}
+
+	/**
+	 * Get the bit indicating if to create a new document if not exists.
+	 *
+	 * @return
+	 */
+	public boolean isUpsert() {
+		return upsert;
+	}
+
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2017 the original author or authors.
+ * Copyright 2016-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 the original author or authors.
+ * Copyright 2017-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,4 +22,4 @@ package org.springframework.data.mongodb.core;
  * @since 2.0
  */
 public interface FluentMongoOperations extends ExecutableFindOperation, ExecutableInsertOperation,
-		ExecutableUpdateOperation, ExecutableRemoveOperation, ExecutableAggregationOperation {}
+		ExecutableUpdateOperation, ExecutableRemoveOperation, ExecutableAggregationOperation, ExecutableMapReduceOperation {}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2017 the original author or authors.
+ * Copyright 2016-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,7 +20,7 @@ import org.springframework.util.Assert;
 
 /**
  * Value object to mitigate different representations of geo command execution results in MongoDB.
- * 
+ *
  * @author Oliver Gierke
  * @author Christoph Strobl
  * @soundtrack Fruitcake - Jeff Coffin (The Inside of the Outside)
@@ -34,7 +34,7 @@ class GeoCommandStatistics {
 
 	/**
 	 * Creates a new {@link GeoCommandStatistics} instance with the given source document.
-	 * 
+	 *
 	 * @param source must not be {@literal null}.
 	 */
 	private GeoCommandStatistics(Document source) {
@@ -45,7 +45,7 @@ class GeoCommandStatistics {
 
 	/**
 	 * Creates a new {@link GeoCommandStatistics} from the given command result extracting the statistics.
-	 * 
+	 *
 	 * @param commandResult must not be {@literal null}.
 	 * @return
 	 */
@@ -60,7 +60,7 @@ class GeoCommandStatistics {
 	/**
 	 * 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 <a href="https://jira.mongodb.org/browse/SERVER-21024">MongoDB Jira SERVER-21024</a>
 	 */

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2017 the original author or authors.
+ * Copyright 2016-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2018 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+import java.util.Collection;
+import java.util.List;
+
+import org.bson.Document;
+import org.bson.conversions.Bson;
+import org.springframework.data.mongodb.core.query.Update;
+import org.springframework.data.util.StreamUtils;
+
+import com.mongodb.client.model.Filters;
+
+/**
+ * A MongoDB document in its mapped state. I.e. after a source document has been mapped using mapping information of the
+ * entity the source document was supposed to represent.
+ *
+ * @author Oliver Gierke
+ * @since 2.1
+ */
+@RequiredArgsConstructor(staticName = "of")
+public class MappedDocument {
+
+	private static final String ID_FIELD = "_id";
+	private static final Document ID_ONLY_PROJECTION = new Document(ID_FIELD, 1);
+
+	private final @Getter Document document;
+
+	public static Document getIdOnlyProjection() {
+		return ID_ONLY_PROJECTION;
+	}
+
+	public static Document getIdIn(Collection<?> ids) {
+		return new Document(ID_FIELD, new Document("$in", ids));
+	}
+
+	public static List<Object> toIds(Collection<Document> documents) {
+
+		return documents.stream()//
+				.map(it -> it.get(ID_FIELD))//
+				.collect(StreamUtils.toUnmodifiableList());
+	}
+
+	public boolean hasId() {
+		return document.containsKey(ID_FIELD);
+	}
+
+	public boolean hasNonNullId() {
+		return hasId() && document.get(ID_FIELD) != null;
+	}
+
+	public Object getId() {
+		return document.get(ID_FIELD);
+	}
+
+	public <T> T getId(Class<T> type) {
+		return document.get(ID_FIELD, type);
+	}
+
+	public boolean isIdPresent(Class<?> type) {
+		return type.isInstance(getId());
+	}
+
+	public Bson getIdFilter() {
+		return Filters.eq(ID_FIELD, document.get(ID_FIELD));
+	}
+
+	public Update updateWithoutId() {
+		return Update.fromDocument(document, ID_FIELD);
+	}
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2017 the original author or authors.
+ * Copyright 2011-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -29,7 +29,7 @@ import com.mongodb.WriteConcern;
  * <li>REMOVE has null document</li>
  * <li>INSERT_LIST has null entityType, document, and query</li>
  * </ul>
- * 
+ *
  * @author Mark Pollack
  * @author Oliver Gierke
  * @author Christoph Strobl
@@ -46,7 +46,7 @@ public class MongoAction {
 
 	/**
 	 * Create an instance of a {@link MongoAction}.
-	 * 
+	 *
 	 * @param defaultWriteConcern the default write concern. Can be {@literal null}.
 	 * @param mongoActionOperation action being taken against the collection. Must not be {@literal null}.
 	 * @param collectionName the collection name, must not be {@literal null} or empty.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2015 the original author or authors.
+ * Copyright 2011-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,7 +18,7 @@ package org.springframework.data.mongodb.core;
 /**
  * Enumeration for operations on a collection. Used with {@link MongoAction} to help determine the WriteConcern to use
  * for a given mutating operation
- * 
+ *
  * @author Mark Pollack
  * @author Oliver Gierke
  * @see MongoAction

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2017 the original author or authors.
+ * Copyright 2011-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,7 +25,7 @@ import com.mongodb.client.MongoDatabase;
 
 /**
  * Mongo server administration exposed via JMX annotations
- * 
+ *
  * @author Mark Pollack
  * @author Thomas Darimont
  * @author Mark Paluch

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2014 the original author or authors.
+ * Copyright 2011-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2017 the original author or authors.
+ * Copyright 2015-2018 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.