DATAMONGO-2061 - Release version 2.1 GA (Lovelace).

Original Pull Request: #610

.travis.yml

@@ -3,36 +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:
-  - |-
-    mongo admin --eval  "db.adminCommand({setFeatureCompatibilityVersion: '3.4'});"
+    - downloads
 
 script: "mvn clean dependency:list test -P${PROFILE} -Dsort"

README.md

@@ -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.1.0.M1</version>
+	<version>2.1.0.RELEASE</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.1.0.M1</version>
+		<version>2.1.0.RELEASE</version>
 	</parent>
 
 	<modules>
@@ -27,9 +27,9 @@
 	<properties>
 		<project.type>multi</project.type>
 		<dist.id>spring-data-mongodb</dist.id>
-		<springdata.commons>2.1.0.M1</springdata.commons>
-		<mongo>3.6.2</mongo>
-		<mongo.reactivestreams>1.7.0</mongo.reactivestreams>
+		<springdata.commons>2.1.0.RELEASE</springdata.commons>
+		<mongo>3.8.2</mongo>
+		<mongo.reactivestreams>1.9.2</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>
@@ -170,6 +138,24 @@
 			</modules>
 		</profile>
 
+		<profile>
+			<id>distribute</id>
+			<build>
+				<plugins>
+					<plugin>
+						<groupId>org.asciidoctor</groupId>
+						<artifactId>asciidoctor-maven-plugin</artifactId>
+						<configuration>
+							<attributes>
+								<mongo-reactivestreams>${mongo.reactivestreams}</mongo-reactivestreams>
+								<reactor>${reactor}</reactor>
+							</attributes>
+						</configuration>
+					</plugin>
+				</plugins>
+			</build>
+		</profile>
+
 	</profiles>
 
 	<dependencies>
@@ -183,8 +169,8 @@
 
 	<repositories>
 		<repository>
-			<id>spring-libs-milestone</id>
-			<url>https://repo.spring.io/libs-milestone</url>
+			<id>spring-libs-release</id>
+			<url>https://repo.spring.io/libs-release</url>
 		</repository>
 	</repositories>
 

spring-data-mongodb-benchmarks/pom.xml

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

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.1.0.M1</version>
+		<version>2.1.0.RELEASE</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.1.0.M1</version>
+			<version>2.1.0.RELEASE</version>
 		</dependency>
 
 		<!-- reactive -->

spring-data-mongodb-distribution/pom.xml

@@ -13,7 +13,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>2.1.0.M1</version>
+		<version>2.1.0.RELEASE</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.1.0.M1</version>
+		<version>2.1.0.RELEASE</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 
@@ -19,6 +19,7 @@
 		<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>
 
@@ -146,7 +147,7 @@
 			<version>1.0.1</version>
 			<scope>test</scope>
 		</dependency>
-		
+
 		<dependency>
 			<groupId>javax.interceptor</groupId>
 			<artifactId>javax.interceptor-api</artifactId>
@@ -215,7 +216,6 @@
 		<dependency>
 			<groupId>com.fasterxml.jackson.core</groupId>
 			<artifactId>jackson-databind</artifactId>
-			<version>${jackson}</version>
 			<optional>true</optional>
 		</dependency>
 
@@ -253,6 +253,13 @@
 			<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>
@@ -296,7 +303,7 @@
 	</dependencies>
 
 	<build>
-	
+
 		<plugins>
 
 			<plugin>
@@ -348,8 +355,8 @@
 					</properties>
 				</configuration>
 			</plugin>
-			
+
 		</plugins>
-		
+
 	</build>
 </project>

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/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

@@ -20,20 +20,22 @@ 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 extends CodecRegistryProvider {
+public interface MongoDbFactory extends CodecRegistryProvider, MongoSessionProvider {
 
 	/**
-	 * Creates a default {@link DB} instance.
+	 * Creates a default {@link MongoDatabase} instance.
 	 *
 	 * @return
 	 * @throws DataAccessException
@@ -56,6 +58,14 @@ public interface MongoDbFactory extends CodecRegistryProvider {
 	 */
 	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();
 
 	/**
@@ -67,4 +77,35 @@ public interface MongoDbFactory extends CodecRegistryProvider {
 	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,526 @@
+/*
+ * 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.
+ * <p />
+ * By default failure of a {@literal commit} operation raises a {@link TransactionSystemException}. One may override
+ * {@link #doCommit(MongoTransactionObject)} to implement the
+ * <a href="https://docs.mongodb.com/manual/core/transactions/#retry-commit-operation">Retry Commit Operation</a>
+ * behavior as outlined in the MongoDB reference manual.
+ *
+ * @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 final 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 {
+			doCommit(mongoTransactionObject);
+		} catch (Exception ex) {
+
+			throw new TransactionSystemException(String.format("Could not commit Mongo transaction for session %s.",
+					debugString(mongoTransactionObject.getSession())), ex);
+		}
+	}
+
+	/**
+	 * Customization hook to perform an actual commit of the given transaction.<br />
+	 * If a commit operation encounters an error, the MongoDB driver throws a {@link MongoException} holding
+	 * {@literal error labels}. <br />
+	 * By default those labels are ignored, nevertheless one might check for
+	 * {@link MongoException#UNKNOWN_TRANSACTION_COMMIT_RESULT_LABEL transient commit errors labels} and retry the the
+	 * commit. <br />
+	 * <code>
+	 *     <pre>
+	 * int retries = 3;
+	 * do {
+	 *     try {
+	 *         transactionObject.commitTransaction();
+	 *         break;
+	 *     } catch (MongoException ex) {
+	 *         if (!ex.hasErrorLabel(MongoException.UNKNOWN_TRANSACTION_COMMIT_RESULT_LABEL)) {
+	 *             throw ex;
+	 *         }
+	 *     }
+	 *     Thread.sleep(500);
+	 * } while (--retries > 0);
+	 *     </pre>
+	 * </code>
+	 *
+	 * @param transactionObject never {@literal null}.
+	 * @throws Exception in case of transaction errors.
+	 */
+	protected void doCommit(MongoTransactionObject transactionObject) throws Exception {
+		transactionObject.commitTransaction();
+	}
+
+	/*
+	 * (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
+	 */
+	protected 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.
+		 */
+		final 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.
+		 */
+		public void commitTransaction() {
+			getRequiredSession().commitTransaction();
+		}
+
+		/**
+		 * Rollback (abort) the transaction.
+		 */
+		public 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
+		public 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

@@ -16,11 +16,15 @@
 
 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;
 
 /**
@@ -65,4 +69,23 @@ public interface ReactiveMongoDatabaseFactory extends CodecRegistryProvider {
 	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/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

@@ -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

@@ -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/MongoCredentialPropertyEditor.java

@@ -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/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/ChangeStreamEvent.java

@@ -17,8 +17,10 @@ package org.springframework.data.mongodb.core;
 
 import lombok.EqualsAndHashCode;
 
-import java.util.concurrent.atomic.AtomicReference;
+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;
@@ -26,6 +28,7 @@ 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
@@ -38,11 +41,17 @@ import com.mongodb.client.model.changestream.ChangeStreamDocument;
 @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;
-	private final AtomicReference<T> converted = new AtomicReference<>();
+
+	// accessed through CONVERTED_UPDATER.
+	private volatile @Nullable T converted;
 
 	/**
 	 * @param raw can be {@literal null}.
@@ -67,6 +76,56 @@ public class ChangeStreamEvent<T> {
 		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()}.
 	 *
@@ -80,36 +139,48 @@ public class ChangeStreamEvent<T> {
 			return null;
 		}
 
-		if (raw.getFullDocument() == null) {
-			return targetType.cast(raw.getFullDocument());
+		Document fullDocument = raw.getFullDocument();
+
+		if (fullDocument == null) {
+			return targetType.cast(fullDocument);
 		}
 
-		return getConverted();
+		return getConverted(fullDocument);
 	}
 
-	private T getConverted() {
+	@SuppressWarnings("unchecked")
+	private T getConverted(Document fullDocument) {
+		return (T) doGetConverted(fullDocument);
+	}
+
+	private Object doGetConverted(Document fullDocument) {
+
+		Object result = CONVERTED_UPDATER.get(this);
 
-		T result = converted.get();
 		if (result != null) {
 			return result;
 		}
 
-		if (ClassUtils.isAssignable(Document.class, raw.getFullDocument().getClass())) {
+		if (ClassUtils.isAssignable(Document.class, fullDocument.getClass())) {
 
-			result = converter.read(targetType, raw.getFullDocument());
-			return converted.compareAndSet(null, result) ? result : converted.get();
+			result = converter.read(targetType, fullDocument);
+			return CONVERTED_UPDATER.compareAndSet(this, null, result) ? result : CONVERTED_UPDATER.get(this);
 		}
 
-		if (converter.getConversionService().canConvert(raw.getFullDocument().getClass(), targetType)) {
+		if (converter.getConversionService().canConvert(fullDocument.getClass(), targetType)) {
 
-			result = converter.getConversionService().convert(raw.getFullDocument(), targetType);
-			return converted.compareAndSet(null, result) ? result : converted.get();
+			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",
-				raw.getFullDocument().getClass(), targetType));
+				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

@@ -17,6 +17,7 @@ package org.springframework.data.mongodb.core;
 
 import lombok.EqualsAndHashCode;
 
+import java.time.Instant;
 import java.util.Arrays;
 import java.util.Optional;
 
@@ -46,6 +47,7 @@ public class ChangeStreamOptions {
 	private @Nullable BsonValue resumeToken;
 	private @Nullable FullDocument fullDocumentLookup;
 	private @Nullable Collation collation;
+	private @Nullable Instant resumeTimestamp;
 
 	protected ChangeStreamOptions() {}
 
@@ -77,6 +79,13 @@ public class ChangeStreamOptions {
 		return Optional.ofNullable(collation);
 	}
 
+	/**
+	 * @return {@link Optional#empty()} if not set.
+	 */
+	public Optional<Instant> getResumeTimestamp() {
+		return Optional.ofNullable(resumeTimestamp);
+	}
+
 	/**
 	 * @return empty {@link ChangeStreamOptions}.
 	 */
@@ -106,6 +115,7 @@ public class ChangeStreamOptions {
 		private @Nullable BsonValue resumeToken;
 		private @Nullable FullDocument fullDocumentLookup;
 		private @Nullable Collation collation;
+		private @Nullable Instant resumeTimestamp;
 
 		private ChangeStreamOptionsBuilder() {}
 
@@ -200,6 +210,20 @@ public class ChangeStreamOptions {
 			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}
 		 */
@@ -211,6 +235,7 @@ public class ChangeStreamOptions {
 			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/DefaultBulkOperations.java

@@ -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

@@ -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/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/ExecutableAggregationOperationSupport.java

@@ -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/ExecutableFindOperationSupport.java

@@ -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)
@@ -242,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() {

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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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/FluentMongoOperations.java

@@ -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/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/MongoDbFactorySupport.java

@@ -0,0 +1,262 @@
+/*
+ * 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.Value;
+
+import org.springframework.aop.framework.ProxyFactory;
+import org.springframework.dao.DataAccessException;
+import org.springframework.dao.support.PersistenceExceptionTranslator;
+import org.springframework.data.mongodb.MongoDbFactory;
+import org.springframework.data.mongodb.SessionAwareMethodInterceptor;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+
+import com.mongodb.ClientSessionOptions;
+import com.mongodb.DB;
+import com.mongodb.WriteConcern;
+import com.mongodb.client.ClientSession;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.MongoDatabase;
+
+/**
+ * Common base class for usage with both {@link com.mongodb.client.MongoClients} and {@link com.mongodb.MongoClient}
+ * defining common properties such as database name and exception translator.
+ * <p/>
+ * Not intended to be used directly.
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @param <C> Client type.
+ * @since 2.1
+ * @see SimpleMongoDbFactory
+ * @see SimpleMongoClientDbFactory
+ */
+public abstract class MongoDbFactorySupport<C> implements MongoDbFactory {
+
+	private final C mongoClient;
+	private final String databaseName;
+	private final boolean mongoInstanceCreated;
+	private final PersistenceExceptionTranslator exceptionTranslator;
+
+	private @Nullable WriteConcern writeConcern;
+
+	/**
+	 * Create a new {@link MongoDbFactorySupport} object given {@code mongoClient}, {@code databaseName},
+	 * {@code mongoInstanceCreated} and {@link PersistenceExceptionTranslator}.
+	 * 
+	 * @param mongoClient must not be {@literal null}.
+	 * @param databaseName must not be {@literal null} or empty.
+	 * @param mongoInstanceCreated {@literal true} if the client instance was created by a subclass of
+	 *          {@link MongoDbFactorySupport} to close the client on {@link #destroy()}.
+	 * @param exceptionTranslator must not be {@literal null}.
+	 */
+	protected MongoDbFactorySupport(C mongoClient, String databaseName, boolean mongoInstanceCreated,
+			PersistenceExceptionTranslator exceptionTranslator) {
+
+		Assert.notNull(mongoClient, "MongoClient must not be null!");
+		Assert.hasText(databaseName, "Database name must not be empty!");
+		Assert.isTrue(databaseName.matches("[^/\\\\.$\"\\s]+"),
+				"Database name must not contain slashes, dots, spaces, quotes, or dollar signs!");
+
+		this.mongoClient = mongoClient;
+		this.databaseName = databaseName;
+		this.mongoInstanceCreated = mongoInstanceCreated;
+		this.exceptionTranslator = exceptionTranslator;
+	}
+
+	/**
+	 * Configures the {@link WriteConcern} to be used on the {@link MongoDatabase} instance being created.
+	 *
+	 * @param writeConcern the writeConcern to set
+	 */
+	public void setWriteConcern(WriteConcern writeConcern) {
+		this.writeConcern = writeConcern;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.MongoDbFactory#getDb()
+	 */
+	public MongoDatabase getDb() throws DataAccessException {
+		return getDb(databaseName);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.MongoDbFactory#getDb(java.lang.String)
+	 */
+	@Override
+	public MongoDatabase getDb(String dbName) throws DataAccessException {
+
+		Assert.hasText(dbName, "Database name must not be empty!");
+
+		MongoDatabase db = doGetMongoDatabase(dbName);
+
+		if (writeConcern == null) {
+			return db;
+		}
+
+		return db.withWriteConcern(writeConcern);
+	}
+
+	/**
+	 * Get the actual {@link MongoDatabase} from the client.
+	 * 
+	 * @param dbName must not be {@literal null} or empty.
+	 * @return
+	 */
+	protected abstract MongoDatabase doGetMongoDatabase(String dbName);
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.DisposableBean#destroy()
+	 */
+	public void destroy() throws Exception {
+		if (mongoInstanceCreated) {
+			closeClient();
+		}
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.MongoDbFactory#getExceptionTranslator()
+	 */
+	public PersistenceExceptionTranslator getExceptionTranslator() {
+		return this.exceptionTranslator;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.MongoDbFactory#withSession(com.mongodb.session.Session)
+	 */
+	public MongoDbFactory withSession(ClientSession session) {
+		return new MongoDbFactorySupport.ClientSessionBoundMongoDbFactory(session, this);
+	}
+
+	/**
+	 * Close the client instance.
+	 */
+	protected abstract void closeClient();
+
+	/**
+	 * @return the Mongo client object.
+	 */
+	protected C getMongoClient() {
+		return mongoClient;
+	}
+
+	/**
+	 * @return the database name.
+	 */
+	protected String getDefaultDatabaseName() {
+		return databaseName;
+	}
+
+	/**
+	 * {@link ClientSession} bound {@link MongoDbFactory} decorating the database with a
+	 * {@link SessionAwareMethodInterceptor}.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	@Value
+	static class ClientSessionBoundMongoDbFactory implements MongoDbFactory {
+
+		ClientSession session;
+		MongoDbFactory delegate;
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.MongoDbFactory#getDb()
+		 */
+		@Override
+		public MongoDatabase getDb() throws DataAccessException {
+			return proxyMongoDatabase(delegate.getDb());
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.MongoDbFactory#getDb(java.lang.String)
+		 */
+		@Override
+		public MongoDatabase getDb(String dbName) throws DataAccessException {
+			return proxyMongoDatabase(delegate.getDb(dbName));
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.MongoDbFactory#getExceptionTranslator()
+		 */
+		@Override
+		public PersistenceExceptionTranslator getExceptionTranslator() {
+			return delegate.getExceptionTranslator();
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.MongoDbFactory#getLegacyDb()
+		 */
+		@Override
+		public DB getLegacyDb() {
+			return delegate.getLegacyDb();
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.MongoDbFactory#getSession(com.mongodb.ClientSessionOptions)
+		 */
+		@Override
+		public ClientSession getSession(ClientSessionOptions options) {
+			return delegate.getSession(options);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.MongoDbFactory#withSession(com.mongodb.session.ClientSession)
+		 */
+		@Override
+		public MongoDbFactory withSession(ClientSession session) {
+			return delegate.withSession(session);
+		}
+
+		private MongoDatabase proxyMongoDatabase(MongoDatabase database) {
+			return createProxyInstance(session, database, MongoDatabase.class);
+		}
+
+		private MongoDatabase proxyDatabase(com.mongodb.session.ClientSession session, MongoDatabase database) {
+			return createProxyInstance(session, database, MongoDatabase.class);
+		}
+
+		private MongoCollection<?> proxyCollection(com.mongodb.session.ClientSession session, MongoCollection<?> collection) {
+			return createProxyInstance(session, collection, MongoCollection.class);
+		}
+
+		private <T> T createProxyInstance(com.mongodb.session.ClientSession session, T target, Class<T> targetType) {
+
+			ProxyFactory factory = new ProxyFactory();
+			factory.setTarget(target);
+			factory.setInterfaces(targetType);
+			factory.setOpaque(true);
+
+			factory.addAdvice(new SessionAwareMethodInterceptor<>(session, target, ClientSession.class, MongoDatabase.class,
+					this::proxyDatabase, MongoCollection.class, this::proxyCollection));
+
+			return targetType.cast(factory.getProxy());
+		}
+	}
+
+}

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

@@ -16,6 +16,7 @@
 package org.springframework.data.mongodb.core;
 
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.Set;
 
@@ -29,6 +30,8 @@ import org.springframework.dao.InvalidDataAccessResourceUsageException;
 import org.springframework.dao.PermissionDeniedDataAccessException;
 import org.springframework.dao.support.PersistenceExceptionTranslator;
 import org.springframework.data.mongodb.BulkOperationException;
+import org.springframework.data.mongodb.ClientSessionException;
+import org.springframework.data.mongodb.MongoTransactionException;
 import org.springframework.data.mongodb.UncategorizedMongoDbException;
 import org.springframework.data.mongodb.util.MongoDbErrorCodes;
 import org.springframework.lang.Nullable;
@@ -51,17 +54,17 @@ import com.mongodb.bulk.BulkWriteError;
  */
 public class MongoExceptionTranslator implements PersistenceExceptionTranslator {
 
-	private static final Set<String> DULICATE_KEY_EXCEPTIONS = new HashSet<String>(
+	private static final Set<String> DUPLICATE_KEY_EXCEPTIONS = new HashSet<>(
 			Arrays.asList("MongoException.DuplicateKey", "DuplicateKeyException"));
 
-	private static final Set<String> RESOURCE_FAILURE_EXCEPTIONS = new HashSet<String>(
+	private static final Set<String> RESOURCE_FAILURE_EXCEPTIONS = new HashSet<>(
 			Arrays.asList("MongoException.Network", "MongoSocketException", "MongoException.CursorNotFound",
 					"MongoCursorNotFoundException", "MongoServerSelectionException", "MongoTimeoutException"));
 
-	private static final Set<String> RESOURCE_USAGE_EXCEPTIONS = new HashSet<String>(
-			Arrays.asList("MongoInternalException"));
+	private static final Set<String> RESOURCE_USAGE_EXCEPTIONS = new HashSet<>(
+			Collections.singletonList("MongoInternalException"));
 
-	private static final Set<String> DATA_INTEGRETY_EXCEPTIONS = new HashSet<String>(
+	private static final Set<String> DATA_INTEGRITY_EXCEPTIONS = new HashSet<>(
 			Arrays.asList("WriteConcernException", "MongoWriteException", "MongoBulkWriteException"));
 
 	/*
@@ -79,7 +82,7 @@ public class MongoExceptionTranslator implements PersistenceExceptionTranslator
 
 		String exception = ClassUtils.getShortName(ClassUtils.getUserClass(ex.getClass()));
 
-		if (DULICATE_KEY_EXCEPTIONS.contains(exception)) {
+		if (DUPLICATE_KEY_EXCEPTIONS.contains(exception)) {
 			return new DuplicateKeyException(ex.getMessage(), ex);
 		}
 
@@ -91,7 +94,7 @@ public class MongoExceptionTranslator implements PersistenceExceptionTranslator
 			return new InvalidDataAccessResourceUsageException(ex.getMessage(), ex);
 		}
 
-		if (DATA_INTEGRETY_EXCEPTIONS.contains(exception)) {
+		if (DATA_INTEGRITY_EXCEPTIONS.contains(exception)) {
 
 			if (ex instanceof MongoServerException) {
 				if (((MongoServerException) ex).getCode() == 11000) {
@@ -119,18 +122,32 @@ public class MongoExceptionTranslator implements PersistenceExceptionTranslator
 			int code = ((MongoException) ex).getCode();
 
 			if (MongoDbErrorCodes.isDuplicateKeyCode(code)) {
-				throw new DuplicateKeyException(ex.getMessage(), ex);
+				return new DuplicateKeyException(ex.getMessage(), ex);
 			} else if (MongoDbErrorCodes.isDataAccessResourceFailureCode(code)) {
-				throw new DataAccessResourceFailureException(ex.getMessage(), ex);
+				return new DataAccessResourceFailureException(ex.getMessage(), ex);
 			} else if (MongoDbErrorCodes.isInvalidDataAccessApiUsageCode(code) || code == 10003 || code == 12001
 					|| code == 12010 || code == 12011 || code == 12012) {
-				throw new InvalidDataAccessApiUsageException(ex.getMessage(), ex);
+				return new InvalidDataAccessApiUsageException(ex.getMessage(), ex);
 			} else if (MongoDbErrorCodes.isPermissionDeniedCode(code)) {
-				throw new PermissionDeniedDataAccessException(ex.getMessage(), ex);
+				return new PermissionDeniedDataAccessException(ex.getMessage(), ex);
+			} else if (MongoDbErrorCodes.isClientSessionFailureCode(code)) {
+				return new ClientSessionException(ex.getMessage(), ex);
+			} else if (MongoDbErrorCodes.isTransactionFailureCode(code)) {
+				return new MongoTransactionException(ex.getMessage(), ex);
 			}
 			return new UncategorizedMongoDbException(ex.getMessage(), ex);
 		}
 
+		// may interfere with OmitStackTraceInFastThrow (enabled by default).
+		// see https://jira.spring.io/browse/DATAMONGO-1905
+		if (ex instanceof IllegalStateException) {
+			for (StackTraceElement elm : ex.getStackTrace()) {
+				if (elm.getClassName().contains("ClientSession")) {
+					return new ClientSessionException(ex.getMessage(), ex);
+				}
+			}
+		}
+
 		// If we get here, we have an exception that resulted from user code,
 		// rather than the persistence provider, so we return null to indicate
 		// that translation should not occur.

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

@@ -18,6 +18,8 @@ package org.springframework.data.mongodb.core;
 import java.util.Collection;
 import java.util.List;
 import java.util.Set;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
 
 import org.bson.Document;
 import org.springframework.data.geo.GeoResults;
@@ -26,6 +28,7 @@ import org.springframework.data.mongodb.core.aggregation.Aggregation;
 import org.springframework.data.mongodb.core.aggregation.AggregationOptions;
 import org.springframework.data.mongodb.core.aggregation.AggregationResults;
 import org.springframework.data.mongodb.core.aggregation.TypedAggregation;
+import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
 import org.springframework.data.mongodb.core.convert.MongoConverter;
 import org.springframework.data.mongodb.core.index.IndexOperations;
 import org.springframework.data.mongodb.core.mapreduce.GroupBy;
@@ -39,9 +42,13 @@ import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.data.mongodb.core.query.Update;
 import org.springframework.data.util.CloseableIterator;
 import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+import org.springframework.util.ClassUtils;
 
+import com.mongodb.ClientSessionOptions;
 import com.mongodb.Cursor;
 import com.mongodb.ReadPreference;
+import com.mongodb.client.ClientSession;
 import com.mongodb.client.MongoCollection;
 import com.mongodb.client.result.DeleteResult;
 import com.mongodb.client.result.UpdateResult;
@@ -151,6 +158,64 @@ public interface MongoOperations extends FluentMongoOperations {
 	@Nullable
 	<T> T execute(String collectionName, CollectionCallback<T> action);
 
+	/**
+	 * Obtain a {@link ClientSession session} bound instance of {@link SessionScoped} binding a new {@link ClientSession}
+	 * with given {@literal sessionOptions} to each and every command issued against MongoDB.
+	 *
+	 * @param sessionOptions must not be {@literal null}.
+	 * @return new instance of {@link SessionScoped}. Never {@literal null}.
+	 * @since 2.1
+	 */
+	SessionScoped withSession(ClientSessionOptions sessionOptions);
+
+	/**
+	 * Obtain a {@link ClientSession session} bound instance of {@link SessionScoped} binding the {@link ClientSession}
+	 * provided by the given {@link Supplier} to each and every command issued against MongoDB.
+	 * <p />
+	 * <strong>Note:</strong> It is up to the caller to manage the {@link ClientSession} lifecycle. Use the
+	 * {@link SessionScoped#execute(SessionCallback, Consumer)} hook to potentially close the {@link ClientSession}.
+	 *
+	 * @param sessionProvider must not be {@literal null}.
+	 * @since 2.1
+	 */
+	default SessionScoped withSession(Supplier<ClientSession> sessionProvider) {
+
+		Assert.notNull(sessionProvider, "SessionProvider must not be null!");
+
+		return new SessionScoped() {
+
+			private final Object lock = new Object();
+			private @Nullable ClientSession session = null;
+
+			@Override
+			public <T> T execute(SessionCallback<T> action, Consumer<ClientSession> onComplete) {
+
+				synchronized (lock) {
+					if (session == null) {
+						session = sessionProvider.get();
+					}
+				}
+
+				try {
+					return action.doInSession(MongoOperations.this.withSession(session));
+				} finally {
+					onComplete.accept(session);
+				}
+			}
+		};
+	}
+
+	/**
+	 * Obtain a {@link ClientSession} bound instance of {@link MongoOperations}.
+	 * <p />
+	 * <strong>Note:</strong> It is up to the caller to manage the {@link ClientSession} lifecycle.
+	 *
+	 * @param session must not be {@literal null}.
+	 * @return {@link ClientSession} bound instance of {@link MongoOperations}.
+	 * @since 2.1
+	 */
+	MongoOperations withSession(ClientSession session);
+
 	/**
 	 * Executes the given {@link Query} on the entity collection of the specified {@code entityType} backed by a Mongo DB
 	 * {@link Cursor}.
@@ -318,7 +383,7 @@ public interface MongoOperations extends FluentMongoOperations {
 	 * Returns a new {@link BulkOperations} for the given entity type and collection name.
 	 *
 	 * @param mode the {@link BulkMode} to use for bulk operations, must not be {@literal null}.
-	 * @param entityClass the name of the entity class. Can be {@literal null}.
+	 * @param entityType the name of the entity class. Can be {@literal null}.
 	 * @param collectionName the name of the collection to work on, must not be {@literal null} or empty.
 	 * @return {@link BulkOperations} on the named collection associated with the given entity class.
 	 */
@@ -357,8 +422,6 @@ public interface MongoOperations extends FluentMongoOperations {
 	 * Execute a group operation over the entire collection. The group operation entity class should match the 'shape' of
 	 * the returned object that takes int account the initial document structure as well as any finalize functions.
 	 *
-	 * @param criteria The criteria that restricts the row that are considered for grouping. If not specified all rows are
-	 *          considered.
 	 * @param inputCollectionName the collection where the group operation will read from
 	 * @param groupBy the conditions under which the group operation will be performed, e.g. keys, initial document,
 	 *          reduce function.
@@ -769,7 +832,7 @@ public interface MongoOperations extends FluentMongoOperations {
 	}
 
 	/**
-	 * Triggers <a href="https://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify<a/>
+	 * Triggers <a href="https://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify <a/>
 	 * to apply provided {@link Update} on documents matching {@link Criteria} of given {@link Query}.
 	 *
 	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
@@ -782,7 +845,7 @@ public interface MongoOperations extends FluentMongoOperations {
 	<T> T findAndModify(Query query, Update update, Class<T> entityClass);
 
 	/**
-	 * Triggers <a href="https://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify<a/>
+	 * Triggers <a href="https://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify <a/>
 	 * to apply provided {@link Update} on documents matching {@link Criteria} of given {@link Query}.
 	 *
 	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
@@ -796,7 +859,7 @@ public interface MongoOperations extends FluentMongoOperations {
 	<T> T findAndModify(Query query, Update update, Class<T> entityClass, String collectionName);
 
 	/**
-	 * Triggers <a href="https://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify<a/>
+	 * Triggers <a href="https://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify <a/>
 	 * to apply provided {@link Update} on documents matching {@link Criteria} of given {@link Query} taking
 	 * {@link FindAndModifyOptions} into account.
 	 *
@@ -813,7 +876,7 @@ public interface MongoOperations extends FluentMongoOperations {
 	<T> T findAndModify(Query query, Update update, FindAndModifyOptions options, Class<T> entityClass);
 
 	/**
-	 * Triggers <a href="https://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify<a/>
+	 * Triggers <a href="https://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify <a/>
 	 * to apply provided {@link Update} on documents matching {@link Criteria} of given {@link Query} taking
 	 * {@link FindAndModifyOptions} into account.
 	 *
@@ -831,6 +894,167 @@ public interface MongoOperations extends FluentMongoOperations {
 	<T> T findAndModify(Query query, Update update, FindAndModifyOptions options, Class<T> entityClass,
 			String collectionName);
 
+	/**
+	 * Triggers
+	 * <a href="https://docs.mongodb.com/manual/reference/method/db.collection.findOneAndReplace/">findOneAndReplace<a/>
+	 * to replace a single document matching {@link Criteria} of given {@link Query} with the {@code replacement}
+	 * document. <br />
+	 * The collection name is derived from the {@literal replacement} type. <br />
+	 * Options are defaulted to {@link FindAndReplaceOptions#empty()}. <br />
+	 * <strong>NOTE:</strong> The replacement entity must not hold an {@literal id}.
+	 *
+	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
+	 *          fields specification. Must not be {@literal null}.
+	 * @param replacement the replacement document. Must not be {@literal null}.
+	 * @return the converted object that was updated or {@literal null}, if not found.
+	 * @since 2.1
+	 */
+	@Nullable
+	default <T> T findAndReplace(Query query, T replacement) {
+		return findAndReplace(query, replacement, FindAndReplaceOptions.empty());
+	}
+
+	/**
+	 * Triggers
+	 * <a href="https://docs.mongodb.com/manual/reference/method/db.collection.findOneAndReplace/">findOneAndReplace<a/>
+	 * to replace a single document matching {@link Criteria} of given {@link Query} with the {@code replacement}
+	 * document.<br />
+	 * Options are defaulted to {@link FindAndReplaceOptions#empty()}. <br />
+	 * <strong>NOTE:</strong> The replacement entity must not hold an {@literal id}.
+	 *
+	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
+	 *          fields specification. Must not be {@literal null}.
+	 * @param replacement the replacement document. Must not be {@literal null}.
+	 * @param collectionName the collection to query. Must not be {@literal null}.
+	 * @return the converted object that was updated or {@literal null}, if not found.
+	 * @since 2.1
+	 */
+	@Nullable
+	default <T> T findAndReplace(Query query, T replacement, String collectionName) {
+		return findAndReplace(query, replacement, FindAndReplaceOptions.empty(), collectionName);
+	}
+
+	/**
+	 * Triggers
+	 * <a href="https://docs.mongodb.com/manual/reference/method/db.collection.findOneAndReplace/">findOneAndReplace<a/>
+	 * to replace a single document matching {@link Criteria} of given {@link Query} with the {@code replacement} document
+	 * taking {@link FindAndReplaceOptions} into account.<br />
+	 * <strong>NOTE:</strong> The replacement entity must not hold an {@literal id}.
+	 *
+	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
+	 *          fields specification. Must not be {@literal null}.
+	 * @param replacement the replacement document. Must not be {@literal null}.
+	 * @param options the {@link FindAndModifyOptions} holding additional information. Must not be {@literal null}.
+	 * @return the converted object that was updated or {@literal null}, if not found. Depending on the value of
+	 *         {@link FindAndReplaceOptions#isReturnNew()} this will either be the object as it was before the update or
+	 *         as it is after the update.
+	 * @since 2.1
+	 */
+	@Nullable
+	default <T> T findAndReplace(Query query, T replacement, FindAndReplaceOptions options) {
+		return findAndReplace(query, replacement, options, getCollectionName(ClassUtils.getUserClass(replacement)));
+	}
+
+	/**
+	 * Triggers
+	 * <a href="https://docs.mongodb.com/manual/reference/method/db.collection.findOneAndReplace/">findOneAndReplace<a/>
+	 * to replace a single document matching {@link Criteria} of given {@link Query} with the {@code replacement} document
+	 * taking {@link FindAndReplaceOptions} into account.<br />
+	 * <strong>NOTE:</strong> The replacement entity must not hold an {@literal id}.
+	 *
+	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
+	 *          fields specification. Must not be {@literal null}.
+	 * @param replacement the replacement document. Must not be {@literal null}.
+	 * @param options the {@link FindAndModifyOptions} holding additional information. Must not be {@literal null}.
+	 * @return the converted object that was updated or {@literal null}, if not found. Depending on the value of
+	 *         {@link FindAndReplaceOptions#isReturnNew()} this will either be the object as it was before the update or
+	 *         as it is after the update.
+	 * @since 2.1
+	 */
+	@Nullable
+	default <T> T findAndReplace(Query query, T replacement, FindAndReplaceOptions options, String collectionName) {
+
+		Assert.notNull(replacement, "Replacement must not be null!");
+		return findAndReplace(query, replacement, options, (Class<T>) ClassUtils.getUserClass(replacement), collectionName);
+	}
+
+	/**
+	 * Triggers
+	 * <a href="https://docs.mongodb.com/manual/reference/method/db.collection.findOneAndReplace/">findOneAndReplace<a/>
+	 * to replace a single document matching {@link Criteria} of given {@link Query} with the {@code replacement} document
+	 * taking {@link FindAndReplaceOptions} into account.<br />
+	 * <strong>NOTE:</strong> The replacement entity must not hold an {@literal id}.
+	 *
+	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
+	 *          fields specification. Must not be {@literal null}.
+	 * @param replacement the replacement document. Must not be {@literal null}.
+	 * @param options the {@link FindAndModifyOptions} holding additional information. Must not be {@literal null}.
+	 * @param entityType the parametrized type. Must not be {@literal null}.
+	 * @param collectionName the collection to query. Must not be {@literal null}.
+	 * @return the converted object that was updated or {@literal null}, if not found. Depending on the value of
+	 *         {@link FindAndReplaceOptions#isReturnNew()} this will either be the object as it was before the update or
+	 *         as it is after the update.
+	 * @since 2.1
+	 */
+	@Nullable
+	default <T> T findAndReplace(Query query, T replacement, FindAndReplaceOptions options, Class<T> entityType,
+			String collectionName) {
+
+		return findAndReplace(query, replacement, options, entityType, collectionName, entityType);
+	}
+
+	/**
+	 * Triggers
+	 * <a href="https://docs.mongodb.com/manual/reference/method/db.collection.findOneAndReplace/">findOneAndReplace<a/>
+	 * to replace a single document matching {@link Criteria} of given {@link Query} with the {@code replacement} document
+	 * taking {@link FindAndReplaceOptions} into account.<br />
+	 * <strong>NOTE:</strong> The replacement entity must not hold an {@literal id}.
+	 *
+	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
+	 *          fields specification. Must not be {@literal null}.
+	 * @param replacement the replacement document. Must not be {@literal null}.
+	 * @param options the {@link FindAndModifyOptions} holding additional information. Must not be {@literal null}.
+	 * @param entityType the type used for mapping the {@link Query} to domain type fields and deriving the collection
+	 *          from. Must not be {@literal null}.
+	 * @param resultType the parametrized type projection return type. Must not be {@literal null}, use the domain type of
+	 *          {@code Object.class} instead.
+	 * @return the converted object that was updated or {@literal null}, if not found. Depending on the value of
+	 *         {@link FindAndReplaceOptions#isReturnNew()} this will either be the object as it was before the update or
+	 *         as it is after the update.
+	 * @since 2.1
+	 */
+	@Nullable
+	default <S, T> T findAndReplace(Query query, S replacement, FindAndReplaceOptions options, Class<S> entityType,
+			Class<T> resultType) {
+
+		return findAndReplace(query, replacement, options, entityType,
+				getCollectionName(ClassUtils.getUserClass(entityType)), resultType);
+	}
+
+	/**
+	 * Triggers
+	 * <a href="https://docs.mongodb.com/manual/reference/method/db.collection.findOneAndReplace/">findOneAndReplace<a/>
+	 * to replace a single document matching {@link Criteria} of given {@link Query} with the {@code replacement} document
+	 * taking {@link FindAndReplaceOptions} into account.<br />
+	 * <strong>NOTE:</strong> The replacement entity must not hold an {@literal id}.
+	 *
+	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
+	 *          fields specification. Must not be {@literal null}.
+	 * @param replacement the replacement document. Must not be {@literal null}.
+	 * @param options the {@link FindAndModifyOptions} holding additional information. Must not be {@literal null}.
+	 * @param entityType the type used for mapping the {@link Query} to domain type fields. Must not be {@literal null}.
+	 * @param collectionName the collection to query. Must not be {@literal null}.
+	 * @param resultType the parametrized type projection return type. Must not be {@literal null}, use the domain type of
+	 *          {@code Object.class} instead.
+	 * @return the converted object that was updated or {@literal null}, if not found. Depending on the value of
+	 *         {@link FindAndReplaceOptions#isReturnNew()} this will either be the object as it was before the update or
+	 *         as it is after the update.
+	 * @since 2.1
+	 */
+	@Nullable
+	<S, T> T findAndReplace(Query query, S replacement, FindAndReplaceOptions options, Class<S> entityType,
+			String collectionName, Class<T> resultType);
+
 	/**
 	 * Map the results of an ad-hoc query on the collection for the entity type to a single instance of an object of the
 	 * specified type. The first document that matches the query is returned and also removed from the collection in the
@@ -917,8 +1141,9 @@ public interface MongoOperations extends FluentMongoOperations {
 	 * Insert is used to initially store the object into the database. To update an existing object use the save method.
 	 *
 	 * @param objectToSave the object to store in the collection. Must not be {@literal null}.
+	 * @return the inserted object.
 	 */
-	void insert(Object objectToSave);
+	<T> T insert(T objectToSave);
 
 	/**
 	 * Insert the object into the specified collection.
@@ -930,32 +1155,36 @@ public interface MongoOperations extends FluentMongoOperations {
 	 *
 	 * @param objectToSave the object to store in the collection. Must not be {@literal null}.
 	 * @param collectionName name of the collection to store the object in. Must not be {@literal null}.
+	 * @return the inserted object.
 	 */
-	void insert(Object objectToSave, String collectionName);
+	<T> T insert(T objectToSave, String collectionName);
 
 	/**
 	 * Insert a Collection of objects into a collection in a single batch write to the database.
 	 *
 	 * @param batchToSave the batch of objects to save. Must not be {@literal null}.
 	 * @param entityClass class that determines the collection to use. Must not be {@literal null}.
+	 * @return the inserted objects that.
 	 */
-	void insert(Collection<? extends Object> batchToSave, Class<?> entityClass);
+	<T> Collection<T> insert(Collection<? extends T> batchToSave, Class<?> entityClass);
 
 	/**
 	 * Insert a batch of objects into the specified collection in a single batch write to the database.
 	 *
 	 * @param batchToSave the list of objects to save. Must not be {@literal null}.
 	 * @param collectionName name of the collection to store the object in. Must not be {@literal null}.
+	 * @return the inserted objects that.
 	 */
-	void insert(Collection<? extends Object> batchToSave, String collectionName);
+	<T> Collection<T> insert(Collection<? extends T> batchToSave, String collectionName);
 
 	/**
 	 * Insert a mixed Collection of objects into a database collection determining the collection name to use based on the
 	 * class.
 	 *
-	 * @param collectionToSave the list of objects to save. Must not be {@literal null}.
+	 * @param objectsToSave the list of objects to save. Must not be {@literal null}.
+	 * @return the inserted objects.
 	 */
-	void insertAll(Collection<? extends Object> objectsToSave);
+	<T> Collection<T> insertAll(Collection<? extends T> objectsToSave);
 
 	/**
 	 * Save the object to the collection for the entity type of the object to save. This will perform an insert if the
@@ -971,8 +1200,9 @@ public interface MongoOperations extends FluentMongoOperations {
 	 * Conversion"</a> for more details.
 	 *
 	 * @param objectToSave the object to store in the collection. Must not be {@literal null}.
+	 * @return the saved object.
 	 */
-	void save(Object objectToSave);
+	<T> T save(T objectToSave);
 
 	/**
 	 * Save the object to the specified collection. This will perform an insert if the object is not already present, that
@@ -989,8 +1219,9 @@ public interface MongoOperations extends FluentMongoOperations {
 	 *
 	 * @param objectToSave the object to store in the collection. Must not be {@literal null}.
 	 * @param collectionName name of the collection to store the object in. Must not be {@literal null}.
+	 * @return the saved object.
 	 */
-	void save(Object objectToSave, String collectionName);
+	<T> T save(T objectToSave, String collectionName);
 
 	/**
 	 * Performs an upsert. If no document is found that matches the query, a new document is created and inserted by
@@ -1142,6 +1373,7 @@ public interface MongoOperations extends FluentMongoOperations {
 	 * @param query the query document that specifies the criteria used to remove a record.
 	 * @param entityClass class that determines the collection to use.
 	 * @return the {@link DeleteResult} which lets you access the results of the previous delete.
+	 * @throws IllegalArgumentException when {@literal query} or {@literal entityClass} is {@literal null}.
 	 */
 	DeleteResult remove(Query query, Class<?> entityClass);
 
@@ -1153,6 +1385,8 @@ public interface MongoOperations extends FluentMongoOperations {
 	 * @param entityClass class of the pojo to be operated on. Can be {@literal null}.
 	 * @param collectionName name of the collection where the objects will removed, must not be {@literal null} or empty.
 	 * @return the {@link DeleteResult} which lets you access the results of the previous delete.
+	 * @throws IllegalArgumentException when {@literal query}, {@literal entityClass} or {@literal collectionName} is
+	 *           {@literal null}.
 	 */
 	DeleteResult remove(Query query, Class<?> entityClass, String collectionName);
 
@@ -1165,6 +1399,7 @@ public interface MongoOperations extends FluentMongoOperations {
 	 * @param query the query document that specifies the criteria used to remove a record.
 	 * @param collectionName name of the collection where the objects will removed, must not be {@literal null} or empty.
 	 * @return the {@link DeleteResult} which lets you access the results of the previous delete.
+	 * @throws IllegalArgumentException when {@literal query} or {@literal collectionName} is {@literal null}.
 	 */
 	DeleteResult remove(Query query, String collectionName);
 

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

@@ -0,0 +1,75 @@
+/*
+ * 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.RequiredArgsConstructor;
+
+import org.bson.Document;
+import org.springframework.data.mapping.SimplePropertyHandler;
+import org.springframework.data.mapping.context.MappingContext;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
+import org.springframework.data.projection.ProjectionFactory;
+import org.springframework.data.projection.ProjectionInformation;
+import org.springframework.util.ClassUtils;
+
+/**
+ * Common operations performed on properties of an entity like extracting fields information for projection creation.
+ *
+ * @author Christoph Strobl
+ * @since 2.1
+ */
+@RequiredArgsConstructor(access = AccessLevel.PACKAGE)
+class PropertyOperations {
+
+	private final MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext;
+
+	/**
+	 * For cases where {@code fields} is {@link Document#isEmpty() empty} include only fields that are required for
+	 * creating the projection (target) type if the {@code targetType} is a {@literal DTO projection} or a
+	 * {@literal closed interface projection}.
+	 *
+	 * @param projectionFactory must not be {@literal null}.
+	 * @param fields must not be {@literal null}.
+	 * @param domainType must not be {@literal null}.
+	 * @param targetType must not be {@literal null}.
+	 * @return {@link Document} with fields to be included.
+	 */
+	Document computeFieldsForProjection(ProjectionFactory projectionFactory, Document fields, Class<?> domainType,
+			Class<?> targetType) {
+
+		if (!fields.isEmpty() || ClassUtils.isAssignable(domainType, targetType)) {
+			return fields;
+		}
+
+		Document projectedFields = new Document();
+
+		if (targetType.isInterface()) {
+
+			ProjectionInformation projectionInformation = projectionFactory.getProjectionInformation(targetType);
+
+			if (projectionInformation.isClosed()) {
+				projectionInformation.getInputProperties().forEach(it -> projectedFields.append(it.getName(), 1));
+			}
+		} else {
+			mappingContext.getRequiredPersistentEntity(targetType).doWithProperties(
+					(SimplePropertyHandler) persistentProperty -> projectedFields.append(persistentProperty.getName(), 1));
+		}
+
+		return projectedFields;
+	}
+}

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

@@ -30,5 +30,4 @@ import com.mongodb.reactivestreams.client.MongoCollection;
 public interface ReactiveCollectionCallback<T> {
 
 	Publisher<T> doInCollection(MongoCollection<Document> collection) throws MongoException, DataAccessException;
-
 }

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

@@ -85,6 +85,23 @@ public interface ReactiveFindOperation {
 		 */
 		Flux<T> all();
 
+		/**
+		 * Get all matching elements using a {@link com.mongodb.CursorType#TailableAwait tailable cursor}. The stream will
+		 * not be completed unless the {@link org.reactivestreams.Subscription} is
+		 * {@link org.reactivestreams.Subscription#cancel() canceled}.
+		 * <p />
+		 * However, the stream may become dead, or invalid, if either the query returns no match or the cursor returns the
+		 * document at the "end" of the collection and then the application deletes that document.
+		 * <p />
+		 * A stream that is no longer in use must be {@link reactor.core.Disposable#dispose()} disposed} otherwise the
+		 * streams will linger and exhaust resources. <br/>
+		 * <strong>NOTE:</strong> Requires a capped collection.
+		 *
+		 * @return the {@link Flux} emitting converted objects.
+		 * @since 2.1
+		 */
+		Flux<T> tail();
+
 		/**
 		 * Get the number of matching elements.
 		 *

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

@@ -169,6 +169,15 @@ class ReactiveFindOperationSupport implements ReactiveFindOperation {
 			return doFind(null);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.TerminatingFind#tail()
+		 */
+		@Override
+		public Flux<T> tail() {
+			return doFind(template.new TailingQueryFindPublisherPreparer(query, domainType));
+		}
+
 		/*
 		 * (non-Javadoc)
 		 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.FindWithQuery#near(org.springframework.data.mongodb.core.query.NearQuery)

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

@@ -19,7 +19,8 @@ package org.springframework.data.mongodb.core;
  * Stripped down interface providing access to a fluent API that specifies a basic set of reactive MongoDB operations.
  *
  * @author Mark Paluch
+ * @author Christoph Strobl
  * @since 2.0
  */
 public interface ReactiveFluentMongoOperations extends ReactiveFindOperation, ReactiveInsertOperation,
-		ReactiveUpdateOperation, ReactiveRemoveOperation, ReactiveAggregationOperation {}
+		ReactiveUpdateOperation, ReactiveRemoveOperation, ReactiveAggregationOperation, ReactiveMapReduceOperation {}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveMapReduceOperation.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 reactor.core.publisher.Flux;
+
+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 ReactiveMapReduceOperation} 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 ReactiveMapReduceOperation {
+
+	/**
+	 * 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 {@link Flux} emitting mapReduce results.
+		 *
+		 * @return a {@link Flux} emitting the already mapped operation results.
+		 */
+		Flux<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 ReactiveMapReduce}.
+		 * @throws IllegalArgumentException if {@literal reduceFunction} is {@literal null} or empty.
+		 */
+		ReactiveMapReduce<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 ReactiveMapReduce}.
+		 * @throws IllegalArgumentException if options is {@literal null}.
+		 */
+		ReactiveMapReduce<T> with(MapReduceOptions options);
+	}
+
+	/**
+	 * {@link ReactiveMapReduce} provides methods for constructing reactive mapReduce operations in a fluent way.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	interface ReactiveMapReduce<T> extends MapReduceWithMapFunction<T>, MapReduceWithReduceFunction<T>,
+			MapReduceWithCollection<T>, MapReduceWithProjection<T>, MapReduceWithOptions<T> {
+
+	}
+}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveMapReduceOperationSupport.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 reactor.core.publisher.Flux;
+
+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 ReactiveMapReduceOperation}.
+ *
+ * @author Christoph Strobl
+ * @since 2.1
+ */
+@RequiredArgsConstructor
+class ReactiveMapReduceOperationSupport implements ReactiveMapReduceOperation {
+
+	private static final Query ALL_QUERY = new Query();
+
+	private final @NonNull ReactiveMongoTemplate template;
+
+	/*
+	 * (non-Javascript)
+	 * @see in org.springframework.data.mongodb.core.ExecutableMapReduceOperation#mapReduce(java.lang.Class)
+	 */
+	@Override
+	public <T> ReactiveMapReduceSupport<T> mapReduce(Class<T> domainType) {
+
+		Assert.notNull(domainType, "DomainType must not be null!");
+
+		return new ReactiveMapReduceSupport<>(template, domainType, domainType, null, ALL_QUERY, null, null, null);
+	}
+
+	/**
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	static class ReactiveMapReduceSupport<T>
+			implements ReactiveMapReduce<T>, MapReduceWithOptions<T>, MapReduceWithCollection<T>, MapReduceWithProjection<T>,
+			MapReduceWithQuery<T>, MapReduceWithReduceFunction<T>, MapReduceWithMapFunction<T> {
+
+		private final ReactiveMongoTemplate 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;
+
+		ReactiveMapReduceSupport(ReactiveMongoTemplate 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 Flux<T> all() {
+
+			return template.mapReduce(query, domainType, getCollectionName(), returnType, mapFunction, reduceFunction,
+					options);
+		}
+
+		/*
+		 * (non-Javascript)
+		 * @see in org.springframework.data.mongodb.core.ReactiveMapReduceOperation.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 ReactiveMapReduceSupport<>(template, domainType, returnType, collection, query, mapFunction,
+					reduceFunction, options);
+		}
+
+		/*
+		 * (non-Javascript)
+		 * @see in org.springframework.data.mongodb.core.ReactiveMapReduceOperation.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 ReactiveMapReduceSupport<>(template, domainType, returnType, collection, query, mapFunction,
+					reduceFunction, options);
+		}
+
+		/*
+		 * (non-Javascript)
+		 * @see in org.springframework.data.mongodb.core.ReactiveMapReduceOperation.MapReduceWithProjection#as(java.lang.Class)
+		 */
+		@Override
+		public <R> MapReduceWithQuery<R> as(Class<R> resultType) {
+
+			Assert.notNull(resultType, "ResultType must not be null!");
+
+			return new ReactiveMapReduceSupport<>(template, domainType, resultType, collection, query, mapFunction,
+					reduceFunction, options);
+		}
+
+		/*
+		 * (non-Javascript)
+		 * @see in org.springframework.data.mongodb.core.ReactiveMapReduceOperation.MapReduceWithOptions#with(org.springframework.data.mongodb.core.mapreduce.MapReduceOptions)
+		 */
+		@Override
+		public ReactiveMapReduce<T> with(MapReduceOptions options) {
+
+			Assert.notNull(options, "Options must not be null! Please consider empty MapReduceOptions#options() instead.");
+
+			return new ReactiveMapReduceSupport<>(template, domainType, returnType, collection, query, mapFunction,
+					reduceFunction, options);
+		}
+
+		/*
+		 * (non-Javascript)
+		 * @see in org.springframework.data.mongodb.core.ReactiveMapReduceOperation.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 ReactiveMapReduceSupport<>(template, domainType, returnType, collection, query, mapFunction,
+					reduceFunction, options);
+		}
+
+		/*
+		 * (non-Javascript)
+		 * @see in org.springframework.data.mongodb.core.ReactiveMapReduceOperation.MapReduceWithReduceFunction#reduce(java.lang.String)
+		 */
+		@Override
+		public ReactiveMapReduce<T> reduce(String reduceFunction) {
+
+			Assert.hasText(reduceFunction, "ReduceFunction name must not be null nor empty!");
+
+			return new ReactiveMapReduceSupport<>(template, domainType, returnType, collection, query, mapFunction,
+					reduceFunction, options);
+		}
+
+		private String getCollectionName() {
+			return StringUtils.hasText(collection) ? collection : template.determineCollectionName(domainType);
+		}
+	}
+}

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

@@ -0,0 +1,68 @@
+/*
+ * 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 org.reactivestreams.Publisher;
+import org.springframework.util.Assert;
+import reactor.core.publisher.Mono;
+import reactor.util.context.Context;
+
+import com.mongodb.reactivestreams.client.ClientSession;
+
+/**
+ * {@link ReactiveMongoContext} utilizes and enriches the Reactor {@link Context} with information potentially required
+ * for e.g. {@link ClientSession} handling and transactions.
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @since 2.1
+ * @see Mono#subscriberContext()
+ * @see Context
+ */
+public class ReactiveMongoContext {
+
+	private static final Class<?> SESSION_KEY = ClientSession.class;
+
+	/**
+	 * Gets the {@code Mono<ClientSession>} from Reactor {@link reactor.util.context.Context}. The resulting {@link Mono}
+	 * emits the {@link ClientSession} if a session is associated with the current {@link reactor.util.context.Context
+	 * subscriber context}. If the context does not contain a session, the resulting {@link Mono} terminates empty (i.e.
+	 * without emitting a value).
+	 *
+	 * @return the {@link Mono} emitting the client session if present; otherwise the {@link Mono} terminates empty.
+	 */
+	public static Mono<ClientSession> getSession() {
+
+		return Mono.subscriberContext().filter(ctx -> ctx.hasKey(SESSION_KEY))
+				.flatMap(ctx -> ctx.<Mono<ClientSession>> get(SESSION_KEY));
+	}
+
+	/**
+	 * Sets the {@link ClientSession} into the Reactor {@link reactor.util.context.Context}.
+	 *
+	 * @param context must not be {@literal null}.
+	 * @param session must not be {@literal null}.
+	 * @return a new {@link Context}.
+	 * @see Context#put(Object, Object)
+	 */
+	public static Context setSession(Context context, Publisher<ClientSession> session) {
+
+		Assert.notNull(context, "Context must not be null!");
+		Assert.notNull(session, "Session publisher must not be null!");
+
+		return context.put(SESSION_KEY, Mono.from(session));
+	}
+}

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

@@ -19,28 +19,35 @@ import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
 import java.util.Collection;
-import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
 
 import org.bson.Document;
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscription;
 import org.springframework.data.geo.GeoResult;
+import org.springframework.data.mongodb.ReactiveMongoDatabaseFactory;
 import org.springframework.data.mongodb.core.aggregation.Aggregation;
 import org.springframework.data.mongodb.core.aggregation.AggregationOptions;
 import org.springframework.data.mongodb.core.aggregation.TypedAggregation;
 import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
 import org.springframework.data.mongodb.core.convert.MongoConverter;
 import org.springframework.data.mongodb.core.index.ReactiveIndexOperations;
+import org.springframework.data.mongodb.core.mapreduce.MapReduceOptions;
 import org.springframework.data.mongodb.core.query.BasicQuery;
 import org.springframework.data.mongodb.core.query.Criteria;
 import org.springframework.data.mongodb.core.query.NearQuery;
 import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.data.mongodb.core.query.Update;
 import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+import org.springframework.util.ClassUtils;
 
+import com.mongodb.ClientSessionOptions;
 import com.mongodb.ReadPreference;
 import com.mongodb.client.result.DeleteResult;
 import com.mongodb.client.result.UpdateResult;
+import com.mongodb.reactivestreams.client.ClientSession;
 import com.mongodb.reactivestreams.client.MongoCollection;
 
 /**
@@ -141,6 +148,92 @@ public interface ReactiveMongoOperations extends ReactiveFluentMongoOperations {
 	 */
 	<T> Flux<T> execute(String collectionName, ReactiveCollectionCallback<T> action);
 
+	/**
+	 * Obtain a {@link ClientSession session} bound instance of {@link SessionScoped} binding the {@link ClientSession}
+	 * provided by the given {@link Supplier} to each and every command issued against MongoDB.
+	 * <p />
+	 * <strong>Note:</strong> It is up to the caller to manage the {@link ClientSession} lifecycle. Use
+	 * {@link ReactiveSessionScoped#execute(ReactiveSessionCallback, Consumer)} to provide a hook for processing the
+	 * {@link ClientSession} when done.
+	 *
+	 * @param sessionProvider must not be {@literal null}.
+	 * @return new instance of {@link ReactiveSessionScoped}. Never {@literal null}.
+	 * @since 2.1
+	 */
+	default ReactiveSessionScoped withSession(Supplier<ClientSession> sessionProvider) {
+
+		Assert.notNull(sessionProvider, "SessionProvider must not be null!");
+
+		return withSession(Mono.fromSupplier(sessionProvider));
+	}
+
+	/**
+	 * Obtain a {@link ClientSession session} bound instance of {@link SessionScoped} binding a new {@link ClientSession}
+	 * with given {@literal sessionOptions} to each and every command issued against MongoDB.
+	 * <p />
+	 * <strong>Note:</strong> It is up to the caller to manage the {@link ClientSession} lifecycle. Use
+	 * {@link ReactiveSessionScoped#execute(ReactiveSessionCallback, Consumer)} to provide a hook for processing the
+	 * {@link ClientSession} when done.
+	 *
+	 * @param sessionOptions must not be {@literal null}.
+	 * @return new instance of {@link ReactiveSessionScoped}. Never {@literal null}.
+	 * @since 2.1
+	 */
+	ReactiveSessionScoped withSession(ClientSessionOptions sessionOptions);
+
+	/**
+	 * Obtain a {@link ClientSession session} bound instance of {@link ReactiveSessionScoped} binding the
+	 * {@link ClientSession} provided by the given {@link Publisher} to each and every command issued against MongoDB.
+	 * <p />
+	 * <strong>Note:</strong> It is up to the caller to manage the {@link ClientSession} lifecycle. Use
+	 * {@link ReactiveSessionScoped#execute(ReactiveSessionCallback, Consumer)} to provide a hook for processing the
+	 * {@link ClientSession} when done.
+	 *
+	 * @param sessionProvider must not be {@literal null}.
+	 * @return new instance of {@link ReactiveSessionScoped}. Never {@literal null}.
+	 * @since 2.1
+	 */
+	ReactiveSessionScoped withSession(Publisher<ClientSession> sessionProvider);
+
+	/**
+	 * Obtain a {@link ClientSession} bound instance of {@link ReactiveMongoOperations}.
+	 * <p />
+	 * <strong>Note:</strong> It is up to the caller to manage the {@link ClientSession} lifecycle.
+	 *
+	 * @param session must not be {@literal null}.
+	 * @return {@link ClientSession} bound instance of {@link ReactiveMongoOperations}.
+	 * @since 2.1
+	 */
+	ReactiveMongoOperations withSession(ClientSession session);
+
+	/**
+	 * Initiate a new {@link ClientSession} and obtain a {@link ClientSession session} bound instance of
+	 * {@link ReactiveSessionScoped}. Starts the transaction and adds the {@link ClientSession} to each and every command
+	 * issued against MongoDB.
+	 * <p/>
+	 * Each {@link ReactiveSessionScoped#execute(ReactiveSessionCallback) execution} initiates a new managed transaction
+	 * that is {@link ClientSession#commitTransaction() committed} on success. Transactions are
+	 * {@link ClientSession#abortTransaction() rolled back} upon errors.
+	 *
+	 * @return new instance of {@link ReactiveSessionScoped}. Never {@literal null}.
+	 */
+	ReactiveSessionScoped inTransaction();
+
+	/**
+	 * Obtain a {@link ClientSession session} bound instance of {@link ReactiveSessionScoped}, start the transaction and
+	 * bind the {@link ClientSession} provided by the given {@link Publisher} to each and every command issued against
+	 * MongoDB.
+	 * <p/>
+	 * Each {@link ReactiveSessionScoped#execute(ReactiveSessionCallback) execution} initiates a new managed transaction
+	 * that is {@link ClientSession#commitTransaction() committed} on success. Transactions are
+	 * {@link ClientSession#abortTransaction() rolled back} upon errors.
+	 *
+	 * @param sessionProvider must not be {@literal null}.
+	 * @return new instance of {@link ReactiveSessionScoped}. Never {@literal null}.
+	 * @since 2.1
+	 */
+	ReactiveSessionScoped inTransaction(Publisher<ClientSession> sessionProvider);
+
 	/**
 	 * Create an uncapped collection with a name based on the provided entity class.
 	 *
@@ -596,6 +689,160 @@ public interface ReactiveMongoOperations extends ReactiveFluentMongoOperations {
 	<T> Mono<T> findAndModify(Query query, Update update, FindAndModifyOptions options, Class<T> entityClass,
 			String collectionName);
 
+	/**
+	 * Triggers
+	 * <a href="https://docs.mongodb.com/manual/reference/method/db.collection.findOneAndReplace/">findOneAndReplace<a/>
+	 * to replace a single document matching {@link Criteria} of given {@link Query} with the {@code replacement}
+	 * document. <br />
+	 * Options are defaulted to {@link FindAndReplaceOptions#empty()}. <br />
+	 * <strong>NOTE:</strong> The replacement entity must not hold an {@literal id}.
+	 *
+	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
+	 *          fields specification. Must not be {@literal null}.
+	 * @param replacement the replacement document. Must not be {@literal null}.
+	 * @return the converted object that was updated or {@link Mono#empty()}, if not found.
+	 * @since 2.1
+	 */
+	default <T> Mono<T> findAndReplace(Query query, T replacement) {
+		return findAndReplace(query, replacement, FindAndReplaceOptions.empty());
+	}
+
+	/**
+	 * Triggers
+	 * <a href="https://docs.mongodb.com/manual/reference/method/db.collection.findOneAndReplace/">findOneAndReplace<a/>
+	 * to replace a single document matching {@link Criteria} of given {@link Query} with the {@code replacement}
+	 * document. <br />
+	 * Options are defaulted to {@link FindAndReplaceOptions#empty()}. <br />
+	 * <strong>NOTE:</strong> The replacement entity must not hold an {@literal id}.
+	 *
+	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
+	 *          fields specification. Must not be {@literal null}.
+	 * @param replacement the replacement document. Must not be {@literal null}.
+	 * @param collectionName the collection to query. Must not be {@literal null}.
+	 * @return the converted object that was updated or {@link Mono#empty()}, if not found.
+	 * @since 2.1
+	 */
+	default <T> Mono<T> findAndReplace(Query query, T replacement, String collectionName) {
+		return findAndReplace(query, replacement, FindAndReplaceOptions.empty(), collectionName);
+	}
+
+	/**
+	 * Triggers
+	 * <a href="https://docs.mongodb.com/manual/reference/method/db.collection.findOneAndReplace/">findOneAndReplace<a/>
+	 * to replace a single document matching {@link Criteria} of given {@link Query} with the {@code replacement} document
+	 * taking {@link FindAndReplaceOptions} into account. <br />
+	 * <strong>NOTE:</strong> The replacement entity must not hold an {@literal id}.
+	 *
+	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
+	 *          fields specification. Must not be {@literal null}.
+	 * @param replacement the replacement document. Must not be {@literal null}.
+	 * @param options the {@link FindAndModifyOptions} holding additional information. Must not be {@literal null}.
+	 * @return the converted object that was updated or {@link Mono#empty()}, if not found. Depending on the value of
+	 *         {@link FindAndReplaceOptions#isReturnNew()} this will either be the object as it was before the update or
+	 *         as it is after the update.
+	 * @since 2.1
+	 */
+	default <T> Mono<T> findAndReplace(Query query, T replacement, FindAndReplaceOptions options) {
+		return findAndReplace(query, replacement, options, getCollectionName(ClassUtils.getUserClass(replacement)));
+	}
+
+	/**
+	 * Triggers
+	 * <a href="https://docs.mongodb.com/manual/reference/method/db.collection.findOneAndReplace/">findOneAndReplace<a/>
+	 * to replace a single document matching {@link Criteria} of given {@link Query} with the {@code replacement} document
+	 * taking {@link FindAndReplaceOptions} into account. <br />
+	 * <strong>NOTE:</strong> The replacement entity must not hold an {@literal id}.
+	 *
+	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
+	 *          fields specification. Must not be {@literal null}.
+	 * @param replacement the replacement document. Must not be {@literal null}.
+	 * @param options the {@link FindAndModifyOptions} holding additional information. Must not be {@literal null}.
+	 * @return the converted object that was updated or {@link Mono#empty()}, if not found. Depending on the value of
+	 *         {@link FindAndReplaceOptions#isReturnNew()} this will either be the object as it was before the update or
+	 *         as it is after the update.
+	 * @since 2.1
+	 */
+	default <T> Mono<T> findAndReplace(Query query, T replacement, FindAndReplaceOptions options, String collectionName) {
+
+		Assert.notNull(replacement, "Replacement must not be null!");
+		return findAndReplace(query, replacement, options, (Class<T>) ClassUtils.getUserClass(replacement), collectionName);
+	}
+
+	/**
+	 * Triggers
+	 * <a href="https://docs.mongodb.com/manual/reference/method/db.collection.findOneAndReplace/">findOneAndReplace<a/>
+	 * to replace a single document matching {@link Criteria} of given {@link Query} with the {@code replacement} document
+	 * taking {@link FindAndReplaceOptions} into account. <br />
+	 * <strong>NOTE:</strong> The replacement entity must not hold an {@literal id}.
+	 *
+	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
+	 *          fields specification. Must not be {@literal null}.
+	 * @param replacement the replacement document. Must not be {@literal null}.
+	 * @param options the {@link FindAndModifyOptions} holding additional information. Must not be {@literal null}.
+	 * @param entityType the parametrized type. Must not be {@literal null}.
+	 * @param collectionName the collection to query. Must not be {@literal null}.
+	 * @return the converted object that was updated or {@link Mono#empty()}, if not found. Depending on the value of
+	 *         {@link FindAndReplaceOptions#isReturnNew()} this will either be the object as it was before the update or
+	 *         as it is after the update.
+	 * @since 2.1
+	 */
+	default <T> Mono<T> findAndReplace(Query query, T replacement, FindAndReplaceOptions options, Class<T> entityType,
+			String collectionName) {
+
+		return findAndReplace(query, replacement, options, entityType, collectionName, entityType);
+	}
+
+	/**
+	 * Triggers
+	 * <a href="https://docs.mongodb.com/manual/reference/method/db.collection.findOneAndReplace/">findOneAndReplace<a/>
+	 * to replace a single document matching {@link Criteria} of given {@link Query} with the {@code replacement} document
+	 * taking {@link FindAndReplaceOptions} into account. <br />
+	 * <strong>NOTE:</strong> The replacement entity must not hold an {@literal id}.
+	 *
+	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
+	 *          fields specification. Must not be {@literal null}.
+	 * @param replacement the replacement document. Must not be {@literal null}.
+	 * @param options the {@link FindAndModifyOptions} holding additional information. Must not be {@literal null}.
+	 * @param entityType the type used for mapping the {@link Query} to domain type fields and deriving the collection
+	 *          from. Must not be {@literal null}.
+	 * @param resultType the parametrized type projection return type. Must not be {@literal null}, use the domain type of
+	 *          {@code Object.class} instead.
+	 * @return the converted object that was updated or {@link Mono#empty()}, if not found. Depending on the value of
+	 *         {@link FindAndReplaceOptions#isReturnNew()} this will either be the object as it was before the update or
+	 *         as it is after the update.
+	 * @since 2.1
+	 */
+	default <S, T> Mono<T> findAndReplace(Query query, S replacement, FindAndReplaceOptions options, Class<S> entityType,
+			Class<T> resultType) {
+
+		return findAndReplace(query, replacement, options, entityType,
+				getCollectionName(ClassUtils.getUserClass(entityType)), resultType);
+	}
+
+	/**
+	 * Triggers
+	 * <a href="https://docs.mongodb.com/manual/reference/method/db.collection.findOneAndReplace/">findOneAndReplace<a/>
+	 * to replace a single document matching {@link Criteria} of given {@link Query} with the {@code replacement} document
+	 * taking {@link FindAndReplaceOptions} into account. <br />
+	 * <strong>NOTE:</strong> The replacement entity must not hold an {@literal id}.
+	 *
+	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
+	 *          fields specification. Must not be {@literal null}.
+	 * @param replacement the replacement document. Must not be {@literal null}.
+	 * @param options the {@link FindAndModifyOptions} holding additional information. Must not be {@literal null}.
+	 * @param entityType the type used for mapping the {@link Query} to domain type fields and deriving the collection
+	 *          from. Must not be {@literal null}.
+	 * @param collectionName the collection to query. Must not be {@literal null}.
+	 * @param resultType resultType the parametrized type projection return type. Must not be {@literal null}, use the
+	 *          domain type of {@code Object.class} instead.
+	 * @return the converted object that was updated or {@link Mono#empty()}, if not found. Depending on the value of
+	 *         {@link FindAndReplaceOptions#isReturnNew()} this will either be the object as it was before the update or
+	 *         as it is after the update.
+	 * @since 2.1
+	 */
+	<S, T> Mono<T> findAndReplace(Query query, S replacement, FindAndReplaceOptions options, Class<S> entityType,
+			String collectionName, Class<T> resultType);
+
 	/**
 	 * Map the results of an ad-hoc query on the collection for the entity type to a single instance of an object of the
 	 * specified type. The first document that matches the query is returned and also removed from the collection in the
@@ -680,7 +927,7 @@ public interface ReactiveMongoOperations extends ReactiveFluentMongoOperations {
 	 * Insert is used to initially store the object into the database. To update an existing object use the save method.
 	 *
 	 * @param objectToSave the object to store in the collection. Must not be {@literal null}.
-	 * @return the saved object.
+	 * @return the inserted object.
 	 */
 	<T> Mono<T> insert(T objectToSave);
 
@@ -694,7 +941,7 @@ public interface ReactiveMongoOperations extends ReactiveFluentMongoOperations {
 	 *
 	 * @param objectToSave the object to store in the collection. Must not be {@literal null}.
 	 * @param collectionName name of the collection to store the object in. Must not be {@literal null}.
-	 * @return the saved object.
+	 * @return the inserted object.
 	 */
 	<T> Mono<T> insert(T objectToSave, String collectionName);
 
@@ -703,7 +950,7 @@ public interface ReactiveMongoOperations extends ReactiveFluentMongoOperations {
 	 *
 	 * @param batchToSave the batch of objects to save. Must not be {@literal null}.
 	 * @param entityClass class that determines the collection to use. Must not be {@literal null}.
-	 * @return the saved objects.
+	 * @return the inserted objects .
 	 */
 	<T> Flux<T> insert(Collection<? extends T> batchToSave, Class<?> entityClass);
 
@@ -712,7 +959,7 @@ public interface ReactiveMongoOperations extends ReactiveFluentMongoOperations {
 	 *
 	 * @param batchToSave the list of objects to save. Must not be {@literal null}.
 	 * @param collectionName name of the collection to store the object in. Must not be {@literal null}.
-	 * @return the saved objects.
+	 * @return the inserted objects.
 	 */
 	<T> Flux<T> insert(Collection<? extends T> batchToSave, String collectionName);
 
@@ -740,7 +987,7 @@ public interface ReactiveMongoOperations extends ReactiveFluentMongoOperations {
 	 * Insert is used to initially store the object into the database. To update an existing object use the save method.
 	 *
 	 * @param objectToSave the object to store in the collection. Must not be {@literal null}.
-	 * @return the saved object.
+	 * @return the inserted objects.
 	 */
 	<T> Mono<T> insert(Mono<? extends T> objectToSave);
 
@@ -749,7 +996,7 @@ public interface ReactiveMongoOperations extends ReactiveFluentMongoOperations {
 	 *
 	 * @param batchToSave the publisher which provides objects to save. Must not be {@literal null}.
 	 * @param entityClass class that determines the collection to use. Must not be {@literal null}.
-	 * @return the saved objects.
+	 * @return the inserted objects.
 	 */
 	<T> Flux<T> insertAll(Mono<? extends Collection<? extends T>> batchToSave, Class<?> entityClass);
 
@@ -758,7 +1005,7 @@ public interface ReactiveMongoOperations extends ReactiveFluentMongoOperations {
 	 *
 	 * @param batchToSave the publisher which provides objects to save. Must not be {@literal null}.
 	 * @param collectionName name of the collection to store the object in. Must not be {@literal null}.
-	 * @return the saved objects.
+	 * @return the inserted objects.
 	 */
 	<T> Flux<T> insertAll(Mono<? extends Collection<? extends T>> batchToSave, String collectionName);
 
@@ -767,7 +1014,7 @@ public interface ReactiveMongoOperations extends ReactiveFluentMongoOperations {
 	 * class.
 	 *
 	 * @param objectsToSave the publisher which provides objects to save. Must not be {@literal null}.
-	 * @return the saved objects.
+	 * @return the inserted objects.
 	 */
 	<T> Flux<T> insertAll(Mono<? extends Collection<? extends T>> objectsToSave);
 
@@ -1110,7 +1357,57 @@ public interface ReactiveMongoOperations extends ReactiveFluentMongoOperations {
 	<T> Flux<T> tail(Query query, Class<T> entityClass, String collectionName);
 
 	/**
-	 * Subscribe to a MongoDB <a href="https://docs.mongodb.com/manual/changeStreams/">Change Streams</a> via the reactive
+	 * Subscribe to a MongoDB <a href="https://docs.mongodb.com/manual/changeStreams/">Change Stream</a> for all events in
+	 * the configured default database via the reactive infrastructure. Use the optional provided {@link Aggregation} to
+	 * filter events. The stream will not be completed unless the {@link org.reactivestreams.Subscription} is
+	 * {@link Subscription#cancel() canceled}.
+	 * <p />
+	 * The {@link ChangeStreamEvent#getBody()} is mapped to the {@literal resultType} while the
+	 * {@link ChangeStreamEvent#getRaw()} contains the unmodified payload.
+	 * <p />
+	 * Use {@link ChangeStreamOptions} to set arguments like {@link ChangeStreamOptions#getResumeToken() the resumseToken}
+	 * for resuming change streams.
+	 *
+	 * @param options must not be {@literal null}. Use {@link ChangeStreamOptions#empty()}.
+	 * @param targetType the result type to use.
+	 * @param <T>
+	 * @return the {@link Flux} emitting {@link ChangeStreamEvent events} as they arrive.
+	 * @since 2.1
+	 * @see ReactiveMongoDatabaseFactory#getMongoDatabase()
+	 * @see ChangeStreamOptions#getFilter()
+	 */
+	default <T> Flux<ChangeStreamEvent<T>> changeStream(ChangeStreamOptions options, Class<T> targetType) {
+		return changeStream(null, options, targetType);
+	}
+
+	/**
+	 * Subscribe to a MongoDB <a href="https://docs.mongodb.com/manual/changeStreams/">Change Stream</a> for all events in
+	 * the given collection via the reactive infrastructure. Use the optional provided {@link Aggregation} to filter
+	 * events. The stream will not be completed unless the {@link org.reactivestreams.Subscription} is
+	 * {@link Subscription#cancel() canceled}.
+	 * <p />
+	 * The {@link ChangeStreamEvent#getBody()} is mapped to the {@literal resultType} while the
+	 * {@link ChangeStreamEvent#getRaw()} contains the unmodified payload.
+	 * <p />
+	 * Use {@link ChangeStreamOptions} to set arguments like {@link ChangeStreamOptions#getResumeToken() the resumseToken}
+	 * for resuming change streams.
+	 *
+	 * @param collectionName the collection to watch. Can be {@literal null} to watch all collections.
+	 * @param options must not be {@literal null}. Use {@link ChangeStreamOptions#empty()}.
+	 * @param targetType the result type to use.
+	 * @param <T>
+	 * @return the {@link Flux} emitting {@link ChangeStreamEvent events} as they arrive.
+	 * @since 2.1
+	 * @see ChangeStreamOptions#getFilter()
+	 */
+	default <T> Flux<ChangeStreamEvent<T>> changeStream(@Nullable String collectionName, ChangeStreamOptions options,
+			Class<T> targetType) {
+
+		return changeStream(null, collectionName, options, targetType);
+	}
+
+	/**
+	 * Subscribe to a MongoDB <a href="https://docs.mongodb.com/manual/changeStreams/">Change Stream</a> via the reactive
 	 * infrastructure. Use the optional provided {@link Aggregation} to filter events. The stream will not be completed
 	 * unless the {@link org.reactivestreams.Subscription} is {@link Subscription#cancel() canceled}.
 	 * <p />
@@ -1120,38 +1417,53 @@ public interface ReactiveMongoOperations extends ReactiveFluentMongoOperations {
 	 * Use {@link ChangeStreamOptions} to set arguments like {@link ChangeStreamOptions#getResumeToken() the resumseToken}
 	 * for resuming change streams.
 	 *
-	 * @param filter can be {@literal null}.
-	 * @param resultType must not be {@literal null}.
-	 * @param options must not be {@literal null}.
-	 * @param collectionName must not be {@literal null} nor empty.
+	 * @param database the database to watch. Can be {@literal null}, uses configured default if so.
+	 * @param collectionName the collection to watch. Can be {@literal null}, watches all collections if so.
+	 * @param options must not be {@literal null}. Use {@link ChangeStreamOptions#empty()}.
+	 * @param targetType the result type to use.
 	 * @param <T>
-	 * @return
+	 * @return the {@link Flux} emitting {@link ChangeStreamEvent events} as they arrive.
 	 * @since 2.1
+	 * @see ChangeStreamOptions#getFilter()
 	 */
-	<T> Flux<ChangeStreamEvent<T>> changeStream(@Nullable Aggregation filter, Class<T> resultType,
-			ChangeStreamOptions options, String collectionName);
+	<T> Flux<ChangeStreamEvent<T>> changeStream(@Nullable String database, @Nullable String collectionName,
+			ChangeStreamOptions options, Class<T> targetType);
 
 	/**
-	 * Subscribe to a MongoDB <a href="https://docs.mongodb.com/manual/changeStreams/">Change Streams</a> via the reactive
-	 * infrastructure. Use the optional provided aggregation chain to filter events. The stream will not be completed
-	 * unless the {@link org.reactivestreams.Subscription} is {@link Subscription#cancel() canceled}.
-	 * <p />
-	 * The {@link ChangeStreamEvent#getBody()} is mapped to the {@literal resultType} while the
-	 * {@link ChangeStreamEvent#getRaw()} contains the unmodified payload.
-	 * <p />
-	 * Use {@link ChangeStreamOptions} to set arguments like {@link ChangeStreamOptions#getResumeToken() the resumeToken}
-	 * for resuming change streams.
+	 * Execute a map-reduce operation. Use {@link MapReduceOptions} to optionally specify an output collection and other
+	 * args.
 	 *
-	 * @param filter can be empty, must not be {@literal null}.
-	 * @param resultType must not be {@literal null}.
-	 * @param options must not be {@literal null}.
-	 * @param collectionName must not be {@literal null} nor empty.
-	 * @param <T>
-	 * @return
+	 * @param filterQuery the selection criteria for the documents going input to the map function. Must not be
+	 *          {@literal null}.
+	 * @param domainType source type used to determine the input collection name and map the filter {@link Query} against.
+	 *          Must not be {@literal null}.
+	 * @param resultType the mapping target of the operations result documents. Must not be {@literal null}.
+	 * @param mapFunction the JavaScript map function. Must not be {@literal null}.
+	 * @param reduceFunction the JavaScript reduce function. Must not be {@literal null}.
+	 * @param options additional options like output collection. Must not be {@literal null}.
+	 * @return a {@link Flux} emitting the result document sequence. Never {@literal null}.
 	 * @since 2.1
 	 */
-	<T> Flux<ChangeStreamEvent<T>> changeStream(List<Document> filter, Class<T> resultType, ChangeStreamOptions options,
-			String collectionName);
+	<T> Flux<T> mapReduce(Query filterQuery, Class<?> domainType, Class<T> resultType, String mapFunction,
+			String reduceFunction, MapReduceOptions options);
+
+	/**
+	 * Execute a map-reduce operation. Use {@link MapReduceOptions} to optionally specify an output collection and other
+	 * args.
+	 *
+	 * @param filterQuery the selection criteria for the documents going input to the map function. Must not be
+	 *          {@literal null}.
+	 * @param domainType source type used to map the filter {@link Query} against. Must not be {@literal null}.
+	 * @param inputCollectionName the input collection.
+	 * @param resultType the mapping target of the operations result documents. Must not be {@literal null}.
+	 * @param mapFunction the JavaScript map function. Must not be {@literal null}.
+	 * @param reduceFunction the JavaScript reduce function. Must not be {@literal null}.
+	 * @param options additional options like output collection. Must not be {@literal null}.
+	 * @return a {@link Flux} emitting the result document sequence. Never {@literal null}.
+	 * @since 2.1
+	 */
+	<T> Flux<T> mapReduce(Query filterQuery, Class<?> domainType, String inputCollectionName, Class<T> resultType,
+			String mapFunction, String reduceFunction, MapReduceOptions options);
 
 	/**
 	 * Returns the underlying {@link MongoConverter}.
@@ -1160,4 +1472,13 @@ public interface ReactiveMongoOperations extends ReactiveFluentMongoOperations {
 	 */
 	MongoConverter getConverter();
 
+	/**
+	 * The collection name used for the specified class by this template.
+	 *
+	 * @param entityClass must not be {@literal null}.
+	 * @return
+	 * @since 2.1
+	 */
+	String getCollectionName(Class<?> entityClass);
+
 }

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveSessionCallback.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.core;
+
+import org.reactivestreams.Publisher;
+import org.springframework.data.mongodb.core.query.Query;
+
+/**
+ * Callback interface for executing operations within a {@link com.mongodb.reactivestreams.client.ClientSession} using
+ * reactive infrastructure.
+ *
+ * @author Christoph Strobl
+ * @since 2.1
+ * @see com.mongodb.reactivestreams.client.ClientSession
+ */
+@FunctionalInterface
+public interface ReactiveSessionCallback<T> {
+
+	/**
+	 * Execute operations against a MongoDB instance via session bound {@link ReactiveMongoOperations}. The session is
+	 * inferred directly into the operation so that no further interaction is necessary.
+	 * <p />
+	 * Please note that only Spring Data-specific abstractions like {@link ReactiveMongoOperations#find(Query, Class)} and
+	 * others are enhanced with the {@link com.mongodb.session.ClientSession}. When obtaining plain MongoDB gateway
+	 * objects like {@link com.mongodb.reactivestreams.client.MongoCollection} or
+	 * {@link com.mongodb.reactivestreams.client.MongoDatabase} via eg.
+	 * {@link ReactiveMongoOperations#getCollection(String)} we leave responsibility for
+	 * {@link com.mongodb.session.ClientSession} again up to the caller.
+	 *
+	 * @param operations will never be {@literal null}.
+	 * @return never {@literal null}.
+	 */
+	Publisher<T> doInSession(ReactiveMongoOperations operations);
+}

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

@@ -0,0 +1,62 @@
+/*
+ * 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 reactor.core.publisher.Flux;
+
+import java.util.function.Consumer;
+
+import com.mongodb.reactivestreams.client.ClientSession;
+
+/**
+ * Gateway interface to execute {@link ClientSession} bound operations against MongoDB via a
+ * {@link ReactiveSessionCallback}.
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @since 2.1
+ */
+public interface ReactiveSessionScoped {
+
+	/**
+	 * Executes the given {@link ReactiveSessionCallback} within the {@link com.mongodb.session.ClientSession}.
+	 * <p/>
+	 * It is up to the caller to make sure the {@link com.mongodb.session.ClientSession} is {@link ClientSession#close()
+	 * closed} when done.
+	 *
+	 * @param action callback object that specifies the MongoDB action the callback action. Must not be {@literal null}.
+	 * @param <T> return type.
+	 * @return a result object returned by the action, can be {@link Flux#empty()}.
+	 */
+	default <T> Flux<T> execute(ReactiveSessionCallback<T> action) {
+		return execute(action, (session) -> {});
+	}
+
+	/**
+	 * Executes the given {@link ReactiveSessionCallback} within the {@link com.mongodb.session.ClientSession}.
+	 * <p/>
+	 * It is up to the caller to make sure the {@link com.mongodb.session.ClientSession} is {@link ClientSession#close()
+	 * closed} when done.
+	 *
+	 * @param action callback object that specifies the MongoDB action the callback action. Must not be {@literal null}.
+	 * @param doFinally callback object that accepts {@link ClientSession} after invoking {@link ReactiveSessionCallback}.
+	 *          This {@link Consumer} is guaranteed to be notified in any case (successful and exceptional outcome of
+	 *          {@link ReactiveSessionCallback}).
+	 * @param <T> return type.
+	 * @return a result object returned by the action, can be {@link Flux#empty()}.
+	 */
+	<T> Flux<T> execute(ReactiveSessionCallback<T> action, Consumer<ClientSession> doFinally);
+}

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

@@ -18,12 +18,13 @@ package org.springframework.data.mongodb.core;
 import reactor.core.publisher.Mono;
 
 import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.mongodb.core.query.Update;
 
 import com.mongodb.client.result.UpdateResult;
 
 /**
- * {@link ReactiveUpdateOperation} allows creation and execution of reactive MongoDB update / findAndModify operations
- * in a fluent API style. <br />
+ * {@link ReactiveUpdateOperation} allows creation and execution of reactive 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 org.springframework.data.mongodb.core.query.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
@@ -68,6 +69,22 @@ public interface ReactiveUpdateOperation {
 		Mono<T> findAndModify();
 	}
 
+	/**
+	 * Compose findAndReplace 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 Mono#empty()} if nothing found. Never {@literal null}.
+		 */
+		Mono<T> findAndReplace();
+	}
+
 	/**
 	 * Compose update execution by calling one of the terminating methods.
 	 */
@@ -108,6 +125,16 @@ public interface ReactiveUpdateOperation {
 		 * @throws IllegalArgumentException if update is {@literal null}.
 		 */
 		TerminatingUpdate<T> apply(org.springframework.data.mongodb.core.query.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);
 	}
 
 	/**
@@ -157,5 +184,45 @@ public interface ReactiveUpdateOperation {
 		TerminatingFindAndModify<T> withOptions(FindAndModifyOptions options);
 	}
 
+	/**
+	 * Define {@link FindAndReplaceOptions}.
+	 *
+	 * @author Mark Paluch
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	interface FindAndReplaceWithOptions<T> extends TerminatingFindAndReplace<T> {
+
+		/**
+		 * Explicitly define {@link FindAndReplaceOptions} for the {@link Update}.
+		 *
+		 * @param options must not be {@literal null}.
+		 * @return new instance of {@link FindAndReplaceOptions}.
+		 * @throws IllegalArgumentException if options is {@literal null}.
+		 */
+		FindAndReplaceWithProjection<T> withOptions(FindAndReplaceOptions options);
+	}
+
+	/**
+	 * Result type override (Optional).
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	interface FindAndReplaceWithProjection<T> extends FindAndReplaceWithOptions<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 FindAndReplaceWithProjection}.
+		 * @throws IllegalArgumentException if resultType is {@literal null}.
+		 */
+		<R> FindAndReplaceWithOptions<R> as(Class<R> resultType);
+
+	}
+
 	interface ReactiveUpdate<T> extends UpdateWithCollection<T>, UpdateWithQuery<T>, UpdateWithUpdate<T> {}
 }

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

@@ -22,6 +22,7 @@ import lombok.experimental.FieldDefaults;
 import reactor.core.publisher.Mono;
 
 import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
 
@@ -50,20 +51,24 @@ class ReactiveUpdateOperationSupport implements ReactiveUpdateOperation {
 
 		Assert.notNull(domainType, "DomainType must not be null!");
 
-		return new ReactiveUpdateSupport<>(template, domainType, ALL_QUERY, null, null, null);
+		return new ReactiveUpdateSupport<>(template, domainType, ALL_QUERY, null, null, null, null, null, domainType);
 	}
 
 	@RequiredArgsConstructor
 	@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
 	static class ReactiveUpdateSupport<T>
-			implements ReactiveUpdate<T>, UpdateWithCollection<T>, UpdateWithQuery<T>, TerminatingUpdate<T> {
+			implements ReactiveUpdate<T>, UpdateWithCollection<T>, UpdateWithQuery<T>, TerminatingUpdate<T>,
+			FindAndReplaceWithOptions<T>, FindAndReplaceWithProjection<T>, TerminatingFindAndReplace<T> {
 
 		@NonNull ReactiveMongoTemplate template;
-		@NonNull Class<T> domainType;
+		@NonNull Class<?> domainType;
 		Query query;
 		org.springframework.data.mongodb.core.query.Update update;
-		String collection;
-		FindAndModifyOptions options;
+		@Nullable String collection;
+		@Nullable FindAndModifyOptions findAndModifyOptions;
+		@Nullable FindAndReplaceOptions findAndReplaceOptions;
+		@Nullable Object replacement;
+		@NonNull Class<T> targetType;
 
 		/*
 		 * (non-Javadoc)
@@ -74,7 +79,8 @@ class ReactiveUpdateOperationSupport implements ReactiveUpdateOperation {
 
 			Assert.notNull(update, "Update must not be null!");
 
-			return new ReactiveUpdateSupport<>(template, domainType, query, update, collection, options);
+			return new ReactiveUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
+					findAndReplaceOptions, replacement, targetType);
 		}
 
 		/*
@@ -86,7 +92,8 @@ class ReactiveUpdateOperationSupport implements ReactiveUpdateOperation {
 
 			Assert.hasText(collection, "Collection must not be null nor empty!");
 
-			return new ReactiveUpdateSupport<>(template, domainType, query, update, collection, options);
+			return new ReactiveUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
+					findAndReplaceOptions, replacement, targetType);
 		}
 
 		/*
@@ -116,7 +123,18 @@ class ReactiveUpdateOperationSupport implements ReactiveUpdateOperation {
 
 			String collectionName = getCollectionName();
 
-			return template.findAndModify(query, update, options, domainType, collectionName);
+			return template.findAndModify(query, update, findAndModifyOptions, targetType, collectionName);
+		}
+
+		/* 
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveUpdateOperation.TerminatingFindAndReplace#findAndReplace()
+		 */
+		@Override
+		public Mono<T> findAndReplace() {
+			return template.findAndReplace(query, replacement,
+					findAndReplaceOptions != null ? findAndReplaceOptions : new FindAndReplaceOptions(), (Class) domainType,
+					getCollectionName(), targetType);
 		}
 
 		/*
@@ -128,7 +146,8 @@ class ReactiveUpdateOperationSupport implements ReactiveUpdateOperation {
 
 			Assert.notNull(query, "Query must not be null!");
 
-			return new ReactiveUpdateSupport<>(template, domainType, query, update, collection, options);
+			return new ReactiveUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
+					findAndReplaceOptions, replacement, targetType);
 		}
 
 		/*
@@ -149,7 +168,47 @@ class ReactiveUpdateOperationSupport implements ReactiveUpdateOperation {
 
 			Assert.notNull(options, "Options must not be null!");
 
-			return new ReactiveUpdateSupport<>(template, domainType, query, update, collection, options);
+			return new ReactiveUpdateSupport<>(template, domainType, query, update, collection, options,
+					findAndReplaceOptions, replacement, targetType);
+		}
+
+		/* 
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveUpdateOperation.UpdateWithUpdate#replaceWith(java.lang.Object)
+		 */
+		@Override
+		public FindAndReplaceWithProjection<T> replaceWith(T replacement) {
+
+			Assert.notNull(replacement, "Replacement must not be null!");
+
+			return new ReactiveUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
+					findAndReplaceOptions, replacement, targetType);
+		}
+
+		/* 
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveUpdateOperation.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 ReactiveUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions, options,
+					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 ReactiveUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
+					findAndReplaceOptions, replacement, resultType);
 		}
 
 		private Mono<UpdateResult> doUpdate(boolean multi, boolean upsert) {

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

@@ -0,0 +1,46 @@
+/*
+ * 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 org.springframework.data.mongodb.core.query.Query;
+import org.springframework.lang.Nullable;
+
+/**
+ * Callback interface for executing operations within a {@link com.mongodb.session.ClientSession}.
+ *
+ * @author Christoph Strobl
+ * @since 2.1
+ * @see com.mongodb.session.ClientSession
+ */
+@FunctionalInterface
+public interface SessionCallback<T> {
+
+	/**
+	 * Execute operations against a MongoDB instance via session bound {@link MongoOperations}. The session is inferred
+	 * directly into the operation so that no further interaction is necessary.
+	 * <p />
+	 * Please note that only Spring Data-specific abstractions like {@link MongoOperations#find(Query, Class)} and others
+	 * are enhanced with the {@link com.mongodb.session.ClientSession}. When obtaining plain MongoDB gateway objects like
+	 * {@link com.mongodb.client.MongoCollection} or {@link com.mongodb.client.MongoDatabase} via eg.
+	 * {@link MongoOperations#getCollection(String)} we leave responsibility for {@link com.mongodb.session.ClientSession}
+	 * again up to the caller.
+	 *
+	 * @param operations will never be {@literal null}.
+	 * @return can be {@literal null}.
+	 */
+	@Nullable
+	T doInSession(MongoOperations operations);
+}

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

@@ -0,0 +1,65 @@
+/*
+ * 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.function.Consumer;
+
+import org.springframework.lang.Nullable;
+
+import com.mongodb.client.ClientSession;
+
+/**
+ * Gateway interface to execute {@link ClientSession} bound operations against MongoDB via a {@link SessionCallback}.
+ * <p />
+ * The very same bound {@link ClientSession} is used for all invocations of {@code execute} on the instance.
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @since 2.1
+ */
+public interface SessionScoped {
+
+	/**
+	 * Executes the given {@link SessionCallback} within the {@link com.mongodb.session.ClientSession}.
+	 * <p/>
+	 * It is up to the caller to make sure the {@link com.mongodb.session.ClientSession} is {@link ClientSession#close()
+	 * closed} when done.
+	 *
+	 * @param action callback object that specifies the MongoDB action the callback action. Must not be {@literal null}.
+	 * @param <T> return type.
+	 * @return a result object returned by the action. Can be {@literal null}.
+	 */
+	@Nullable
+	default <T> T execute(SessionCallback<T> action) {
+		return execute(action, session -> {});
+	}
+
+	/**
+	 * Executes the given {@link SessionCallback} within the {@link com.mongodb.session.ClientSession}.
+	 * <p/>
+	 * It is up to the caller to make sure the {@link com.mongodb.session.ClientSession} is {@link ClientSession#close()
+	 * closed} when done.
+	 *
+	 * @param action callback object that specifies the MongoDB action the callback action. Must not be {@literal null}.
+	 * @param doFinally callback object that accepts {@link ClientSession} after invoking {@link SessionCallback}. This
+	 *          {@link Consumer} is guaranteed to be notified in any case (successful and exceptional outcome of
+	 *          {@link SessionCallback}).
+	 * @param <T> return type.
+	 * @return a result object returned by the action. Can be {@literal null}.
+	 */
+	@Nullable
+	<T> T execute(SessionCallback<T> action, Consumer<ClientSession> doFinally);
+}

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

@@ -0,0 +1,116 @@
+/*
+ * 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 org.springframework.beans.factory.DisposableBean;
+
+import com.mongodb.ClientSessionOptions;
+import com.mongodb.ConnectionString;
+import com.mongodb.DB;
+import com.mongodb.client.ClientSession;
+import com.mongodb.client.MongoClient;
+import com.mongodb.client.MongoClients;
+import com.mongodb.client.MongoDatabase;
+
+/**
+ * Factory to create {@link MongoDatabase} instances from a {@link MongoClient} instance.
+ *
+ * @author Christoph Strobl
+ * @since 2.1
+ */
+public class SimpleMongoClientDbFactory extends MongoDbFactorySupport<MongoClient> implements DisposableBean {
+
+	/**
+	 * Creates a new {@link SimpleMongoClientDbFactory} instance for the given {@code connectionString}.
+	 *
+	 * @param connectionString connection coordinates for a database connection. Must contain a database name and must not
+	 *          be {@literal null} or empty.
+	 * @see <a href="https://docs.mongodb.com/manual/reference/connection-string/">MongoDB Connection String reference</a>
+	 */
+	public SimpleMongoClientDbFactory(String connectionString) {
+		this(new ConnectionString(connectionString));
+	}
+
+	/**
+	 * Creates a new {@link SimpleMongoClientDbFactory} instance from the given {@link MongoClient}.
+	 *
+	 * @param connectionString connection coordinates for a database connection. Must contain also a database name and not
+	 *          be {@literal null}.
+	 */
+	public SimpleMongoClientDbFactory(ConnectionString connectionString) {
+		this(MongoClients.create(connectionString), connectionString.getDatabase(), true);
+	}
+
+	/**
+	 * Creates a new {@link SimpleMongoClientDbFactory} instance from the given {@link MongoClient}.
+	 *
+	 * @param mongoClient must not be {@literal null}.
+	 * @param databaseName must not be {@literal null} or empty.
+	 */
+	public SimpleMongoClientDbFactory(MongoClient mongoClient, String databaseName) {
+		this(mongoClient, databaseName, false);
+	}
+
+	/**
+	 * Creates a new {@link SimpleMongoClientDbFactory} instance from the given {@link MongoClient}.
+	 *
+	 * @param mongoClient must not be {@literal null}.
+	 * @param databaseName must not be {@literal null} or empty.
+	 * @param mongoInstanceCreated
+	 */
+	private SimpleMongoClientDbFactory(MongoClient mongoClient, String databaseName, boolean mongoInstanceCreated) {
+		super(mongoClient, databaseName, mongoInstanceCreated, new MongoExceptionTranslator());
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.MongoDbFactory#getLegacyDb()
+	 */
+	@Override
+	public DB getLegacyDb() {
+
+		throw new UnsupportedOperationException(String.format(
+				"%s does not support legacy DBObject API! Please consider using SimpleMongoDbFactory for that purpose.",
+				MongoClient.class));
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.MongoDbFactory#getSession(com.mongodb.ClientSessionOptions)
+	 */
+	@Override
+	public ClientSession getSession(ClientSessionOptions options) {
+		return getMongoClient().startSession(options);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.MongoDbFactoryBase#closeClient()
+	 */
+	@Override
+	protected void closeClient() {
+		getMongoClient().close();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.MongoDbFactoryBase#doGetMongoDatabase(java.lang.String)
+	 */
+	@Override
+	protected MongoDatabase doGetMongoDatabase(String dbName) {
+		return getMongoClient().getDatabase(dbName);
+	}
+}

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

@@ -15,43 +15,33 @@
  */
 package org.springframework.data.mongodb.core;
 
-import java.net.UnknownHostException;
-
 import org.springframework.beans.factory.DisposableBean;
-import org.springframework.dao.DataAccessException;
-import org.springframework.dao.support.PersistenceExceptionTranslator;
-import org.springframework.data.mongodb.MongoDbFactory;
-import org.springframework.lang.Nullable;
-import org.springframework.util.Assert;
 
+import com.mongodb.ClientSessionOptions;
 import com.mongodb.DB;
 import com.mongodb.MongoClient;
 import com.mongodb.MongoClientURI;
 import com.mongodb.WriteConcern;
+import com.mongodb.client.ClientSession;
+import com.mongodb.client.MongoCollection;
 import com.mongodb.client.MongoDatabase;
 
 /**
- * Factory to create {@link DB} instances from a {@link MongoClient} instance.
+ * Factory to create {@link MongoDatabase} instances from a {@link MongoClient} instance.
  *
  * @author Mark Pollack
  * @author Oliver Gierke
  * @author Thomas Darimont
  * @author Christoph Strobl
+ * @author George Moraitis
+ * @author Mark Paluch
  */
-public class SimpleMongoDbFactory implements DisposableBean, MongoDbFactory {
-
-	private final MongoClient mongoClient;
-	private final String databaseName;
-	private final boolean mongoInstanceCreated;
-	private final PersistenceExceptionTranslator exceptionTranslator;
-
-	private @Nullable WriteConcern writeConcern;
+public class SimpleMongoDbFactory extends MongoDbFactorySupport<MongoClient> implements DisposableBean {
 
 	/**
 	 * Creates a new {@link SimpleMongoDbFactory} instance from the given {@link MongoClientURI}.
 	 *
-	 * @param uri must not be {@literal null}.
-	 * @throws UnknownHostException
+	 * @param uri coordinates for a database connection. Must contain a database name and must not be {@literal null}.
 	 * @since 1.7
 	 */
 	public SimpleMongoDbFactory(MongoClientURI uri) {
@@ -62,7 +52,7 @@ public class SimpleMongoDbFactory implements DisposableBean, MongoDbFactory {
 	 * Creates a new {@link SimpleMongoDbFactory} instance from the given {@link MongoClient}.
 	 *
 	 * @param mongoClient must not be {@literal null}.
-	 * @param databaseName must not be {@literal null}.
+	 * @param databaseName must not be {@literal null} or empty.
 	 * @since 1.7
 	 */
 	public SimpleMongoDbFactory(MongoClient mongoClient, String databaseName) {
@@ -70,81 +60,48 @@ public class SimpleMongoDbFactory implements DisposableBean, MongoDbFactory {
 	}
 
 	/**
-	 * @param client
+	 * @param mongoClient
 	 * @param databaseName
 	 * @param mongoInstanceCreated
 	 * @since 1.7
 	 */
 	private SimpleMongoDbFactory(MongoClient mongoClient, String databaseName, boolean mongoInstanceCreated) {
-
-		Assert.notNull(mongoClient, "MongoClient must not be null!");
-		Assert.hasText(databaseName, "Database name must not be empty!");
-		Assert.isTrue(databaseName.matches("[\\w-]+"),
-				"Database name must only contain letters, numbers, underscores and dashes!");
-
-		this.mongoClient = mongoClient;
-		this.databaseName = databaseName;
-		this.mongoInstanceCreated = mongoInstanceCreated;
-		this.exceptionTranslator = new MongoExceptionTranslator();
+		super(mongoClient, databaseName, mongoInstanceCreated, new MongoExceptionTranslator());
 	}
 
-	/**
-	 * Configures the {@link WriteConcern} to be used on the {@link DB} instance being created.
-	 *
-	 * @param writeConcern the writeConcern to set
-	 */
-	public void setWriteConcern(WriteConcern writeConcern) {
-		this.writeConcern = writeConcern;
-	}
-
-	/*
+	/* 
 	 * (non-Javadoc)
-	 * @see org.springframework.data.mongodb.MongoDbFactory#getDb()
+	 * @see org.springframework.data.mongodb.MongoDbFactory#getLegacyDb()
 	 */
-	public MongoDatabase getDb() throws DataAccessException {
-		return getDb(databaseName);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.mongodb.MongoDbFactory#getDb(java.lang.String)
-	 */
-	public MongoDatabase getDb(String dbName) throws DataAccessException {
-
-		Assert.hasText(dbName, "Database name must not be empty.");
-
-		MongoDatabase db = mongoClient.getDatabase(dbName);
-
-		if (writeConcern == null) {
-			return db;
-		}
-
-		return db.withWriteConcern(writeConcern);
-	}
-
-	/**
-	 * Clean up the Mongo instance if it was created by the factory itself.
-	 *
-	 * @see DisposableBean#destroy()
-	 */
-	public void destroy() throws Exception {
-		if (mongoInstanceCreated) {
-			mongoClient.close();
-		}
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.mongodb.MongoDbFactory#getExceptionTranslator()
-	 */
-	@Override
-	public PersistenceExceptionTranslator getExceptionTranslator() {
-		return this.exceptionTranslator;
-	}
-
-	@SuppressWarnings("deprecation")
 	@Override
 	public DB getLegacyDb() {
-		return mongoClient.getDB(databaseName);
+		return getMongoClient().getDB(getDefaultDatabaseName());
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.MongoDbFactory#getSession(com.mongodb.ClientSessionOptions)
+	 */
+	@Override
+	public ClientSession getSession(ClientSessionOptions options) {
+		return getMongoClient().startSession(options);
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.MongoDbFactoryBase#closeClient()
+	 */
+	@Override
+	protected void closeClient() {
+		getMongoClient().close();
+	}
+
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.MongoDbFactoryBase#doGetMongoDatabase(java.lang.String)
+	 */
+	@Override
+	protected MongoDatabase doGetMongoDatabase(String dbName) {
+		return getMongoClient().getDatabase(dbName);
 	}
 }

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

@@ -15,19 +15,25 @@
  */
 package org.springframework.data.mongodb.core;
 
-import java.net.UnknownHostException;
+import lombok.Value;
+import reactor.core.publisher.Mono;
 
+import org.springframework.aop.framework.ProxyFactory;
 import org.springframework.beans.factory.DisposableBean;
 import org.springframework.dao.DataAccessException;
 import org.springframework.dao.support.PersistenceExceptionTranslator;
 import org.springframework.data.mongodb.ReactiveMongoDatabaseFactory;
+import org.springframework.data.mongodb.SessionAwareMethodInterceptor;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
+import com.mongodb.ClientSessionOptions;
 import com.mongodb.ConnectionString;
 import com.mongodb.WriteConcern;
+import com.mongodb.reactivestreams.client.ClientSession;
 import com.mongodb.reactivestreams.client.MongoClient;
 import com.mongodb.reactivestreams.client.MongoClients;
+import com.mongodb.reactivestreams.client.MongoCollection;
 import com.mongodb.reactivestreams.client.MongoDatabase;
 
 /**
@@ -51,9 +57,8 @@ public class SimpleReactiveMongoDatabaseFactory implements DisposableBean, React
 	 * Creates a new {@link SimpleReactiveMongoDatabaseFactory} instance from the given {@link ConnectionString}.
 	 *
 	 * @param connectionString must not be {@literal null}.
-	 * @throws UnknownHostException
 	 */
-	public SimpleReactiveMongoDatabaseFactory(ConnectionString connectionString) throws UnknownHostException {
+	public SimpleReactiveMongoDatabaseFactory(ConnectionString connectionString) {
 		this(MongoClients.create(connectionString), connectionString.getDatabase(), true);
 	}
 
@@ -72,8 +77,8 @@ public class SimpleReactiveMongoDatabaseFactory implements DisposableBean, React
 
 		Assert.notNull(client, "MongoClient must not be null!");
 		Assert.hasText(databaseName, "Database name must not be empty!");
-		Assert.isTrue(databaseName.matches("[\\w-]+"),
-				"Database name must only contain letters, numbers, underscores and dashes!");
+		Assert.isTrue(databaseName.matches("[^/\\\\.$\"\\s]+"),
+				"Database name must not contain slashes, dots, spaces, quotes, or dollar signs!");
 
 		this.mongo = client;
 		this.databaseName = databaseName;
@@ -129,4 +134,106 @@ public class SimpleReactiveMongoDatabaseFactory implements DisposableBean, React
 	public PersistenceExceptionTranslator getExceptionTranslator() {
 		return this.exceptionTranslator;
 	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.ReactiveMongoDbFactory#getSession(com.mongodb.ClientSessionOptions)
+	 */
+	@Override
+	public Mono<ClientSession> getSession(ClientSessionOptions options) {
+		return Mono.from(mongo.startSession(options));
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.ReactiveMongoDbFactory#withSession(com.mongodb.session.ClientSession)
+	 */
+	@Override
+	public ReactiveMongoDatabaseFactory withSession(ClientSession session) {
+		return new ClientSessionBoundMongoDbFactory(session, this);
+	}
+
+	/**
+	 * {@link ClientSession} bound {@link ReactiveMongoDatabaseFactory} decorating the database with a
+	 * {@link SessionAwareMethodInterceptor}.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	@Value
+	static class ClientSessionBoundMongoDbFactory implements ReactiveMongoDatabaseFactory {
+
+		ClientSession session;
+		ReactiveMongoDatabaseFactory delegate;
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.ReactiveMongoDatabaseFactory#getMongoDatabase()
+		 */
+		@Override
+		public MongoDatabase getMongoDatabase() throws DataAccessException {
+			return decorateDatabase(delegate.getMongoDatabase());
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.ReactiveMongoDatabaseFactory#getMongoDatabase(java.lang.String)
+		 */
+		@Override
+		public MongoDatabase getMongoDatabase(String dbName) throws DataAccessException {
+			return decorateDatabase(delegate.getMongoDatabase(dbName));
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.ReactiveMongoDatabaseFactory#getExceptionTranslator()
+		 */
+		@Override
+		public PersistenceExceptionTranslator getExceptionTranslator() {
+			return delegate.getExceptionTranslator();
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.ReactiveMongoDatabaseFactory#getSession(com.mongodb.ClientSessionOptions)
+		 */
+		@Override
+		public Mono<ClientSession> getSession(ClientSessionOptions options) {
+			return delegate.getSession(options);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.ReactiveMongoDatabaseFactory#withSession(com.mongodb.session.ClientSession)
+		 */
+		@Override
+		public ReactiveMongoDatabaseFactory withSession(ClientSession session) {
+			return delegate.withSession(session);
+		}
+
+		private MongoDatabase decorateDatabase(MongoDatabase database) {
+			return createProxyInstance(session, database, MongoDatabase.class);
+		}
+
+		private MongoDatabase proxyDatabase(com.mongodb.session.ClientSession session, MongoDatabase database) {
+			return createProxyInstance(session, database, MongoDatabase.class);
+		}
+
+		private MongoCollection proxyCollection(com.mongodb.session.ClientSession session, MongoCollection collection) {
+			return createProxyInstance(session, collection, MongoCollection.class);
+		}
+
+		private <T> T createProxyInstance(com.mongodb.session.ClientSession session, T target, Class<T> targetType) {
+
+			ProxyFactory factory = new ProxyFactory();
+			factory.setTarget(target);
+			factory.setInterfaces(targetType);
+			factory.setOpaque(true);
+
+			factory.addAdvice(new SessionAwareMethodInterceptor<>(session, target, ClientSession.class, MongoDatabase.class,
+					this::proxyDatabase, MongoCollection.class, this::proxyCollection));
+
+			return targetType.cast(factory.getProxy());
+		}
+	}
 }

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/aggregation/AbstractAggregationExpression.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.
@@ -20,12 +20,16 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
 
 import org.bson.Document;
+import org.springframework.data.mongodb.core.aggregation.Aggregation.SystemVariable;
+import org.springframework.util.Assert;
 import org.springframework.util.ObjectUtils;
 
 /**
  * @author Christoph Strobl
+ * @author Matt Morrissette
  * @since 1.10
  */
 abstract class AbstractAggregationExpression implements AggregationExpression {
@@ -46,29 +50,7 @@ abstract class AbstractAggregationExpression implements AggregationExpression {
 
 	@SuppressWarnings("unchecked")
 	public Document toDocument(Object value, AggregationOperationContext context) {
-
-		Object valueToUse;
-		if (value instanceof List) {
-
-			List<Object> arguments = (List<Object>) value;
-			List<Object> args = new ArrayList<Object>(arguments.size());
-
-			for (Object val : arguments) {
-				args.add(unpack(val, context));
-			}
-			valueToUse = args;
-		} else if (value instanceof java.util.Map) {
-
-			Document dbo = new Document();
-			for (java.util.Map.Entry<String, Object> entry : ((java.util.Map<String, Object>) value).entrySet()) {
-				dbo.put(entry.getKey(), unpack(entry.getValue(), context));
-			}
-			valueToUse = dbo;
-		} else {
-			valueToUse = unpack(value, context);
-		}
-
-		return new Document(getMongoMethod(), valueToUse);
+		return new Document(getMongoMethod(), unpack(value, context));
 	}
 
 	protected static List<Field> asFields(String... fieldRefs) {
@@ -94,14 +76,27 @@ abstract class AbstractAggregationExpression implements AggregationExpression {
 		if (value instanceof List) {
 
 			List<Object> sourceList = (List<Object>) value;
-			List<Object> mappedList = new ArrayList<Object>(sourceList.size());
+			List<Object> mappedList = new ArrayList<>(sourceList.size());
+
+			sourceList.stream().map((item) -> unpack(item, context)).forEach(mappedList::add);
 
-			for (Object item : sourceList) {
-				mappedList.add(unpack(item, context));
-			}
 			return mappedList;
 		}
 
+		if (value instanceof Map) {
+
+			Document targetDocument = new Document();
+
+			Map<String, Object> sourceMap = (Map<String, Object>) value;
+			sourceMap.forEach((k, v) -> targetDocument.append(k, unpack(v, context)));
+
+			return targetDocument;
+		}
+
+		if (value instanceof SystemVariable) {
+			return value.toString();
+		}
+
 		return value;
 	}
 
@@ -112,9 +107,7 @@ abstract class AbstractAggregationExpression implements AggregationExpression {
 			List<Object> clone = new ArrayList<Object>((List) this.value);
 
 			if (value instanceof List) {
-				for (Object val : (List) value) {
-					clone.add(val);
-				}
+				clone.addAll((List) value);
 			} else {
 				clone.add(value);
 			}
@@ -127,10 +120,9 @@ abstract class AbstractAggregationExpression implements AggregationExpression {
 	@SuppressWarnings("unchecked")
 	protected java.util.Map<String, Object> append(String key, Object value) {
 
-		if (!(this.value instanceof java.util.Map)) {
-			throw new IllegalArgumentException("o_O");
-		}
-		java.util.Map<String, Object> clone = new LinkedHashMap<String, Object>((java.util.Map<String, Object>) this.value);
+		Assert.isInstanceOf(Map.class, this.value, "Value must be a type of Map!");
+
+		java.util.Map<String, Object> clone = new LinkedHashMap<>((java.util.Map) this.value);
 		clone.put(key, value);
 		return clone;
 
@@ -144,7 +136,67 @@ abstract class AbstractAggregationExpression implements AggregationExpression {
 		if (value instanceof java.util.Map) {
 			return new ArrayList<Object>(((java.util.Map) value).values());
 		}
-		return new ArrayList<Object>(Collections.singletonList(value));
+		return new ArrayList<>(Collections.singletonList(value));
+	}
+
+	/**
+	 * Get the value at a given index.
+	 *
+	 * @param index
+	 * @param <T>
+	 * @return
+	 * @since 2.1
+	 */
+	@SuppressWarnings("unchecked")
+	protected <T> T get(int index) {
+		return (T) values().get(index);
+	}
+
+	/**
+	 * Get the value for a given key.
+	 *
+	 * @param key
+	 * @param <T>
+	 * @return
+	 * @since 2.1
+	 */
+	@SuppressWarnings("unchecked")
+	protected <T> T get(Object key) {
+
+		Assert.isInstanceOf(Map.class, this.value, "Value must be a type of Map!");
+
+		return (T) ((java.util.Map<String, Object>) this.value).get(key);
+	}
+
+	/**
+	 * Get the argument map.
+	 *
+	 * @since 2.1
+	 * @return
+	 */
+	@SuppressWarnings("unchecked")
+	protected java.util.Map<String, Object> argumentMap() {
+
+		Assert.isInstanceOf(Map.class, this.value, "Value must be a type of Map!");
+
+		return Collections.unmodifiableMap((java.util.Map) value);
+	}
+
+	/**
+	 * Check if the given key is available.
+	 *
+	 * @param key
+	 * @return
+	 * @since 2.1
+	 */
+	@SuppressWarnings("unchecked")
+	protected boolean contains(Object key) {
+
+		if (!(this.value instanceof java.util.Map)) {
+			return false;
+		}
+
+		return ((java.util.Map<String, Object>) this.value).containsKey(key);
 	}
 
 	protected abstract String getMongoMethod();

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

@@ -64,6 +64,33 @@ public class Aggregation {
 	 */
 	public static final String CURRENT = SystemVariable.CURRENT.toString();
 
+	/**
+	 * A variable to conditionally exclude a field. In a {@code $projection}, a field set to the variable
+	 * {@literal REMOVE} is excluded from the output.
+	 *
+	 * <pre>
+	 * <code>
+	 *
+	 * db.books.aggregate( [
+	 * {
+	 *     $project: {
+	 *         title: 1,
+	 *         "author.first": 1,
+	 *         "author.last" : 1,
+	 *         "author.middle": {
+	 *             $cond: {
+	 *                 if: { $eq: [ "", "$author.middle" ] },
+	 *                 then: "$$REMOVE",
+	 *                 else: "$author.middle"
+	 *             }
+	 *         }
+	 *     }
+	 * } ] )
+	 * </code>
+	 * </pre>
+	 */
+	public static final String REMOVE = SystemVariable.REMOVE.toString();
+
 	public static final AggregationOperationContext DEFAULT_CONTEXT = AggregationOperationRenderer.DEFAULT_CONTEXT;
 	public static final AggregationOptions DEFAULT_OPTIONS = newAggregationOptions().build();
 
@@ -648,11 +675,12 @@ public class Aggregation {
 	 * Describes the system variables available in MongoDB aggregation framework pipeline expressions.
 	 *
 	 * @author Thomas Darimont
-	 * @see <a href="https://docs.mongodb.org/manual/reference/aggregation-variables">Aggregation Variables</a>
+	 * @author Christoph Strobl
+	 * @see <a href="https://docs.mongodb.com/manual/reference/aggregation-variables">Aggregation Variables</a>.
 	 */
 	enum SystemVariable {
 
-		ROOT, CURRENT;
+		ROOT, CURRENT, REMOVE;
 
 		private static final String PREFIX = "$$";
 

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

@@ -41,7 +41,7 @@ class AggregationOperationRenderer {
 	 * {@link Document} representation.
 	 *
 	 * @param operations must not be {@literal null}.
-	 * @param context must not be {@literal null}.
+	 * @param rootContext must not be {@literal null}.
 	 * @return the {@link List} of {@link Document}.
 	 */
 	static List<Document> toDocument(List<AggregationOperation> operations, AggregationOperationContext rootContext) {
@@ -59,7 +59,7 @@ class AggregationOperationRenderer {
 				FieldsExposingAggregationOperation exposedFieldsOperation = (FieldsExposingAggregationOperation) operation;
 				ExposedFields fields = exposedFieldsOperation.getFields();
 
-				if (operation instanceof InheritsFieldsAggregationOperation) {
+				if (operation instanceof InheritsFieldsAggregationOperation || exposedFieldsOperation.inheritsFields()) {
 					contextToUse = new InheritingExposedFieldsAggregationOperationContext(fields, contextToUse);
 				} else {
 					contextToUse = fields.exposesNoFields() ? DEFAULT_CONTEXT

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

@@ -267,6 +267,19 @@ public class ArrayOperators {
 			return (usesFieldRef() ? In.arrayOf(fieldReference) : In.arrayOf(expression)).containsValue(value);
 		}
 
+		/**
+		 * Creates new {@link AggregationExpression} that converts the associated expression into an object.
+		 * <strong>NOTE:</strong> Requires MongoDB 3.6 or later.
+		 *
+		 * @return new instance of {@link ArrayToObject}.
+		 * @since 2.1
+		 */
+		public ArrayToObject toObject() {
+
+			return usesFieldRef() ? ArrayToObject.arrayValueOfToObject(fieldReference)
+					: ArrayToObject.arrayValueOfToObject(expression);
+		}
+
 		/**
 		 * @author Christoph Strobl
 		 */
@@ -1497,4 +1510,59 @@ public class ArrayOperators {
 			In containsValue(Object value);
 		}
 	}
+
+	/**
+	 * {@link AggregationExpression} for {@code $arrayToObject} that transforms an array into a single document. <br />
+	 * <strong>NOTE:</strong> Requires MongoDB 3.6 or later.
+	 *
+	 * @author Christoph Strobl
+	 * @see <a href=
+	 *      "https://docs.mongodb.com/manual/reference/operator/aggregation/arrayToObject/">https://docs.mongodb.com/manual/reference/operator/aggregation/arrayToObject/</a>
+	 * @since 2.1
+	 */
+	public static class ArrayToObject extends AbstractAggregationExpression {
+
+		private ArrayToObject(Object value) {
+			super(value);
+		}
+
+		/**
+		 * Converts the given array (e.g. an array of two-element arrays, a field reference to an array,...) to an object.
+		 *
+		 * @param array must not be {@literal null}.
+		 * @return new instance of {@link ArrayToObject}.
+		 */
+		public static ArrayToObject arrayToObject(Object array) {
+			return new ArrayToObject(array);
+		}
+
+		/**
+		 * Converts the array pointed to by the given {@link Field field reference} to an object.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return new instance of {@link ArrayToObject}.
+		 */
+		public static ArrayToObject arrayValueOfToObject(String fieldReference) {
+			return new ArrayToObject(Fields.field(fieldReference));
+		}
+
+		/**
+		 * Converts the result array of the given {@link AggregationExpression expression} to an object.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return new instance of {@link ArrayToObject}.
+		 */
+		public static ArrayToObject arrayValueOfToObject(AggregationExpression expression) {
+			return new ArrayToObject(expression);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.aggregation.AbstractAggregationExpression#getMongoMethod()
+		 */
+		@Override
+		protected String getMongoMethod() {
+			return "$arrayToObject";
+		}
+	}
 }

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

@@ -0,0 +1,695 @@
+/*
+ * 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.aggregation;
+
+import java.util.Collections;
+
+import org.springframework.data.mongodb.core.schema.JsonSchemaObject.Type;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+
+/**
+ * Gateway to {@literal convert} aggregation operations.
+ *
+ * @author Christoph Strobl
+ * @since 2.1
+ */
+public class ConvertOperators {
+
+	/**
+	 * Take the field referenced by given {@literal fieldReference}.
+	 *
+	 * @param fieldReference must not be {@literal null}.
+	 * @return
+	 */
+	public static ConvertOperatorFactory valueOf(String fieldReference) {
+		return new ConvertOperatorFactory(fieldReference);
+	}
+
+	/**
+	 * Take the value resulting from the given {@link AggregationExpression}.
+	 *
+	 * @param expression must not be {@literal null}.
+	 * @return
+	 */
+	public static ConvertOperatorFactory valueOf(AggregationExpression expression) {
+		return new ConvertOperatorFactory(expression);
+	}
+
+	/**
+	 * @author Christoph Strobl
+	 */
+	public static class ConvertOperatorFactory {
+
+		private final @Nullable String fieldReference;
+		private final @Nullable AggregationExpression expression;
+
+		/**
+		 * Creates new {@link ConvertOperatorFactory} for given {@literal fieldReference}.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 */
+		public ConvertOperatorFactory(String fieldReference) {
+
+			Assert.notNull(fieldReference, "FieldReference must not be null!");
+
+			this.fieldReference = fieldReference;
+			this.expression = null;
+		}
+
+		/**
+		 * Creates new {@link ConvertOperatorFactory} for given {@link AggregationExpression}.
+		 *
+		 * @param expression must not be {@literal null}.
+		 */
+		public ConvertOperatorFactory(AggregationExpression expression) {
+
+			Assert.notNull(expression, "Expression must not be null!");
+
+			this.fieldReference = null;
+			this.expression = expression;
+		}
+
+		/**
+		 * Creates new {@link Convert aggregation expression} that takes the associated value and converts it into the type
+		 * specified by the given {@code stringTypeIdentifier}. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @param stringTypeIdentifier must not be {@literal null}.
+		 * @return new instance of {@link Convert}.
+		 */
+		public Convert convertTo(String stringTypeIdentifier) {
+			return createConvert().to(stringTypeIdentifier);
+		}
+
+		/**
+		 * Creates new {@link Convert aggregation expression} that takes the associated value and converts it into the type
+		 * specified by the given {@code numericTypeIdentifier}. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @param numericTypeIdentifier must not be {@literal null}.
+		 * @return new instance of {@link Convert}.
+		 */
+		public Convert convertTo(int numericTypeIdentifier) {
+			return createConvert().to(numericTypeIdentifier);
+		}
+
+		/**
+		 * Creates new {@link Convert aggregation expression} that takes the associated value and converts it into the type
+		 * specified by the given {@link Type}. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @param type must not be {@literal null}.
+		 * @return new instance of {@link Convert}.
+		 */
+		public Convert convertTo(Type type) {
+			return createConvert().to(type);
+		}
+
+		/**
+		 * Creates new {@link Convert aggregation expression} that takes the associated value and converts it into the type
+		 * specified by the value of the given {@link Field field reference}. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return new instance of {@link Convert}.
+		 */
+		public Convert convertToTypeOf(String fieldReference) {
+			return createConvert().toTypeOf(fieldReference);
+		}
+
+		/**
+		 * Creates new {@link Convert aggregation expression} that takes the associated value and converts it into the type
+		 * specified by the given {@link AggregationExpression expression}. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return new instance of {@link Convert}.
+		 */
+		public Convert convertToTypeOf(AggregationExpression expression) {
+			return createConvert().toTypeOf(expression);
+		}
+
+		/**
+		 * Creates new {@link ToBool aggregation expression} for {@code $toBool} that converts a value to boolean. Shorthand
+		 * for {@link #convertTo(String) #convertTo("bool")}. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @return new instance of {@link ToBool}.
+		 */
+		public ToBool convertToBoolean() {
+			return ToBool.toBoolean(valueObject());
+		}
+
+		/**
+		 * Creates new {@link ToDate aggregation expression} for {@code $toDate} that converts a value to a date. Shorthand
+		 * for {@link #convertTo(String) #convertTo("date")}. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @return new instance of {@link ToDate}.
+		 */
+		public ToDate convertToDate() {
+			return ToDate.toDate(valueObject());
+		}
+
+		/**
+		 * Creates new {@link ToDecimal aggregation expression} for {@code $toDecimal} that converts a value to a decimal.
+		 * Shorthand for {@link #convertTo(String) #convertTo("decimal")}. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @return new instance of {@link ToDecimal}.
+		 */
+		public ToDecimal convertToDecimal() {
+			return ToDecimal.toDecimal(valueObject());
+		}
+
+		/**
+		 * Creates new {@link ToDouble aggregation expression} for {@code $toDouble} that converts a value to a decimal.
+		 * Shorthand for {@link #convertTo(String) #convertTo("double")}. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @return new instance of {@link ToDouble}.
+		 */
+		public ToDouble convertToDouble() {
+			return ToDouble.toDouble(valueObject());
+		}
+
+		/**
+		 * Creates new {@link ToInt aggregation expression} for {@code $toInt} that converts a value to an int. Shorthand
+		 * for {@link #convertTo(String) #convertTo("int")}. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @return new instance of {@link ToInt}.
+		 */
+		public ToInt convertToInt() {
+			return ToInt.toInt(valueObject());
+		}
+
+		/**
+		 * Creates new {@link ToInt aggregation expression} for {@code $toLong} that converts a value to a long. Shorthand
+		 * for {@link #convertTo(String) #convertTo("long")}. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @return new instance of {@link ToInt}.
+		 */
+		public ToLong convertToLong() {
+			return ToLong.toLong(valueObject());
+		}
+
+		/**
+		 * Creates new {@link ToInt aggregation expression} for {@code $toObjectId} that converts a value to a objectId. Shorthand
+		 * for {@link #convertTo(String) #convertTo("objectId")}. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @return new instance of {@link ToInt}.
+		 */
+		public ToObjectId convertToObjectId() {
+			return ToObjectId.toObjectId(valueObject());
+		}
+
+		/**
+		 * Creates new {@link ToInt aggregation expression} for {@code $toString} that converts a value to a string. Shorthand
+		 * for {@link #convertTo(String) #convertTo("string")}. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @return new instance of {@link ToInt}.
+		 */
+		public ToString convertToString() {
+			return ToString.toString(valueObject());
+		}
+
+		private Convert createConvert() {
+			return usesFieldRef() ? Convert.convertValueOf(fieldReference) : Convert.convertValueOf(expression);
+		}
+
+		private Object valueObject() {
+			return usesFieldRef() ? Fields.field(fieldReference) : expression;
+		}
+
+		private boolean usesFieldRef() {
+			return fieldReference != null;
+		}
+	}
+
+	/**
+	 * {@link AggregationExpression} for {@code $convert} that converts a value to a specified type. <br />
+	 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+	 *
+	 * @author Christoph Strobl
+	 * @see <a href=
+	 * "https://docs.mongodb.com/manual/reference/operator/aggregation/convert/">https://docs.mongodb.com/manual/reference/operator/aggregation/convert/</a>
+	 * @since 2.1
+	 */
+	public static class Convert extends AbstractAggregationExpression {
+
+		private Convert(Object value) {
+			super(value);
+		}
+
+		/**
+		 * Creates new {@link Convert} using the given value for the {@literal input} attribute.
+		 *
+		 * @param value must not be {@literal null}.
+		 * @return new instance of {@link Convert}.
+		 */
+		public static Convert convertValue(Object value) {
+			return new Convert(Collections.singletonMap("input", value));
+		}
+
+		/**
+		 * Creates new {@link Convert} using the value of the provided {@link Field fieldReference} as {@literal input}
+		 * value.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return new instance of {@link Convert}.
+		 */
+		public static Convert convertValueOf(String fieldReference) {
+			return convertValue(Fields.field(fieldReference));
+		}
+
+		/**
+		 * Creates new {@link Convert} using the result of the provided {@link AggregationExpression expression} as
+		 * {@literal input} value.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return new instance of {@link Convert}.
+		 */
+		public static Convert convertValueOf(AggregationExpression expression) {
+			return convertValue(expression);
+		}
+
+		/**
+		 * Specify the conversion target type via its {@link String} representation.
+		 * <ul>
+		 * <li>double</li>
+		 * <li>string</li>
+		 * <li>objectId</li>
+		 * <li>bool</li>
+		 * <li>date</li>
+		 * <li>int</li>
+		 * <li>long</li>
+		 * <li>decimal</li>
+		 * </ul>
+		 *
+		 * @param stringTypeIdentifier must not be {@literal null}.
+		 * @return new instance of {@link Convert}.
+		 */
+		public Convert to(String stringTypeIdentifier) {
+			return new Convert(append("to", stringTypeIdentifier));
+		}
+
+		/**
+		 * Specify the conversion target type via its numeric representation.
+		 * <dl>
+		 * <dt>1</dt>
+		 * <dd>double</dd>
+		 * <dt>2</dt>
+		 * <dd>string</li>
+		 * <dt>7</dt>
+		 * <dd>objectId</li>
+		 * <dt>8</dt>
+		 * <dd>bool</dd>
+		 * <dt>9</dt>
+		 * <dd>date</dd>
+		 * <dt>16</dt>
+		 * <dd>int</dd>
+		 * <dt>18</dt>
+		 * <dd>long</dd>
+		 * <dt>19</dt>
+		 * <dd>decimal</dd>
+		 * </dl>
+		 *
+		 * @param numericTypeIdentifier must not be {@literal null}.
+		 * @return new instance of {@link Convert}.
+		 */
+		public Convert to(int numericTypeIdentifier) {
+			return new Convert(append("to", numericTypeIdentifier));
+		}
+
+		/**
+		 * Specify the conversion target type.
+		 *
+		 * @param type must not be {@literal null}.
+		 * @return new instance of {@link Convert}.
+		 */
+		public Convert to(Type type) {
+
+			String typeString = Type.BOOLEAN.equals(type) ? "bool" : type.value().toString();
+			return to(typeString);
+		}
+
+		/**
+		 * Specify the conversion target type via the value of the given field.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return new instance of {@link Convert}.
+		 */
+		public Convert toTypeOf(String fieldReference) {
+			return new Convert(append("to", Fields.field(fieldReference)));
+		}
+
+		/**
+		 * Specify the conversion target type via the value of the given {@link AggregationExpression expression}.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return new instance of {@link Convert}.
+		 */
+		public Convert toTypeOf(AggregationExpression expression) {
+			return new Convert(append("to", expression));
+		}
+
+		/**
+		 * Optionally specify the value to return on encountering an error during conversion.
+		 *
+		 * @param value must not be {@literal null}.
+		 * @return new instance of {@link Convert}.
+		 */
+		public Convert onErrorReturn(Object value) {
+			return new Convert(append("onError", value));
+		}
+
+		/**
+		 * Optionally specify the field holding the value to return on encountering an error during conversion.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return new instance of {@link Convert}.
+		 */
+		public Convert onErrorReturnValueOf(String fieldReference) {
+			return onErrorReturn(Fields.field(fieldReference));
+		}
+
+		/**
+		 * Optionally specify the expression to evaluate and return on encountering an error during conversion.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return new instance of {@link Convert}.
+		 */
+		public Convert onErrorReturnValueOf(AggregationExpression expression) {
+			return onErrorReturn(expression);
+		}
+
+		/**
+		 * Optionally specify the value to return when the input is {@literal null} or missing.
+		 *
+		 * @param value must not be {@literal null}.
+		 * @return new instance of {@link Convert}.
+		 */
+		public Convert onNullReturn(Object value) {
+			return new Convert(append("onNull", value));
+		}
+
+		/**
+		 * Optionally specify the field holding the value to return when the input is {@literal null} or missing.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return new instance of {@link Convert}.
+		 */
+		public Convert onNullReturnValueOf(String fieldReference) {
+			return onNullReturn(Fields.field(fieldReference));
+		}
+
+		/**
+		 * Optionally specify the expression to evaluate and return when the input is {@literal null} or missing.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return new instance of {@link Convert}.
+		 */
+		public Convert onNullReturnValueOf(AggregationExpression expression) {
+			return onNullReturn(expression);
+		}
+
+		@Override
+		protected String getMongoMethod() {
+			return "$convert";
+		}
+	}
+
+	/**
+	 * {@link AggregationExpression} for {@code $toBool} that converts a value to {@literal boolean}. Shorthand for
+	 * {@link Convert#to(String) Convert#to("bool")}. <br />
+	 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+	 *
+	 * @author Christoph Strobl
+	 * @see <a href=
+	 *      "https://docs.mongodb.com/manual/reference/operator/aggregation/toBool/">https://docs.mongodb.com/manual/reference/operator/aggregation/toBool/</a>
+	 * @since 2.1
+	 */
+	public static class ToBool extends AbstractAggregationExpression {
+
+		private ToBool(Object value) {
+			super(value);
+		}
+
+		/**
+		 * Creates new {@link ToBool} using the given value as input.
+		 *
+		 * @param value must not be {@literal null}.
+		 * @return new instance of {@link ToBool}.
+		 */
+		public static ToBool toBoolean(Object value) {
+			return new ToBool(value);
+		}
+
+		@Override
+		protected String getMongoMethod() {
+			return "$toBool";
+		}
+	}
+
+	/**
+	 * {@link AggregationExpression} for {@code $toDate} that converts a value to {@literal date}. Shorthand for
+	 * {@link Convert#to(String) Convert#to("date")}. <br />
+	 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+	 *
+	 * @author Christoph Strobl
+	 * @see <a href=
+	 *      "https://docs.mongodb.com/manual/reference/operator/aggregation/toDate/">https://docs.mongodb.com/manual/reference/operator/aggregation/toDate/</a>
+	 * @since 2.1
+	 */
+	public static class ToDate extends AbstractAggregationExpression {
+
+		private ToDate(Object value) {
+			super(value);
+		}
+
+		/**
+		 * Creates new {@link ToDate} using the given value as input.
+		 *
+		 * @param value must not be {@literal null}.
+		 * @return new instance of {@link ToDate}.
+		 */
+		public static ToDate toDate(Object value) {
+			return new ToDate(value);
+		}
+
+		@Override
+		protected String getMongoMethod() {
+			return "$toDate";
+		}
+	}
+
+	/**
+	 * {@link AggregationExpression} for {@code $toDecimal} that converts a value to {@literal decimal}. Shorthand for
+	 * {@link Convert#to(String) Convert#to("decimal")}. <br />
+	 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+	 *
+	 * @author Christoph Strobl
+	 * @see <a href=
+	 *      "https://docs.mongodb.com/manual/reference/operator/aggregation/toDecimal/">https://docs.mongodb.com/manual/reference/operator/aggregation/toDecimal/</a>
+	 * @since 2.1
+	 */
+	public static class ToDecimal extends AbstractAggregationExpression {
+
+		private ToDecimal(Object value) {
+			super(value);
+		}
+
+		/**
+		 * Creates new {@link ToDecimal} using the given value as input.
+		 *
+		 * @param value must not be {@literal null}.
+		 * @return new instance of {@link ToDecimal}.
+		 */
+		public static ToDecimal toDecimal(Object value) {
+			return new ToDecimal(value);
+		}
+
+		@Override
+		protected String getMongoMethod() {
+			return "$toDecimal";
+		}
+	}
+
+	/**
+	 * {@link AggregationExpression} for {@code $toDouble} that converts a value to {@literal double}. Shorthand for
+	 * {@link Convert#to(String) Convert#to("double")}. <br />
+	 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+	 *
+	 * @author Christoph Strobl
+	 * @see <a href=
+	 *      "https://docs.mongodb.com/manual/reference/operator/aggregation/toDouble/">https://docs.mongodb.com/manual/reference/operator/aggregation/toDouble/</a>
+	 * @since 2.1
+	 */
+	public static class ToDouble extends AbstractAggregationExpression {
+
+		private ToDouble(Object value) {
+			super(value);
+		}
+
+		/**
+		 * Creates new {@link ToDouble} using the given value as input.
+		 *
+		 * @param value must not be {@literal null}.
+		 * @return new instance of {@link ToDouble}.
+		 */
+		public static ToDouble toDouble(Object value) {
+			return new ToDouble(value);
+		}
+
+		@Override
+		protected String getMongoMethod() {
+			return "$toDouble";
+		}
+	}
+
+	/**
+	 * {@link AggregationExpression} for {@code $toInt} that converts a value to {@literal integer}. Shorthand for
+	 * {@link Convert#to(String) Convert#to("int")}. <br />
+	 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+	 *
+	 * @author Christoph Strobl
+	 * @see <a href=
+	 *      "https://docs.mongodb.com/manual/reference/operator/aggregation/toInt/">https://docs.mongodb.com/manual/reference/operator/aggregation/toInt/</a>
+	 * @since 2.1
+	 */
+	public static class ToInt extends AbstractAggregationExpression {
+
+		private ToInt(Object value) {
+			super(value);
+		}
+
+		/**
+		 * Creates new {@link ToInt} using the given value as input.
+		 *
+		 * @param value must not be {@literal null}.
+		 * @return new instance of {@link ToInt}.
+		 */
+		public static ToInt toInt(Object value) {
+			return new ToInt(value);
+		}
+
+		@Override
+		protected String getMongoMethod() {
+			return "$toInt";
+		}
+	}
+
+	/**
+	 * {@link AggregationExpression} for {@code $toLong} that converts a value to {@literal long}. Shorthand for
+	 * {@link Convert#to(String) Convert#to("long")}. <br />
+	 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+	 *
+	 * @author Christoph Strobl
+	 * @see <a href=
+	 *      "https://docs.mongodb.com/manual/reference/operator/aggregation/toLong/">https://docs.mongodb.com/manual/reference/operator/aggregation/toLong/</a>
+	 * @since 2.1
+	 */
+	public static class ToLong extends AbstractAggregationExpression {
+
+		private ToLong(Object value) {
+			super(value);
+		}
+
+		/**
+		 * Creates new {@link ToLong} using the given value as input.
+		 *
+		 * @param value must not be {@literal null}.
+		 * @return new instance of {@link ToLong}.
+		 */
+		public static ToLong toLong(Object value) {
+			return new ToLong(value);
+		}
+
+		@Override
+		protected String getMongoMethod() {
+			return "$toLong";
+		}
+	}
+
+	/**
+	 * {@link AggregationExpression} for {@code $toObjectId} that converts a value to {@literal objectId}. Shorthand for
+	 * {@link Convert#to(String) Convert#to("objectId")}. <br />
+	 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+	 *
+	 * @author Christoph Strobl
+	 * @see <a href=
+	 *      "https://docs.mongodb.com/manual/reference/operator/aggregation/toObjectId/">https://docs.mongodb.com/manual/reference/operator/aggregation/toObjectId/</a>
+	 * @since 2.1
+	 */
+	public static class ToObjectId extends AbstractAggregationExpression {
+
+		private ToObjectId(Object value) {
+			super(value);
+		}
+
+		/**
+		 * Creates new {@link ToObjectId} using the given value as input.
+		 *
+		 * @param value must not be {@literal null}.
+		 * @return new instance of {@link ToObjectId}.
+		 */
+		public static ToObjectId toObjectId(Object value) {
+			return new ToObjectId(value);
+		}
+
+		@Override
+		protected String getMongoMethod() {
+			return "$toObjectId";
+		}
+	}
+
+	/**
+	 * {@link AggregationExpression} for {@code $toString} that converts a value to {@literal string}. Shorthand for
+	 * {@link Convert#to(String) Convert#to("string")}. <br />
+	 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+	 *
+	 * @author Christoph Strobl
+	 * @see <a href=
+	 *      "https://docs.mongodb.com/manual/reference/operator/aggregation/toString/">https://docs.mongodb.com/manual/reference/operator/aggregation/toString/</a>
+	 * @since 2.1
+	 */
+	public static class ToString extends AbstractAggregationExpression {
+
+		private ToString(Object value) {
+			super(value);
+		}
+
+		/**
+		 * Creates new {@link ToString} using the given value as input.
+		 *
+		 * @param value must not be {@literal null}.
+		 * @return new instance of {@link ToString}.
+		 */
+		public static ToString toString(Object value) {
+			return new ToString(value);
+		}
+
+		@Override
+		protected String getMongoMethod() {
+			return "$toString";
+		}
+	}
+}

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

@@ -33,9 +33,26 @@ public interface FieldsExposingAggregationOperation extends AggregationOperation
 	 */
 	ExposedFields getFields();
 
+	/**
+	 * @return {@literal true} to conditionally inherit fields from previous operations.
+	 * @since 2.0.6
+	 */
+	default boolean inheritsFields() {
+		return false;
+	}
+
 	/**
 	 * Marker interface for {@link AggregationOperation} that inherits fields from previous operations.
 	 */
-	interface InheritsFieldsAggregationOperation extends FieldsExposingAggregationOperation {}
+	interface InheritsFieldsAggregationOperation extends FieldsExposingAggregationOperation {
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.aggregation.FieldsExposingAggregationOperation#inheritsFields()
+		 */
+		@Override
+		default boolean inheritsFields() {
+			return true;
+		}
+	}
 }

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

@@ -17,7 +17,9 @@ package org.springframework.data.mongodb.core.aggregation;
 
 import org.bson.Document;
 import org.springframework.data.mongodb.core.query.NearQuery;
+import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
 
 /**
  * Represents a {@code geoNear} aggregation operation.
@@ -28,26 +30,55 @@ import org.springframework.util.Assert;
  * @author Thomas Darimont
  * @author Christoph Strobl
  * @since 1.3
+ * @see <a href="https://docs.mongodb.com/manual/reference/operator/aggregation/geoNear/">MongoDB Aggregation Framework:
+ *      $geoNear</a>
  */
 public class GeoNearOperation implements AggregationOperation {
 
 	private final NearQuery nearQuery;
 	private final String distanceField;
+	private final @Nullable String indexKey;
 
 	/**
 	 * Creates a new {@link GeoNearOperation} from the given {@link NearQuery} and the given distance field. The
 	 * {@code distanceField} defines output field that contains the calculated distance.
 	 *
-	 * @param query must not be {@literal null}.
+	 * @param nearQuery must not be {@literal null}.
 	 * @param distanceField must not be {@literal null}.
 	 */
 	public GeoNearOperation(NearQuery nearQuery, String distanceField) {
+		this(nearQuery, distanceField, null);
+	}
+
+	/**
+	 * Creates a new {@link GeoNearOperation} from the given {@link NearQuery} and the given distance field. The
+	 * {@code distanceField} defines output field that contains the calculated distance.
+	 *
+	 * @param nearQuery must not be {@literal null}.
+	 * @param distanceField must not be {@literal null}.
+	 * @param indexKey can be {@literal null};
+	 * @since 2.1
+	 */
+	private GeoNearOperation(NearQuery nearQuery, String distanceField, @Nullable String indexKey) {
 
 		Assert.notNull(nearQuery, "NearQuery must not be null.");
 		Assert.hasLength(distanceField, "Distance field must not be null or empty.");
 
 		this.nearQuery = nearQuery;
 		this.distanceField = distanceField;
+		this.indexKey = indexKey;
+	}
+
+	/**
+	 * Optionally specify the geospatial index to use via the field to use in the calculation. <br />
+	 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+	 *
+	 * @param key the geospatial index field to use when calculating the distance.
+	 * @return new instance of {@link GeoNearOperation}.
+	 * @since 2.1
+	 */
+	public GeoNearOperation useIndex(String key) {
+		return new GeoNearOperation(nearQuery, distanceField, key);
 	}
 
 	/*
@@ -60,6 +91,10 @@ public class GeoNearOperation implements AggregationOperation {
 		Document command = context.getMappedObject(nearQuery.toDocument());
 		command.put("distanceField", distanceField);
 
+		if (StringUtils.hasText(indexKey)) {
+			command.put("key", indexKey);
+		}
+
 		return new Document("$geoNear", command);
 	}
 }

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

@@ -0,0 +1,298 @@
+/*
+ * 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.aggregation;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import org.bson.Document;
+import org.springframework.util.Assert;
+
+/**
+ * Gateway for
+ * <a href="https://docs.mongodb.com/manual/meta/aggregation-quick-reference/#object-expression-operators">object
+ * expression operators</a>.
+ *
+ * @author Christoph Strobl
+ * @since 2.1
+ */
+public class ObjectOperators {
+
+	/**
+	 * Take the value referenced by given {@literal fieldReference}.
+	 *
+	 * @param fieldReference must not be {@literal null}.
+	 * @return new instance of {@link ObjectOperatorFactory}.
+	 */
+	public static ObjectOperatorFactory valueOf(String fieldReference) {
+		return new ObjectOperatorFactory(Fields.field(fieldReference));
+	}
+
+	/**
+	 * Take the value provided by the given {@link AggregationExpression}.
+	 *
+	 * @param expression must not be {@literal null}.
+	 * @return new instance of {@link ObjectOperatorFactory}.
+	 */
+	public static ObjectOperatorFactory valueOf(AggregationExpression expression) {
+		return new ObjectOperatorFactory(expression);
+	}
+
+	/**
+	 * @author Christoph Strobl
+	 */
+	public static class ObjectOperatorFactory {
+
+		private final Object value;
+
+		/**
+		 * Creates new {@link ObjectOperatorFactory} for given {@literal value}.
+		 *
+		 * @param value must not be {@literal null}.
+		 */
+		public ObjectOperatorFactory(Object value) {
+
+			Assert.notNull(value, "Value must not be null!");
+
+			this.value = value;
+		}
+
+		/**
+		 * Creates new {@link MergeObjects aggregation expression} that takes the associated value and uses
+		 * {@literal $mergeObjects} as an accumulator within the {@literal $group} stage. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @return new instance of {@link MergeObjects}.
+		 */
+		public MergeObjects merge() {
+			return MergeObjects.merge(value);
+		}
+
+		/**
+		 * Creates new {@link MergeObjects aggregation expression} that takes the associated value and combines it with the
+		 * given values (documents or mapped objects) into a single document. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @return new instance of {@link MergeObjects}.
+		 */
+		public MergeObjects mergeWith(Object... values) {
+			return merge().mergeWith(values);
+		}
+
+		/**
+		 * Creates new {@link MergeObjects aggregation expression} that takes the associated value and combines it with the
+		 * values of the given {@link Field field references} into a single document. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @return new instance of {@link MergeObjects}.
+		 */
+		public MergeObjects mergeWithValuesOf(String... fieldReferences) {
+			return merge().mergeWithValuesOf(fieldReferences);
+		}
+
+		/**
+		 * Creates new {@link MergeObjects aggregation expression} that takes the associated value and combines it with the
+		 * result values of the given {@link Aggregation expressions} into a single document. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @return new instance of {@link MergeObjects}.
+		 */
+		public MergeObjects mergeWithValuesOf(AggregationExpression... expression) {
+			return merge().mergeWithValuesOf(expression);
+		}
+
+		/**
+		 * Creates new {@link ObjectToArray aggregation expression} that takes the associated value and converts it to an
+		 * array of {@link Document documents} that contain two fields {@literal k} and {@literal v} each. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 3.6 or later.
+		 * 
+		 * @since 2.1
+		 */
+		public ObjectToArray toArray() {
+			return ObjectToArray.toArray(value);
+		}
+	}
+
+	/**
+	 * {@link AggregationExpression} for {@code $mergeObjects} that combines multiple documents into a single document.
+	 * <br />
+	 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+	 *
+	 * @author Christoph Strobl
+	 * @see <a href=
+	 *      "https://docs.mongodb.com/manual/reference/operator/aggregation/mergeObjects/">https://docs.mongodb.com/manual/reference/operator/aggregation/mergeObjects/</a>
+	 * @since 2.1
+	 */
+	public static class MergeObjects extends AbstractAggregationExpression {
+
+		private MergeObjects(Object value) {
+			super(value);
+		}
+
+		/**
+		 * Creates new {@link MergeObjects aggregation expression} that takes given values and combines them into a single
+		 * document. <br />
+		 *
+		 * @param values must not be {@literal null}.
+		 * @return new instance of {@link MergeObjects}.
+		 */
+		public static MergeObjects merge(Object... values) {
+			return new MergeObjects(Arrays.asList(values));
+		}
+
+		/**
+		 * Creates new {@link MergeObjects aggregation expression} that takes the given {@link Field field references} and
+		 * combines them into a single document.
+		 *
+		 * @param fieldReferences must not be {@literal null}.
+		 * @return new instance of {@link MergeObjects}.
+		 */
+		public static MergeObjects mergeValuesOf(String... fieldReferences) {
+			return merge(Arrays.stream(fieldReferences).map(Fields::field).toArray());
+		}
+
+		/**
+		 * Creates new {@link MergeObjects aggregation expression} that takes the result of the given {@link Aggregation
+		 * expressions} and combines them into a single document.
+		 *
+		 * @param expressions must not be {@literal null}.
+		 * @return new instance of {@link MergeObjects}.
+		 */
+		public static MergeObjects mergeValuesOf(AggregationExpression... expressions) {
+			return merge(expressions);
+		}
+
+		/**
+		 * Creates new {@link MergeObjects aggregation expression} by adding the given {@link Field field references}.
+		 *
+		 * @param fieldReferences must not be {@literal null}.
+		 * @return new instance of {@link MergeObjects}.
+		 */
+		public MergeObjects mergeWithValuesOf(String... fieldReferences) {
+			return mergeWith(Arrays.stream(fieldReferences).map(Fields::field).toArray());
+		}
+
+		/**
+		 * Creates new {@link MergeObjects aggregation expression} by adding the given {@link AggregationExpression
+		 * expressions}.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return new instance of {@link MergeObjects}.
+		 */
+		public MergeObjects mergeWithValuesOf(AggregationExpression... expression) {
+			return mergeWith(expression);
+		}
+
+		/**
+		 * Creates new {@link MergeObjects aggregation expression} by adding the given values (documents or mapped objects).
+		 *
+		 * @param values must not be {@literal null}.
+		 * @return new instance of {@link MergeObjects}.
+		 */
+		public MergeObjects mergeWith(Object... values) {
+			return new MergeObjects(append(Arrays.asList(values)));
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.aggregation.AbstractAggregationExpression#toDocument(java.lang.Object, org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)
+		 */
+		@Override
+		public Document toDocument(Object value, AggregationOperationContext context) {
+			return super.toDocument(potentiallyExtractSingleValue(value), context);
+		}
+
+		@SuppressWarnings("unchecked")
+		private Object potentiallyExtractSingleValue(Object value) {
+
+			if (value instanceof Collection) {
+
+				Collection<Object> collection = ((Collection<Object>) value);
+				if (collection.size() == 1) {
+					return collection.iterator().next();
+				}
+			}
+			return value;
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.aggregation.AbstractAggregationExpression#getMongoMethod()
+		 */
+		@Override
+		protected String getMongoMethod() {
+			return "$mergeObjects";
+		}
+	}
+
+	/**
+	 * {@link AggregationExpression} for {@code $objectToArray} that converts a document to an array of {@link Document
+	 * documents} that each contains two fields {@literal k} and {@literal v}. <br />
+	 * <strong>NOTE:</strong> Requires MongoDB 3.6 or later.
+	 *
+	 * @author Christoph Strobl
+	 * @see <a href=
+	 *      "https://docs.mongodb.com/manual/reference/operator/aggregation/objectToArray/">https://docs.mongodb.com/manual/reference/operator/aggregation/objectToArray/</a>
+	 * @since 2.1
+	 */
+	public static class ObjectToArray extends AbstractAggregationExpression {
+
+		private ObjectToArray(Object value) {
+			super(value);
+		}
+
+		/**
+		 * Creates new {@link ObjectToArray aggregation expression} that takes the value pointed to by given {@link Field
+		 * fieldReference} and converts it to an array.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return new instance of {@link ObjectToArray}.
+		 */
+		public static ObjectToArray valueOfToArray(String fieldReference) {
+			return toArray(Fields.field(fieldReference));
+		}
+
+		/**
+		 * Creates new {@link ObjectToArray aggregation expression} that takes the result value of the given
+		 * {@link AggregationExpression expression} and converts it to an array.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return new instance of {@link ObjectToArray}.
+		 */
+		public static ObjectToArray valueOfToArray(AggregationExpression expression) {
+			return toArray(expression);
+		}
+
+		/**
+		 * Creates new {@link ObjectToArray aggregation expression} that takes the given value and converts it to an array.
+		 *
+		 * @param value must not be {@literal null}.
+		 * @return new instance of {@link ObjectToArray}.
+		 */
+		public static ObjectToArray toArray(Object value) {
+			return new ObjectToArray(value);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.aggregation.AbstractAggregationExpression#getMongoMethod()
+		 */
+		@Override
+		protected String getMongoMethod() {
+			return "$objectToArray";
+		}
+	}
+}

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

@@ -102,7 +102,7 @@ public class PrefixingDelegatingAggregationOperationContext implements Aggregati
 	}
 
 	private String prefixKey(String key) {
-		return (key.startsWith("$") || blacklist.contains(key)) ? key : (prefix + "." + key);
+		return (key.startsWith("$") || isBlacklisted(key)) ? key : (prefix + "." + key);
 	}
 
 	private Object prefixCollection(Collection<Object> sourceCollection) {
@@ -119,4 +119,23 @@ public class PrefixingDelegatingAggregationOperationContext implements Aggregati
 
 		return prefixed;
 	}
+
+	private boolean isBlacklisted(String key) {
+
+		if (blacklist.contains(key)) {
+			return true;
+		}
+
+		if (!key.contains(".")) {
+			return false;
+		}
+
+		for (String blacklisted : blacklist) {
+			if (key.startsWith(blacklisted + ".")) {
+				return true;
+			}
+		}
+
+		return false;
+	}
 }

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

@@ -140,11 +140,6 @@ public class ProjectionOperation implements FieldsExposingAggregationOperation {
 	 */
 	public ProjectionOperation andExclude(String... fieldNames) {
 
-		for (String fieldName : fieldNames) {
-			Assert.isTrue(Fields.UNDERSCORE_ID.equals(fieldName),
-					String.format(EXCLUSION_ERROR, fieldName, Fields.UNDERSCORE_ID));
-		}
-
 		List<FieldProjection> excludeProjections = FieldProjection.from(Fields.fields(fieldNames), false);
 		return new ProjectionOperation(this.projections, excludeProjections);
 	}
@@ -188,6 +183,18 @@ public class ProjectionOperation implements FieldsExposingAggregationOperation {
 		return fields != null ? fields : ExposedFields.empty();
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.aggregation.FieldsExposingAggregationOperation#inheritsFields()
+	 */
+	@Override
+	public boolean inheritsFields() {
+
+		return projections.stream().filter(FieldProjection.class::isInstance) //
+				.map(FieldProjection.class::cast) //
+				.anyMatch(FieldProjection::isExcluded);
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperation#toDocument(org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)
@@ -455,7 +462,7 @@ public class ProjectionOperation implements FieldsExposingAggregationOperation {
 			}
 
 			if (value instanceof AggregationExpression) {
-				return this.operation.and(new ExpressionProjection(Fields.field(alias), (AggregationExpression) value));
+				return this.operation.and(new ExpressionProjection(Fields.field(alias, alias), (AggregationExpression) value));
 			}
 
 			return this.operation.and(new FieldProjection(Fields.field(alias, getRequiredName()), null));
@@ -1197,6 +1204,18 @@ public class ProjectionOperation implements FieldsExposingAggregationOperation {
 			return this.operation.and(DateOperators.DateToString.dateOf(getRequiredName()).toString(format));
 		}
 
+		/**
+		 * Generates a {@code $dateToString} expression that takes the date representation of the previously mentioned field
+		 * using the server default format. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @return
+		 * @since 2.1
+		 */
+		public ProjectionOperationBuilder dateAsFormattedString() {
+			return this.operation.and(DateOperators.DateToString.dateOf(getRequiredName()).defaultFormat());
+		}
+
 		/**
 		 * Generates a {@code $let} expression that binds variables for use in the specified expression, and returns the
 		 * result of the expression.
@@ -1344,6 +1363,13 @@ public class ProjectionOperation implements FieldsExposingAggregationOperation {
 				return projections;
 			}
 
+			/**
+			 * @return {@literal true} if this field is excluded.
+			 */
+			public boolean isExcluded() {
+				return Boolean.FALSE.equals(value);
+			}
+
 			/*
 			 * (non-Javadoc)
 			 * @see org.springframework.data.mongodb.core.aggregation.ProjectionOperation.Projection#toDocument(org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)

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

@@ -350,8 +350,7 @@ public class StringOperators {
 		 * @return
 		 */
 		public StrLenBytes length() {
-			return usesFieldRef() ? StrLenBytes.stringLengthOf(fieldReference)
-					: StrLenBytes.stringLengthOf(expression);
+			return usesFieldRef() ? StrLenBytes.stringLengthOf(fieldReference) : StrLenBytes.stringLengthOf(expression);
 		}
 
 		/**
@@ -391,6 +390,132 @@ public class StringOperators {
 			return usesFieldRef() ? SubstrCP.valueOf(fieldReference) : SubstrCP.valueOf(expression);
 		}
 
+		/**
+		 * Creates new {@link AggregationExpression} that takes the associated string representation and trims whitespaces
+		 * from the beginning and end. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @return new instance of {@link Trim}.
+		 * @since 2.1
+		 */
+		public Trim trim() {
+			return createTrim();
+		}
+
+		/**
+		 * Creates new {@link AggregationExpression} that takes the associated string representation and trims the given
+		 * character sequence from the beginning and end. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @param chars must not be {@literal null}.
+		 * @return new instance of {@link Trim}.
+		 * @since 2.1
+		 */
+		public Trim trim(String chars) {
+			return trim().chars(chars);
+		}
+
+		/**
+		 * Creates new {@link AggregationExpression} that takes the associated string representation and trims the character
+		 * sequence resulting from the given {@link AggregationExpression} from the beginning and end. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return new instance of {@link Trim}.
+		 * @since 2.1
+		 */
+		public Trim trim(AggregationExpression expression) {
+			return trim().charsOf(expression);
+		}
+
+		private Trim createTrim() {
+			return usesFieldRef() ? Trim.valueOf(fieldReference) : Trim.valueOf(expression);
+		}
+
+		/**
+		 * Creates new {@link AggregationExpression} that takes the associated string representation and trims whitespaces
+		 * from the beginning. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @return new instance of {@link LTrim}.
+		 * @since 2.1
+		 */
+		public LTrim ltrim() {
+			return createLTrim();
+		}
+
+		/**
+		 * Creates new {@link AggregationExpression} that takes the associated string representation and trims the given
+		 * character sequence from the beginning. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @param chars must not be {@literal null}.
+		 * @return new instance of {@link LTrim}.
+		 * @since 2.1
+		 */
+		public LTrim ltrim(String chars) {
+			return ltrim().chars(chars);
+		}
+
+		/**
+		 * Creates new {@link AggregationExpression} that takes the associated string representation and trims the character
+		 * sequence resulting from the given {@link AggregationExpression} from the beginning. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return new instance of {@link LTrim}.
+		 * @since 2.1
+		 */
+		public LTrim ltrim(AggregationExpression expression) {
+			return ltrim().charsOf(expression);
+		}
+
+		private LTrim createLTrim() {
+			return usesFieldRef() ? LTrim.valueOf(fieldReference) : LTrim.valueOf(expression);
+		}
+
+		/**
+		 * Creates new {@link AggregationExpression} that takes the associated string representation and trims whitespaces
+		 * from the end. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @return new instance of {@link RTrim}.
+		 * @since 2.1
+		 */
+		public RTrim rtrim() {
+			return createRTrim();
+		}
+
+		/**
+		 * Creates new {@link AggregationExpression} that takes the associated string representation and trims the given
+		 * character sequence from the end. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @param chars must not be {@literal null}.
+		 * @return new instance of {@link RTrim}.
+		 * @since 2.1
+		 */
+		public RTrim rtrim(String chars) {
+			return rtrim().chars(chars);
+		}
+
+		/**
+		 * Creates new {@link AggregationExpression} that takes the associated string representation and trims the character
+		 * sequence resulting from the given {@link AggregationExpression} from the end. <br />
+		 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return new instance of {@link RTrim}.
+		 * @since 2.1
+		 */
+		public RTrim rtrim(AggregationExpression expression) {
+			return rtrim().charsOf(expression);
+		}
+
+		private RTrim createRTrim() {
+			return usesFieldRef() ? RTrim.valueOf(fieldReference) : RTrim.valueOf(expression);
+		}
+
 		private boolean usesFieldRef() {
 			return fieldReference != null;
 		}
@@ -1072,4 +1197,257 @@ public class StringOperators {
 			return new SubstrCP(append(Arrays.asList(start, nrOfChars)));
 		}
 	}
+
+	/**
+	 * {@link AggregationExpression} for {@code $trim} which removes whitespace or the specified characters from the
+	 * beginning and end of a string. <br />
+	 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	public static class Trim extends AbstractAggregationExpression {
+
+		private Trim(Object value) {
+			super(value);
+		}
+
+		/**
+		 * Creates new {@link Trim} using the value of the provided {@link Field fieldReference} as {@literal input} value.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return new instance of {@link LTrim}.
+		 */
+		public static Trim valueOf(String fieldReference) {
+
+			Assert.notNull(fieldReference, "FieldReference must not be null!");
+			return new Trim(Collections.singletonMap("input", Fields.field(fieldReference)));
+		}
+
+		/**
+		 * Creates new {@link Trim} using the result of the provided {@link AggregationExpression} as {@literal input}
+		 * value.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return new instance of {@link Trim}.
+		 */
+		public static Trim valueOf(AggregationExpression expression) {
+
+			Assert.notNull(expression, "Expression must not be null!");
+			return new Trim(Collections.singletonMap("input", expression));
+		}
+
+		/**
+		 * Optional specify the character(s) to trim from the beginning.
+		 *
+		 * @param chars must not be {@literal null}.
+		 * @return new instance of {@link Trim}.
+		 */
+		public Trim chars(String chars) {
+
+			Assert.notNull(chars, "Chars must not be null!");
+			return new Trim(append("chars", chars));
+		}
+
+		/**
+		 * Optional specify the reference to the {@link Field field} holding the character values to trim from the
+		 * beginning.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return new instance of {@link Trim}.
+		 */
+		public Trim charsOf(String fieldReference) {
+			return new Trim(append("chars", Fields.field(fieldReference)));
+		}
+
+		/**
+		 * Optional specify the {@link AggregationExpression} evaluating to the character sequence to trim from the
+		 * beginning.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return new instance of {@link Trim}.
+		 */
+		public Trim charsOf(AggregationExpression expression) {
+			return new Trim(append("chars", expression));
+		}
+
+		/**
+		 * Remove whitespace or the specified characters from the beginning of a string.<br />
+		 *
+		 * @return new instance of {@link LTrim}.
+		 */
+		public LTrim left() {
+			return new LTrim(argumentMap());
+		}
+
+		/**
+		 * Remove whitespace or the specified characters from the end of a string.<br />
+		 *
+		 * @return new instance of {@link RTrim}.
+		 */
+		public RTrim right() {
+			return new RTrim(argumentMap());
+		}
+
+		@Override
+		protected String getMongoMethod() {
+			return "$trim";
+		}
+	}
+
+	/**
+	 * {@link AggregationExpression} for {@code $ltrim} which removes whitespace or the specified characters from the
+	 * beginning of a string. <br />
+	 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	public static class LTrim extends AbstractAggregationExpression {
+
+		private LTrim(Object value) {
+			super(value);
+		}
+
+		/**
+		 * Creates new {@link LTrim} using the value of the provided {@link Field fieldReference} as {@literal input} value.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return new instance of {@link LTrim}.
+		 */
+		public static LTrim valueOf(String fieldReference) {
+
+			Assert.notNull(fieldReference, "FieldReference must not be null!");
+			return new LTrim(Collections.singletonMap("input", Fields.field(fieldReference)));
+		}
+
+		/**
+		 * Creates new {@link LTrim} using the result of the provided {@link AggregationExpression} as {@literal input}
+		 * value.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return new instance of {@link LTrim}.
+		 */
+		public static LTrim valueOf(AggregationExpression expression) {
+
+			Assert.notNull(expression, "Expression must not be null!");
+			return new LTrim(Collections.singletonMap("input", expression));
+		}
+
+		/**
+		 * Optional specify the character(s) to trim from the beginning.
+		 *
+		 * @param chars must not be {@literal null}.
+		 * @return new instance of {@link LTrim}.
+		 */
+		public LTrim chars(String chars) {
+
+			Assert.notNull(chars, "Chars must not be null!");
+			return new LTrim(append("chars", chars));
+		}
+
+		/**
+		 * Optional specify the reference to the {@link Field field} holding the character values to trim from the
+		 * beginning.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return new instance of {@link LTrim}.
+		 */
+		public LTrim charsOf(String fieldReference) {
+			return new LTrim(append("chars", Fields.field(fieldReference)));
+		}
+
+		/**
+		 * Optional specify the {@link AggregationExpression} evaluating to the character sequence to trim from the
+		 * beginning.
+		 * 
+		 * @param expression must not be {@literal null}.
+		 * @return new instance of {@link LTrim}.
+		 */
+		public LTrim charsOf(AggregationExpression expression) {
+			return new LTrim(append("chars", expression));
+		}
+
+		@Override
+		protected String getMongoMethod() {
+			return "$ltrim";
+		}
+	}
+
+	/**
+	 * {@link AggregationExpression} for {@code $rtrim} which removes whitespace or the specified characters from the end
+	 * of a string. <br />
+	 * <strong>NOTE:</strong> Requires MongoDB 4.0 or later.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	public static class RTrim extends AbstractAggregationExpression {
+
+		private RTrim(Object value) {
+			super(value);
+		}
+
+		/**
+		 * Creates new {@link RTrim} using the value of the provided {@link Field fieldReference} as {@literal input} value.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return new instance of {@link RTrim}.
+		 */
+		public static RTrim valueOf(String fieldReference) {
+
+			Assert.notNull(fieldReference, "FieldReference must not be null!");
+			return new RTrim(Collections.singletonMap("input", Fields.field(fieldReference)));
+		}
+
+		/**
+		 * Creates new {@link RTrim} using the result of the provided {@link AggregationExpression} as {@literal input}
+		 * value.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return new instance of {@link RTrim}.
+		 */
+		public static RTrim valueOf(AggregationExpression expression) {
+
+			Assert.notNull(expression, "Expression must not be null!");
+			return new RTrim(Collections.singletonMap("input", expression));
+		}
+
+		/**
+		 * Optional specify the character(s) to trim from the end.
+		 *
+		 * @param chars must not be {@literal null}.
+		 * @return new instance of {@link RTrim}.
+		 */
+		public RTrim chars(String chars) {
+
+			Assert.notNull(chars, "Chars must not be null!");
+			return new RTrim(append("chars", chars));
+		}
+
+		/**
+		 * Optional specify the reference to the {@link Field field} holding the character values to trim from the end.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return new instance of {@link RTrim}.
+		 */
+		public RTrim charsOf(String fieldReference) {
+			return new RTrim(append("chars", Fields.field(fieldReference)));
+		}
+
+		/**
+		 * Optional specify the {@link AggregationExpression} evaluating to the character sequence to trim from the end.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return new instance of {@link RTrim}.
+		 */
+		public RTrim charsOf(AggregationExpression expression) {
+			return new RTrim(append("chars", expression));
+		}
+
+		@Override
+		protected String getMongoMethod() {
+			return "$rtrim";
+		}
+	}
 }

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

@@ -18,12 +18,12 @@ package org.springframework.data.mongodb.core.aggregation;
 import static org.springframework.data.mongodb.core.aggregation.Fields.*;
 
 import org.bson.Document;
+import org.springframework.data.mapping.PersistentPropertyPath;
 import org.springframework.data.mapping.PropertyPath;
 import org.springframework.data.mapping.context.MappingContext;
-import org.springframework.data.mapping.context.PersistentPropertyPath;
+import org.springframework.data.mongodb.core.aggregation.ExposedFields.DirectFieldReference;
 import org.springframework.data.mongodb.core.aggregation.ExposedFields.ExposedField;
 import org.springframework.data.mongodb.core.aggregation.ExposedFields.FieldReference;
-import org.springframework.data.mongodb.core.aggregation.ExposedFields.DirectFieldReference;
 import org.springframework.data.mongodb.core.convert.QueryMapper;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
@@ -95,8 +95,8 @@ public class TypeBasedAggregationOperationContext implements AggregationOperatio
 
 	private FieldReference getReferenceFor(Field field) {
 
-		PersistentPropertyPath<MongoPersistentProperty> propertyPath = mappingContext.getPersistentPropertyPath(
-				field.getTarget(), type);
+		PersistentPropertyPath<MongoPersistentProperty> propertyPath = mappingContext
+				.getPersistentPropertyPath(field.getTarget(), type);
 		Field mappedField = field(field.getName(),
 				propertyPath.toDotPath(MongoPersistentProperty.PropertyToFieldNameConverter.INSTANCE));
 

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

@@ -22,6 +22,7 @@ import org.springframework.dao.InvalidDataAccessApiUsageException;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
 import org.springframework.lang.Nullable;
+import org.springframework.util.StringUtils;
 
 import com.mongodb.DBRef;
 
@@ -47,7 +48,7 @@ public interface DbRefResolver {
 	 * @return
 	 */
 	@Nullable
-	Object resolveDbRef(MongoPersistentProperty property, DBRef dbref, DbRefResolverCallback callback,
+	Object resolveDbRef(MongoPersistentProperty property, @Nullable DBRef dbref, DbRefResolverCallback callback,
 			DbRefProxyHandler proxyHandler);
 
 	/**
@@ -59,8 +60,15 @@ public interface DbRefResolver {
 	 * @param id will never be {@literal null}.
 	 * @return
 	 */
-	DBRef createDbRef(org.springframework.data.mongodb.core.mapping.DBRef annotation, MongoPersistentEntity<?> entity,
-			Object id);
+	default DBRef createDbRef(@Nullable org.springframework.data.mongodb.core.mapping.DBRef annotation,
+			MongoPersistentEntity<?> entity, Object id) {
+
+		if (annotation != null && StringUtils.hasText(annotation.db())) {
+			return new DBRef(annotation.db(), entity.getCollection(), id);
+		}
+
+		return new DBRef(entity.getCollection(), id);
+	}
 
 	/**
 	 * Actually loads the {@link DBRef} from the datasource.

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

@@ -40,9 +40,9 @@ import org.springframework.cglib.proxy.MethodProxy;
 import org.springframework.dao.DataAccessException;
 import org.springframework.dao.InvalidDataAccessApiUsageException;
 import org.springframework.dao.support.PersistenceExceptionTranslator;
+import org.springframework.data.mongodb.ClientSessionException;
 import org.springframework.data.mongodb.LazyLoadingException;
 import org.springframework.data.mongodb.MongoDbFactory;
-import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
 import org.springframework.lang.Nullable;
 import org.springframework.objenesis.ObjenesisStd;
@@ -51,7 +51,7 @@ import org.springframework.util.ReflectionUtils;
 import org.springframework.util.StringUtils;
 
 import com.mongodb.DBRef;
-import com.mongodb.client.MongoDatabase;
+import com.mongodb.client.MongoCollection;
 import com.mongodb.client.model.Filters;
 
 /**
@@ -89,7 +89,7 @@ public class DefaultDbRefResolver implements DbRefResolver {
 	 * @see org.springframework.data.mongodb.core.convert.DbRefResolver#resolveDbRef(org.springframework.data.mongodb.core.mapping.MongoPersistentProperty, org.springframework.data.mongodb.core.convert.DbRefResolverCallback)
 	 */
 	@Override
-	public Object resolveDbRef(MongoPersistentProperty property, DBRef dbref, DbRefResolverCallback callback,
+	public Object resolveDbRef(MongoPersistentProperty property, @Nullable DBRef dbref, DbRefResolverCallback callback,
 			DbRefProxyHandler handler) {
 
 		Assert.notNull(property, "Property must not be null!");
@@ -103,21 +103,6 @@ public class DefaultDbRefResolver implements DbRefResolver {
 		return callback.resolve(property);
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.mongodb.core.convert.DbRefResolver#created(org.springframework.data.mongodb.core.mapping.MongoPersistentProperty, org.springframework.data.mongodb.core.mapping.MongoPersistentEntity, java.lang.Object)
-	 */
-	@Override
-	public DBRef createDbRef(org.springframework.data.mongodb.core.mapping.DBRef annotation,
-			MongoPersistentEntity<?> entity, Object id) {
-
-		if (annotation != null && StringUtils.hasText(annotation.db())) {
-			return new DBRef(annotation.db(), entity.getCollection(), id);
-		}
-
-		return new DBRef(entity.getCollection(), id);
-	}
-
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.mongodb.core.convert.DbRefResolver#fetch(com.mongodb.DBRef)
@@ -126,9 +111,7 @@ public class DefaultDbRefResolver implements DbRefResolver {
 	public Document fetch(DBRef dbRef) {
 
 		StringUtils.hasText(dbRef.getDatabaseName());
-		return (StringUtils.hasText(dbRef.getDatabaseName()) ? mongoDbFactory.getDb(dbRef.getDatabaseName())
-				: mongoDbFactory.getDb()).getCollection(dbRef.getCollectionName(), Document.class)
-						.find(Filters.eq("_id", dbRef.getId())).first();
+		return getCollection(dbRef).find(Filters.eq("_id", dbRef.getId())).first();
 	}
 
 	/*
@@ -158,9 +141,7 @@ public class DefaultDbRefResolver implements DbRefResolver {
 			ids.add(ref.getId());
 		}
 
-		MongoDatabase db = mongoDbFactory.getDb();
-
-		List<Document> result = db.getCollection(collection) //
+		List<Document> result = getCollection(refs.iterator().next()) //
 				.find(new Document("_id", new Document("$in", ids))) //
 				.into(new ArrayList<>());
 
@@ -466,6 +447,11 @@ public class DefaultDbRefResolver implements DbRefResolver {
 				} catch (RuntimeException ex) {
 
 					DataAccessException translatedException = this.exceptionTranslator.translateExceptionIfPossible(ex);
+
+					if (translatedException instanceof ClientSessionException) {
+						throw new LazyLoadingException("Unable to lazily resolve DBRef! Invalid session state.", ex);
+					}
+
 					throw new LazyLoadingException("Unable to lazily resolve DBRef!",
 							translatedException != null ? translatedException : ex);
 				}
@@ -474,4 +460,17 @@ public class DefaultDbRefResolver implements DbRefResolver {
 			return result;
 		}
 	}
+
+	/**
+	 * Customization hook for obtaining the {@link MongoCollection} for a given {@link DBRef}.
+	 *
+	 * @param dbref must not be {@literal null}.
+	 * @return the {@link MongoCollection} the given {@link DBRef} points to.
+	 * @since 2.1
+	 */
+	protected MongoCollection<Document> getCollection(DBRef dbref) {
+
+		return (StringUtils.hasText(dbref.getDatabaseName()) ? mongoDbFactory.getDb(dbref.getDatabaseName())
+				: mongoDbFactory.getDb()).getCollection(dbref.getCollectionName(), Document.class);
+	}
 }

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

@@ -21,6 +21,7 @@ import java.util.Map;
 
 import org.bson.Document;
 import org.bson.conversions.Bson;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
 import org.springframework.data.mongodb.util.BsonUtils;
 import org.springframework.lang.Nullable;
@@ -58,6 +59,14 @@ class DocumentAccessor {
 		this.document = document;
 	}
 
+	/**
+	 * @return the underlying {@link Bson document}.
+	 * @since 2.1
+	 */
+	Bson getDocument() {
+		return this.document;
+	}
+
 	/**
 	 * Puts the given value into the backing {@link Document} based on the coordinates defined through the given
 	 * {@link MongoPersistentProperty}. By default this will be the plain field name. But field names might also consist
@@ -103,13 +112,14 @@ class DocumentAccessor {
 	public Object get(MongoPersistentProperty property) {
 
 		String fieldName = property.getFieldName();
+		Map<String, Object> map = BsonUtils.asMap(document);
 
 		if (!fieldName.contains(".")) {
-			return BsonUtils.asMap(this.document).get(fieldName);
+			return map.get(fieldName);
 		}
 
 		Iterator<String> parts = Arrays.asList(fieldName.split("\\.")).iterator();
-		Map<String, Object> source = BsonUtils.asMap(this.document);
+		Map<String, Object> source = map;
 		Object result = null;
 
 		while (source != null && parts.hasNext()) {
@@ -124,6 +134,17 @@ class DocumentAccessor {
 		return result;
 	}
 
+	/**
+	 * Returns the raw identifier for the given {@link MongoPersistentEntity} or the value of the default identifier
+	 * field.
+	 *
+	 * @param entity must not be {@literal null}.
+	 * @return
+	 */
+	public Object getRawId(MongoPersistentEntity<?> entity) {
+		return entity.hasIdProperty() ? get(entity.getRequiredIdProperty()) : BsonUtils.asMap(document).get("_id");
+	}
+
 	/**
 	 * Returns whether the underlying {@link Document} has a value ({@literal null} or non-{@literal null}) for the given
 	 * {@link MongoPersistentProperty}.
@@ -131,21 +152,27 @@ class DocumentAccessor {
 	 * @param property must not be {@literal null}.
 	 * @return
 	 */
+	@SuppressWarnings("unchecked")
 	public boolean hasValue(MongoPersistentProperty property) {
 
 		Assert.notNull(property, "Property must not be null!");
 
 		String fieldName = property.getFieldName();
 
+
+		if (this.document instanceof Document) {
+
+			if (((Document) this.document).containsKey(fieldName)) {
+				return true;
+			}
+		} else if (this.document instanceof DBObject) {
+			if (((DBObject) this.document).containsField(fieldName)) {
+				return true;
+			}
+		}
+
 		if (!fieldName.contains(".")) {
-
-			if (this.document instanceof Document) {
-				return ((Document) this.document).containsKey(fieldName);
-			}
-
-			if (this.document instanceof DBObject) {
-				return ((DBObject) this.document).containsField(fieldName);
-			}
+			return false;
 		}
 
 		String[] parts = fieldName.split("\\.");

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

@@ -15,10 +15,13 @@
  */
 package org.springframework.data.mongodb.core.convert;
 
+import java.text.Collator;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
 
 import org.bson.Document;
 import org.springframework.core.convert.converter.Converter;
@@ -41,11 +44,13 @@ import org.springframework.data.mongodb.core.geo.GeoJsonPoint;
 import org.springframework.data.mongodb.core.geo.GeoJsonPolygon;
 import org.springframework.data.mongodb.core.geo.Sphere;
 import org.springframework.data.mongodb.core.query.GeoCommand;
+import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.NumberUtils;
 import org.springframework.util.ObjectUtils;
 
 import com.mongodb.BasicDBList;
+import com.mongodb.Function;
 
 /**
  * Wrapper class to contain useful geo structure converters for the usage with Mongo.
@@ -58,6 +63,26 @@ import com.mongodb.BasicDBList;
  */
 abstract class GeoConverters {
 
+
+	private final static Map<String, Function<Document, GeoJson<?>>> converters;
+
+	static {
+
+		Collator caseInsensitive = Collator.getInstance();
+		caseInsensitive.setStrength(Collator.PRIMARY);
+
+		Map<String, Function<Document, GeoJson<?>>> geoConverters = new TreeMap<>(caseInsensitive);
+		geoConverters.put("point", DocumentToGeoJsonPointConverter.INSTANCE::convert);
+		geoConverters.put("multipoint", DocumentToGeoJsonMultiPointConverter.INSTANCE::convert);
+		geoConverters.put("linestring", DocumentToGeoJsonLineStringConverter.INSTANCE::convert);
+		geoConverters.put("multilinestring", DocumentToGeoJsonMultiLineStringConverter.INSTANCE::convert);
+		geoConverters.put("polygon", DocumentToGeoJsonPolygonConverter.INSTANCE::convert);
+		geoConverters.put("multipolygon", DocumentToGeoJsonMultiPolygonConverter.INSTANCE::convert);
+		geoConverters.put("geometrycollection", DocumentToGeoJsonGeometryCollectionConverter.INSTANCE::convert);
+
+		converters = geoConverters;
+	}
+
 	/**
 	 * Private constructor to prevent instantiation.
 	 */
@@ -91,7 +116,8 @@ abstract class GeoConverters {
 				, DocumentToGeoJsonMultiLineStringConverter.INSTANCE //
 				, DocumentToGeoJsonMultiPointConverter.INSTANCE //
 				, DocumentToGeoJsonMultiPolygonConverter.INSTANCE //
-				, DocumentToGeoJsonGeometryCollectionConverter.INSTANCE);
+				, DocumentToGeoJsonGeometryCollectionConverter.INSTANCE //
+				, DocumentToGeoJsonConverter.INSTANCE);
 	}
 
 	/**
@@ -101,7 +127,7 @@ abstract class GeoConverters {
 	 * @since 1.5
 	 */
 	@ReadingConverter
-	static enum DocumentToPointConverter implements Converter<Document, Point> {
+	enum DocumentToPointConverter implements Converter<Document, Point> {
 
 		INSTANCE;
 
@@ -132,7 +158,7 @@ abstract class GeoConverters {
 	 * @author Thomas Darimont
 	 * @since 1.5
 	 */
-	static enum PointToDocumentConverter implements Converter<Point, Document> {
+	enum PointToDocumentConverter implements Converter<Point, Document> {
 
 		INSTANCE;
 
@@ -147,13 +173,13 @@ abstract class GeoConverters {
 	}
 
 	/**
-	 * Converts a {@link Box} into a {@link BasicDBList}.
+	 * Converts a {@link Box} into a {@link Document}.
 	 *
 	 * @author Thomas Darimont
 	 * @since 1.5
 	 */
 	@WritingConverter
-	static enum BoxToDocumentConverter implements Converter<Box, Document> {
+	enum BoxToDocumentConverter implements Converter<Box, Document> {
 
 		INSTANCE;
 
@@ -176,13 +202,13 @@ abstract class GeoConverters {
 	}
 
 	/**
-	 * Converts a {@link BasicDBList} into a {@link Box}.
+	 * Converts a {@link Document} into a {@link Box}.
 	 *
 	 * @author Thomas Darimont
 	 * @since 1.5
 	 */
 	@ReadingConverter
-	static enum DocumentToBoxConverter implements Converter<Document, Box> {
+	enum DocumentToBoxConverter implements Converter<Document, Box> {
 
 		INSTANCE;
 
@@ -205,12 +231,12 @@ abstract class GeoConverters {
 	}
 
 	/**
-	 * Converts a {@link Circle} into a {@link BasicDBList}.
+	 * Converts a {@link Circle} into a {@link Document}.
 	 *
 	 * @author Thomas Darimont
 	 * @since 1.5
 	 */
-	static enum CircleToDocumentConverter implements Converter<Circle, Document> {
+	enum CircleToDocumentConverter implements Converter<Circle, Document> {
 
 		INSTANCE;
 
@@ -276,7 +302,7 @@ abstract class GeoConverters {
 	}
 
 	/**
-	 * Converts a {@link Sphere} into a {@link BasicDBList}.
+	 * Converts a {@link Sphere} into a {@link Document}.
 	 *
 	 * @author Thomas Darimont
 	 * @since 1.5
@@ -305,13 +331,13 @@ abstract class GeoConverters {
 	}
 
 	/**
-	 * Converts a {@link BasicDBList} into a {@link Sphere}.
+	 * Converts a {@link Document} into a {@link Sphere}.
 	 *
 	 * @author Thomas Darimont
 	 * @since 1.5
 	 */
 	@ReadingConverter
-	static enum DocumentToSphereConverter implements Converter<Document, Sphere> {
+	enum DocumentToSphereConverter implements Converter<Document, Sphere> {
 
 		INSTANCE;
 
@@ -347,12 +373,12 @@ abstract class GeoConverters {
 	}
 
 	/**
-	 * Converts a {@link Polygon} into a {@link BasicDBList}.
+	 * Converts a {@link Polygon} into a {@link Document}.
 	 *
 	 * @author Thomas Darimont
 	 * @since 1.5
 	 */
-	static enum PolygonToDocumentConverter implements Converter<Polygon, Document> {
+	enum PolygonToDocumentConverter implements Converter<Polygon, Document> {
 
 		INSTANCE;
 
@@ -368,7 +394,7 @@ abstract class GeoConverters {
 			}
 
 			List<Point> points = source.getPoints();
-			List<Document> pointTuples = new ArrayList<Document>(points.size());
+			List<Document> pointTuples = new ArrayList<>(points.size());
 
 			for (Point point : points) {
 				pointTuples.add(PointToDocumentConverter.INSTANCE.convert(point));
@@ -381,13 +407,13 @@ abstract class GeoConverters {
 	}
 
 	/**
-	 * Converts a {@link BasicDBList} into a {@link Polygon}.
+	 * Converts a {@link Document} into a {@link Polygon}.
 	 *
 	 * @author Thomas Darimont
 	 * @since 1.5
 	 */
 	@ReadingConverter
-	static enum DocumentToPolygonConverter implements Converter<Document, Polygon> {
+	enum DocumentToPolygonConverter implements Converter<Document, Polygon> {
 
 		INSTANCE;
 
@@ -404,7 +430,7 @@ abstract class GeoConverters {
 			}
 
 			List<Document> points = (List<Document>) source.get("points");
-			List<Point> newPoints = new ArrayList<Point>(points.size());
+			List<Point> newPoints = new ArrayList<>(points.size());
 
 			for (Document element : points) {
 
@@ -417,12 +443,12 @@ abstract class GeoConverters {
 	}
 
 	/**
-	 * Converts a {@link Sphere} into a {@link BasicDBList}.
+	 * Converts a {@link Sphere} into a {@link Document}.
 	 *
 	 * @author Thomas Darimont
 	 * @since 1.5
 	 */
-	static enum GeoCommandToDocumentConverter implements Converter<GeoCommand, Document> {
+	enum GeoCommandToDocumentConverter implements Converter<GeoCommand, Document> {
 
 		INSTANCE;
 
@@ -482,7 +508,7 @@ abstract class GeoConverters {
 	 * @since 1.7
 	 */
 	@SuppressWarnings("rawtypes")
-	static enum GeoJsonToDocumentConverter implements Converter<GeoJson, Document> {
+	enum GeoJsonToDocumentConverter implements Converter<GeoJson, Document> {
 
 		INSTANCE;
 
@@ -545,7 +571,7 @@ abstract class GeoConverters {
 	 * @author Christoph Strobl
 	 * @since 1.7
 	 */
-	static enum GeoJsonPointToDocumentConverter implements Converter<GeoJsonPoint, Document> {
+	enum GeoJsonPointToDocumentConverter implements Converter<GeoJsonPoint, Document> {
 
 		INSTANCE;
 
@@ -563,7 +589,7 @@ abstract class GeoConverters {
 	 * @author Christoph Strobl
 	 * @since 1.7
 	 */
-	static enum GeoJsonPolygonToDocumentConverter implements Converter<GeoJsonPolygon, Document> {
+	enum GeoJsonPolygonToDocumentConverter implements Converter<GeoJsonPolygon, Document> {
 
 		INSTANCE;
 
@@ -581,7 +607,7 @@ abstract class GeoConverters {
 	 * @author Christoph Strobl
 	 * @since 1.7
 	 */
-	static enum DocumentToGeoJsonPointConverter implements Converter<Document, GeoJsonPoint> {
+	enum DocumentToGeoJsonPointConverter implements Converter<Document, GeoJsonPoint> {
 
 		INSTANCE;
 
@@ -609,7 +635,7 @@ abstract class GeoConverters {
 	 * @author Christoph Strobl
 	 * @since 1.7
 	 */
-	static enum DocumentToGeoJsonPolygonConverter implements Converter<Document, GeoJsonPolygon> {
+	enum DocumentToGeoJsonPolygonConverter implements Converter<Document, GeoJsonPolygon> {
 
 		INSTANCE;
 
@@ -654,7 +680,7 @@ abstract class GeoConverters {
 					String.format("Cannot convert type '%s' to MultiPolygon.", source.get("type")));
 
 			List dbl = (List) source.get("coordinates");
-			List<GeoJsonPolygon> polygones = new ArrayList<GeoJsonPolygon>();
+			List<GeoJsonPolygon> polygones = new ArrayList<>();
 
 			for (Object polygon : dbl) {
 				polygones.add(toGeoJsonPolygon((List) polygon));
@@ -668,7 +694,7 @@ abstract class GeoConverters {
 	 * @author Christoph Strobl
 	 * @since 1.7
 	 */
-	static enum DocumentToGeoJsonLineStringConverter implements Converter<Document, GeoJsonLineString> {
+	enum DocumentToGeoJsonLineStringConverter implements Converter<Document, GeoJsonLineString> {
 
 		INSTANCE;
 
@@ -696,7 +722,7 @@ abstract class GeoConverters {
 	 * @author Christoph Strobl
 	 * @since 1.7
 	 */
-	static enum DocumentToGeoJsonMultiPointConverter implements Converter<Document, GeoJsonMultiPoint> {
+	enum DocumentToGeoJsonMultiPointConverter implements Converter<Document, GeoJsonMultiPoint> {
 
 		INSTANCE;
 
@@ -724,7 +750,7 @@ abstract class GeoConverters {
 	 * @author Christoph Strobl
 	 * @since 1.7
 	 */
-	static enum DocumentToGeoJsonMultiLineStringConverter implements Converter<Document, GeoJsonMultiLineString> {
+	enum DocumentToGeoJsonMultiLineStringConverter implements Converter<Document, GeoJsonMultiLineString> {
 
 		INSTANCE;
 
@@ -756,7 +782,7 @@ abstract class GeoConverters {
 	 * @author Christoph Strobl
 	 * @since 1.7
 	 */
-	static enum DocumentToGeoJsonGeometryCollectionConverter implements Converter<Document, GeoJsonGeometryCollection> {
+	enum DocumentToGeoJsonGeometryCollectionConverter implements Converter<Document, GeoJsonGeometryCollection> {
 
 		INSTANCE;
 
@@ -775,41 +801,12 @@ abstract class GeoConverters {
 			Assert.isTrue(ObjectUtils.nullSafeEquals(source.get("type"), "GeometryCollection"),
 					String.format("Cannot convert type '%s' to GeometryCollection.", source.get("type")));
 
-			List<GeoJson<?>> geometries = new ArrayList<GeoJson<?>>();
+			List<GeoJson<?>> geometries = new ArrayList<>();
 			for (Object o : (List) source.get("geometries")) {
-				geometries.add(convertGeometries((Document) o));
+				geometries.add(toGenericGeoJson((Document) o));
 			}
+
 			return new GeoJsonGeometryCollection(geometries);
-
-		}
-
-		private static GeoJson<?> convertGeometries(Document source) {
-
-			Object type = source.get("type");
-			if (ObjectUtils.nullSafeEquals(type, "Point")) {
-				return DocumentToGeoJsonPointConverter.INSTANCE.convert(source);
-			}
-
-			if (ObjectUtils.nullSafeEquals(type, "MultiPoint")) {
-				return DocumentToGeoJsonMultiPointConverter.INSTANCE.convert(source);
-			}
-
-			if (ObjectUtils.nullSafeEquals(type, "LineString")) {
-				return DocumentToGeoJsonLineStringConverter.INSTANCE.convert(source);
-			}
-
-			if (ObjectUtils.nullSafeEquals(type, "MultiLineString")) {
-				return DocumentToGeoJsonMultiLineStringConverter.INSTANCE.convert(source);
-			}
-
-			if (ObjectUtils.nullSafeEquals(type, "Polygon")) {
-				return DocumentToGeoJsonPolygonConverter.INSTANCE.convert(source);
-			}
-			if (ObjectUtils.nullSafeEquals(type, "MultiPolygon")) {
-				return DocumentToGeoJsonMultiPolygonConverter.INSTANCE.convert(source);
-			}
-
-			throw new IllegalArgumentException(String.format("Cannot convert unknown GeoJson type %s", type));
 		}
 	}
 
@@ -827,7 +824,7 @@ abstract class GeoConverters {
 	@SuppressWarnings("unchecked")
 	static List<Point> toListOfPoint(List listOfCoordinatePairs) {
 
-		List<Point> points = new ArrayList<Point>();
+		List<Point> points = new ArrayList<>();
 
 		for (Object point : listOfCoordinatePairs) {
 
@@ -852,6 +849,46 @@ abstract class GeoConverters {
 		return new GeoJsonPolygon(toListOfPoint((List) dbList.get(0)));
 	}
 
+	/**
+	 * Converter implementation transforming a {@link Document} into a concrete {@link GeoJson} based on the embedded
+	 * {@literal type} information.
+	 *
+	 * @since 2.1
+	 * @author Christoph Strobl
+	 */
+	@ReadingConverter
+	enum DocumentToGeoJsonConverter implements Converter<Document, GeoJson> {
+		INSTANCE;
+
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.core.convert.converter.Converter#convert(java.lang.Object)
+		 */
+		@Nullable
+		@Override
+		public GeoJson convert(Document source) {
+			return toGenericGeoJson(source);
+		}
+	}
+
+	private static GeoJson<?> toGenericGeoJson(Document source) {
+
+		String type = source.get("type", String.class);
+
+		if(type != null) {
+
+			Function<Document, GeoJson<?>> converter = converters.get(type);
+
+			if(converter != null){
+				return converter.apply(source);
+			}
+		}
+
+		throw new IllegalArgumentException(
+				String.format("No converter found capable of converting GeoJson type %s.", type));
+	}
+
 	private static double toPrimitiveDoubleValue(Object value) {
 
 		Assert.isInstanceOf(Number.class, value, "Argument must be a Number.");

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

@@ -15,17 +15,8 @@
  */
 package org.springframework.data.mongodb.core.convert;
 
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.Map.Entry;
-import java.util.Optional;
-import java.util.Set;
 
 import org.bson.Document;
 import org.bson.conversions.Bson;
@@ -42,6 +33,7 @@ import org.springframework.data.convert.TypeMapper;
 import org.springframework.data.mapping.Association;
 import org.springframework.data.mapping.MappingException;
 import org.springframework.data.mapping.PersistentPropertyAccessor;
+import org.springframework.data.mapping.PreferredConstructor;
 import org.springframework.data.mapping.PreferredConstructor.Parameter;
 import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.data.mapping.model.ConvertingPropertyAccessor;
@@ -250,13 +242,15 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 			throw new MappingException(String.format(INVALID_TYPE_TO_READ, target, typeToUse.getType()));
 		}
 
-		return read((MongoPersistentEntity<S>) mappingContext.getRequiredPersistentEntity(typeToUse), target, path);
+		return read((MongoPersistentEntity<S>) entity, target, path);
 	}
 
 	private ParameterValueProvider<MongoPersistentProperty> getParameterProvider(MongoPersistentEntity<?> entity,
-			Bson source, DefaultSpELExpressionEvaluator evaluator, ObjectPath path) {
+			DocumentAccessor source, SpELExpressionEvaluator evaluator, ObjectPath path) {
 
-		MongoDbPropertyValueProvider provider = new MongoDbPropertyValueProvider(source, evaluator, path);
+
+		AssociationAwareMongoDbPropertyValueProvider provider = new AssociationAwareMongoDbPropertyValueProvider(source,
+				evaluator, path);
 		PersistentEntityParameterValueProvider<MongoPersistentProperty> parameterProvider = new PersistentEntityParameterValueProvider<>(
 				entity, provider, path.getCurrentObject());
 
@@ -264,63 +258,108 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 				path);
 	}
 
-	@Nullable
 	private <S extends Object> S read(final MongoPersistentEntity<S> entity, final Document bson, final ObjectPath path) {
 
-		DefaultSpELExpressionEvaluator evaluator = new DefaultSpELExpressionEvaluator(bson, spELContext);
+		SpELExpressionEvaluator evaluator = new DefaultSpELExpressionEvaluator(bson, spELContext);
+		DocumentAccessor documentAccessor = new DocumentAccessor(bson);
+
+		PreferredConstructor<S, MongoPersistentProperty> persistenceConstructor = entity.getPersistenceConstructor();
+
+		ParameterValueProvider<MongoPersistentProperty> provider = persistenceConstructor != null
+				&& persistenceConstructor.hasParameters() ? getParameterProvider(entity, documentAccessor, evaluator, path)
+						: NoOpParameterValueProvider.INSTANCE;
 
-		ParameterValueProvider<MongoPersistentProperty> provider = getParameterProvider(entity, bson, evaluator, path);
 		EntityInstantiator instantiator = instantiators.getInstantiatorFor(entity);
 		S instance = instantiator.createInstance(entity, provider);
 
-		PersistentPropertyAccessor accessor = new ConvertingPropertyAccessor(entity.getPropertyAccessor(instance),
-				conversionService);
-
-		MongoPersistentProperty idProperty = entity.getIdProperty();
-		DocumentAccessor documentAccessor = new DocumentAccessor(bson);
-
-		// make sure id property is set before all other properties
-		Object idValue = null;
-
-		if (idProperty != null && documentAccessor.hasValue(idProperty)) {
-
-			idValue = readIdValue(path, evaluator, idProperty, documentAccessor);
-			accessor.setProperty(idProperty, idValue);
+		if (entity.requiresPropertyPopulation()) {
+			return populateProperties(entity, documentAccessor, path, evaluator, instance);
 		}
 
-		ObjectPath currentPath = path.push(instance, entity, idValue != null ? bson.get(idProperty.getFieldName()) : null);
-
-		MongoDbPropertyValueProvider valueProvider = new MongoDbPropertyValueProvider(documentAccessor, evaluator,
-				currentPath);
-
-		DbRefResolverCallback callback = new DefaultDbRefResolverCallback(bson, currentPath, evaluator,
-				MappingMongoConverter.this);
-		readProperties(entity, accessor, idProperty, documentAccessor, valueProvider, callback);
-
 		return instance;
 	}
 
-	private Object readIdValue(ObjectPath path, DefaultSpELExpressionEvaluator evaluator,
-			MongoPersistentProperty idProperty, DocumentAccessor documentAccessor) {
+	private <S> S populateProperties(MongoPersistentEntity<S> entity, DocumentAccessor documentAccessor, ObjectPath path,
+			SpELExpressionEvaluator evaluator, S instance) {
+
+		PersistentPropertyAccessor<S> accessor = new ConvertingPropertyAccessor<>(entity.getPropertyAccessor(instance),
+				conversionService);
+
+		// Make sure id property is set before all other properties
+
+		Object rawId = readAndPopulateIdentifier(accessor, documentAccessor, entity,
+				path, evaluator);
+		ObjectPath currentPath = path.push(accessor.getBean(), entity, rawId);
+
+		MongoDbPropertyValueProvider valueProvider = new MongoDbPropertyValueProvider(documentAccessor, evaluator,
+				currentPath);
+
+		readProperties(entity, accessor, documentAccessor, valueProvider, currentPath, evaluator);
+
+		return accessor.getBean();
+	}
+
+	/**
+	 * Reads the identifier from either the bean backing the {@link PersistentPropertyAccessor} or the source document in
+	 * case the identifier has not be populated yet. In this case the identifier is set on the bean for further reference.
+	 *
+	 * @param accessor must not be {@literal null}.
+	 * @param document must not be {@literal null}.
+	 * @param entity must not be {@literal null}.
+	 * @param path
+	 * @param evaluator
+	 * @return
+	 */
+	private Object readAndPopulateIdentifier(PersistentPropertyAccessor<?> accessor, DocumentAccessor document,
+			MongoPersistentEntity<?> entity, ObjectPath path, SpELExpressionEvaluator evaluator) {
+
+		Object rawId = document.getRawId(entity);
+
+		if (!entity.hasIdProperty() || rawId == null) {
+			return rawId;
+		}
+
+		MongoPersistentProperty idProperty = entity.getRequiredIdProperty();
+
+		if (idProperty.isImmutable() && entity.isConstructorArgument(idProperty)) {
+			return rawId;
+		}
+
+		accessor.setProperty(idProperty, readIdValue(path, evaluator, idProperty, rawId));
+
+		return rawId;
+	}
+
+	private Object readIdValue(ObjectPath path, SpELExpressionEvaluator evaluator, MongoPersistentProperty idProperty,
+			Object rawId) {
 
 		String expression = idProperty.getSpelExpression();
-		Object resolvedValue = expression != null ? evaluator.evaluate(expression) : documentAccessor.get(idProperty);
+		Object resolvedValue = expression != null ? evaluator.evaluate(expression) : rawId;
 
 		return resolvedValue != null ? readValue(resolvedValue, idProperty.getTypeInformation(), path) : null;
 	}
 
-	private void readProperties(MongoPersistentEntity<?> entity, PersistentPropertyAccessor accessor,
-			@Nullable MongoPersistentProperty idProperty, DocumentAccessor documentAccessor,
-			MongoDbPropertyValueProvider valueProvider, DbRefResolverCallback callback) {
+	private void readProperties(MongoPersistentEntity<?> entity, PersistentPropertyAccessor<?> accessor,
+			DocumentAccessor documentAccessor, MongoDbPropertyValueProvider valueProvider, ObjectPath currentPath,
+			SpELExpressionEvaluator evaluator) {
+
+		DbRefResolverCallback callback = null;
 
 		for (MongoPersistentProperty prop : entity) {
 
 			if (prop.isAssociation() && !entity.isConstructorArgument(prop)) {
-				readAssociation(prop.getAssociation(), accessor, documentAccessor, dbRefProxyHandler, callback);
+
+				if (callback == null) {
+					callback = getDbRefResolverCallback(documentAccessor, currentPath, evaluator);
+				}
+
+				readAssociation(prop.getRequiredAssociation(), accessor, documentAccessor, dbRefProxyHandler, callback);
 				continue;
 			}
-			// we skip the id property since it was already set
-			if (idProperty != null && idProperty.equals(prop)) {
+
+			// We skip the id property since it was already set
+
+			if (entity.isIdProperty(prop)) {
 				continue;
 			}
 
@@ -329,7 +368,12 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 			}
 
 			if (prop.isAssociation()) {
-				readAssociation(prop.getAssociation(), accessor, documentAccessor, dbRefProxyHandler, callback);
+
+				if (callback == null) {
+					callback = getDbRefResolverCallback(documentAccessor, currentPath, evaluator);
+				}
+
+				readAssociation(prop.getRequiredAssociation(), accessor, documentAccessor, dbRefProxyHandler, callback);
 				continue;
 			}
 
@@ -337,7 +381,14 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 		}
 	}
 
-	private void readAssociation(Association<MongoPersistentProperty> association, PersistentPropertyAccessor accessor,
+	private DbRefResolverCallback getDbRefResolverCallback(DocumentAccessor documentAccessor, ObjectPath currentPath,
+			SpELExpressionEvaluator evaluator) {
+
+		return new DefaultDbRefResolverCallback(documentAccessor.getDocument(), currentPath, evaluator,
+				MappingMongoConverter.this);
+	}
+
+	private void readAssociation(Association<MongoPersistentProperty> association, PersistentPropertyAccessor<?> accessor,
 			DocumentAccessor documentAccessor, DbRefProxyHandler handler, DbRefResolverCallback callback) {
 
 		MongoPersistentProperty property = association.getInverse();
@@ -357,7 +408,7 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 	 */
 	public DBRef toDBRef(Object object, @Nullable MongoPersistentProperty referringProperty) {
 
-		org.springframework.data.mongodb.core.mapping.DBRef annotation = null;
+		org.springframework.data.mongodb.core.mapping.DBRef annotation;
 
 		if (referringProperty != null) {
 			annotation = referringProperty.getDBRef();
@@ -378,7 +429,7 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 	 *
 	 * @see org.springframework.data.mongodb.core.convert.MongoWriter#write(java.lang.Object, com.mongodb.Document)
 	 */
-	public void write(final Object obj, final Bson bson) {
+	public void write(Object obj, Bson bson) {
 
 		if (null == obj) {
 			return;
@@ -394,20 +445,32 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 			removeFromMap(bson, "_id");
 		}
 
-		boolean handledByCustomConverter = conversions.hasCustomWriteTarget(entityType, Document.class);
-		if (!handledByCustomConverter && !(bson instanceof Collection)) {
+		if (requiresTypeHint(entityType)) {
 			typeMapper.writeType(type, bson);
 		}
 	}
 
+	/**
+	 * Check if a given type requires a type hint (aka {@literal _class} attribute) when writing to the document.
+	 *
+	 * @param type must not be {@literal null}.
+	 * @return {@literal true} if not a simple type, {@link Collection} or type with custom write target.
+	 */
+	private boolean requiresTypeHint(Class<?> type) {
+
+		return !conversions.isSimpleType(type) && !ClassUtils.isAssignable(Collection.class, type)
+				&& !conversions.hasCustomWriteTarget(type, Document.class);
+	}
+
 	/**
 	 * Internal write conversion method which should be used for nested invocations.
 	 *
 	 * @param obj
 	 * @param bson
+	 * @param typeHint
 	 */
 	@SuppressWarnings("unchecked")
-	protected void writeInternal(@Nullable Object obj, final Bson bson, final TypeInformation<?> typeHint) {
+	protected void writeInternal(@Nullable Object obj, Bson bson, @Nullable TypeInformation<?> typeHint) {
 
 		if (null == obj) {
 			return;
@@ -428,7 +491,7 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 		}
 
 		if (Collection.class.isAssignableFrom(entityType)) {
-			writeCollectionInternal((Collection<?>) obj, ClassTypeInformation.LIST, (BasicDBList) bson);
+			writeCollectionInternal((Collection<?>) obj, ClassTypeInformation.LIST, (Collection<?>) bson);
 			return;
 		}
 
@@ -437,7 +500,7 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 		addCustomTypeKeyIfNecessary(typeHint, obj, bson);
 	}
 
-	protected void writeInternal(@Nullable Object obj, final Bson bson, MongoPersistentEntity<?> entity) {
+	protected void writeInternal(@Nullable Object obj, Bson bson, @Nullable MongoPersistentEntity<?> entity) {
 
 		if (obj == null) {
 			return;
@@ -447,10 +510,10 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 			throw new MappingException("No mapping metadata found for entity of type " + obj.getClass().getName());
 		}
 
-		PersistentPropertyAccessor accessor = entity.getPropertyAccessor(obj);
+		PersistentPropertyAccessor<?> accessor = entity.getPropertyAccessor(obj);
 		DocumentAccessor dbObjectAccessor = new DocumentAccessor(bson);
-
 		MongoPersistentProperty idProperty = entity.getIdProperty();
+
 		if (idProperty != null && !dbObjectAccessor.hasValue(idProperty)) {
 
 			Object value = idMapper.convertId(accessor.getProperty(idProperty));
@@ -459,11 +522,12 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 				dbObjectAccessor.put(idProperty, value);
 			}
 		}
+
 		writeProperties(bson, entity, accessor, dbObjectAccessor, idProperty);
 	}
 
-	private void writeProperties(Bson bson, MongoPersistentEntity<?> entity, PersistentPropertyAccessor accessor,
-			DocumentAccessor dbObjectAccessor, MongoPersistentProperty idProperty) {
+	private void writeProperties(Bson bson, MongoPersistentEntity<?> entity, PersistentPropertyAccessor<?> accessor,
+			DocumentAccessor dbObjectAccessor, @Nullable MongoPersistentProperty idProperty) {
 
 		// Write the properties
 		for (MongoPersistentProperty prop : entity) {
@@ -472,7 +536,7 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 				continue;
 			}
 			if (prop.isAssociation()) {
-				writeAssociation(prop.getAssociation(), accessor, dbObjectAccessor);
+				writeAssociation(prop.getRequiredAssociation(), accessor, dbObjectAccessor);
 				continue;
 			}
 
@@ -490,8 +554,8 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 		}
 	}
 
-	private void writeAssociation(Association<MongoPersistentProperty> association, PersistentPropertyAccessor accessor,
-			DocumentAccessor dbObjectAccessor) {
+	private void writeAssociation(Association<MongoPersistentProperty> association,
+			PersistentPropertyAccessor<?> accessor, DocumentAccessor dbObjectAccessor) {
 
 		MongoPersistentProperty inverseProp = association.getInverse();
 
@@ -499,7 +563,7 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 	}
 
 	@SuppressWarnings({ "unchecked" })
-	protected void writePropertyInternal(Object obj, DocumentAccessor accessor, MongoPersistentProperty prop) {
+	protected void writePropertyInternal(@Nullable Object obj, DocumentAccessor accessor, MongoPersistentProperty prop) {
 
 		if (obj == null) {
 			return;
@@ -654,17 +718,21 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 	}
 
 	/**
-	 * Populates the given {@link BasicDBList} with values from the given {@link Collection}.
+	 * Populates the given {@link Collection sink} with converted values from the given {@link Collection source}.
 	 *
-	 * @param source the collection to create a {@link BasicDBList} for, must not be {@literal null}.
+	 * @param source the collection to create a {@link Collection} for, must not be {@literal null}.
 	 * @param type the {@link TypeInformation} to consider or {@literal null} if unknown.
-	 * @param sink the {@link BasicDBList} to write to.
+	 * @param sink the {@link Collection} to write to.
 	 * @return
 	 */
-	private BasicDBList writeCollectionInternal(Collection<?> source, TypeInformation<?> type, BasicDBList sink) {
+	@SuppressWarnings("unchecked")
+	private List<Object> writeCollectionInternal(Collection<?> source, @Nullable TypeInformation<?> type,
+			Collection<?> sink) {
 
 		TypeInformation<?> componentType = null;
 
+		List<Object> collection = sink instanceof List ? (List<Object>) sink : new ArrayList<>(sink);
+
 		if (type != null) {
 			componentType = type.getComponentType();
 		}
@@ -674,17 +742,17 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 			Class<?> elementType = element == null ? null : element.getClass();
 
 			if (elementType == null || conversions.isSimpleType(elementType)) {
-				sink.add(getPotentiallyConvertedSimpleWrite(element));
+				collection.add(getPotentiallyConvertedSimpleWrite(element));
 			} else if (element instanceof Collection || elementType.isArray()) {
-				sink.add(writeCollectionInternal(asCollection(element), componentType, new BasicDBList()));
+				collection.add(writeCollectionInternal(asCollection(element), componentType, new BasicDBList()));
 			} else {
 				Document document = new Document();
 				writeInternal(element, document, componentType);
-				sink.add(document);
+				collection.add(document);
 			}
 		}
 
-		return sink;
+		return collection;
 	}
 
 	/**
@@ -868,9 +936,9 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 	 */
 	@Nullable
 	@SuppressWarnings({ "rawtypes", "unchecked" })
-	private Object getPotentiallyConvertedSimpleRead(@Nullable Object value, Class<?> target) {
+	private Object getPotentiallyConvertedSimpleRead(@Nullable Object value, @Nullable Class<?> target) {
 
-		if (value == null || target == null || target.isAssignableFrom(value.getClass())) {
+		if (value == null || target == null || ClassUtils.isAssignableValue(target, value)) {
 			return value;
 		}
 
@@ -933,58 +1001,61 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 	 * Reads the given {@link BasicDBList} into a collection of the given {@link TypeInformation}.
 	 *
 	 * @param targetType must not be {@literal null}.
-	 * @param sourceValue must not be {@literal null}.
+	 * @param source must not be {@literal null}.
 	 * @param path must not be {@literal null}.
 	 * @return the converted {@link Collection} or array, will never be {@literal null}.
 	 */
-	@SuppressWarnings({ "rawtypes", "unchecked" })
-	private Object readCollectionOrArray(TypeInformation<?> targetType, List sourceValue, ObjectPath path) {
+	@SuppressWarnings("unchecked")
+	private Object readCollectionOrArray(TypeInformation<?> targetType, Collection<?> source, ObjectPath path) {
 
 		Assert.notNull(targetType, "Target type must not be null!");
 		Assert.notNull(path, "Object path must not be null!");
 
 		Class<?> collectionType = targetType.getType();
+		collectionType = Collection.class.isAssignableFrom(collectionType) //
+				? collectionType //
+				: List.class;
 
-		TypeInformation<?> componentType = targetType.getComponentType() != null ? targetType.getComponentType()
+		TypeInformation<?> componentType = targetType.getComponentType() != null //
+				? targetType.getComponentType() //
 				: ClassTypeInformation.OBJECT;
 		Class<?> rawComponentType = componentType.getType();
 
-		collectionType = Collection.class.isAssignableFrom(collectionType) ? collectionType : List.class;
-		Collection<Object> items = targetType.getType().isArray() ? new ArrayList<>(sourceValue.size())
-				: CollectionFactory.createCollection(collectionType, rawComponentType, sourceValue.size());
+		Collection<Object> items = targetType.getType().isArray() //
+				? new ArrayList<>(source.size()) //
+				: CollectionFactory.createCollection(collectionType, rawComponentType, source.size());
 
-		if (sourceValue.isEmpty()) {
+		if (source.isEmpty()) {
 			return getPotentiallyConvertedSimpleRead(items, targetType.getType());
 		}
 
-		if (!DBRef.class.equals(rawComponentType) && isCollectionOfDbRefWhereBulkFetchIsPossible(sourceValue)) {
+		if (!DBRef.class.equals(rawComponentType) && isCollectionOfDbRefWhereBulkFetchIsPossible(source)) {
 
-			List<Object> objects = bulkReadAndConvertDBRefs((List<DBRef>) sourceValue, componentType, path, rawComponentType);
+			List<Object> objects = bulkReadAndConvertDBRefs((List<DBRef>) source, componentType, path, rawComponentType);
 			return getPotentiallyConvertedSimpleRead(objects, targetType.getType());
 		}
 
-		for (Object dbObjItem : sourceValue) {
+		for (Object element : source) {
 
-			if (dbObjItem instanceof DBRef) {
-				items.add(DBRef.class.equals(rawComponentType) ? dbObjItem
-						: readAndConvertDBRef((DBRef) dbObjItem, componentType, path, rawComponentType));
-			} else if (dbObjItem instanceof Document) {
-				items.add(read(componentType, (Document) dbObjItem, path));
-			} else if (dbObjItem instanceof BasicDBObject) {
-				items.add(read(componentType, (BasicDBObject) dbObjItem, path));
+			if (element instanceof DBRef) {
+				items.add(DBRef.class.equals(rawComponentType) ? element
+						: readAndConvertDBRef((DBRef) element, componentType, path, rawComponentType));
+			} else if (element instanceof Document) {
+				items.add(read(componentType, (Document) element, path));
+			} else if (element instanceof BasicDBObject) {
+				items.add(read(componentType, (BasicDBObject) element, path));
 			} else {
 
-				if (dbObjItem instanceof Collection) {
+				if (!Object.class.equals(rawComponentType) && element instanceof Collection) {
 					if (!rawComponentType.isArray() && !ClassUtils.isAssignable(Iterable.class, rawComponentType)) {
 						throw new MappingException(
-								String.format(INCOMPATIBLE_TYPES, dbObjItem, dbObjItem.getClass(), rawComponentType, path));
+								String.format(INCOMPATIBLE_TYPES, element, element.getClass(), rawComponentType, path));
 					}
 				}
-
-				if (dbObjItem instanceof List) {
-					items.add(readCollectionOrArray(ClassTypeInformation.OBJECT, (List) dbObjItem, path));
+				if (element instanceof List) {
+					items.add(readCollectionOrArray(componentType, (Collection<Object>) element, path));
 				} else {
-					items.add(getPotentiallyConvertedSimpleRead(dbObjItem, rawComponentType));
+					items.add(getPotentiallyConvertedSimpleRead(element, rawComponentType));
 				}
 			}
 		}
@@ -1045,8 +1116,8 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 				map.put(key, DBRef.class.equals(rawValueType) ? value
 						: readAndConvertDBRef((DBRef) value, defaultedValueType, ObjectPath.ROOT, rawValueType));
 			} else if (value instanceof List) {
-				map.put(key,
-						readCollectionOrArray(valueType != null ? valueType : ClassTypeInformation.LIST, (List) value, path));
+				map.put(key, readCollectionOrArray(valueType != null ? valueType : ClassTypeInformation.LIST,
+						(List<Object>) value, path));
 			} else {
 				map.put(key, getPotentiallyConvertedSimpleRead(value, rawValueType));
 			}
@@ -1084,8 +1155,7 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 				"Cannot add key/value pair to %s. as map. Given Bson must be a Document or DBObject!", bson.getClass()));
 	}
 
-	@SuppressWarnings("unchecked")
-	private static void addAllToMap(Bson bson, Map value) {
+	private static void addAllToMap(Bson bson, Map<String, ?> value) {
 
 		if (bson instanceof Document) {
 			((Document) bson).putAll(value);
@@ -1140,10 +1210,8 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 			return getPotentiallyConvertedSimpleWrite(obj);
 		}
 
-		TypeInformation<?> typeHint = typeInformation;
-
 		if (obj instanceof List) {
-			return maybeConvertList((List<Object>) obj, typeHint);
+			return maybeConvertList((List<Object>) obj, typeInformation);
 		}
 
 		if (obj instanceof Document) {
@@ -1151,7 +1219,7 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 			Document newValueDocument = new Document();
 			for (String vk : ((Document) obj).keySet()) {
 				Object o = ((Document) obj).get(vk);
-				newValueDocument.put(vk, convertToMongoType(o, typeHint));
+				newValueDocument.put(vk, convertToMongoType(o, typeInformation));
 			}
 			return newValueDocument;
 		}
@@ -1162,7 +1230,7 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 			for (String vk : ((DBObject) obj).keySet()) {
 
 				Object o = ((DBObject) obj).get(vk);
-				newValueDbo.put(vk, convertToMongoType(o, typeHint));
+				newValueDbo.put(vk, convertToMongoType(o, typeInformation));
 			}
 
 			return newValueDbo;
@@ -1173,18 +1241,18 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 			Document result = new Document();
 
 			for (Map.Entry<Object, Object> entry : ((Map<Object, Object>) obj).entrySet()) {
-				result.put(entry.getKey().toString(), convertToMongoType(entry.getValue(), typeHint));
+				result.put(entry.getKey().toString(), convertToMongoType(entry.getValue(), typeInformation));
 			}
 
 			return result;
 		}
 
 		if (obj.getClass().isArray()) {
-			return maybeConvertList(Arrays.asList((Object[]) obj), typeHint);
+			return maybeConvertList(Arrays.asList((Object[]) obj), typeInformation);
 		}
 
 		if (obj instanceof Collection) {
-			return maybeConvertList((Collection<?>) obj, typeHint);
+			return maybeConvertList((Collection<?>) obj, typeInformation);
 		}
 
 		Document newDocument = new Document();
@@ -1219,6 +1287,7 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 	 * @param recursively whether to apply the removal recursively
 	 * @return
 	 */
+	@SuppressWarnings("unchecked")
 	private Object removeTypeInfo(Object object, boolean recursively) {
 
 		if (!(object instanceof Document)) {
@@ -1239,7 +1308,7 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 						removeTypeInfo(element, recursively);
 					}
 				} else if (value instanceof List) {
-					for (Object element : (List) value) {
+					for (Object element : (List<Object>) value) {
 						removeTypeInfo(element, recursively);
 					}
 				} else {
@@ -1269,12 +1338,14 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 	 * of the configured source {@link Document}.
 	 *
 	 * @author Oliver Gierke
+	 * @author Mark Paluch
+	 * @author Christoph Strobl
 	 */
 	class MongoDbPropertyValueProvider implements PropertyValueProvider<MongoPersistentProperty> {
 
-		private final DocumentAccessor source;
-		private final SpELExpressionEvaluator evaluator;
-		private final ObjectPath path;
+		final DocumentAccessor accessor;
+		final SpELExpressionEvaluator evaluator;
+		final ObjectPath path;
 
 		/**
 		 * Creates a new {@link MongoDbPropertyValueProvider} for the given source, {@link SpELExpressionEvaluator} and
@@ -1284,15 +1355,8 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 		 * @param evaluator must not be {@literal null}.
 		 * @param path must not be {@literal null}.
 		 */
-		public MongoDbPropertyValueProvider(Bson source, SpELExpressionEvaluator evaluator, ObjectPath path) {
-
-			Assert.notNull(source, "Source document must no be null!");
-			Assert.notNull(evaluator, "SpELExpressionEvaluator must not be null!");
-			Assert.notNull(path, "ObjectPath must not be null!");
-
-			this.source = new DocumentAccessor(source);
-			this.evaluator = evaluator;
-			this.path = path;
+		MongoDbPropertyValueProvider(Bson source, SpELExpressionEvaluator evaluator, ObjectPath path) {
+			this(new DocumentAccessor(source), evaluator, path);
 		}
 
 		/**
@@ -1303,13 +1367,13 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 		 * @param evaluator must not be {@literal null}.
 		 * @param path must not be {@literal null}.
 		 */
-		public MongoDbPropertyValueProvider(DocumentAccessor accessor, SpELExpressionEvaluator evaluator, ObjectPath path) {
+		MongoDbPropertyValueProvider(DocumentAccessor accessor, SpELExpressionEvaluator evaluator, ObjectPath path) {
 
 			Assert.notNull(accessor, "DocumentAccessor must no be null!");
 			Assert.notNull(evaluator, "SpELExpressionEvaluator must not be null!");
 			Assert.notNull(path, "ObjectPath must not be null!");
 
-			this.source = accessor;
+			this.accessor = accessor;
 			this.evaluator = evaluator;
 			this.path = path;
 		}
@@ -1322,7 +1386,7 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 		public <T> T getPropertyValue(MongoPersistentProperty property) {
 
 			String expression = property.getSpelExpression();
-			Object value = expression != null ? evaluator.evaluate(expression) : source.get(property);
+			Object value = expression != null ? evaluator.evaluate(expression) : accessor.get(property);
 
 			if (value == null) {
 				return null;
@@ -1332,6 +1396,55 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 		}
 	}
 
+	/**
+	 * {@link PropertyValueProvider} that is aware of {@link MongoPersistentProperty#isAssociation()} and that delegates
+	 * resolution to {@link DbRefResolver}.
+	 *
+	 * @author Mark Paluch
+	 * @author Christoph Strobl
+	 * @since 2.1
+	 */
+	class AssociationAwareMongoDbPropertyValueProvider extends MongoDbPropertyValueProvider {
+
+		/**
+		 * Creates a new {@link AssociationAwareMongoDbPropertyValueProvider} for the given source,
+		 * {@link SpELExpressionEvaluator} and {@link ObjectPath}.
+		 *
+		 * @param source must not be {@literal null}.
+		 * @param evaluator must not be {@literal null}.
+		 * @param path must not be {@literal null}.
+		 */
+		AssociationAwareMongoDbPropertyValueProvider(DocumentAccessor source, SpELExpressionEvaluator evaluator,
+				ObjectPath path) {
+			super(source, evaluator, path);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.convert.PropertyValueProvider#getPropertyValue(org.springframework.data.mapping.PersistentProperty)
+		 */
+		@Nullable
+		@SuppressWarnings("unchecked")
+		public <T> T getPropertyValue(MongoPersistentProperty property) {
+
+			if (property.isDbReference() && property.getDBRef().lazy()) {
+
+				Object rawRefValue = accessor.get(property);
+				if (rawRefValue == null) {
+					return null;
+				}
+
+				DbRefResolverCallback callback = new DefaultDbRefResolverCallback(accessor.getDocument(), path, evaluator,
+						MappingMongoConverter.this);
+
+				DBRef dbref = rawRefValue instanceof DBRef ? (DBRef) rawRefValue : null;
+				return (T) dbRefResolver.resolveDbRef(property, dbref, callback, dbRefProxyHandler);
+			}
+
+			return super.getPropertyValue(property);
+		}
+	}
+
 	/**
 	 * Extension of {@link SpELExpressionParameterValueProvider} to recursively trigger value conversion on the raw
 	 * resolved SpEL value.
@@ -1379,7 +1492,7 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 		} else if (value instanceof DBRef) {
 			return potentiallyReadOrResolveDbRef((DBRef) value, type, path, rawType);
 		} else if (value instanceof List) {
-			return (T) readCollectionOrArray(type, (List) value, path);
+			return (T) readCollectionOrArray(type, (List<Object>) value, path);
 		} else if (value instanceof Document) {
 			return (T) read(type, (Document) value, path);
 		} else if (value instanceof DBObject) {
@@ -1495,7 +1608,7 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 	 * @param source must not be {@literal null}.
 	 * @return
 	 */
-	private static boolean isCollectionOfDbRefWhereBulkFetchIsPossible(Iterable<Object> source) {
+	private static boolean isCollectionOfDbRefWhereBulkFetchIsPossible(Iterable<?> source) {
 
 		Assert.notNull(source, "Iterable of DBRefs must not be null!");
 
@@ -1527,4 +1640,14 @@ public class MappingMongoConverter extends AbstractMongoConverter implements App
 	static class NestedDocument {
 
 	}
+
+	enum NoOpParameterValueProvider implements ParameterValueProvider<MongoPersistentProperty> {
+
+		INSTANCE;
+
+		@Override
+		public <T> T getParameterValue(Parameter<T, MongoPersistentProperty> parameter) {
+			return null;
+		}
+	}
 }

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

@@ -69,7 +69,6 @@ public interface MongoConverter
 		Assert.notNull(targetType, "TargetType must not be null!");
 		Assert.notNull(dbRefResolver, "DbRefResolver must not be null!");
 
-
 		if (targetType != Object.class && ClassUtils.isAssignable(targetType, source.getClass())) {
 			return (T) source;
 		}

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

@@ -164,13 +164,14 @@ public class MongoExampleMapper {
 			if (exampleSpecAccessor.hasPropertySpecifier(mappedPropertyPath)) {
 
 				PropertyValueTransformer valueTransformer = exampleSpecAccessor.getValueTransformerForPath(mappedPropertyPath);
-				value = valueTransformer.convert(value);
-				if (value == null) {
+				Optional converted = valueTransformer.apply(Optional.ofNullable(value));
+
+				if(!converted.isPresent()) {
 					iter.remove();
 					continue;
 				}
 
-				entry.setValue(value);
+				entry.setValue(converted.get());
 			}
 
 			if (entry.getValue() instanceof String) {

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

@@ -0,0 +1,72 @@
+/*
+ * 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.convert;
+
+import java.util.List;
+
+import org.bson.Document;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
+import org.springframework.lang.Nullable;
+
+import com.mongodb.DBRef;
+
+/**
+ * No-Operation {@link org.springframework.data.mongodb.core.mapping.DBRef} resolver throwing
+ * {@link UnsupportedOperationException} when attempting to resolve database references.
+ *
+ * @author Mark Paluch
+ * @author Christoph Strobl
+ * @since 2.1
+ */
+public enum NoOpDbRefResolver implements DbRefResolver {
+
+	INSTANCE;
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.convert.DbRefResolver#resolveDbRef(org.springframework.data.mongodb.core.mapping.MongoPersistentProperty, org.springframework.data.mongodb.core.convert.DbRefResolverCallback, org.springframework.data.mongodb.core.convert.DbRefProxyHandler)
+	 */
+	@Override
+	@Nullable
+	public Object resolveDbRef(MongoPersistentProperty property, @Nullable DBRef dbref, DbRefResolverCallback callback,
+			DbRefProxyHandler proxyHandler) {
+
+		return handle();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.convert.DbRefResolver#fetch(com.mongodb.DBRef)
+	 */
+	@Override
+	@Nullable
+	public Document fetch(DBRef dbRef) {
+		return handle();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.convert.DbRefResolver#bulkFetch(java.util.List)
+	 */
+	@Override
+	public List<Document> bulkFetch(List<DBRef> dbRefs) {
+		return handle();
+	}
+
+	private <T> T handle() throws UnsupportedOperationException {
+		throw new UnsupportedOperationException("DBRef resolution is not supported!");
+	}
+}

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

@@ -15,8 +15,6 @@
  */
 package org.springframework.data.mongodb.core.convert;
 
-import lombok.Value;
-
 import java.util.ArrayList;
 import java.util.List;
 
@@ -45,26 +43,33 @@ class ObjectPath {
 
 	static final ObjectPath ROOT = new ObjectPath();
 
-	private final ObjectPathItem[] items;
+	private final @Nullable ObjectPath parent;
+	private final @Nullable Object object;
+	private final @Nullable Object idValue;
+	private final String collection;
 
 	private ObjectPath() {
-		this.items = new ObjectPathItem[0];
+
+		this.parent = null;
+		this.object = null;
+		this.idValue = null;
+		this.collection = "";
 	}
 
 	/**
-	 * Creates a new {@link ObjectPath} from the given parent {@link ObjectPath} by adding the provided
-	 * {@link ObjectPathItem} to it.
+	 * Creates a new {@link ObjectPath} from the given parent {@link ObjectPath} and adding the provided path values.
 	 *
 	 * @param parent must not be {@literal null}.
-	 * @param item
+	 * @param collection
+	 * @param idValue
+	 * @param collection
 	 */
-	private ObjectPath(ObjectPath parent, ObjectPath.ObjectPathItem item) {
+	private ObjectPath(ObjectPath parent, Object object, @Nullable Object idValue, String collection) {
 
-		ObjectPathItem[] items = new ObjectPathItem[parent.items.length + 1];
-		System.arraycopy(parent.items, 0, items, 0, parent.items.length);
-		items[parent.items.length] = item;
-
-		this.items = items;
+		this.parent = parent;
+		this.object = object;
+		this.idValue = idValue;
+		this.collection = collection;
 	}
 
 	/**
@@ -80,8 +85,7 @@ class ObjectPath {
 		Assert.notNull(object, "Object must not be null!");
 		Assert.notNull(entity, "MongoPersistentEntity must not be null!");
 
-		ObjectPathItem item = new ObjectPathItem(object, id, entity.getCollection());
-		return new ObjectPath(this, item);
+		return new ObjectPath(this, object, id, entity.getCollection());
 	}
 
 	/**
@@ -100,15 +104,15 @@ class ObjectPath {
 		Assert.notNull(id, "Id must not be null!");
 		Assert.hasText(collection, "Collection name must not be null!");
 
-		for (ObjectPathItem item : items) {
+		for (ObjectPath current = this; current != null; current = current.parent) {
 
-			Object object = item.getObject();
+			Object object = current.getObject();
 
-			if (object == null || item.getIdValue() == null) {
+			if (object == null || current.getIdValue() == null) {
 				continue;
 			}
 
-			if (collection.equals(item.getCollection()) && id.equals(item.getIdValue())) {
+			if (collection.equals(current.getCollection()) && id.equals(current.getIdValue())) {
 				return object;
 			}
 		}
@@ -133,15 +137,15 @@ class ObjectPath {
 		Assert.hasText(collection, "Collection name must not be null!");
 		Assert.notNull(type, "Type must not be null!");
 
-		for (ObjectPathItem item : items) {
+		for (ObjectPath current = this; current != null; current = current.parent) {
 
-			Object object = item.getObject();
+			Object object = current.getObject();
 
-			if (object == null || item.getIdValue() == null) {
+			if (object == null || current.getIdValue() == null) {
 				continue;
 			}
 
-			if (collection.equals(item.getCollection()) && id.equals(item.getIdValue())
+			if (collection.equals(current.getCollection()) && id.equals(current.getIdValue())
 					&& ClassUtils.isAssignable(type, object.getClass())) {
 				return type.cast(object);
 			}
@@ -157,7 +161,21 @@ class ObjectPath {
 	 */
 	@Nullable
 	Object getCurrentObject() {
-		return items.length == 0 ? null : items[items.length - 1].getObject();
+		return getObject();
+	}
+
+	@Nullable
+	private Object getObject() {
+		return object;
+	}
+
+	@Nullable
+	private Object getIdValue() {
+		return idValue;
+	}
+
+	private String getCollection() {
+		return collection;
 	}
 
 	/*
@@ -167,31 +185,16 @@ class ObjectPath {
 	@Override
 	public String toString() {
 
-		if (items.length == 0) {
+		if (parent == null) {
 			return "[empty]";
 		}
 
-		List<String> strings = new ArrayList<>(items.length);
+		List<String> strings = new ArrayList<>();
 
-		for (ObjectPathItem item : items) {
-			strings.add(ObjectUtils.nullSafeToString(item.object));
+		for (ObjectPath current = this; current != null; current = current.parent) {
+			strings.add(ObjectUtils.nullSafeToString(current.getObject()));
 		}
 
 		return StringUtils.collectionToDelimitedString(strings, " -> ");
 	}
-
-	/**
-	 * An item in an {@link ObjectPath}.
-	 *
-	 * @author Thomas Darimont
-	 * @author Oliver Gierke
-	 * @author Mark Paluch
-	 */
-	@Value
-	private static class ObjectPathItem {
-
-		Object object;
-		@Nullable Object idValue;
-		String collection;
-	}
 }

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

@@ -35,11 +35,11 @@ import org.springframework.data.domain.Example;
 import org.springframework.data.mapping.Association;
 import org.springframework.data.mapping.MappingException;
 import org.springframework.data.mapping.PersistentEntity;
+import org.springframework.data.mapping.PersistentPropertyPath;
 import org.springframework.data.mapping.PropertyPath;
 import org.springframework.data.mapping.PropertyReferenceException;
 import org.springframework.data.mapping.context.InvalidPersistentPropertyPath;
 import org.springframework.data.mapping.context.MappingContext;
-import org.springframework.data.mapping.context.PersistentPropertyPath;
 import org.springframework.data.mongodb.core.convert.MappingMongoConverter.NestedDocument;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
@@ -312,7 +312,7 @@ public class QueryMapper {
 	@SuppressWarnings("unchecked")
 	protected Object getMappedValue(Field documentField, Object value) {
 
-		if (documentField.isIdField()) {
+		if (documentField.isIdField() && !documentField.isAssociation()) {
 
 			if (isDBObject(value)) {
 				DBObject valueDbo = (DBObject) value;
@@ -850,15 +850,18 @@ public class QueryMapper {
 
 		/*
 		 * (non-Javadoc)
-		 * @see org.springframework.data.mongodb.core.convert.QueryMapper.Field#isIdKey()
+		 * @see org.springframework.data.mongodb.core.convert.QueryMapper.Field#isIdField()
 		 */
 		@Override
 		public boolean isIdField() {
 
-			MongoPersistentProperty idProperty = entity.getIdProperty();
+			MongoPersistentProperty idProperty = (property != null && property.isIdProperty()) ? property
+					: entity.getIdProperty();
 
 			if (idProperty != null) {
-				return idProperty.getName().equals(name) || idProperty.getFieldName().equals(name);
+
+				return name.equals(idProperty.getName()) || name.equals(idProperty.getFieldName())
+						|| name.endsWith("." + idProperty.getName()) || name.endsWith("." + idProperty.getFieldName());
 			}
 
 			return DEFAULT_ID_NAMES.contains(name);

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

@@ -70,7 +70,9 @@ public @interface CompoundIndex {
 	/**
 	 * @return
 	 * @see <a href="https://docs.mongodb.org/manual/core/index-creation/#index-creation-duplicate-dropping">https://docs.mongodb.org/manual/core/index-creation/#index-creation-duplicate-dropping</a>
+	 * @deprecated since 2.1. No longer supported by MongoDB as of server version 3.0.
 	 */
+	@Deprecated
 	boolean dropDups() default false;
 
 	/**

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

@@ -36,6 +36,10 @@ import org.springframework.util.StringUtils;
 @SuppressWarnings("deprecation")
 public class Index implements IndexDefinition {
 
+	/**
+	 * @deprecated since 2.1. No longer supported by MongoDB as of server version 3.0.
+	 */
+	@Deprecated
 	public enum Duplicates {
 		RETAIN
 	}
@@ -43,7 +47,6 @@ public class Index implements IndexDefinition {
 	private final Map<String, Direction> fieldSpec = new LinkedHashMap<String, Direction>();
 	private @Nullable String name;
 	private boolean unique = false;
-	private boolean dropDuplicates = false;
 	private boolean sparse = false;
 	private boolean background = false;
 	private long expire = -1;
@@ -183,9 +186,6 @@ public class Index implements IndexDefinition {
 		if (unique) {
 			document.put("unique", true);
 		}
-		if (dropDuplicates) {
-			document.put("dropDups", true);
-		}
 		if (sparse) {
 			document.put("sparse", true);
 		}

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

@@ -13,21 +13,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 package org.springframework.data.mongodb.core.index;
 
 /**
- * TODO: Revisit for a better pattern.
+ * Provider interface to obtain {@link IndexOperations} by MongoDB collection name.
  *
  * @author Mark Paluch
  * @author Jens Schauder
  * @since 2.0
  */
+@FunctionalInterface
 public interface IndexOperationsProvider {
 
 	/**
 	 * Returns the operations that can be performed on indexes
 	 *
+	 * @param collectionName name of the MongoDB collection, must not be {@literal null}.
 	 * @return index operations on the named collection
 	 */
 	IndexOperations indexOps(String collectionName);

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

@@ -56,7 +56,9 @@ public @interface Indexed {
 	/**
 	 * @return
 	 * @see <a href="https://docs.mongodb.org/manual/core/index-creation/#index-creation-duplicate-dropping">https://docs.mongodb.org/manual/core/index-creation/#index-creation-duplicate-dropping</a>
+	 * @deprecated since 2.1. No longer supported by MongoDB as of server version 3.0.
 	 */
+	@Deprecated
 	boolean dropDups() default false;
 
 	/**

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

@@ -18,6 +18,7 @@ package org.springframework.data.mongodb.core.index;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationEvent;
 import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.context.ApplicationListener;
 import org.springframework.data.mapping.context.MappingContextEvent;
 import org.springframework.data.mongodb.core.MongoTemplate;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
@@ -38,7 +39,20 @@ import org.springframework.util.Assert;
  */
 public class MongoMappingEventPublisher implements ApplicationEventPublisher {
 
-	private final MongoPersistentEntityIndexCreator indexCreator;
+	private final ApplicationListener<MappingContextEvent<?, ?>> indexCreator;
+
+	/**
+	 * Creates a new {@link MongoMappingEventPublisher} for the given {@link ApplicationListener}.
+	 *
+	 * @param indexCreator must not be {@literal null}.
+	 * @since 2.1
+	 */
+	public MongoMappingEventPublisher(ApplicationListener<MappingContextEvent<?, ?>> indexCreator) {
+
+		Assert.notNull(indexCreator, "ApplicationListener must not be null!");
+
+		this.indexCreator = indexCreator;
+	}
 
 	/**
 	 * Creates a new {@link MongoMappingEventPublisher} for the given {@link MongoPersistentEntityIndexCreator}.
@@ -48,6 +62,7 @@ public class MongoMappingEventPublisher implements ApplicationEventPublisher {
 	public MongoMappingEventPublisher(MongoPersistentEntityIndexCreator indexCreator) {
 
 		Assert.notNull(indexCreator, "MongoPersistentEntityIndexCreator must not be null!");
+
 		this.indexCreator = indexCreator;
 	}
 

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

@@ -0,0 +1,34 @@
+/*
+ * 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.index;
+
+/**
+ * Provider interface to obtain {@link ReactiveIndexOperations} by MongoDB collection name.
+ *
+ * @author Mark Paluch
+ * @since 2.1
+ */
+@FunctionalInterface
+public interface ReactiveIndexOperationsProvider {
+
+	/**
+	 * Returns the operations that can be performed on indexes.
+	 *
+	 * @param collectionName name of the MongoDB collection, must not be {@literal null}.
+	 * @return index operations on the named collection
+	 */
+	ReactiveIndexOperations indexOps(String collectionName);
+}

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

@@ -0,0 +1,186 @@
+/*
+ * 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.index;
+
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.dao.DataIntegrityViolationException;
+import org.springframework.data.mapping.context.MappingContext;
+import org.springframework.data.mongodb.UncategorizedMongoDbException;
+import org.springframework.data.mongodb.core.index.MongoPersistentEntityIndexResolver.IndexDefinitionHolder;
+import org.springframework.data.mongodb.core.mapping.Document;
+import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
+import org.springframework.data.mongodb.util.MongoDbErrorCodes;
+import org.springframework.util.Assert;
+import org.springframework.util.ObjectUtils;
+
+import com.mongodb.MongoException;
+
+/**
+ * Component that inspects {@link MongoPersistentEntity} instances contained in the given {@link MongoMappingContext}
+ * for indexing metadata and ensures the indexes to be available using reactive infrastructure.
+ *
+ * @author Mark Paluch
+ * @since 2.1
+ */
+public class ReactiveMongoPersistentEntityIndexCreator {
+
+	private static final Logger LOGGER = LoggerFactory.getLogger(ReactiveMongoPersistentEntityIndexCreator.class);
+
+	private final Map<Class<?>, Boolean> classesSeen = new ConcurrentHashMap<Class<?>, Boolean>();
+	private final MongoMappingContext mappingContext;
+	private final ReactiveIndexOperationsProvider operationsProvider;
+	private final IndexResolver indexResolver;
+
+	/**
+	 * Creates a new {@link ReactiveMongoPersistentEntityIndexCreator} for the given {@link MongoMappingContext},
+	 * {@link ReactiveIndexOperationsProvider}.
+	 *
+	 * @param mappingContext must not be {@literal null}.
+	 * @param operationsProvider must not be {@literal null}.
+	 */
+	public ReactiveMongoPersistentEntityIndexCreator(MongoMappingContext mappingContext,
+			ReactiveIndexOperationsProvider operationsProvider) {
+		this(mappingContext, operationsProvider, new MongoPersistentEntityIndexResolver(mappingContext));
+	}
+
+	/**
+	 * Creates a new {@link ReactiveMongoPersistentEntityIndexCreator} for the given {@link MongoMappingContext},
+	 * {@link ReactiveIndexOperationsProvider}, and {@link IndexResolver}.
+	 *
+	 * @param mappingContext must not be {@literal null}.
+	 * @param operationsProvider must not be {@literal null}.
+	 * @param indexResolver must not be {@literal null}.
+	 */
+	public ReactiveMongoPersistentEntityIndexCreator(MongoMappingContext mappingContext,
+			ReactiveIndexOperationsProvider operationsProvider, IndexResolver indexResolver) {
+
+		Assert.notNull(mappingContext, "MongoMappingContext must not be null!");
+		Assert.notNull(operationsProvider, "ReactiveIndexOperations must not be null!");
+		Assert.notNull(indexResolver, "IndexResolver must not be null!");
+
+		this.mappingContext = mappingContext;
+		this.operationsProvider = operationsProvider;
+		this.indexResolver = indexResolver;
+	}
+
+	/**
+	 * Returns whether the current index creator was registered for the given {@link MappingContext}.
+	 *
+	 * @param context
+	 * @return
+	 */
+	public boolean isIndexCreatorFor(MappingContext<?, ?> context) {
+		return this.mappingContext.equals(context);
+	}
+
+	/**
+	 * Inspect entities for index creation.
+	 *
+	 * @return a {@link Mono} that completes without value after indexes were created.
+	 */
+	public Mono<Void> checkForIndexes(MongoPersistentEntity<?> entity) {
+
+		Class<?> type = entity.getType();
+
+		if (!classesSeen.containsKey(type)) {
+
+			if (this.classesSeen.put(type, Boolean.TRUE) == null) {
+
+				if (LOGGER.isDebugEnabled()) {
+					LOGGER.debug("Analyzing class " + type + " for index information.");
+				}
+
+				return checkForAndCreateIndexes(entity);
+			}
+		}
+
+		return Mono.empty();
+	}
+
+	private Mono<Void> checkForAndCreateIndexes(MongoPersistentEntity<?> entity) {
+
+		List<Mono<?>> publishers = new ArrayList<>();
+
+		if (entity.isAnnotationPresent(Document.class)) {
+			for (IndexDefinitionHolder indexToCreate : indexResolver.resolveIndexFor(entity.getTypeInformation())) {
+				publishers.add(createIndex(indexToCreate));
+			}
+		}
+
+		return publishers.isEmpty() ? Mono.empty() : Flux.merge(publishers).then();
+	}
+
+	Mono<String> createIndex(IndexDefinitionHolder indexDefinition) {
+
+		return operationsProvider.indexOps(indexDefinition.getCollection()).ensureIndex(indexDefinition) //
+				.onErrorResume(ReactiveMongoPersistentEntityIndexCreator::isDataIntegrityViolation,
+						e -> translateException(e, indexDefinition));
+
+	}
+
+	private Mono<? extends String> translateException(Throwable e, IndexDefinitionHolder indexDefinition) {
+
+		Mono<IndexInfo> existingIndex = fetchIndexInformation(indexDefinition);
+
+		Mono<String> defaultError = Mono.error(new DataIntegrityViolationException(
+				String.format("Cannot create index for '%s' in collection '%s' with keys '%s' and options '%s'.",
+						indexDefinition.getPath(), indexDefinition.getCollection(), indexDefinition.getIndexKeys(),
+						indexDefinition.getIndexOptions()),
+				e.getCause()));
+
+		return existingIndex.flatMap(it -> {
+			return Mono.<String> error(new DataIntegrityViolationException(
+					String.format("Index already defined as '%s'.", indexDefinition.getPath()), e.getCause()));
+		}).switchIfEmpty(defaultError);
+	}
+
+	private Mono<IndexInfo> fetchIndexInformation(IndexDefinitionHolder indexDefinition) {
+
+		Object indexNameToLookUp = indexDefinition.getIndexOptions().get("name");
+
+		Flux<IndexInfo> existingIndexes = operationsProvider.indexOps(indexDefinition.getCollection()).getIndexInfo();
+
+		return existingIndexes //
+				.filter(indexInfo -> ObjectUtils.nullSafeEquals(indexNameToLookUp, indexInfo.getName())) //
+				.next() //
+				.doOnError(e -> {
+					LOGGER.debug(
+							String.format("Failed to load index information for collection '%s'.", indexDefinition.getCollection()),
+							e);
+				});
+	}
+
+	private static boolean isDataIntegrityViolation(Throwable t) {
+
+		if (t instanceof UncategorizedMongoDbException) {
+
+			return t.getCause() instanceof MongoException
+					&& MongoDbErrorCodes.isDataIntegrityViolationCode(((MongoException) t.getCause()).getCode());
+		}
+
+		return false;
+	}
+}

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

@@ -21,11 +21,6 @@ import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Map;
 
-import org.springframework.beans.BeansException;
-import org.springframework.context.ApplicationContext;
-import org.springframework.context.ApplicationContextAware;
-import org.springframework.context.expression.BeanFactoryAccessor;
-import org.springframework.context.expression.BeanFactoryResolver;
 import org.springframework.data.annotation.Id;
 import org.springframework.data.mapping.Association;
 import org.springframework.data.mapping.AssociationHandler;
@@ -38,7 +33,6 @@ import org.springframework.expression.Expression;
 import org.springframework.expression.ParserContext;
 import org.springframework.expression.common.LiteralExpression;
 import org.springframework.expression.spel.standard.SpelExpressionParser;
-import org.springframework.expression.spel.support.StandardEvaluationContext;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
@@ -55,7 +49,7 @@ import org.springframework.util.StringUtils;
  * @author Mark Paluch
  */
 public class BasicMongoPersistentEntity<T> extends BasicPersistentEntity<T, MongoPersistentProperty>
-		implements MongoPersistentEntity<T>, ApplicationContextAware {
+		implements MongoPersistentEntity<T> {
 
 	private static final String AMBIGUOUS_FIELD_MAPPING = "Ambiguous field mapping detected! Both %s and %s map to the same field name %s! Disambiguate using @Field annotation!";
 	private static final SpelExpressionParser PARSER = new SpelExpressionParser();
@@ -63,7 +57,6 @@ public class BasicMongoPersistentEntity<T> extends BasicPersistentEntity<T, Mong
 	private final String collection;
 	private final String language;
 
-	private final StandardEvaluationContext context;
 	private final @Nullable Expression expression;
 
 	/**
@@ -79,8 +72,6 @@ public class BasicMongoPersistentEntity<T> extends BasicPersistentEntity<T, Mong
 		Class<?> rawType = typeInformation.getType();
 		String fallback = MongoCollectionUtils.getPreferredCollectionName(rawType);
 
-		this.context = new StandardEvaluationContext();
-
 		if (this.isAnnotationPresent(Document.class)) {
 			Document document = this.getRequiredAnnotation(Document.class);
 
@@ -95,23 +86,15 @@ public class BasicMongoPersistentEntity<T> extends BasicPersistentEntity<T, Mong
 		}
 	}
 
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.context.ApplicationContextAware#setApplicationContext(org.springframework.context.ApplicationContext)
-	 */
-	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
-
-		context.addPropertyAccessor(new BeanFactoryAccessor());
-		context.setBeanResolver(new BeanFactoryResolver(applicationContext));
-		context.setRootObject(applicationContext);
-	}
-
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.mongodb.core.mapping.MongoPersistentEntity#getCollection()
 	 */
 	public String getCollection() {
-		return expression == null ? collection : expression.getValue(context, String.class);
+
+		return expression == null //
+				? collection //
+				: expression.getValue(getEvaluationContext(null), String.class);
 	}
 
 	/*

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

@@ -24,11 +24,14 @@ import org.springframework.lang.Nullable;
  * {@link MongoPersistentProperty} caching access to {@link #isIdProperty()} and {@link #getFieldName()}.
  *
  * @author Oliver Gierke
+ * @author Mark Paluch
  */
 public class CachingMongoPersistentProperty extends BasicMongoPersistentProperty {
 
 	private @Nullable Boolean isIdProperty;
 	private @Nullable Boolean isAssociation;
+	private @Nullable boolean dbRefResolved;
+	private @Nullable DBRef dbref;
 	private @Nullable String fieldName;
 	private @Nullable Boolean usePropertyAccess;
 	private @Nullable Boolean isTransient;
@@ -36,8 +39,7 @@ public class CachingMongoPersistentProperty extends BasicMongoPersistentProperty
 	/**
 	 * Creates a new {@link CachingMongoPersistentProperty}.
 	 *
-	 * @param field
-	 * @param propertyDescriptor
+	 * @param property
 	 * @param owner
 	 * @param simpleTypeHolder
 	 * @param fieldNamingStrategy
@@ -114,4 +116,28 @@ public class CachingMongoPersistentProperty extends BasicMongoPersistentProperty
 
 		return this.isTransient;
 	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.mapping.BasicMongoPersistentProperty#isDbReference()
+	 */
+	@Override
+	public boolean isDbReference() {
+		return getDBRef() != null;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.mapping.BasicMongoPersistentProperty#getDBRef()
+	 */
+	@Override
+	public DBRef getDBRef() {
+
+		if (!dbRefResolved) {
+			this.dbref = super.getDBRef();
+			this.dbRefResolved = true;
+		}
+
+		return this.dbref;
+	}
 }

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

@@ -21,13 +21,14 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+import org.springframework.core.annotation.AliasFor;
 import org.springframework.data.annotation.Persistent;
 
 /**
  * Identifies a domain object to be persisted to MongoDB.
  *
- * @author Jon Brisbin <jbrisbin@vmware.com>
- * @author Oliver Gierke ogierke@vmware.com
+ * @author Jon Brisbin
+ * @author Oliver Gierke
  * @author Christoph Strobl
  */
 @Persistent
@@ -36,6 +37,24 @@ import org.springframework.data.annotation.Persistent;
 @Target({ ElementType.TYPE })
 public @interface Document {
 
+	/**
+	 * The collection the document representing the entity is supposed to be stored in. If not configured, a default
+	 * collection name will be derived from the type's name. The attribute supports SpEL expressions to dynamically
+	 * calculate the collection to based on a per operation basis.
+	 * 
+	 * @return the name of the collection to be used.
+	 */
+	@AliasFor("collection")
+	String value() default "";
+
+	/**
+	 * The collection the document representing the entity is supposed to be stored in. If not configured, a default
+	 * collection name will be derived from the type's name. The attribute supports SpEL expressions to dynamically
+	 * calculate the collection to based on a per operation basis.
+	 * 
+	 * @return the name of the collection to be used.
+	 */
+	@AliasFor("value")
 	String collection() default "";
 
 	/**

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

@@ -87,14 +87,7 @@ public class MongoMappingContext extends AbstractMappingContext<BasicMongoPersis
 	 */
 	@Override
 	protected <T> BasicMongoPersistentEntity<T> createPersistentEntity(TypeInformation<T> typeInformation) {
-
-		BasicMongoPersistentEntity<T> entity = new BasicMongoPersistentEntity<T>(typeInformation);
-
-		if (context != null) {
-			entity.setApplicationContext(context);
-		}
-
-		return entity;
+		return new BasicMongoPersistentEntity<T>(typeInformation);
 	}
 
 	/*
@@ -103,6 +96,9 @@ public class MongoMappingContext extends AbstractMappingContext<BasicMongoPersis
 	 */
 	@Override
 	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
+
+		super.setApplicationContext(applicationContext);
+
 		this.context = applicationContext;
 	}
 }

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

@@ -22,13 +22,13 @@ import java.util.Set;
 import java.util.UUID;
 import java.util.regex.Pattern;
 
-import org.bson.BsonObjectId;
+import org.bson.*;
 import org.bson.types.Binary;
 import org.bson.types.CodeWScope;
+import org.bson.types.CodeWithScope;
+import org.bson.types.Decimal128;
 import org.bson.types.ObjectId;
 import org.springframework.data.mapping.model.SimpleTypeHolder;
-import org.springframework.data.mongodb.util.MongoClientVersion;
-import org.springframework.util.ClassUtils;
 
 import com.mongodb.DBRef;
 
@@ -54,15 +54,29 @@ public abstract class MongoSimpleTypes {
 		simpleTypes.add(ObjectId.class);
 		simpleTypes.add(BsonObjectId.class);
 		simpleTypes.add(CodeWScope.class);
+		simpleTypes.add(CodeWithScope.class);
 		simpleTypes.add(org.bson.Document.class);
 		simpleTypes.add(Pattern.class);
 		simpleTypes.add(Binary.class);
 		simpleTypes.add(UUID.class);
+		simpleTypes.add(Decimal128.class);
 
-		if (MongoClientVersion.isMongo34Driver()) {
-			simpleTypes
-					.add(ClassUtils.resolveClassName("org.bson.types.Decimal128", MongoSimpleTypes.class.getClassLoader()));
-		}
+		simpleTypes.add(BsonBinary.class);
+		simpleTypes.add(BsonBoolean.class);
+		simpleTypes.add(BsonDateTime.class);
+		simpleTypes.add(BsonDbPointer.class);
+		simpleTypes.add(BsonDecimal128.class);
+		simpleTypes.add(BsonDocument.class);
+		simpleTypes.add(BsonDocument.class);
+		simpleTypes.add(BsonDouble.class);
+		simpleTypes.add(BsonInt32.class);
+		simpleTypes.add(BsonInt64.class);
+		simpleTypes.add(BsonJavaScript.class);
+		simpleTypes.add(BsonJavaScriptWithScope.class);
+		simpleTypes.add(BsonObjectId.class);
+		simpleTypes.add(BsonRegularExpression.class);
+		simpleTypes.add(BsonString.class);
+		simpleTypes.add(BsonTimestamp.class);
 
 		MONGO_SIMPLE_TYPES = Collections.unmodifiableSet(simpleTypes);
 	}

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

@@ -15,8 +15,6 @@
  */
 package org.springframework.data.mongodb.core.mapping.event;
 
-import java.util.Optional;
-
 import org.springframework.beans.factory.ObjectFactory;
 import org.springframework.context.ApplicationListener;
 import org.springframework.core.Ordered;
@@ -53,9 +51,7 @@ public class AuditingEventListener implements ApplicationListener<BeforeConvertE
 	 */
 	@Override
 	public void onApplicationEvent(BeforeConvertEvent<Object> event) {
-
-		Optional.ofNullable(event.getSource())//
-				.ifPresent(it -> auditingHandlerFactory.getObject().markAudited(it));
+		event.mapSource(it -> auditingHandlerFactory.getObject().markAudited(it));
 	}
 
 	/*