DATAMONGO-1776 - Release version 2.0 GA (Kay).

Javadoc, modifiers.

Original pull request: #503.

.gitignore

@@ -15,3 +15,4 @@ src/ant/.ant-targets-upload-dist.xml
 atlassian-ide-plugin.xml
 /.gradle/
 /.idea/
+*.graphml

.travis.yml

@@ -6,18 +6,20 @@ jdk:
 before_script:
   - mongod --version
 
+services:
+  - mongodb
+
 env:
   matrix:
     - PROFILE=ci
-    - PROFILE=mongo34-next
-    - PROFILE=mongo35-next
+    - PROFILE=mongo36-next
 
 # 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
+      - mongodb-3.4-precise
     packages:
     - mongodb-org-server
     - mongodb-org-shell

lombok.config

@@ -0,0 +1,2 @@
+lombok.nonNull.exceptionType = IllegalArgumentException
+lombok.log.fieldName = LOG

pom.xml

@@ -5,7 +5,7 @@
 
 	<groupId>org.springframework.data</groupId>
 	<artifactId>spring-data-mongodb-parent</artifactId>
-	<version>2.0.0.M2</version>
+	<version>2.0.0.RELEASE</version>
 	<packaging>pom</packaging>
 
 	<name>Spring Data MongoDB</name>
@@ -15,22 +15,22 @@
 	<parent>
 		<groupId>org.springframework.data.build</groupId>
 		<artifactId>spring-data-parent</artifactId>
-		<version>2.0.0.M2</version>
+		<version>2.0.0.RELEASE</version>
 	</parent>
 
 	<modules>
 		<module>spring-data-mongodb</module>
 		<module>spring-data-mongodb-cross-store</module>
-		<module>spring-data-mongodb-log4j</module>
 		<module>spring-data-mongodb-distribution</module>
 	</modules>
 
 	<properties>
 		<project.type>multi</project.type>
 		<dist.id>spring-data-mongodb</dist.id>
-		<springdata.commons>2.0.0.M2</springdata.commons>
-		<mongo>3.4.2</mongo>
-		<mongo.reactivestreams>1.3.0</mongo.reactivestreams>
+		<springdata.commons>2.0.0.RELEASE</springdata.commons>
+		<mongo>3.5.0</mongo>
+		<mongo.reactivestreams>1.6.0</mongo.reactivestreams>
+		<jmh.version>1.19</jmh.version>
 	</properties>
 
 	<developers>
@@ -115,11 +115,11 @@
 
 	<profiles>
 
-		<profile>
+		<!-- not-yet available profile>
 
-			<id>mongo34-next</id>
+			<id>mongo35-next</id>
 			<properties>
-				<mongo>3.4.3-SNAPSHOT</mongo>
+				<mongo>3.5.1-SNAPSHOT</mongo>
 			</properties>
 
 			<repositories>
@@ -129,13 +129,13 @@
 				</repository>
 			</repositories>
 
-		</profile>
+		</profile -->
 
 		<profile>
 
-			<id>mongo35-next</id>
+			<id>mongo36-next</id>
 			<properties>
-				<mongo>3.5.0-SNAPSHOT</mongo>
+				<mongo>3.6.0-SNAPSHOT</mongo>
 			</properties>
 
 			<repositories>
@@ -160,6 +160,16 @@
 			</build>
 		</profile>
 
+		<profile>
+			<id>benchmarks</id>
+			<modules>
+				<module>spring-data-mongodb</module>
+				<module>spring-data-mongodb-cross-store</module>
+				<module>spring-data-mongodb-distribution</module>
+				<module>spring-data-mongodb-benchmarks</module>
+			</modules>
+		</profile>
+
 	</profiles>
 
 	<dependencies>
@@ -173,8 +183,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/README.md

@@ -0,0 +1,76 @@
+# Benchmarks
+
+Benchmarks are based on [JMH](http://openjdk.java.net/projects/code-tools/jmh/).
+
+# Running Benchmarks
+
+Running benchmarks is disabled by default and can be activated via the `benchmarks` profile.
+To run the benchmarks with default settings use.
+
+```bash
+mvn -P benchmarks clean test
+```
+
+A basic report will be printed to the CLI.
+
+```bash
+# Run complete. Total time: 00:00:15
+
+Benchmark                                    Mode  Cnt        Score       Error  Units
+MappingMongoConverterBenchmark.readObject   thrpt   10  1920157,631 ± 64310,809  ops/s
+MappingMongoConverterBenchmark.writeObject  thrpt   10   782732,857 ± 53804,130  ops/s
+```
+
+## Running all Benchmarks of a specific class
+
+To run all Benchmarks of a specific class, just provide its simple class name via the `benchmark` command line argument.
+
+```bash
+mvn -P benchmarks clean test -D benchmark=MappingMongoConverterBenchmark
+```
+
+## Running a single Benchmark
+
+To run a single Benchmark provide its containing class simple name followed by `#` and the method name via the `benchmark` command line argument.
+
+```bash
+mvn -P benchmarks clean test -D benchmark=MappingMongoConverterBenchmark#readObjectWith2Properties
+```
+
+# Saving Benchmark Results
+
+A detailed benchmark report is stored in JSON format in the `/target/reports/performance` directory.
+To store the report in a different location use the `benchmarkReportDir` command line argument.
+
+## MongoDB
+
+Results can be directly piped to MongoDB by providing a valid [Connection String](https://docs.mongodb.com/manual/reference/connection-string/) via the `publishTo` command line argument.
+
+```bash
+mvn -P benchmarks clean test -D publishTo=mongodb://127.0.0.1:27017
+```
+
+NOTE: If the uri does not explicitly define a database the default `spring-data-mongodb-benchmarks` is used. 
+
+## HTTP Endpoint
+
+The benchmark report can also be posted as `application/json` to an HTTP Endpoint by providing a valid URl via the `publishTo` command line argument.
+
+```bash
+mvn -P benchmarks clean test -D publishTo=http://127.0.0.1:8080/capture-benchmarks
+```
+
+# Customizing Benchmarks
+
+Following options can be set via command line.
+
+Option | Default Value
+--- | ---
+warmupIterations | 10
+warmupTime | 1 (seconds)
+measurementIterations | 10
+measurementTime | 1 (seconds)
+forks | 1
+benchmarkReportDir | /target/reports/performance (always relative to project root dir)
+benchmark | .* (single benchmark via `classname#benchmark`)
+publishTo | \[not set\] (mongodb-uri or http-endpoint)

spring-data-mongodb-benchmarks/pom.xml

@@ -0,0 +1,111 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+		 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+	<modelVersion>4.0.0</modelVersion>
+
+	<parent>
+		<groupId>org.springframework.data</groupId>
+		<artifactId>spring-data-mongodb-parent</artifactId>
+		<version>2.0.0.RELEASE</version>
+		<relativePath>../pom.xml</relativePath>
+	</parent>
+
+	<artifactId>spring-data-mongodb-benchmarks</artifactId>
+	<packaging>jar</packaging>
+
+	<name>Spring Data MongoDB - Microbenchmarks</name>
+
+	<properties>
+		<!-- Skip tests by default; run only if -DskipTests=false is specified or benchmarks profile is activated  -->
+		<skipTests>true</skipTests>
+	</properties>
+
+	<dependencies>
+
+		<dependency>
+			<groupId>${project.groupId}</groupId>
+			<artifactId>spring-data-mongodb</artifactId>
+			<version>${project.version}</version>
+		</dependency>
+
+		<dependency>
+			<groupId>junit</groupId>
+			<artifactId>junit</artifactId>
+			<version>${junit}</version>
+			<scope>compile</scope>
+		</dependency>
+
+		<dependency>
+			<groupId>org.openjdk.jmh</groupId>
+			<artifactId>jmh-core</artifactId>
+			<version>${jmh.version}</version>
+		</dependency>
+
+		<dependency>
+			<groupId>org.openjdk.jmh</groupId>
+			<artifactId>jmh-generator-annprocess</artifactId>
+			<version>${jmh.version}</version>
+			<scope>provided</scope>
+		</dependency>
+
+	</dependencies>
+
+	<profiles>
+
+		<profile>
+			<id>benchmarks</id>
+			<properties>
+				<skipTests>false</skipTests>
+			</properties>
+		</profile>
+	</profiles>
+
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>pl.project13.maven</groupId>
+				<artifactId>git-commit-id-plugin</artifactId>
+				<version>2.2.2</version>
+				<executions>
+					<execution>
+						<goals>
+							<goal>revision</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
+			<plugin>
+				<artifactId>maven-jar-plugin</artifactId>
+				<executions>
+					<execution>
+						<id>default-jar</id>
+						<phase>never</phase>
+					</execution>
+				</executions>
+			</plugin>
+			<plugin>
+				<artifactId>maven-surefire-plugin</artifactId>
+				<configuration>
+					<testSourceDirectory>${project.build.sourceDirectory}</testSourceDirectory>
+					<testClassesDirectory>${project.build.outputDirectory}</testClassesDirectory>
+					<excludes>
+						<exclude>**/AbstractMicrobenchmark.java</exclude>
+						<exclude>**/*$*.class</exclude>
+						<exclude>**/generated/*.class</exclude>
+					</excludes>
+					<includes>
+						<include>**/*Benchmark*</include>
+					</includes>
+					<systemPropertyVariables>
+						<benchmarkReportDir>${project.build.directory}/reports/performance</benchmarkReportDir>
+						<project.version>${project.version}</project.version>
+						<git.dirty>${git.dirty}</git.dirty>
+						<git.commit.id>${git.commit.id}</git.commit.id>
+						<git.branch>${git.branch}</git.branch>
+					</systemPropertyVariables>
+				</configuration>
+			</plugin>
+		</plugins>
+	</build>
+</project>

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

@@ -0,0 +1,180 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import org.bson.Document;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.TearDown;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.mongodb.core.ExecutableFindOperation.FindWithQuery;
+import org.springframework.data.mongodb.core.ExecutableFindOperation.TerminatingFind;
+import org.springframework.data.mongodb.core.mapping.Field;
+import org.springframework.data.mongodb.core.query.BasicQuery;
+import org.springframework.data.mongodb.microbenchmark.AbstractMicrobenchmark;
+
+import com.mongodb.MongoClient;
+import com.mongodb.ServerAddress;
+import com.mongodb.client.MongoCollection;
+
+/**
+ * @author Christoph Strobl
+ */
+public class ProjectionsBenchmark extends AbstractMicrobenchmark {
+
+	private static final String DB_NAME = "projections-benchmark";
+	private static final String COLLECTION_NAME = "projections";
+
+	private MongoTemplate template;
+	private MongoClient client;
+	private MongoCollection<Document> mongoCollection;
+
+	private Person source;
+
+	private FindWithQuery<Person> asPerson;
+	private FindWithQuery<DtoProjection> asDtoProjection;
+	private FindWithQuery<ClosedProjection> asClosedProjection;
+	private FindWithQuery<OpenProjection> asOpenProjection;
+
+	private TerminatingFind<Person> asPersonWithFieldsRestriction;
+	private Document fields = new Document("firstname", 1);
+
+	@Setup
+	public void setUp() {
+
+		client = new MongoClient(new ServerAddress());
+		template = new MongoTemplate(client, DB_NAME);
+
+		source = new Person();
+		source.firstname = "luke";
+		source.lastname = "skywalker";
+
+		source.address = new Address();
+		source.address.street = "melenium falcon 1";
+		source.address.city = "deathstar";
+
+		template.save(source, COLLECTION_NAME);
+
+		asPerson = template.query(Person.class).inCollection(COLLECTION_NAME);
+		asDtoProjection = template.query(Person.class).inCollection(COLLECTION_NAME).as(DtoProjection.class);
+		asClosedProjection = template.query(Person.class).inCollection(COLLECTION_NAME).as(ClosedProjection.class);
+		asOpenProjection = template.query(Person.class).inCollection(COLLECTION_NAME).as(OpenProjection.class);
+
+		asPersonWithFieldsRestriction = template.query(Person.class).inCollection(COLLECTION_NAME)
+				.matching(new BasicQuery(new Document(), fields));
+
+		mongoCollection = client.getDatabase(DB_NAME).getCollection(COLLECTION_NAME);
+	}
+
+	@TearDown
+	public void tearDown() {
+
+		client.dropDatabase(DB_NAME);
+		client.close();
+	}
+
+	/**
+	 * Set the baseline for comparison by using the plain MongoDB java driver api without any additional fluff.
+	 *
+	 * @return
+	 */
+	@Benchmark // DATAMONGO-1733
+	public Object baseline() {
+		return mongoCollection.find().first();
+	}
+
+	/**
+	 * Read into the domain type including all fields.
+	 *
+	 * @return
+	 */
+	@Benchmark // DATAMONGO-1733
+	public Object readIntoDomainType() {
+		return asPerson.all();
+	}
+
+	/**
+	 * Read into the domain type but restrict query to only return one field.
+	 *
+	 * @return
+	 */
+	@Benchmark // DATAMONGO-1733
+	public Object readIntoDomainTypeRestrictingToOneField() {
+		return asPersonWithFieldsRestriction.all();
+	}
+
+	/**
+	 * Read into dto projection that only needs to map one field back.
+	 *
+	 * @return
+	 */
+	@Benchmark // DATAMONGO-1733
+	public Object readIntoDtoProjectionWithOneField() {
+		return asDtoProjection.all();
+	}
+
+	/**
+	 * Read into closed interface projection.
+	 *
+	 * @return
+	 */
+	@Benchmark // DATAMONGO-1733
+	public Object readIntoClosedProjectionWithOneField() {
+		return asClosedProjection.all();
+	}
+
+	/**
+	 * Read into an open projection backed by the mapped domain object.
+	 *
+	 * @return
+	 */
+	@Benchmark // DATAMONGO-1733
+	public Object readIntoOpenProjection() {
+		return asOpenProjection.all();
+	}
+
+	static class Person {
+
+		@Id String id;
+		String firstname;
+		String lastname;
+		Address address;
+	}
+
+	static class Address {
+
+		String city;
+		String street;
+	}
+
+	static class DtoProjection {
+
+		@Field("firstname") String name;
+	}
+
+	static interface ClosedProjection {
+
+		String getFirstname();
+	}
+
+	static interface OpenProjection {
+
+		@Value("#{target.firstname}")
+		String name();
+	}
+
+}

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

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core.convert;
+
+import static org.springframework.data.mongodb.core.query.Criteria.*;
+import static org.springframework.data.mongodb.core.query.Query.*;
+
+import lombok.Data;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.bson.types.ObjectId;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.TearDown;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.mapping.DBRef;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.mongodb.microbenchmark.AbstractMicrobenchmark;
+
+import com.mongodb.MongoClient;
+import com.mongodb.ServerAddress;
+
+/**
+ * @author Christoph Strobl
+ */
+@State(Scope.Benchmark)
+public class DbRefMappingBenchmark extends AbstractMicrobenchmark {
+
+	private static final String DB_NAME = "dbref-loading-benchmark";
+
+	private MongoClient client;
+	private MongoTemplate template;
+
+	private Query queryObjectWithDBRef;
+	private Query queryObjectWithDBRefList;
+
+	@Setup
+	public void setUp() throws Exception {
+
+		client = new MongoClient(new ServerAddress());
+		template = new MongoTemplate(client, DB_NAME);
+
+		List<RefObject> refObjects = new ArrayList<>();
+		for (int i = 0; i < 1; i++) {
+			RefObject o = new RefObject();
+			template.save(o);
+			refObjects.add(o);
+		}
+
+		ObjectWithDBRef singleDBRef = new ObjectWithDBRef();
+		singleDBRef.ref = refObjects.iterator().next();
+		template.save(singleDBRef);
+
+		ObjectWithDBRef multipleDBRefs = new ObjectWithDBRef();
+		multipleDBRefs.refList = refObjects;
+		template.save(multipleDBRefs);
+
+		queryObjectWithDBRef = query(where("id").is(singleDBRef.id));
+		queryObjectWithDBRefList = query(where("id").is(multipleDBRefs.id));
+	}
+
+	@TearDown
+	public void tearDown() {
+
+		client.dropDatabase(DB_NAME);
+		client.close();
+	}
+
+	@Benchmark // DATAMONGO-1720
+	public ObjectWithDBRef readSingleDbRef() {
+		return template.findOne(queryObjectWithDBRef, ObjectWithDBRef.class);
+	}
+
+	@Benchmark // DATAMONGO-1720
+	public ObjectWithDBRef readMultipleDbRefs() {
+		return template.findOne(queryObjectWithDBRefList, ObjectWithDBRef.class);
+	}
+
+	@Data
+	static class ObjectWithDBRef {
+
+		private @Id ObjectId id;
+		private @DBRef RefObject ref;
+		private @DBRef List<RefObject> refList;
+	}
+
+	@Data
+	static class RefObject {
+
+		private @Id String id;
+		private String someValue;
+	}
+}

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

@@ -0,0 +1,181 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core.convert;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+
+import org.bson.Document;
+import org.bson.types.ObjectId;
+import org.openjdk.jmh.annotations.Benchmark;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.Setup;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.TearDown;
+import org.springframework.data.annotation.Id;
+import org.springframework.data.geo.Point;
+import org.springframework.data.mongodb.core.SimpleMongoDbFactory;
+import org.springframework.data.mongodb.core.mapping.Field;
+import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
+import org.springframework.data.mongodb.microbenchmark.AbstractMicrobenchmark;
+
+import com.mongodb.MongoClient;
+import com.mongodb.ServerAddress;
+
+/**
+ * @author Christoph Strobl
+ */
+@State(Scope.Benchmark)
+public class MappingMongoConverterBenchmark extends AbstractMicrobenchmark {
+
+	private static final String DB_NAME = "mapping-mongo-converter-benchmark";
+
+	private MongoClient client;
+	private MongoMappingContext mappingContext;
+	private MappingMongoConverter converter;
+	private Document documentWith2Properties, documentWith2PropertiesAnd1Nested;
+	private Customer objectWith2PropertiesAnd1Nested;
+
+	private Document documentWithFlatAndComplexPropertiesPlusListAndMap;
+	private SlightlyMoreComplexObject objectWithFlatAndComplexPropertiesPlusListAndMap;
+
+	@Setup
+	public void setUp() throws Exception {
+
+		client = new MongoClient(new ServerAddress());
+
+		this.mappingContext = new MongoMappingContext();
+		this.mappingContext.setInitialEntitySet(Collections.singleton(Customer.class));
+		this.mappingContext.afterPropertiesSet();
+
+		DbRefResolver dbRefResolver = new DefaultDbRefResolver(new SimpleMongoDbFactory(client, DB_NAME));
+
+		this.converter = new MappingMongoConverter(dbRefResolver, mappingContext);
+		this.converter.setCustomConversions(new MongoCustomConversions(Collections.emptyList()));
+		this.converter.afterPropertiesSet();
+
+		// just a flat document
+		this.documentWith2Properties = new Document("firstname", "Dave").append("lastname", "Matthews");
+
+		// document with a nested one
+		Document address = new Document("zipCode", "ABCDE").append("city", "Some Place");
+		this.documentWith2PropertiesAnd1Nested = new Document("firstname", "Dave").//
+				append("lastname", "Matthews").//
+				append("address", address);
+
+		// object equivalent of documentWith2PropertiesAnd1Nested
+		this.objectWith2PropertiesAnd1Nested = new Customer("Dave", "Matthews", new Address("zipCode", "City"));
+
+		// a bit more challenging object with list & map conversion.
+		objectWithFlatAndComplexPropertiesPlusListAndMap = new SlightlyMoreComplexObject();
+		objectWithFlatAndComplexPropertiesPlusListAndMap.id = UUID.randomUUID().toString();
+		objectWithFlatAndComplexPropertiesPlusListAndMap.addressList = Arrays.asList(new Address("zip-1", "city-1"),
+				new Address("zip-2", "city-2"));
+		objectWithFlatAndComplexPropertiesPlusListAndMap.customer = objectWith2PropertiesAnd1Nested;
+		objectWithFlatAndComplexPropertiesPlusListAndMap.customerMap = new LinkedHashMap<>();
+		objectWithFlatAndComplexPropertiesPlusListAndMap.customerMap.put("dave", objectWith2PropertiesAnd1Nested);
+		objectWithFlatAndComplexPropertiesPlusListAndMap.customerMap.put("deborah",
+				new Customer("Deborah Anne", "Dyer", new Address("?", "london")));
+		objectWithFlatAndComplexPropertiesPlusListAndMap.customerMap.put("eddie",
+				new Customer("Eddie", "Vedder", new Address("??", "Seattle")));
+		objectWithFlatAndComplexPropertiesPlusListAndMap.intOne = Integer.MIN_VALUE;
+		objectWithFlatAndComplexPropertiesPlusListAndMap.intTwo = Integer.MAX_VALUE;
+		objectWithFlatAndComplexPropertiesPlusListAndMap.location = new Point(-33.865143, 151.209900);
+		objectWithFlatAndComplexPropertiesPlusListAndMap.renamedField = "supercalifragilisticexpialidocious";
+		objectWithFlatAndComplexPropertiesPlusListAndMap.stringOne = "¯\\_(ツ)_/¯";
+		objectWithFlatAndComplexPropertiesPlusListAndMap.stringTwo = " (╯°□°）╯︵ ┻━┻";
+
+		// JSON equivalent of objectWithFlatAndComplexPropertiesPlusListAndMap
+		documentWithFlatAndComplexPropertiesPlusListAndMap = Document.parse(
+				"{ \"_id\" : \"517f6aee-e9e0-44f0-88ed-f3694a019f27\", \"intOne\" : -2147483648, \"intTwo\" : 2147483647, \"stringOne\" : \"¯\\\\_(ツ)_/¯\", \"stringTwo\" : \" (╯°□°）╯︵ ┻━┻\", \"explicit-field-name\" : \"supercalifragilisticexpialidocious\", \"location\" : { \"x\" : -33.865143, \"y\" : 151.2099 }, \"objectWith2PropertiesAnd1Nested\" : { \"firstname\" : \"Dave\", \"lastname\" : \"Matthews\", \"address\" : { \"zipCode\" : \"zipCode\", \"city\" : \"City\" } }, \"addressList\" : [{ \"zipCode\" : \"zip-1\", \"city\" : \"city-1\" }, { \"zipCode\" : \"zip-2\", \"city\" : \"city-2\" }], \"customerMap\" : { \"dave\" : { \"firstname\" : \"Dave\", \"lastname\" : \"Matthews\", \"address\" : { \"zipCode\" : \"zipCode\", \"city\" : \"City\" } }, \"deborah\" : { \"firstname\" : \"Deborah Anne\", \"lastname\" : \"Dyer\", \"address\" : { \"zipCode\" : \"?\", \"city\" : \"london\" } }, \"eddie\" : { \"firstname\" : \"Eddie\", \"lastname\" : \"Vedder\", \"address\" : { \"zipCode\" : \"??\", \"city\" : \"Seattle\" } } }, \"_class\" : \"org.springframework.data.mongodb.core.convert.MappingMongoConverterBenchmark$SlightlyMoreComplexObject\" }");
+
+	}
+
+	@TearDown
+	public void tearDown() {
+
+		client.dropDatabase(DB_NAME);
+		client.close();
+	}
+
+	@Benchmark // DATAMONGO-1720
+	public Customer readObjectWith2Properties() {
+		return converter.read(Customer.class, documentWith2Properties);
+	}
+
+	@Benchmark // DATAMONGO-1720
+	public Customer readObjectWith2PropertiesAnd1NestedObject() {
+		return converter.read(Customer.class, documentWith2PropertiesAnd1Nested);
+	}
+
+	@Benchmark // DATAMONGO-1720
+	public Document writeObjectWith2PropertiesAnd1NestedObject() {
+
+		Document sink = new Document();
+		converter.write(objectWith2PropertiesAnd1Nested, sink);
+		return sink;
+	}
+
+	@Benchmark // DATAMONGO-1720
+	public Object readObjectWithListAndMapsOfComplexType() {
+		return converter.read(SlightlyMoreComplexObject.class, documentWithFlatAndComplexPropertiesPlusListAndMap);
+	}
+
+	@Benchmark // DATAMONGO-1720
+	public Object writeObjectWithListAndMapsOfComplexType() {
+
+		Document sink = new Document();
+		converter.write(objectWithFlatAndComplexPropertiesPlusListAndMap, sink);
+		return sink;
+	}
+
+	@Getter
+	@RequiredArgsConstructor
+	static class Customer {
+
+		private @Id ObjectId id;
+		private final String firstname, lastname;
+		private final Address address;
+	}
+
+	@Getter
+	@AllArgsConstructor
+	static class Address {
+		private String zipCode, city;
+	}
+
+	@Data
+	static class SlightlyMoreComplexObject {
+
+		@Id String id;
+		int intOne, intTwo;
+		String stringOne, stringTwo;
+		@Field("explicit-field-name") String renamedField;
+		Point location;
+		Customer customer;
+		List<Address> addressList;
+		Map<String, Customer> customerMap;
+	}
+}

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

@@ -0,0 +1,328 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.microbenchmark;
+
+import java.io.File;
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.Collection;
+import java.util.Date;
+
+import org.junit.Test;
+import org.openjdk.jmh.annotations.Fork;
+import org.openjdk.jmh.annotations.Measurement;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.results.RunResult;
+import org.openjdk.jmh.results.format.ResultFormatType;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.options.ChainedOptionsBuilder;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+import org.openjdk.jmh.runner.options.TimeValue;
+import org.springframework.core.env.StandardEnvironment;
+import org.springframework.util.CollectionUtils;
+import org.springframework.util.ResourceUtils;
+import org.springframework.util.StringUtils;
+
+/**
+ * @author Christoph Strobl
+ */
+@Warmup(iterations = AbstractMicrobenchmark.WARMUP_ITERATIONS)
+@Measurement(iterations = AbstractMicrobenchmark.MEASUREMENT_ITERATIONS)
+@Fork(AbstractMicrobenchmark.FORKS)
+@State(Scope.Thread)
+public class AbstractMicrobenchmark {
+
+	static final int WARMUP_ITERATIONS = 5;
+	static final int MEASUREMENT_ITERATIONS = 10;
+	static final int FORKS = 1;
+	static final String[] JVM_ARGS = { "-server", "-XX:+HeapDumpOnOutOfMemoryError", "-Xms1024m", "-Xmx1024m",
+			"-XX:MaxDirectMemorySize=1024m" };
+
+	private final StandardEnvironment environment = new StandardEnvironment();
+
+	/**
+	 * Run matching {@link org.openjdk.jmh.annotations.Benchmark} methods with options collected from
+	 * {@link org.springframework.core.env.Environment}.
+	 *
+	 * @throws Exception
+	 * @see #options(String)
+	 */
+	@Test
+	public void run() throws Exception {
+
+		String includes = includes();
+
+		if (!includes.contains(org.springframework.util.ClassUtils.getShortName(getClass()))) {
+			return;
+		}
+
+		publishResults(new Runner(options(includes).build()).run());
+	}
+
+	/**
+	 * Get the regex for all benchmarks to be included in the run. By default every benchmark within classes matching the
+	 * current ones short name. <br />
+	 * The {@literal benchmark} command line argument allows overriding the defaults using {@code #} as class / method
+	 * name separator.
+	 *
+	 * @return never {@literal null}.
+	 * @see org.springframework.util.ClassUtils#getShortName(Class)
+	 */
+	protected String includes() {
+
+		String tests = environment.getProperty("benchmark", String.class);
+
+		if (!StringUtils.hasText(tests)) {
+			return ".*" + org.springframework.util.ClassUtils.getShortName(getClass()) + ".*";
+		}
+
+		if (!tests.contains("#")) {
+			return ".*" + tests + ".*";
+		}
+
+		String[] args = tests.split("#");
+		return ".*" + args[0] + "." + args[1];
+	}
+
+	/**
+	 * Collect all options for the {@link Runner}.
+	 *
+	 * @param includes regex for matching benchmarks to be included in the run.
+	 * @return never {@literal null}.
+	 * @throws Exception
+	 */
+	protected ChainedOptionsBuilder options(String includes) throws Exception {
+
+		ChainedOptionsBuilder optionsBuilder = new OptionsBuilder().include(includes).jvmArgs(jvmArgs());
+
+		optionsBuilder = warmup(optionsBuilder);
+		optionsBuilder = measure(optionsBuilder);
+		optionsBuilder = forks(optionsBuilder);
+		optionsBuilder = report(optionsBuilder);
+
+		return optionsBuilder;
+	}
+
+	/**
+	 * JVM args to apply to {@link Runner} via its {@link org.openjdk.jmh.runner.options.Options}.
+	 *
+	 * @return {@link #JVM_ARGS} by default.
+	 */
+	protected String[] jvmArgs() {
+
+		String[] args = new String[JVM_ARGS.length];
+		System.arraycopy(JVM_ARGS, 0, args, 0, JVM_ARGS.length);
+		return args;
+	}
+
+	/**
+	 * Read {@code warmupIterations} property from {@link org.springframework.core.env.Environment}.
+	 *
+	 * @return -1 if not set.
+	 */
+	protected int getWarmupIterations() {
+		return environment.getProperty("warmupIterations", Integer.class, -1);
+	}
+
+	/**
+	 * Read {@code measurementIterations} property from {@link org.springframework.core.env.Environment}.
+	 *
+	 * @return -1 if not set.
+	 */
+	protected int getMeasurementIterations() {
+		return environment.getProperty("measurementIterations", Integer.class, -1);
+
+	}
+
+	/**
+	 * Read {@code forks} property from {@link org.springframework.core.env.Environment}.
+	 *
+	 * @return -1 if not set.
+	 */
+	protected int getForksCount() {
+		return environment.getProperty("forks", Integer.class, -1);
+	}
+
+	/**
+	 * Read {@code benchmarkReportDir} property from {@link org.springframework.core.env.Environment}.
+	 *
+	 * @return {@literal null} if not set.
+	 */
+	protected String getReportDirectory() {
+		return environment.getProperty("benchmarkReportDir");
+	}
+
+	/**
+	 * Read {@code measurementTime} property from {@link org.springframework.core.env.Environment}.
+	 *
+	 * @return -1 if not set.
+	 */
+	protected long getMeasurementTime() {
+		return environment.getProperty("measurementTime", Long.class, -1L);
+	}
+
+	/**
+	 * Read {@code warmupTime} property from {@link org.springframework.core.env.Environment}.
+	 *
+	 * @return -1 if not set.
+	 */
+	protected long getWarmupTime() {
+		return environment.getProperty("warmupTime", Long.class, -1L);
+	}
+
+	/**
+	 * {@code project.version_yyyy-MM-dd_ClassName.json} eg.
+	 * {@literal 1.11.0.BUILD-SNAPSHOT_2017-03-07_MappingMongoConverterBenchmark.json}
+	 *
+	 * @return
+	 */
+	protected String reportFilename() {
+
+		StringBuilder sb = new StringBuilder();
+
+		if (environment.containsProperty("project.version")) {
+
+			sb.append(environment.getProperty("project.version"));
+			sb.append("_");
+		}
+
+		sb.append(new SimpleDateFormat("yyyy-MM-dd").format(new Date()));
+		sb.append("_");
+		sb.append(org.springframework.util.ClassUtils.getShortName(getClass()));
+		sb.append(".json");
+		return sb.toString();
+	}
+
+	/**
+	 * Apply measurement options to {@link ChainedOptionsBuilder}.
+	 *
+	 * @param optionsBuilder must not be {@literal null}.
+	 * @return {@link ChainedOptionsBuilder} with options applied.
+	 * @see #getMeasurementIterations()
+	 * @see #getMeasurementTime()
+	 */
+	private ChainedOptionsBuilder measure(ChainedOptionsBuilder optionsBuilder) {
+
+		int measurementIterations = getMeasurementIterations();
+		long measurementTime = getMeasurementTime();
+
+		if (measurementIterations > 0) {
+			optionsBuilder = optionsBuilder.measurementIterations(measurementIterations);
+		}
+
+		if (measurementTime > 0) {
+			optionsBuilder = optionsBuilder.measurementTime(TimeValue.seconds(measurementTime));
+		}
+
+		return optionsBuilder;
+	}
+
+	/**
+	 * Apply warmup options to {@link ChainedOptionsBuilder}.
+	 *
+	 * @param optionsBuilder must not be {@literal null}.
+	 * @return {@link ChainedOptionsBuilder} with options applied.
+	 * @see #getWarmupIterations()
+	 * @see #getWarmupTime()
+	 */
+	private ChainedOptionsBuilder warmup(ChainedOptionsBuilder optionsBuilder) {
+
+		int warmupIterations = getWarmupIterations();
+		long warmupTime = getWarmupTime();
+
+		if (warmupIterations > 0) {
+			optionsBuilder = optionsBuilder.warmupIterations(warmupIterations);
+		}
+
+		if (warmupTime > 0) {
+			optionsBuilder = optionsBuilder.warmupTime(TimeValue.seconds(warmupTime));
+		}
+
+		return optionsBuilder;
+	}
+
+	/**
+	 * Apply forks option to {@link ChainedOptionsBuilder}.
+	 *
+	 * @param optionsBuilder must not be {@literal null}.
+	 * @return {@link ChainedOptionsBuilder} with options applied.
+	 * @see #getForksCount()
+	 */
+	private ChainedOptionsBuilder forks(ChainedOptionsBuilder optionsBuilder) {
+
+		int forks = getForksCount();
+
+		if (forks <= 0) {
+			return optionsBuilder;
+		}
+
+		return optionsBuilder.forks(forks);
+	}
+
+	/**
+	 * Apply report option to {@link ChainedOptionsBuilder}.
+	 *
+	 * @param optionsBuilder must not be {@literal null}.
+	 * @return {@link ChainedOptionsBuilder} with options applied.
+	 * @throws IOException if report file cannot be created.
+	 * @see #getReportDirectory()
+	 */
+	private ChainedOptionsBuilder report(ChainedOptionsBuilder optionsBuilder) throws IOException {
+
+		String reportDir = getReportDirectory();
+
+		if (!StringUtils.hasText(reportDir)) {
+			return optionsBuilder;
+		}
+
+		String reportFilePath = reportDir + (reportDir.endsWith(File.separator) ? "" : File.separator) + reportFilename();
+		File file = ResourceUtils.getFile(reportFilePath);
+
+		if (file.exists()) {
+			file.delete();
+		} else {
+
+			file.getParentFile().mkdirs();
+			file.createNewFile();
+		}
+
+		optionsBuilder.resultFormat(ResultFormatType.JSON);
+		optionsBuilder.result(reportFilePath);
+
+		return optionsBuilder;
+	}
+
+	/**
+	 * Publish results to an external system.
+	 *
+	 * @param results must not be {@literal null}.
+	 */
+	private void publishResults(Collection<RunResult> results) {
+
+		if (CollectionUtils.isEmpty(results) || !environment.containsProperty("publishTo")) {
+			return;
+		}
+
+		String uri = environment.getProperty("publishTo");
+		try {
+			ResultsWriter.forUri(uri).write(results);
+		} catch (Exception e) {
+			System.err.println(String.format("Cannot save benchmark results to '%s'. Error was %s.", uri, e));
+		}
+	}
+}

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

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.microbenchmark;
+
+import lombok.SneakyThrows;
+
+import java.io.OutputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.net.URLConnection;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.util.Collection;
+
+import org.openjdk.jmh.results.RunResult;
+import org.springframework.core.env.StandardEnvironment;
+import org.springframework.util.CollectionUtils;
+
+/**
+ * {@link ResultsWriter} implementation of {@link URLConnection}.
+ *
+ * @since 2.0
+ */
+class HttpResultsWriter implements ResultsWriter {
+
+	private final String url;
+
+	HttpResultsWriter(String url) {
+		this.url = url;
+	}
+
+	@Override
+	@SneakyThrows
+	public void write(Collection<RunResult> results) {
+
+		if (CollectionUtils.isEmpty(results)) {
+			return;
+		}
+
+		StandardEnvironment env = new StandardEnvironment();
+
+		String projectVersion = env.getProperty("project.version", "unknown");
+		String gitBranch = env.getProperty("git.branch", "unknown");
+		String gitDirty = env.getProperty("git.dirty", "no");
+		String gitCommitId = env.getProperty("git.commit.id", "unknown");
+
+		HttpURLConnection connection = (HttpURLConnection) new URL(url).openConnection();
+		connection.setConnectTimeout((int) Duration.ofSeconds(1).toMillis());
+		connection.setReadTimeout((int) Duration.ofSeconds(1).toMillis());
+		connection.setDoOutput(true);
+		connection.setRequestMethod("POST");
+
+		connection.setRequestProperty("Content-Type", "application/json");
+		connection.addRequestProperty("X-Project-Version", projectVersion);
+		connection.addRequestProperty("X-Git-Branch", gitBranch);
+		connection.addRequestProperty("X-Git-Dirty", gitDirty);
+		connection.addRequestProperty("X-Git-Commit-Id", gitCommitId);
+
+		try (OutputStream output = connection.getOutputStream()) {
+			output.write(ResultsWriter.jsonifyResults(results).getBytes(StandardCharsets.UTF_8));
+		}
+
+		if (connection.getResponseCode() >= 400) {
+			throw new IllegalStateException(
+					String.format("Status %d %s", connection.getResponseCode(), connection.getResponseMessage()));
+		}
+	}
+}

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

@@ -0,0 +1,131 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.microbenchmark;
+
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+
+import org.bson.Document;
+import org.openjdk.jmh.results.RunResult;
+import org.springframework.core.env.StandardEnvironment;
+import org.springframework.util.ObjectUtils;
+import org.springframework.util.StringUtils;
+
+import com.mongodb.BasicDBObject;
+import com.mongodb.MongoClient;
+import com.mongodb.MongoClientURI;
+import com.mongodb.client.MongoDatabase;
+import com.mongodb.util.JSON;
+
+/**
+ * MongoDB specific {@link ResultsWriter} implementation.
+ *
+ * @author Christoph Strobl
+ * @since 2.0
+ */
+class MongoResultsWriter implements ResultsWriter {
+
+	private final String uri;
+
+	MongoResultsWriter(String uri) {
+		this.uri = uri;
+	}
+
+	@Override
+	public void write(Collection<RunResult> results) {
+
+		Date now = new Date();
+		StandardEnvironment env = new StandardEnvironment();
+
+		String projectVersion = env.getProperty("project.version", "unknown");
+		String gitBranch = env.getProperty("git.branch", "unknown");
+		String gitDirty = env.getProperty("git.dirty", "no");
+		String gitCommitId = env.getProperty("git.commit.id", "unknown");
+
+		MongoClientURI uri = new MongoClientURI(this.uri);
+		MongoClient client = new MongoClient(uri);
+
+		String dbName = StringUtils.hasText(uri.getDatabase()) ? uri.getDatabase() : "spring-data-mongodb-benchmarks";
+		MongoDatabase db = client.getDatabase(dbName);
+
+		for (BasicDBObject dbo : (List<BasicDBObject>) JSON.parse(ResultsWriter.jsonifyResults(results))) {
+
+			String collectionName = extractClass(dbo.get("benchmark").toString());
+
+			Document sink = new Document();
+			sink.append("_version", projectVersion);
+			sink.append("_branch", gitBranch);
+			sink.append("_commit", gitCommitId);
+			sink.append("_dirty", gitDirty);
+			sink.append("_method", extractBenchmarkName(dbo.get("benchmark").toString()));
+			sink.append("_date", now);
+			sink.append("_snapshot", projectVersion.toLowerCase().contains("snapshot"));
+
+			sink.putAll(dbo);
+
+			db.getCollection(collectionName).insertOne(fixDocumentKeys(sink));
+		}
+
+		client.close();
+	}
+
+	/**
+	 * Replace {@code .} by {@code ,}.
+	 *
+	 * @param doc
+	 * @return
+	 */
+	private Document fixDocumentKeys(Document doc) {
+
+		Document sanitized = new Document();
+
+		for (Object key : doc.keySet()) {
+
+			Object value = doc.get(key);
+			if (value instanceof Document) {
+				value = fixDocumentKeys((Document) value);
+			} else if (value instanceof BasicDBObject) {
+				value = fixDocumentKeys(new Document((BasicDBObject) value));
+			}
+
+			if (key instanceof String) {
+
+				String newKey = (String) key;
+				if (newKey.contains(".")) {
+					newKey = newKey.replace('.', ',');
+				}
+
+				sanitized.put(newKey, value);
+			} else {
+				sanitized.put(ObjectUtils.nullSafeToString(key).replace('.', ','), value);
+			}
+		}
+
+		return sanitized;
+	}
+
+	private static String extractClass(String source) {
+
+		String tmp = source.substring(0, source.lastIndexOf('.'));
+		return tmp.substring(tmp.lastIndexOf(".") + 1);
+	}
+
+	private static String extractBenchmarkName(String source) {
+		return source.substring(source.lastIndexOf(".") + 1);
+	}
+
+}

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

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.microbenchmark;
+
+import lombok.SneakyThrows;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Collection;
+
+import org.openjdk.jmh.results.RunResult;
+import org.openjdk.jmh.results.format.ResultFormatFactory;
+import org.openjdk.jmh.results.format.ResultFormatType;
+
+/**
+ * @author Christoph Strobl
+ * @since 2.0
+ */
+interface ResultsWriter {
+
+	/**
+	 * Write the {@link RunResult}s.
+	 *
+	 * @param results can be {@literal null}.
+	 */
+	void write(Collection<RunResult> results);
+
+	/**
+	 * Get the uri specific {@link ResultsWriter}.
+	 *
+	 * @param uri must not be {@literal null}.
+	 * @return
+	 */
+	static ResultsWriter forUri(String uri) {
+		return uri.startsWith("mongodb:") ? new MongoResultsWriter(uri) : new HttpResultsWriter(uri);
+	}
+
+	/**
+	 * Convert {@link RunResult}s to JMH Json representation.
+	 *
+	 * @param results
+	 * @return json string representation of results.
+	 * @see org.openjdk.jmh.results.format.JSONResultFormat
+	 */
+	@SneakyThrows
+	static String jsonifyResults(Collection<RunResult> results) {
+
+		ByteArrayOutputStream baos = new ByteArrayOutputStream();
+		ResultFormatFactory.getInstance(ResultFormatType.JSON, new PrintStream(baos, true, "UTF-8")).writeOut(results);
+
+		return new String(baos.toByteArray(), StandardCharsets.UTF_8);
+	}
+}

spring-data-mongodb-benchmarks/src/main/resources/logback.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+
+	<appender name="console" class="ch.qos.logback.core.ConsoleAppender">
+		<encoder>
+			<pattern>%d %5p %40.40c:%4L - %m%n</pattern>
+		</encoder>
+	</appender>
+
+	<root level="error">
+		<appender-ref ref="console" />
+	</root>
+
+</configuration>

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

@@ -6,7 +6,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>2.0.0.M2</version>
+		<version>2.0.0.RELEASE</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 
@@ -16,6 +16,7 @@
 	<properties>
 		<jpa>2.1.1</jpa>
 		<hibernate>5.2.1.Final</hibernate>
+		<java-module-name>spring.data.mongodb.cross.store</java-module-name>
 	</properties>
 
 	<dependencies>
@@ -48,14 +49,13 @@
 		<dependency>
 			<groupId>org.springframework.data</groupId>
 			<artifactId>spring-data-mongodb</artifactId>
-			<version>2.0.0.M2</version>
+			<version>2.0.0.RELEASE</version>
 		</dependency>
 
 		<!-- reactive -->
 		<dependency>
 		 	<groupId>io.projectreactor</groupId>
 			<artifactId>reactor-core</artifactId>
-			<version>${reactor}</version>
 			<optional>true</optional>
 		</dependency>
 

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011 the original author or authors.
+ * Copyright 2011-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,6 +17,12 @@ package org.springframework.data.mongodb.crossstore;
 
 import org.springframework.data.crossstore.ChangeSetBacked;
 
+/**
+ * @author Thomas Risberg
+ * @author Oliver Gierke
+ * @deprecated will be removed without replacement.
+ */
+@Deprecated
 public interface DocumentBacked extends ChangeSetBacked {
 
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2016 the original author or authors.
+ * Copyright 2011-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -40,7 +40,9 @@ import com.mongodb.client.result.DeleteResult;
  * @author Oliver Gierke
  * @author Alex Vengrovsk
  * @author Mark Paluch
+ * @deprecated will be removed without replacement.
  */
+@Deprecated
 public class MongoChangeSetPersister implements ChangeSetPersister<Object> {
 
 	private static final String ENTITY_CLASS = "_entity_class";

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011 the original author or authors.
+ * Copyright 2011-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -40,7 +40,9 @@ import org.springframework.transaction.support.TransactionSynchronizationManager
  * Aspect to turn an object annotated with @Document into a persistent document using Mongo.
  * 
  * @author Thomas Risberg
+ * @deprecated will be removed without replacement.
  */
+@Deprecated
 public aspect MongoDocumentBacking {
 
 	private static final Logger LOGGER = LoggerFactory.getLogger(MongoDocumentBacking.class);

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011 the original author or authors.
+ * Copyright 2011-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,7 +22,9 @@ import java.lang.annotation.Target;
 
 /**
  * @author Thomas Risberg
+ * @deprecated will be removed without replacement.
  */
+@Deprecated
 @Retention(RetentionPolicy.RUNTIME)
 @Target({ ElementType.FIELD })
 public @interface RelatedDocument {

spring-data-mongodb-distribution/pom.xml

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

spring-data-mongodb-log4j/README.md

@@ -1,52 +0,0 @@
-# MongoDB Log4J Appender
-
-This module sets up a Log4J appender that puts logging events in MongoDB. It is fully configurable
-and connects directly to the MongoDB server using the driver. It has no dependency on any Spring package.
-
-To use it, configure a host, port, (optionally) applicationId, and database property in your Log4J configuration:
-
-    log4j.appender.stdout=org.springframework.data.mongodb.log4j.MongoLog4jAppender
-    log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
-    log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - <%m>%n
-    log4j.appender.stdout.host = localhost
-    log4j.appender.stdout.port = 27017
-    log4j.appender.stdout.database = logs
-    log4j.appender.stdout.collectionPattern = %c
-    log4j.appender.stdout.applicationId = my.application
-    log4j.appender.stdout.warnOrHigherWriteConcern = FSYNC_SAFE
-
-It will even support properties in your MDC (so long as they're Strings or support .toString()).
-
-The collection name is configurable as well. If you don't specify anything, it will use the Category name.
-If you want to specify a collection name, you can give it a Log4J pattern layout format string which will have
-the following additional MDC variables in the context when the collection name is rendered:
-
-    "year" = Calendar.YEAR
-    "month" = Calendar.MONTH + 1
-    "day" = Calendar.DAY_OF_MONTH
-    "hour" = Calendar.HOUR_OF_DAY
-    "applicationId" = configured applicationId
-
-An example log entry might look like:
-
-    {
-      "_id" : ObjectId("4d89341a8ef397e06940d5cd"),
-      "applicationId" : "my.application",
-      "name" : "org.springframework.data.mongodb.log4j.MongoLog4jAppenderIntegrationTests",
-      "level" : "DEBUG",
-      "timestamp" : ISODate("2011-03-23T16:53:46.778Z"),
-      "properties" : {
-        "property" : "one"
-      },
-      "message" : "DEBUG message"
-    }
-
-To set WriteConcern levels for WARN or higher messages, set warnOrHigherWriteConcern to one of the following:
-
-* FSYNC_SAFE
-* NONE
-* NORMAL
-* REPLICAS_SAFE
-* SAFE
-
-[http://api.mongodb.org/java/2.5-pre-/com/mongodb/WriteConcern.html#field_detail](http://api.mongodb.org/java/2.5-pre-/com/mongodb/WriteConcern.html#field_detail)

spring-data-mongodb-log4j/pom.xml

@@ -1,30 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
-	<modelVersion>4.0.0</modelVersion>
-	
-	<parent>
-		<groupId>org.springframework.data</groupId>
-		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>2.0.0.M2</version>
-		<relativePath>../pom.xml</relativePath>
-	</parent>
-
-	<artifactId>spring-data-mongodb-log4j</artifactId>
-	<name>Spring Data MongoDB - Log4J Appender</name>
-
-	<properties>
-		<log4j>1.2.16</log4j>
-	</properties>
-
-	<dependencies>
-
-		<!-- Logging -->
-		<dependency>
-			<groupId>log4j</groupId>
-			<artifactId>log4j</artifactId>
-			<version>${log4j}</version>
-		</dependency>
-
-	</dependencies>
-
-</project>

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

@@ -1,298 +0,0 @@
-/*
- * Copyright 2011-2016 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * 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.log4j;
-
-import java.net.UnknownHostException;
-import java.util.Arrays;
-import java.util.Calendar;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-
-import org.apache.log4j.AppenderSkeleton;
-import org.apache.log4j.Level;
-import org.apache.log4j.MDC;
-import org.apache.log4j.PatternLayout;
-import org.apache.log4j.spi.LoggingEvent;
-
-import com.mongodb.BasicDBList;
-import com.mongodb.BasicDBObject;
-import com.mongodb.DB;
-import com.mongodb.Mongo;
-import com.mongodb.MongoClient;
-import com.mongodb.MongoCredential;
-import com.mongodb.ServerAddress;
-import com.mongodb.WriteConcern;
-
-/**
- * Log4j appender writing log entries into a MongoDB instance.
- *
- * @author Jon Brisbin
- * @author Oliver Gierke
- * @author Christoph Strobl
- * @author Ricardo Espirito Santo
- */
-public class MongoLog4jAppender extends AppenderSkeleton {
-
-	public static final String LEVEL = "level";
-	public static final String NAME = "name";
-	public static final String APP_ID = "applicationId";
-	public static final String TIMESTAMP = "timestamp";
-	public static final String PROPERTIES = "properties";
-	public static final String TRACEBACK = "traceback";
-	public static final String MESSAGE = "message";
-	public static final String YEAR = "year";
-	public static final String MONTH = "month";
-	public static final String DAY = "day";
-	public static final String HOUR = "hour";
-
-	protected String host = "localhost";
-	protected int port = 27017;
-	protected String username;
-	protected String password;
-	protected String authenticationDatabase;
-	protected String database = "logs";
-	protected String collectionPattern = "%c";
-	protected PatternLayout collectionLayout = new PatternLayout(collectionPattern);
-	protected String applicationId = System.getProperty("APPLICATION_ID", null);
-	protected WriteConcern warnOrHigherWriteConcern = WriteConcern.ACKNOWLEDGED;
-	protected WriteConcern infoOrLowerWriteConcern = WriteConcern.UNACKNOWLEDGED;
-	protected Mongo mongo;
-	protected DB db;
-
-	public MongoLog4jAppender() {}
-
-	public MongoLog4jAppender(boolean isActive) {
-		super(isActive);
-	}
-
-	public String getHost() {
-		return host;
-	}
-
-	public void setHost(String host) {
-		this.host = host;
-	}
-
-	public int getPort() {
-		return port;
-	}
-
-	public void setPort(int port) {
-		this.port = port;
-	}
-
-	/**
-	 * @return
-	 * @since 1.10
-	 */
-	public String getUsername() {
-		return username;
-	}
-
-	/**
-	 * @param username may be {@literal null} for unauthenticated access.
-	 * @since 1.10
-	 */
-	public void setUsername(String username) {
-		this.username = username;
-	}
-
-	/**
-	 * @return
-	 * @since 1.10
-	 */
-	public String getPassword() {
-		return password;
-	}
-
-	/**
-	 * @param password may be {@literal null} for unauthenticated access.
-	 * @since 1.10
-	 */
-	public void setPassword(String password) {
-		this.password = password;
-	}
-
-	/**
-	 * @return
-	 */
-	public String getAuthenticationDatabase() {
-		return authenticationDatabase;
-	}
-
-	/**
-	 * @param authenticationDatabase may be {@literal null} to use {@link #getDatabase()} as authentication database.
-	 * @since 1.10
-	 */
-	public void setAuthenticationDatabase(String authenticationDatabase) {
-		this.authenticationDatabase = authenticationDatabase;
-	}
-
-	public String getDatabase() {
-		return database;
-	}
-
-	public void setDatabase(String database) {
-		this.database = database;
-	}
-
-	public String getCollectionPattern() {
-		return collectionPattern;
-	}
-
-	public void setCollectionPattern(String collectionPattern) {
-		this.collectionPattern = collectionPattern;
-		this.collectionLayout = new PatternLayout(collectionPattern);
-	}
-
-	public String getApplicationId() {
-		return applicationId;
-	}
-
-	public void setApplicationId(String applicationId) {
-		this.applicationId = applicationId;
-	}
-
-	public String getWarnOrHigherWriteConcern() {
-		return warnOrHigherWriteConcern.toString();
-	}
-
-	public void setWarnOrHigherWriteConcern(String wc) {
-		this.warnOrHigherWriteConcern = WriteConcern.valueOf(wc);
-	}
-
-	public String getInfoOrLowerWriteConcern() {
-		return infoOrLowerWriteConcern.toString();
-	}
-
-	public void setInfoOrLowerWriteConcern(String wc) {
-		this.infoOrLowerWriteConcern = WriteConcern.valueOf(wc);
-	}
-
-	protected void connectToMongo() throws UnknownHostException {
-
-		this.mongo = createMongoClient();
-		this.db = mongo.getDB(database);
-	}
-
-	private MongoClient createMongoClient() throws UnknownHostException {
-
-		ServerAddress serverAddress = new ServerAddress(host, port);
-
-		if (null == password || null == username) {
-			return new MongoClient(serverAddress);
-		}
-
-		String authenticationDatabaseToUse = authenticationDatabase == null ? this.database : authenticationDatabase;
-		MongoCredential mongoCredential = MongoCredential.createCredential(username,
-				authenticationDatabaseToUse, password.toCharArray());
-		List<MongoCredential> credentials = Collections.singletonList(mongoCredential);
-		return new MongoClient(serverAddress, credentials);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.apache.log4j.AppenderSkeleton#append(org.apache.log4j.spi.LoggingEvent)
-	 */
-	@Override
-	@SuppressWarnings({ "unchecked" })
-	protected void append(final LoggingEvent event) {
-		if (null == db) {
-			try {
-				connectToMongo();
-			} catch (UnknownHostException e) {
-				throw new RuntimeException(e.getMessage(), e);
-			}
-		}
-
-		BasicDBObject dbo = new BasicDBObject();
-		if (null != applicationId) {
-			dbo.put(APP_ID, applicationId);
-			MDC.put(APP_ID, applicationId);
-		}
-		dbo.put(NAME, event.getLogger().getName());
-		dbo.put(LEVEL, event.getLevel().toString());
-		Calendar tstamp = Calendar.getInstance();
-		tstamp.setTimeInMillis(event.getTimeStamp());
-		dbo.put(TIMESTAMP, tstamp.getTime());
-
-		// Copy properties into document
-		Map<Object, Object> props = event.getProperties();
-		if (null != props && !props.isEmpty()) {
-			BasicDBObject propsDbo = new BasicDBObject();
-			for (Map.Entry<Object, Object> entry : props.entrySet()) {
-				propsDbo.put(entry.getKey().toString(), entry.getValue().toString());
-			}
-			dbo.put(PROPERTIES, propsDbo);
-		}
-
-		// Copy traceback info (if there is any) into the document
-		String[] traceback = event.getThrowableStrRep();
-		if (null != traceback && traceback.length > 0) {
-			BasicDBList tbDbo = new BasicDBList();
-			tbDbo.addAll(Arrays.asList(traceback));
-			dbo.put(TRACEBACK, tbDbo);
-		}
-
-		// Put the rendered message into the document
-		dbo.put(MESSAGE, event.getRenderedMessage());
-
-		// Insert the document
-		Calendar now = Calendar.getInstance();
-		MDC.put(YEAR, now.get(Calendar.YEAR));
-		MDC.put(MONTH, String.format("%1$02d", now.get(Calendar.MONTH) + 1));
-		MDC.put(DAY, String.format("%1$02d", now.get(Calendar.DAY_OF_MONTH)));
-		MDC.put(HOUR, String.format("%1$02d", now.get(Calendar.HOUR_OF_DAY)));
-
-		String coll = collectionLayout.format(event);
-
-		MDC.remove(YEAR);
-		MDC.remove(MONTH);
-		MDC.remove(DAY);
-		MDC.remove(HOUR);
-		if (null != applicationId) {
-			MDC.remove(APP_ID);
-		}
-
-		WriteConcern wc;
-		if (event.getLevel().isGreaterOrEqual(Level.WARN)) {
-			wc = warnOrHigherWriteConcern;
-		} else {
-			wc = infoOrLowerWriteConcern;
-		}
-		db.getCollection(coll).insert(dbo, wc);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.apache.log4j.AppenderSkeleton#close()
-	 */
-	public void close() {
-
-		if (mongo != null) {
-			mongo.close();
-		}
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.apache.log4j.AppenderSkeleton#requiresLayout()
-	 */
-	public boolean requiresLayout() {
-		return true;
-	}
-}

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

@@ -1,5 +0,0 @@
-/**
- * Infrastructure for to use MongoDB as a logging sink.
- */
-package org.springframework.data.mongodb.log4j;
-

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

@@ -1,114 +0,0 @@
-/*
- * Copyright 2016 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.mongodb.log4j;
-
-import static org.hamcrest.Matchers.*;
-import static org.junit.Assert.*;
-
-import java.util.Calendar;
-import java.util.Collections;
-
-import org.apache.log4j.LogManager;
-import org.apache.log4j.Logger;
-import org.apache.log4j.MDC;
-import org.apache.log4j.PropertyConfigurator;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-import com.mongodb.BasicDBList;
-import com.mongodb.BasicDBObject;
-import com.mongodb.BasicDBObjectBuilder;
-import com.mongodb.DB;
-import com.mongodb.DBCursor;
-import com.mongodb.MongoClient;
-import com.mongodb.MongoCredential;
-import com.mongodb.ServerAddress;
-
-/**
- * Integration tests for {@link MongoLog4jAppender} using authentication.
- *
- * @author Mark Paluch
- */
-public class MongoLog4jAppenderAuthenticationIntegrationTests {
-
-	private final static String username = "admin";
-	private final static String password = "test";
-	private final static String authenticationDatabase = "logs";
-
-	MongoClient mongo;
-	DB db;
-	String collection;
-	ServerAddress serverLocation;
-
-	Logger log;
-
-	@Before
-	public void setUp() throws Exception {
-
-		serverLocation = new ServerAddress("localhost", 27017);
-
-		mongo = new MongoClient(serverLocation);
-		db = mongo.getDB("logs");
-
-		BasicDBList roles = new BasicDBList();
-		roles.add("dbOwner");
-		db.command(new BasicDBObjectBuilder().add("createUser", username).add("pwd", password).add("roles", roles).get());
-		mongo.close();
-
-		mongo = new MongoClient(serverLocation, Collections
-				.singletonList(MongoCredential.createCredential(username, authenticationDatabase, password.toCharArray())));
-		db = mongo.getDB("logs");
-
-		Calendar now = Calendar.getInstance();
-		collection = String.valueOf(now.get(Calendar.YEAR)) + String.format("%1$02d", now.get(Calendar.MONTH) + 1);
-
-		LogManager.resetConfiguration();
-		PropertyConfigurator.configure(getClass().getResource("/log4j-with-authentication.properties"));
-
-		log = Logger.getLogger(MongoLog4jAppenderIntegrationTests.class.getName());
-	}
-
-	@After
-	public void tearDown() {
-
-		if (db != null) {
-			db.getCollection(collection).remove(new BasicDBObject());
-			db.command(new BasicDBObject("dropUser", username));
-		}
-
-		LogManager.resetConfiguration();
-		PropertyConfigurator.configure(getClass().getResource("/log4j.properties"));
-	}
-
-	@Test
-	public void testLogging() {
-
-		log.debug("DEBUG message");
-		log.info("INFO message");
-		log.warn("WARN message");
-		log.error("ERROR message");
-
-		DBCursor msgs = db.getCollection(collection).find();
-		assertThat(msgs.count(), is(4));
-	}
-
-	@Test
-	public void testProperties() {
-		MDC.put("property", "one");
-		log.debug("DEBUG message");
-	}
-}

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

@@ -1,87 +0,0 @@
-/*
- * Copyright 2011-2016 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * 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.log4j;
-
-import static org.hamcrest.Matchers.*;
-import static org.junit.Assert.*;
-
-import java.util.Calendar;
-
-import org.apache.log4j.LogManager;
-import org.apache.log4j.Logger;
-import org.apache.log4j.MDC;
-import org.apache.log4j.PropertyConfigurator;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-import com.mongodb.BasicDBObject;
-import com.mongodb.DB;
-import com.mongodb.DBCursor;
-import com.mongodb.MongoClient;
-import com.mongodb.ServerAddress;
-
-/**
- * Integration tests for {@link MongoLog4jAppender}.
- *
- * @author Jon Brisbin
- * @author Oliver Gierke
- * @author Christoph Strobl
- */
-public class MongoLog4jAppenderIntegrationTests {
-
-	MongoClient mongo;
-	DB db;
-	String collection;
-	ServerAddress serverLocation;
-	Logger log;
-
-	@Before
-	public void setUp() throws Exception {
-		serverLocation = new ServerAddress("localhost", 27017);
-
-		mongo = new MongoClient(serverLocation);
-		db = mongo.getDB("logs");
-
-		Calendar now = Calendar.getInstance();
-		collection = String.valueOf(now.get(Calendar.YEAR)) + String.format("%1$02d", now.get(Calendar.MONTH) + 1);
-
-		log = Logger.getLogger(MongoLog4jAppenderIntegrationTests.class.getName());
-	}
-
-	@After
-	public void tearDown() {
-		db.getCollection(collection).remove(new BasicDBObject());
-	}
-
-	@Test
-	public void testLogging() {
-
-		log.debug("DEBUG message");
-		log.info("INFO message");
-		log.warn("WARN message");
-		log.error("ERROR message");
-
-		DBCursor msgs = db.getCollection(collection).find();
-		assertThat(msgs.count(), is(4));
-	}
-
-	@Test
-	public void testProperties() {
-		MDC.put("property", "one");
-		log.debug("DEBUG message");
-	}
-}

spring-data-mongodb-log4j/src/test/resources/log4j-with-authentication.properties

@@ -1,16 +0,0 @@
-log4j.rootCategory=INFO, mongo
-
-log4j.appender.mongo=org.springframework.data.mongodb.log4j.MongoLog4jAppender
-log4j.appender.mongo.layout=org.apache.log4j.PatternLayout
-log4j.appender.mongo.layout.ConversionPattern=%d %p [%c] - <%m>%n
-log4j.appender.mongo.host = localhost
-log4j.appender.mongo.port = 27017
-log4j.appender.mongo.database = logs
-log4j.appender.mongo.username = admin
-log4j.appender.mongo.password = test
-log4j.appender.mongo.authenticationDatabase = logs
-log4j.appender.mongo.collectionPattern = %X{year}%X{month}
-log4j.appender.mongo.applicationId = my.application
-log4j.appender.mongo.warnOrHigherWriteConcern = FSYNC_SAFE
-
-log4j.category.org.springframework.data.mongodb=DEBUG

spring-data-mongodb-log4j/src/test/resources/log4j.properties

@@ -1,13 +0,0 @@
-log4j.rootCategory=INFO, mongo
-
-log4j.appender.mongo=org.springframework.data.mongodb.log4j.MongoLog4jAppender
-log4j.appender.mongo.layout=org.apache.log4j.PatternLayout
-log4j.appender.mongo.layout.ConversionPattern=%d %p [%c] - <%m>%n
-log4j.appender.mongo.host = localhost
-log4j.appender.mongo.port = 27017
-log4j.appender.mongo.database = logs
-log4j.appender.mongo.collectionPattern = %X{year}%X{month}
-log4j.appender.mongo.applicationId = my.application
-log4j.appender.mongo.warnOrHigherWriteConcern = FSYNC_SAFE
-
-log4j.category.org.springframework.data.mongodb=DEBUG

spring-data-mongodb/pom.xml

@@ -11,13 +11,14 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>2.0.0.M2</version>
+		<version>2.0.0.RELEASE</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 
 	<properties>
 		<objenesis>1.3</objenesis>
-		<equalsverifier>1.5</equalsverifier>
+		<equalsverifier>1.7.8</equalsverifier>
+		<java-module-name>spring.data.mongodb</java-module-name>
 	</properties>
 
 	<dependencies>
@@ -106,14 +107,12 @@
 		<dependency>
 		 	<groupId>io.projectreactor</groupId>
 			<artifactId>reactor-core</artifactId>
-			<version>${reactor}</version>
 			<optional>true</optional>
 		</dependency>
 
 		<dependency>
-		 	<groupId>io.projectreactor.addons</groupId>
+			<groupId>io.projectreactor</groupId>
 			<artifactId>reactor-test</artifactId>
-			<version>${reactor}</version>
 			<optional>true</optional>
 		</dependency>
 
@@ -139,6 +138,21 @@
 		</dependency>
 
 		<!-- CDI -->
+		<!-- Dependency order required to build against CDI 1.0 and test with CDI 2.0 -->
+		<dependency>
+			<groupId>org.apache.geronimo.specs</groupId>
+			<artifactId>geronimo-jcdi_2.0_spec</artifactId>
+			<version>1.0.1</version>
+			<scope>test</scope>
+		</dependency>
+		
+		<dependency>
+			<groupId>javax.interceptor</groupId>
+			<artifactId>javax.interceptor-api</artifactId>
+			<version>1.2.1</version>
+			<scope>test</scope>
+		</dependency>
+
 		<dependency>
 			<groupId>javax.enterprise</groupId>
 			<artifactId>cdi-api</artifactId>
@@ -148,26 +162,19 @@
 		</dependency>
 
 		<dependency>
-			<groupId>javax.el</groupId>
-			<artifactId>el-api</artifactId>
-			<version>${cdi}</version>
+			<groupId>javax.annotation</groupId>
+			<artifactId>javax.annotation-api</artifactId>
+			<version>${javax-annotation-api}</version>
 			<scope>test</scope>
 		</dependency>
 
 		<dependency>
-			<groupId>org.apache.openwebbeans.test</groupId>
-			<artifactId>cditest-owb</artifactId>
+			<groupId>org.apache.openwebbeans</groupId>
+			<artifactId>openwebbeans-se</artifactId>
 			<version>${webbeans}</version>
 			<scope>test</scope>
 		</dependency>
 
-		<dependency>
-			<groupId>javax.servlet</groupId>
-			<artifactId>servlet-api</artifactId>
-			<version>2.5</version>
-			<scope>test</scope>
-		</dependency>
-
 		<!-- JSR 303 Validation -->
 		<dependency>
 			<groupId>javax.validation</groupId>
@@ -231,11 +238,124 @@
 			<scope>test</scope>
 		</dependency>
 
+		<dependency>
+			<groupId>de.schauderhaft.degraph</groupId>
+			<artifactId>degraph-check</artifactId>
+			<version>0.1.4</version>
+			<scope>test</scope>
+		</dependency>
+
+		<!-- Kotlin extension -->
+		<dependency>
+			<groupId>org.jetbrains.kotlin</groupId>
+			<artifactId>kotlin-stdlib</artifactId>
+			<version>${kotlin}</version>
+			<optional>true</optional>
+		</dependency>
+		<dependency>
+			<groupId>org.jetbrains.kotlin</groupId>
+			<artifactId>kotlin-reflect</artifactId>
+			<version>${kotlin}</version>
+			<optional>true</optional>
+		</dependency>
+		<dependency>
+			<groupId>org.jetbrains.kotlin</groupId>
+			<artifactId>kotlin-test</artifactId>
+			<version>${kotlin}</version>
+			<scope>test</scope>
+		</dependency>
+		<dependency>
+			<groupId>com.nhaarman</groupId>
+			<artifactId>mockito-kotlin</artifactId>
+			<version>1.5.0</version>
+			<scope>test</scope>
+			<exclusions>
+				<exclusion>
+					<groupId>org.jetbrains.kotlin</groupId>
+					<artifactId>kotlin-stdlib</artifactId>
+				</exclusion>
+				<exclusion>
+					<groupId>org.jetbrains.kotlin</groupId>
+					<artifactId>kotlin-reflect</artifactId>
+				</exclusion>
+				<exclusion>
+					<groupId>org.mockito</groupId>
+					<artifactId>mockito-core</artifactId>
+				</exclusion>
+			</exclusions>
+		</dependency>
+
 	</dependencies>
 
 	<build>
 		<plugins>
 
+			<plugin>
+				<artifactId>kotlin-maven-plugin</artifactId>
+				<groupId>org.jetbrains.kotlin</groupId>
+				<version>${kotlin}</version>
+				<configuration>
+					<jvmTarget>${source.level}</jvmTarget>
+				</configuration>
+				<executions>
+					<execution>
+						<id>compile</id>
+						<phase>compile</phase>
+						<goals>
+							<goal>compile</goal>
+						</goals>
+						<configuration>
+							<sourceDirs>
+								<sourceDir>${project.basedir}/src/main/kotlin</sourceDir>
+								<sourceDir>${project.basedir}/src/main/java</sourceDir>
+							</sourceDirs>
+						</configuration>
+					</execution>
+					<execution>
+						<id>test-compile</id>
+						<phase>test-compile</phase>
+						<goals>
+							<goal>test-compile</goal>
+						</goals>
+						<configuration>
+							<sourceDirs>
+								<sourceDir>${project.basedir}/src/test/kotlin</sourceDir>
+								<sourceDir>${project.basedir}/src/test/java</sourceDir>
+							</sourceDirs>
+						</configuration>
+					</execution>
+				</executions>
+			</plugin>
+
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-compiler-plugin</artifactId>
+				<executions>
+					<execution>
+						<id>default-compile</id>
+						<phase>none</phase>
+					</execution>
+					<execution>
+						<id>default-testCompile</id>
+						<phase>none</phase>
+					</execution>
+					<execution>
+						<id>java-compile</id>
+						<phase>compile</phase>
+						<goals>
+							<goal>compile</goal>
+						</goals>
+					</execution>
+					<execution>
+						<id>java-test-compile</id>
+						<phase>test-compile</phase>
+						<goals>
+							<goal>testCompile</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
+
 			<plugin>
 				<groupId>com.mysema.maven</groupId>
 				<artifactId>apt-maven-plugin</artifactId>

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2012 the original author or authors.
+ * Copyright 2010-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,16 +17,18 @@ package org.springframework.data.mongodb;
 
 import org.springframework.dao.DataAccessResourceFailureException;
 import org.springframework.data.authentication.UserCredentials;
+import org.springframework.lang.Nullable;
 
 /**
  * Exception being thrown in case we cannot connect to a MongoDB instance.
- * 
+ *
  * @author Oliver Gierke
+ * @author Mark Paluch
  */
 public class CannotGetMongoDbConnectionException extends DataAccessResourceFailureException {
 
 	private final UserCredentials credentials;
-	private final String database;
+	private final @Nullable String database;
 
 	private static final long serialVersionUID = 1172099106475265589L;
 
@@ -40,7 +42,7 @@ public class CannotGetMongoDbConnectionException extends DataAccessResourceFailu
 		this(msg, null, UserCredentials.NO_CREDENTIALS);
 	}
 
-	public CannotGetMongoDbConnectionException(String msg, String database, UserCredentials credentials) {
+	public CannotGetMongoDbConnectionException(String msg, @Nullable String database, UserCredentials credentials) {
 		super(msg);
 		this.database = database;
 		this.credentials = credentials;
@@ -48,7 +50,7 @@ public class CannotGetMongoDbConnectionException extends DataAccessResourceFailu
 
 	/**
 	 * Returns the {@link UserCredentials} that were used when trying to connect to the MongoDB instance.
-	 * 
+	 *
 	 * @return
 	 */
 	public UserCredentials getCredentials() {
@@ -57,9 +59,10 @@ public class CannotGetMongoDbConnectionException extends DataAccessResourceFailu
 
 	/**
 	 * Returns the name of the database trying to be accessed.
-	 * 
+	 *
 	 * @return
 	 */
+	@Nullable
 	public String getDatabase() {
 		return database;
 	}

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

@@ -1,112 +1,114 @@
-/*
- * Copyright 2011-2017 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.mongodb.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.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 com.mongodb.MongoClient;
-
-/**
- * Base class for Spring Data MongoDB configuration using JavaConfig.
- *
- * @author Mark Pollack
- * @author Oliver Gierke
- * @author Thomas Darimont
- * @author Ryan Tenney
- * @author Christoph Strobl
- * @author Mark Paluch
- * @see MongoConfigurationSupport
- */
-@Configuration
-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
-	 * {@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 #mongo()}.
-	 *
-	 * @see #mongoClient()
-	 * @see #mongoTemplate()
-	 * @return
-	 */
-	@Bean
-	public MongoDbFactory mongoDbFactory() {
-		return new SimpleMongoDbFactory(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 AbstractMongoConfiguration} 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
-	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;
-	}
-}
+/*
+ * Copyright 2011-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.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.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.MongoClient;
+
+/**
+ * Base class for Spring Data MongoDB configuration using JavaConfig.
+ *
+ * @author Mark Pollack
+ * @author Oliver Gierke
+ * @author Thomas Darimont
+ * @author Ryan Tenney
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @see MongoConfigurationSupport
+ */
+@Configuration
+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
+	 * {@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 #mongo()}.
+	 *
+	 * @see #mongoClient()
+	 * @see #mongoTemplate()
+	 * @return
+	 */
+	@Bean
+	public MongoDbFactory mongoDbFactory() {
+		return new SimpleMongoDbFactory(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 AbstractMongoConfiguration} 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/AbstractReactiveMongoConfiguration.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016 the original author or authors.
+ * Copyright 2016-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,17 +13,14 @@
  * 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.ReactiveMongoDatabaseFactory;
-import org.springframework.data.mongodb.core.MongoTemplate;
 import org.springframework.data.mongodb.core.ReactiveMongoOperations;
-import org.springframework.data.mongodb.core.SimpleReactiveMongoDatabaseFactory;
 import org.springframework.data.mongodb.core.ReactiveMongoTemplate;
-import org.springframework.data.mongodb.core.SimpleMongoDbFactory;
+import org.springframework.data.mongodb.core.SimpleReactiveMongoDatabaseFactory;
 import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
 
 import com.mongodb.reactivestreams.client.MongoClient;
@@ -32,6 +29,7 @@ import com.mongodb.reactivestreams.client.MongoClient;
  * Base class for reactive Spring Data MongoDB configuration using JavaConfig.
  *
  * @author Mark Paluch
+ * @author Christoph Strobl
  * @since 2.0
  * @see MongoConfigurationSupport
  */
@@ -39,45 +37,44 @@ import com.mongodb.reactivestreams.client.MongoClient;
 public abstract class AbstractReactiveMongoConfiguration 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 the Reactive Streams {@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
+	 * @return never {@literal null}.
 	 */
-	public abstract MongoClient mongoClient();
+	public abstract MongoClient reactiveMongoClient();
 
 	/**
-	 * Creates a {@link ReactiveMongoTemplate}.
+	 * Creates {@link ReactiveMongoOperations}.
 	 *
-	 * @return
+	 * @return never {@literal null}.
 	 */
 	@Bean
 	public ReactiveMongoOperations reactiveMongoTemplate() throws Exception {
-		return new ReactiveMongoTemplate(mongoDbFactory(), mappingMongoConverter());
+		return new ReactiveMongoTemplate(reactiveMongoDbFactory(), mappingMongoConverter());
 	}
 
 	/**
-	 * Creates a {@link SimpleMongoDbFactory} to be used by the {@link MongoTemplate}. Will use the {@link Mongo} instance
-	 * configured in {@link #mongoClient()}.
+	 * Creates a {@link ReactiveMongoDatabaseFactory} to be used by the {@link ReactiveMongoOperations}. Will use the
+	 * {@link MongoClient} instance configured in {@link #reactiveMongoClient()}.
 	 *
-	 * @see #mongoClient()
+	 * @see #reactiveMongoClient()
 	 * @see #reactiveMongoTemplate()
-	 * @return
-	 * @throws Exception
+	 * @return never {@literal null}.
 	 */
 	@Bean
-	public ReactiveMongoDatabaseFactory mongoDbFactory() {
-		return new SimpleReactiveMongoDatabaseFactory(mongoClient(), getDatabaseName());
+	public ReactiveMongoDatabaseFactory reactiveMongoDbFactory() {
+		return new SimpleReactiveMongoDatabaseFactory(reactiveMongoClient(), getDatabaseName());
 	}
 
 	/**
-	 * Creates a {@link MappingMongoConverter} using the configured {@link #mongoDbFactory()} and
+	 * Creates a {@link MappingMongoConverter} using the configured {@link #reactiveMongoDbFactory()} and
 	 * {@link #mongoMappingContext()}. Will get {@link #customConversions()} applied.
 	 *
 	 * @see #customConversions()
 	 * @see #mongoMappingContext()
-	 * @see #mongoDbFactory()
-	 * @return
+	 * @see #reactiveMongoDbFactory()
+	 * @return never {@literal null}.
 	 * @throws Exception
 	 */
 	@Bean

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2016 the original author or authors.
+ * Copyright 2015-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.springframework.data.mongodb.core;
+package org.springframework.data.mongodb.config;
 
 import org.springframework.context.annotation.Bean;
 import org.springframework.data.mongodb.core.geo.GeoJsonModule;
@@ -23,6 +23,7 @@ import org.springframework.data.web.config.SpringDataJacksonModules;
  * Configuration class to expose {@link GeoJsonModule} as a Spring bean.
  * 
  * @author Oliver Gierke
+ * @author Jens Schauder
  */
 public class GeoJsonConfiguration implements SpringDataJacksonModules {
 

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

@@ -53,8 +53,8 @@ import org.springframework.data.annotation.Persistent;
 import org.springframework.data.config.BeanComponentDefinitionBuilder;
 import org.springframework.data.mapping.context.MappingContextIsNewStrategyFactory;
 import org.springframework.data.mapping.model.CamelCaseAbbreviatingFieldNamingStrategy;
-import org.springframework.data.mongodb.core.convert.CustomConversions;
 import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
+import org.springframework.data.mongodb.core.convert.MongoCustomConversions;
 import org.springframework.data.mongodb.core.convert.QueryMapper;
 import org.springframework.data.mongodb.core.index.MongoPersistentEntityIndexCreator;
 import org.springframework.data.mongodb.core.mapping.Document;
@@ -122,12 +122,15 @@ public class MappingMongoConverterParser implements BeanDefinitionParser {
 			converterBuilder.addPropertyValue("customConversions", conversionsDefinition);
 		}
 
-		if(!registry.containsBeanDefinition("indexOperationsProvider")){
+		if (!registry.containsBeanDefinition("indexOperationsProvider")) {
 
-			BeanDefinitionBuilder indexOperationsProviderBuilder = BeanDefinitionBuilder.genericBeanDefinition("org.springframework.data.mongodb.core.DefaultIndexOperationsProvider");
+			BeanDefinitionBuilder indexOperationsProviderBuilder = BeanDefinitionBuilder
+					.genericBeanDefinition("org.springframework.data.mongodb.core.DefaultIndexOperationsProvider");
 			indexOperationsProviderBuilder.addConstructorArgReference(dbFactoryRef);
-			indexOperationsProviderBuilder.addConstructorArgValue(BeanDefinitionBuilder.genericBeanDefinition(QueryMapper.class).addConstructorArgReference(id).getBeanDefinition());
-			parserContext.registerBeanComponent(new BeanComponentDefinition(indexOperationsProviderBuilder.getBeanDefinition(), "indexOperationsProvider"));
+			indexOperationsProviderBuilder.addConstructorArgValue(BeanDefinitionBuilder
+					.genericBeanDefinition(QueryMapper.class).addConstructorArgReference(id).getBeanDefinition());
+			parserContext.registerBeanComponent(
+					new BeanComponentDefinition(indexOperationsProviderBuilder.getBeanDefinition(), "indexOperationsProvider"));
 		}
 
 		try {
@@ -140,15 +143,15 @@ public class MappingMongoConverterParser implements BeanDefinitionParser {
 			indexHelperBuilder.addConstructorArgReference("indexOperationsProvider");
 			indexHelperBuilder.addDependsOn(ctxRef);
 
-			parserContext.registerBeanComponent(new BeanComponentDefinition(indexHelperBuilder.getBeanDefinition(),
-					INDEX_HELPER_BEAN_NAME));
+			parserContext.registerBeanComponent(
+					new BeanComponentDefinition(indexHelperBuilder.getBeanDefinition(), INDEX_HELPER_BEAN_NAME));
 		}
 
 		BeanDefinition validatingMongoEventListener = potentiallyCreateValidatingMongoEventListener(element, parserContext);
 
 		if (validatingMongoEventListener != null) {
-			parserContext.registerBeanComponent(new BeanComponentDefinition(validatingMongoEventListener,
-					VALIDATING_EVENT_LISTENER_BEAN_NAME));
+			parserContext.registerBeanComponent(
+					new BeanComponentDefinition(validatingMongoEventListener, VALIDATING_EVENT_LISTENER_BEAN_NAME));
 		}
 
 		parserContext.registerBeanComponent(new BeanComponentDefinition(converterBuilder.getBeanDefinition(), id));
@@ -287,7 +290,7 @@ public class MappingMongoConverterParser implements BeanDefinitionParser {
 				}
 			}
 
-			BeanDefinitionBuilder conversionsBuilder = BeanDefinitionBuilder.rootBeanDefinition(CustomConversions.class);
+			BeanDefinitionBuilder conversionsBuilder = BeanDefinitionBuilder.rootBeanDefinition(MongoCustomConversions.class);
 			conversionsBuilder.addConstructorArgValue(converterBeans);
 
 			AbstractBeanDefinition conversionsBean = conversionsBuilder.getBeanDefinition();
@@ -335,8 +338,8 @@ public class MappingMongoConverterParser implements BeanDefinitionParser {
 			return beanDef;
 		}
 
-		parserContext.getReaderContext().error(
-				"Element <converter> must specify 'ref' or contain a bean definition for the converter", element);
+		parserContext.getReaderContext()
+				.error("Element <converter> must specify 'ref' or contain a bean definition for the converter", element);
 		return null;
 	}
 
@@ -348,8 +351,8 @@ public class MappingMongoConverterParser implements BeanDefinitionParser {
 		mappingContextStrategyFactoryBuilder.addConstructorArgReference(mappingContextRef);
 
 		BeanComponentDefinitionBuilder builder = new BeanComponentDefinitionBuilder(element, context);
-		context.registerBeanComponent(builder.getComponent(mappingContextStrategyFactoryBuilder,
-				IS_NEW_STRATEGY_FACTORY_BEAN_NAME));
+		context.registerBeanComponent(
+				builder.getComponent(mappingContextStrategyFactoryBuilder, IS_NEW_STRATEGY_FACTORY_BEAN_NAME));
 
 		return IS_NEW_STRATEGY_FACTORY_BEAN_NAME;
 	}
@@ -379,7 +382,8 @@ public class MappingMongoConverterParser implements BeanDefinitionParser {
 		 * (non-Javadoc)
 		 * @see org.springframework.core.type.filter.TypeFilter#match(org.springframework.core.type.classreading.MetadataReader, org.springframework.core.type.classreading.MetadataReaderFactory)
 		 */
-		public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
+		public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
+				throws IOException {
 
 			for (TypeFilter delegate : delegates) {
 				if (delegate.match(metadataReader, metadataReaderFactory)) {

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

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 package org.springframework.data.mongodb.config;
 
 import java.util.Arrays;
@@ -28,20 +27,14 @@ import org.springframework.context.annotation.ClassPathScanningCandidateComponen
 import org.springframework.core.convert.converter.Converter;
 import org.springframework.core.type.filter.AnnotationTypeFilter;
 import org.springframework.data.annotation.Persistent;
-import org.springframework.data.authentication.UserCredentials;
+import org.springframework.data.convert.CustomConversions;
 import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.data.mapping.context.MappingContextIsNewStrategyFactory;
 import org.springframework.data.mapping.context.PersistentEntities;
 import org.springframework.data.mapping.model.CamelCaseAbbreviatingFieldNamingStrategy;
 import org.springframework.data.mapping.model.FieldNamingStrategy;
 import org.springframework.data.mapping.model.PropertyNameFieldNamingStrategy;
-import org.springframework.data.mongodb.MongoDbFactory;
-import org.springframework.data.mongodb.core.MongoTemplate;
-import org.springframework.data.mongodb.core.SimpleMongoDbFactory;
-import org.springframework.data.mongodb.core.convert.CustomConversions;
-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.convert.MongoCustomConversions;
 import org.springframework.data.mongodb.core.mapping.Document;
 import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
 import org.springframework.data.support.CachingIsNewStrategyFactory;
@@ -49,9 +42,6 @@ import org.springframework.data.support.IsNewStrategyFactory;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.StringUtils;
 
-import com.mongodb.Mongo;
-import com.mongodb.MongoClient;
-
 /**
  * Base class for Spring Data MongoDB to be extended for JavaConfiguration usage.
  *
@@ -117,13 +107,13 @@ public abstract class MongoConfigurationSupport {
 	/**
 	 * Register custom {@link Converter}s in a {@link CustomConversions} object if required. These
 	 * {@link CustomConversions} will be registered with the {@link #mappingMongoConverter()} and
-	 * {@link #mongoMappingContext()}. Returns an empty {@link CustomConversions} instance by default.
+	 * {@link #mongoMappingContext()}. Returns an empty {@link MongoCustomConversions} instance by default.
 	 *
 	 * @return must not be {@literal null}.
 	 */
 	@Bean
 	public CustomConversions customConversions() {
-		return new CustomConversions(Collections.emptyList());
+		return new MongoCustomConversions(Collections.emptyList());
 	}
 
 	/**

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015 the original author or authors.
+ * Copyright 2015-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,6 +16,8 @@
 package org.springframework.data.mongodb.config;
 
 import java.beans.PropertyEditorSupport;
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -23,13 +25,14 @@ import java.util.Properties;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+import org.springframework.lang.Nullable;
 import org.springframework.util.StringUtils;
 
 import com.mongodb.MongoCredential;
 
 /**
  * Parse a {@link String} to a Collection of {@link MongoCredential}.
- * 
+ *
  * @author Christoph Strobl
  * @author Oliver Gierke
  * @since 1.7
@@ -39,23 +42,23 @@ public class MongoCredentialPropertyEditor extends PropertyEditorSupport {
 	private static final Pattern GROUP_PATTERN = Pattern.compile("(\\\\?')(.*?)\\1");
 
 	private static final String AUTH_MECHANISM_KEY = "uri.authMechanism";
-	private static final String USERNAME_PASSWORD_DELIMINATOR = ":";
-	private static final String DATABASE_DELIMINATOR = "@";
-	private static final String OPTIONS_DELIMINATOR = "?";
-	private static final String OPTION_VALUE_DELIMINATOR = "&";
+	private static final String USERNAME_PASSWORD_DELIMITER = ":";
+	private static final String DATABASE_DELIMITER = "@";
+	private static final String OPTIONS_DELIMITER = "?";
+	private static final String OPTION_VALUE_DELIMITER = "&";
 
 	/*
 	 * (non-Javadoc)
 	 * @see java.beans.PropertyEditorSupport#setAsText(java.lang.String)
 	 */
 	@Override
-	public void setAsText(String text) throws IllegalArgumentException {
+	public void setAsText(@Nullable String text) throws IllegalArgumentException {
 
 		if (!StringUtils.hasText(text)) {
 			return;
 		}
 
-		List<MongoCredential> credentials = new ArrayList<MongoCredential>();
+		List<MongoCredential> credentials = new ArrayList<>();
 
 		for (String credentialString : extractCredentialsString(text)) {
 
@@ -115,7 +118,7 @@ public class MongoCredentialPropertyEditor extends PropertyEditorSupport {
 	private List<String> extractCredentialsString(String source) {
 
 		Matcher matcher = GROUP_PATTERN.matcher(source);
-		List<String> list = new ArrayList<String>();
+		List<String> list = new ArrayList<>();
 
 		while (matcher.find()) {
 
@@ -132,39 +135,44 @@ public class MongoCredentialPropertyEditor extends PropertyEditorSupport {
 
 	private static String[] extractUserNameAndPassword(String text) {
 
-		int index = text.lastIndexOf(DATABASE_DELIMINATOR);
+		int index = text.lastIndexOf(DATABASE_DELIMITER);
 
-		index = index != -1 ? index : text.lastIndexOf(OPTIONS_DELIMINATOR);
+		index = index != -1 ? index : text.lastIndexOf(OPTIONS_DELIMITER);
 
-		return index == -1 ? new String[] {} : text.substring(0, index).split(USERNAME_PASSWORD_DELIMINATOR);
+		if (index == -1) {
+			return new String[] {};
+		}
+
+		return Arrays.stream(text.substring(0, index).split(USERNAME_PASSWORD_DELIMITER))
+				.map(MongoCredentialPropertyEditor::decodeParameter).toArray(String[]::new);
 	}
 
 	private static String extractDB(String text) {
 
-		int dbSeperationIndex = text.lastIndexOf(DATABASE_DELIMINATOR);
+		int dbSeparationIndex = text.lastIndexOf(DATABASE_DELIMITER);
 
-		if (dbSeperationIndex == -1) {
+		if (dbSeparationIndex == -1) {
 			return "";
 		}
 
-		String tmp = text.substring(dbSeperationIndex + 1);
-		int optionsSeperationIndex = tmp.lastIndexOf(OPTIONS_DELIMINATOR);
+		String tmp = text.substring(dbSeparationIndex + 1);
+		int optionsSeparationIndex = tmp.lastIndexOf(OPTIONS_DELIMITER);
 
-		return optionsSeperationIndex > -1 ? tmp.substring(0, optionsSeperationIndex) : tmp;
+		return optionsSeparationIndex > -1 ? tmp.substring(0, optionsSeparationIndex) : tmp;
 	}
 
 	private static Properties extractOptions(String text) {
 
-		int optionsSeperationIndex = text.lastIndexOf(OPTIONS_DELIMINATOR);
-		int dbSeperationIndex = text.lastIndexOf(OPTIONS_DELIMINATOR);
+		int optionsSeparationIndex = text.lastIndexOf(OPTIONS_DELIMITER);
+		int dbSeparationIndex = text.lastIndexOf(OPTIONS_DELIMITER);
 
-		if (optionsSeperationIndex == -1 || dbSeperationIndex > optionsSeperationIndex) {
+		if (optionsSeparationIndex == -1 || dbSeparationIndex > optionsSeparationIndex) {
 			return new Properties();
 		}
 
 		Properties properties = new Properties();
 
-		for (String option : text.substring(optionsSeperationIndex + 1).split(OPTION_VALUE_DELIMINATOR)) {
+		for (String option : text.substring(optionsSeparationIndex + 1).split(OPTION_VALUE_DELIMITER)) {
 			String[] optionArgs = option.split("=");
 			properties.put(optionArgs[0], optionArgs[1]);
 		}
@@ -195,4 +203,12 @@ public class MongoCredentialPropertyEditor extends PropertyEditorSupport {
 			throw new IllegalArgumentException("Credentials need to specify username!");
 		}
 	}
+
+	private static String decodeParameter(String it) {
+		try {
+			return URLDecoder.decode(it, "UTF-8");
+		} catch (UnsupportedEncodingException e) {
+			throw new IllegalArgumentException("o_O UTF-8 not supported!", e);
+		}
+	}
 }

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

@@ -1,11 +1,11 @@
 /*
- * Copyright 2011-2017 by the original author(s).
+ * Copyright 2011-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *      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,
@@ -33,6 +33,7 @@ import org.springframework.beans.factory.xml.ParserContext;
 import org.springframework.data.config.BeanComponentDefinitionBuilder;
 import org.springframework.data.mongodb.core.MongoClientFactoryBean;
 import org.springframework.data.mongodb.core.SimpleMongoDbFactory;
+import org.springframework.lang.Nullable;
 import org.springframework.util.StringUtils;
 import org.w3c.dom.Element;
 
@@ -42,12 +43,13 @@ import com.mongodb.MongoURI;
 
 /**
  * {@link BeanDefinitionParser} to parse {@code db-factory} elements into {@link BeanDefinition}s.
- * 
+ *
  * @author Jon Brisbin
  * @author Oliver Gierke
  * @author Thomas Darimont
  * @author Christoph Strobl
  * @author Viktor Khoroshko
+ * @author Mark Paluch
  */
 public class MongoDbFactoryParser extends AbstractBeanDefinitionParser {
 
@@ -62,7 +64,7 @@ public class MongoDbFactoryParser extends AbstractBeanDefinitionParser {
 		MONGO_URI_ALLOWED_ADDITIONAL_ATTRIBUTES = Collections.unmodifiableSet(mongoUriAllowedAdditionalAttributes);
 	}
 
-	/* 
+	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.beans.factory.xml.AbstractBeanDefinitionParser#resolveId(org.w3c.dom.Element, org.springframework.beans.factory.support.AbstractBeanDefinition, org.springframework.beans.factory.xml.ParserContext)
 	 */
@@ -74,7 +76,7 @@ public class MongoDbFactoryParser extends AbstractBeanDefinitionParser {
 		return StringUtils.hasText(id) ? id : BeanNames.DB_FACTORY_BEAN_NAME;
 	}
 
-	/* 
+	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.beans.factory.xml.AbstractBeanDefinitionParser#parseInternal(org.w3c.dom.Element, org.springframework.beans.factory.xml.ParserContext)
 	 */
@@ -119,7 +121,7 @@ public class MongoDbFactoryParser extends AbstractBeanDefinitionParser {
 	/**
 	 * Registers a default {@link BeanDefinition} of a {@link Mongo} instance and returns the name under which the
 	 * {@link Mongo} instance was registered under.
-	 * 
+	 *
 	 * @param element must not be {@literal null}.
 	 * @param parserContext must not be {@literal null}.
 	 * @return
@@ -138,11 +140,12 @@ public class MongoDbFactoryParser extends AbstractBeanDefinitionParser {
 	 * attributes. <br />
 	 * Errors when configured element contains {@literal uri} or {@literal client-uri} along with other attributes except
 	 * {@literal write-concern} and/or {@literal id}.
-	 * 
+	 *
 	 * @param element must not be {@literal null}.
 	 * @param parserContext
 	 * @return {@literal null} in case no client-/uri defined.
 	 */
+	@Nullable
 	private BeanDefinition getMongoUri(Element element, ParserContext parserContext) {
 
 		boolean hasClientUri = element.hasAttribute("client-uri");

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

@@ -1,76 +1,76 @@
-/*
- * Copyright 2011-2017 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.mongodb.config;
-
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.beans.factory.parsing.BeanComponentDefinition;
-import org.springframework.beans.factory.parsing.CompositeComponentDefinition;
-import org.springframework.beans.factory.support.BeanDefinitionBuilder;
-import org.springframework.beans.factory.xml.BeanDefinitionParser;
-import org.springframework.beans.factory.xml.ParserContext;
-import org.springframework.data.mongodb.core.MongoAdmin;
-import org.springframework.data.mongodb.monitor.*;
-import org.springframework.util.StringUtils;
-import org.w3c.dom.Element;
-
-/**
- * @author Mark Pollack
- * @author Thomas Risberg
- * @author John Brisbin
- * @author Oliver Gierke
- * @author Christoph Strobl
- */
-public class MongoJmxParser implements BeanDefinitionParser {
-
-	public BeanDefinition parse(Element element, ParserContext parserContext) {
-		String name = element.getAttribute("mongo-ref");
-		if (!StringUtils.hasText(name)) {
-			name = BeanNames.MONGO_BEAN_NAME;
-		}
-		registerJmxComponents(name, element, parserContext);
-		return null;
-	}
-
-	protected void registerJmxComponents(String mongoRefName, Element element, ParserContext parserContext) {
-		Object eleSource = parserContext.extractSource(element);
-
-		CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), eleSource);
-
-		createBeanDefEntry(AssertMetrics.class, compositeDef, mongoRefName, eleSource, parserContext);
-		createBeanDefEntry(BackgroundFlushingMetrics.class, compositeDef, mongoRefName, eleSource, parserContext);
-		createBeanDefEntry(BtreeIndexCounters.class, compositeDef, mongoRefName, eleSource, parserContext);
-		createBeanDefEntry(ConnectionMetrics.class, compositeDef, mongoRefName, eleSource, parserContext);
-		createBeanDefEntry(GlobalLockMetrics.class, compositeDef, mongoRefName, eleSource, parserContext);
-		createBeanDefEntry(MemoryMetrics.class, compositeDef, mongoRefName, eleSource, parserContext);
-		createBeanDefEntry(OperationCounters.class, compositeDef, mongoRefName, eleSource, parserContext);
-		createBeanDefEntry(ServerInfo.class, compositeDef, mongoRefName, eleSource, parserContext);
-		createBeanDefEntry(MongoAdmin.class, compositeDef, mongoRefName, eleSource, parserContext);
-
-		parserContext.registerComponent(compositeDef);
-
-	}
-
-	protected void createBeanDefEntry(Class<?> clazz, CompositeComponentDefinition compositeDef, String mongoRefName,
-			Object eleSource, ParserContext parserContext) {
-		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(clazz);
-		builder.getRawBeanDefinition().setSource(eleSource);
-		builder.addConstructorArgReference(mongoRefName);
-		BeanDefinition assertDef = builder.getBeanDefinition();
-		String assertName = parserContext.getReaderContext().registerWithGeneratedName(assertDef);
-		compositeDef.addNestedComponent(new BeanComponentDefinition(assertDef, assertName));
-	}
-
-}
+/*
+ * Copyright 2011-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.config;
+
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.parsing.BeanComponentDefinition;
+import org.springframework.beans.factory.parsing.CompositeComponentDefinition;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.xml.BeanDefinitionParser;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.springframework.data.mongodb.core.MongoAdmin;
+import org.springframework.data.mongodb.monitor.*;
+import org.springframework.util.StringUtils;
+import org.w3c.dom.Element;
+
+/**
+ * @author Mark Pollack
+ * @author Thomas Risberg
+ * @author John Brisbin
+ * @author Oliver Gierke
+ * @author Christoph Strobl
+ */
+public class MongoJmxParser implements BeanDefinitionParser {
+
+	public BeanDefinition parse(Element element, ParserContext parserContext) {
+		String name = element.getAttribute("mongo-ref");
+		if (!StringUtils.hasText(name)) {
+			name = BeanNames.MONGO_BEAN_NAME;
+		}
+		registerJmxComponents(name, element, parserContext);
+		return null;
+	}
+
+	protected void registerJmxComponents(String mongoRefName, Element element, ParserContext parserContext) {
+		Object eleSource = parserContext.extractSource(element);
+
+		CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), eleSource);
+
+		createBeanDefEntry(AssertMetrics.class, compositeDef, mongoRefName, eleSource, parserContext);
+		createBeanDefEntry(BackgroundFlushingMetrics.class, compositeDef, mongoRefName, eleSource, parserContext);
+		createBeanDefEntry(BtreeIndexCounters.class, compositeDef, mongoRefName, eleSource, parserContext);
+		createBeanDefEntry(ConnectionMetrics.class, compositeDef, mongoRefName, eleSource, parserContext);
+		createBeanDefEntry(GlobalLockMetrics.class, compositeDef, mongoRefName, eleSource, parserContext);
+		createBeanDefEntry(MemoryMetrics.class, compositeDef, mongoRefName, eleSource, parserContext);
+		createBeanDefEntry(OperationCounters.class, compositeDef, mongoRefName, eleSource, parserContext);
+		createBeanDefEntry(ServerInfo.class, compositeDef, mongoRefName, eleSource, parserContext);
+		createBeanDefEntry(MongoAdmin.class, compositeDef, mongoRefName, eleSource, parserContext);
+
+		parserContext.registerComponent(compositeDef);
+
+	}
+
+	protected void createBeanDefEntry(Class<?> clazz, CompositeComponentDefinition compositeDef, String mongoRefName,
+			Object eleSource, ParserContext parserContext) {
+		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(clazz);
+		builder.getRawBeanDefinition().setSource(eleSource);
+		builder.addConstructorArgReference(mongoRefName);
+		BeanDefinition assertDef = builder.getBeanDefinition();
+		String assertName = parserContext.getReaderContext().registerWithGeneratedName(assertDef);
+		compositeDef.addNestedComponent(new BeanComponentDefinition(assertDef, assertName));
+	}
+
+}

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

@@ -1,170 +1,170 @@
-/*
- * Copyright 2011-2017 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.mongodb.config;
-
-import static org.springframework.data.config.ParsingUtils.*;
-
-import java.util.Map;
-
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.beans.factory.config.CustomEditorConfigurer;
-import org.springframework.beans.factory.support.BeanDefinitionBuilder;
-import org.springframework.beans.factory.support.ManagedMap;
-import org.springframework.beans.factory.xml.BeanDefinitionParser;
-import org.springframework.data.mongodb.core.MongoClientOptionsFactoryBean;
-import org.springframework.util.xml.DomUtils;
-import org.w3c.dom.Element;
-
-/**
- * Utility methods for {@link BeanDefinitionParser} implementations for MongoDB.
- * 
- * @author Mark Pollack
- * @author Oliver Gierke
- * @author Thomas Darimont
- * @author Christoph Strobl
- */
-@SuppressWarnings("deprecation")
-abstract class MongoParsingUtils {
-
-	private MongoParsingUtils() {}
-
-	/**
-	 * Parses the mongo replica-set element.
-	 * 
-	 * @param parserContext the parser context
-	 * @param element the mongo element
-	 * @param mongoBuilder the bean definition builder to populate
-	 * @return
-	 */
-	static void parseReplicaSet(Element element, BeanDefinitionBuilder mongoBuilder) {
-		setPropertyValue(mongoBuilder, element, "replica-set", "replicaSetSeeds");
-	}
-
-	/**
-	 * Parses the {@code mongo:client-options} sub-element. Populates the given attribute factory with the proper
-	 * attributes.
-	 * 
-	 * @param element must not be {@literal null}.
-	 * @param mongoClientBuilder must not be {@literal null}.
-	 * @return
-	 * @since 1.7
-	 */
-	public static boolean parseMongoClientOptions(Element element, BeanDefinitionBuilder mongoClientBuilder) {
-
-		Element optionsElement = DomUtils.getChildElementByTagName(element, "client-options");
-
-		if (optionsElement == null) {
-			return false;
-		}
-
-		BeanDefinitionBuilder clientOptionsDefBuilder = BeanDefinitionBuilder
-				.genericBeanDefinition(MongoClientOptionsFactoryBean.class);
-
-		setPropertyValue(clientOptionsDefBuilder, optionsElement, "description", "description");
-		setPropertyValue(clientOptionsDefBuilder, optionsElement, "min-connections-per-host", "minConnectionsPerHost");
-		setPropertyValue(clientOptionsDefBuilder, optionsElement, "connections-per-host", "connectionsPerHost");
-		setPropertyValue(clientOptionsDefBuilder, optionsElement, "threads-allowed-to-block-for-connection-multiplier",
-				"threadsAllowedToBlockForConnectionMultiplier");
-		setPropertyValue(clientOptionsDefBuilder, optionsElement, "max-wait-time", "maxWaitTime");
-		setPropertyValue(clientOptionsDefBuilder, optionsElement, "max-connection-idle-time", "maxConnectionIdleTime");
-		setPropertyValue(clientOptionsDefBuilder, optionsElement, "max-connection-life-time", "maxConnectionLifeTime");
-		setPropertyValue(clientOptionsDefBuilder, optionsElement, "connect-timeout", "connectTimeout");
-		setPropertyValue(clientOptionsDefBuilder, optionsElement, "socket-timeout", "socketTimeout");
-		setPropertyValue(clientOptionsDefBuilder, optionsElement, "socket-keep-alive", "socketKeepAlive");
-		setPropertyValue(clientOptionsDefBuilder, optionsElement, "read-preference", "readPreference");
-		setPropertyValue(clientOptionsDefBuilder, optionsElement, "write-concern", "writeConcern");
-		setPropertyValue(clientOptionsDefBuilder, optionsElement, "heartbeat-frequency", "heartbeatFrequency");
-		setPropertyValue(clientOptionsDefBuilder, optionsElement, "min-heartbeat-frequency", "minHeartbeatFrequency");
-		setPropertyValue(clientOptionsDefBuilder, optionsElement, "heartbeat-connect-timeout", "heartbeatConnectTimeout");
-		setPropertyValue(clientOptionsDefBuilder, optionsElement, "heartbeat-socket-timeout", "heartbeatSocketTimeout");
-		setPropertyValue(clientOptionsDefBuilder, optionsElement, "ssl", "ssl");
-		setPropertyReference(clientOptionsDefBuilder, optionsElement, "ssl-socket-factory-ref", "sslSocketFactory");
-		setPropertyValue(clientOptionsDefBuilder, optionsElement, "server-selection-timeout", "serverSelectionTimeout");
-
-		mongoClientBuilder.addPropertyValue("mongoClientOptions", clientOptionsDefBuilder.getBeanDefinition());
-
-		return true;
-	}
-
-	/**
-	 * Returns the {@link BeanDefinitionBuilder} to build a {@link BeanDefinition} for a
-	 * {@link WriteConcernPropertyEditor}.
-	 * 
-	 * @return
-	 */
-	static BeanDefinitionBuilder getWriteConcernPropertyEditorBuilder() {
-
-		Map<String, Class<?>> customEditors = new ManagedMap<String, Class<?>>();
-		customEditors.put("com.mongodb.WriteConcern", WriteConcernPropertyEditor.class);
-
-		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(CustomEditorConfigurer.class);
-		builder.addPropertyValue("customEditors", customEditors);
-
-		return builder;
-	}
-
-	/**
-	 * One should only register one bean definition but want to have the convenience of using
-	 * AbstractSingleBeanDefinitionParser but have the side effect of registering a 'default' property editor with the
-	 * container.
-	 */
-	static BeanDefinitionBuilder getServerAddressPropertyEditorBuilder() {
-
-		Map<String, String> customEditors = new ManagedMap<String, String>();
-		customEditors.put("com.mongodb.ServerAddress[]",
-				"org.springframework.data.mongodb.config.ServerAddressPropertyEditor");
-
-		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(CustomEditorConfigurer.class);
-		builder.addPropertyValue("customEditors", customEditors);
-		return builder;
-	}
-
-	/**
-	 * Returns the {@link BeanDefinitionBuilder} to build a {@link BeanDefinition} for a
-	 * {@link ReadPreferencePropertyEditor}.
-	 * 
-	 * @return
-	 * @since 1.7
-	 */
-	static BeanDefinitionBuilder getReadPreferencePropertyEditorBuilder() {
-
-		Map<String, Class<?>> customEditors = new ManagedMap<String, Class<?>>();
-		customEditors.put("com.mongodb.ReadPreference", ReadPreferencePropertyEditor.class);
-
-		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(CustomEditorConfigurer.class);
-		builder.addPropertyValue("customEditors", customEditors);
-
-		return builder;
-	}
-
-	/**
-	 * Returns the {@link BeanDefinitionBuilder} to build a {@link BeanDefinition} for a
-	 * {@link MongoCredentialPropertyEditor}.
-	 * 
-	 * @return
-	 * @since 1.7
-	 */
-	static BeanDefinitionBuilder getMongoCredentialPropertyEditor() {
-
-		Map<String, Class<?>> customEditors = new ManagedMap<String, Class<?>>();
-		customEditors.put("com.mongodb.MongoCredential[]", MongoCredentialPropertyEditor.class);
-
-		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(CustomEditorConfigurer.class);
-		builder.addPropertyValue("customEditors", customEditors);
-
-		return builder;
-	}
-}
+/*
+ * Copyright 2011-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.config;
+
+import static org.springframework.data.config.ParsingUtils.*;
+
+import java.util.Map;
+
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.config.CustomEditorConfigurer;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.support.ManagedMap;
+import org.springframework.beans.factory.xml.BeanDefinitionParser;
+import org.springframework.data.mongodb.core.MongoClientOptionsFactoryBean;
+import org.springframework.util.xml.DomUtils;
+import org.w3c.dom.Element;
+
+/**
+ * Utility methods for {@link BeanDefinitionParser} implementations for MongoDB.
+ * 
+ * @author Mark Pollack
+ * @author Oliver Gierke
+ * @author Thomas Darimont
+ * @author Christoph Strobl
+ */
+@SuppressWarnings("deprecation")
+abstract class MongoParsingUtils {
+
+	private MongoParsingUtils() {}
+
+	/**
+	 * Parses the mongo replica-set element.
+	 * 
+	 * @param parserContext the parser context
+	 * @param element the mongo element
+	 * @param mongoBuilder the bean definition builder to populate
+	 * @return
+	 */
+	static void parseReplicaSet(Element element, BeanDefinitionBuilder mongoBuilder) {
+		setPropertyValue(mongoBuilder, element, "replica-set", "replicaSetSeeds");
+	}
+
+	/**
+	 * Parses the {@code mongo:client-options} sub-element. Populates the given attribute factory with the proper
+	 * attributes.
+	 * 
+	 * @param element must not be {@literal null}.
+	 * @param mongoClientBuilder must not be {@literal null}.
+	 * @return
+	 * @since 1.7
+	 */
+	public static boolean parseMongoClientOptions(Element element, BeanDefinitionBuilder mongoClientBuilder) {
+
+		Element optionsElement = DomUtils.getChildElementByTagName(element, "client-options");
+
+		if (optionsElement == null) {
+			return false;
+		}
+
+		BeanDefinitionBuilder clientOptionsDefBuilder = BeanDefinitionBuilder
+				.genericBeanDefinition(MongoClientOptionsFactoryBean.class);
+
+		setPropertyValue(clientOptionsDefBuilder, optionsElement, "description", "description");
+		setPropertyValue(clientOptionsDefBuilder, optionsElement, "min-connections-per-host", "minConnectionsPerHost");
+		setPropertyValue(clientOptionsDefBuilder, optionsElement, "connections-per-host", "connectionsPerHost");
+		setPropertyValue(clientOptionsDefBuilder, optionsElement, "threads-allowed-to-block-for-connection-multiplier",
+				"threadsAllowedToBlockForConnectionMultiplier");
+		setPropertyValue(clientOptionsDefBuilder, optionsElement, "max-wait-time", "maxWaitTime");
+		setPropertyValue(clientOptionsDefBuilder, optionsElement, "max-connection-idle-time", "maxConnectionIdleTime");
+		setPropertyValue(clientOptionsDefBuilder, optionsElement, "max-connection-life-time", "maxConnectionLifeTime");
+		setPropertyValue(clientOptionsDefBuilder, optionsElement, "connect-timeout", "connectTimeout");
+		setPropertyValue(clientOptionsDefBuilder, optionsElement, "socket-timeout", "socketTimeout");
+		setPropertyValue(clientOptionsDefBuilder, optionsElement, "socket-keep-alive", "socketKeepAlive");
+		setPropertyValue(clientOptionsDefBuilder, optionsElement, "read-preference", "readPreference");
+		setPropertyValue(clientOptionsDefBuilder, optionsElement, "write-concern", "writeConcern");
+		setPropertyValue(clientOptionsDefBuilder, optionsElement, "heartbeat-frequency", "heartbeatFrequency");
+		setPropertyValue(clientOptionsDefBuilder, optionsElement, "min-heartbeat-frequency", "minHeartbeatFrequency");
+		setPropertyValue(clientOptionsDefBuilder, optionsElement, "heartbeat-connect-timeout", "heartbeatConnectTimeout");
+		setPropertyValue(clientOptionsDefBuilder, optionsElement, "heartbeat-socket-timeout", "heartbeatSocketTimeout");
+		setPropertyValue(clientOptionsDefBuilder, optionsElement, "ssl", "ssl");
+		setPropertyReference(clientOptionsDefBuilder, optionsElement, "ssl-socket-factory-ref", "sslSocketFactory");
+		setPropertyValue(clientOptionsDefBuilder, optionsElement, "server-selection-timeout", "serverSelectionTimeout");
+
+		mongoClientBuilder.addPropertyValue("mongoClientOptions", clientOptionsDefBuilder.getBeanDefinition());
+
+		return true;
+	}
+
+	/**
+	 * Returns the {@link BeanDefinitionBuilder} to build a {@link BeanDefinition} for a
+	 * {@link WriteConcernPropertyEditor}.
+	 * 
+	 * @return
+	 */
+	static BeanDefinitionBuilder getWriteConcernPropertyEditorBuilder() {
+
+		Map<String, Class<?>> customEditors = new ManagedMap<String, Class<?>>();
+		customEditors.put("com.mongodb.WriteConcern", WriteConcernPropertyEditor.class);
+
+		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(CustomEditorConfigurer.class);
+		builder.addPropertyValue("customEditors", customEditors);
+
+		return builder;
+	}
+
+	/**
+	 * One should only register one bean definition but want to have the convenience of using
+	 * AbstractSingleBeanDefinitionParser but have the side effect of registering a 'default' property editor with the
+	 * container.
+	 */
+	static BeanDefinitionBuilder getServerAddressPropertyEditorBuilder() {
+
+		Map<String, String> customEditors = new ManagedMap<String, String>();
+		customEditors.put("com.mongodb.ServerAddress[]",
+				"org.springframework.data.mongodb.config.ServerAddressPropertyEditor");
+
+		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(CustomEditorConfigurer.class);
+		builder.addPropertyValue("customEditors", customEditors);
+		return builder;
+	}
+
+	/**
+	 * Returns the {@link BeanDefinitionBuilder} to build a {@link BeanDefinition} for a
+	 * {@link ReadPreferencePropertyEditor}.
+	 * 
+	 * @return
+	 * @since 1.7
+	 */
+	static BeanDefinitionBuilder getReadPreferencePropertyEditorBuilder() {
+
+		Map<String, Class<?>> customEditors = new ManagedMap<String, Class<?>>();
+		customEditors.put("com.mongodb.ReadPreference", ReadPreferencePropertyEditor.class);
+
+		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(CustomEditorConfigurer.class);
+		builder.addPropertyValue("customEditors", customEditors);
+
+		return builder;
+	}
+
+	/**
+	 * Returns the {@link BeanDefinitionBuilder} to build a {@link BeanDefinition} for a
+	 * {@link MongoCredentialPropertyEditor}.
+	 * 
+	 * @return
+	 * @since 1.7
+	 */
+	static BeanDefinitionBuilder getMongoCredentialPropertyEditor() {
+
+		Map<String, Class<?>> customEditors = new ManagedMap<String, Class<?>>();
+		customEditors.put("com.mongodb.MongoCredential[]", MongoCredentialPropertyEditor.class);
+
+		BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(CustomEditorConfigurer.class);
+		builder.addPropertyValue("customEditors", customEditors);
+
+		return builder;
+	}
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015 the original author or authors.
+ * Copyright 2015-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,6 +17,8 @@ package org.springframework.data.mongodb.config;
 
 import java.beans.PropertyEditorSupport;
 
+import org.springframework.lang.Nullable;
+
 import com.mongodb.ReadPreference;
 
 /**
@@ -32,7 +34,7 @@ public class ReadPreferencePropertyEditor extends PropertyEditorSupport {
 	 * @see java.beans.PropertyEditorSupport#setAsText(java.lang.String)
 	 */
 	@Override
-	public void setAsText(String readPreferenceString) throws IllegalArgumentException {
+	public void setAsText(@Nullable String readPreferenceString) throws IllegalArgumentException {
 
 		if (readPreferenceString == null) {
 			return;
@@ -59,8 +61,8 @@ public class ReadPreferencePropertyEditor extends PropertyEditorSupport {
 		} else if ("NEAREST".equalsIgnoreCase(readPreferenceString)) {
 			setValue(ReadPreference.nearest());
 		} else {
-			throw new IllegalArgumentException(String.format("Cannot find matching ReadPreference for %s",
-					readPreferenceString));
+			throw new IllegalArgumentException(
+					String.format("Cannot find matching ReadPreference for %s", readPreferenceString));
 		}
 	}
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2013 the original author or authors.
+ * Copyright 2011-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,6 +23,7 @@ import java.util.Set;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
 
@@ -30,10 +31,11 @@ import com.mongodb.ServerAddress;
 
 /**
  * Parse a {@link String} to a {@link ServerAddress} array. The format is host1:port1,host2:port2,host3:port3.
- * 
+ *
  * @author Mark Pollack
  * @author Oliver Gierke
  * @author Thomas Darimont
+ * @author Christoph Strobl
  */
 public class ServerAddressPropertyEditor extends PropertyEditorSupport {
 
@@ -49,7 +51,7 @@ public class ServerAddressPropertyEditor extends PropertyEditorSupport {
 	 * @see java.beans.PropertyEditorSupport#setAsText(java.lang.String)
 	 */
 	@Override
-	public void setAsText(String replicaSetString) {
+	public void setAsText(@Nullable String replicaSetString) {
 
 		if (!StringUtils.hasText(replicaSetString)) {
 			setValue(null);
@@ -78,10 +80,11 @@ public class ServerAddressPropertyEditor extends PropertyEditorSupport {
 
 	/**
 	 * Parses the given source into a {@link ServerAddress}.
-	 * 
+	 *
 	 * @param source
 	 * @return the
 	 */
+	@Nullable
 	private ServerAddress parseServerAddress(String source) {
 
 		if (!StringUtils.hasText(source)) {
@@ -112,7 +115,7 @@ public class ServerAddressPropertyEditor extends PropertyEditorSupport {
 
 	/**
 	 * Extract the host and port from the given {@link String}.
-	 * 
+	 *
 	 * @param addressAndPortSource must not be {@literal null}.
 	 * @return
 	 */

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011 the original author or authors.
+ * Copyright 2011-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,6 +17,9 @@ package org.springframework.data.mongodb.config;
 
 import java.beans.PropertyEditorSupport;
 
+import org.springframework.lang.Nullable;
+import org.springframework.util.StringUtils;
+
 import com.mongodb.WriteConcern;
 
 /**
@@ -26,6 +29,7 @@ import com.mongodb.WriteConcern;
  * string value.
  * 
  * @author Mark Pollack
+ * @author Christoph Strobl
  */
 public class WriteConcernPropertyEditor extends PropertyEditorSupport {
 
@@ -33,7 +37,11 @@ public class WriteConcernPropertyEditor extends PropertyEditorSupport {
 	 * Parse a string to a List<ServerAddress>
 	 */
 	@Override
-	public void setAsText(String writeConcernString) {
+	public void setAsText(@Nullable String writeConcernString) {
+
+		if (!StringUtils.hasText(writeConcernString)) {
+			return;
+		}
 
 		WriteConcern writeConcern = WriteConcern.valueOf(writeConcernString);
 		if (writeConcern != null) {

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

@@ -1,5 +1,6 @@
 /**
  * Spring XML namespace configuration for MongoDB specific repositories.
  */
+@org.springframework.lang.NonNullApi
 package org.springframework.data.mongodb.config;
 

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2016 the original author or authors.
+ * Copyright 2015-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -28,7 +28,7 @@ import com.mongodb.bulk.BulkWriteResult;
  * 2.6 and make use of low level bulk commands on the protocol level. This interface defines a fluent API to add
  * multiple single operations or list of similar operations in sequence which can then eventually be executed by calling
  * {@link #execute()}.
- * 
+ *
  * @author Tobias Trelle
  * @author Oliver Gierke
  * @since 1.9
@@ -49,7 +49,7 @@ public interface BulkOperations {
 
 	/**
 	 * Add a single insert to the bulk operation.
-	 * 
+	 *
 	 * @param documents the document to insert, must not be {@literal null}.
 	 * @return the current {@link BulkOperations} instance with the insert added, will never be {@literal null}.
 	 */
@@ -57,7 +57,7 @@ public interface BulkOperations {
 
 	/**
 	 * Add a list of inserts to the bulk operation.
-	 * 
+	 *
 	 * @param documents List of documents to insert, must not be {@literal null}.
 	 * @return the current {@link BulkOperations} instance with the insert added, will never be {@literal null}.
 	 */
@@ -65,7 +65,7 @@ public interface BulkOperations {
 
 	/**
 	 * Add a single update to the bulk operation. For the update request, only the first matching document is updated.
-	 * 
+	 *
 	 * @param query update criteria, must not be {@literal null}.
 	 * @param update {@link Update} operation to perform, must not be {@literal null}.
 	 * @return the current {@link BulkOperations} instance with the update added, will never be {@literal null}.
@@ -74,7 +74,7 @@ public interface BulkOperations {
 
 	/**
 	 * Add a list of updates to the bulk operation. For each update request, only the first matching document is updated.
-	 * 
+	 *
 	 * @param updates Update operations to perform.
 	 * @return the current {@link BulkOperations} instance with the update added, will never be {@literal null}.
 	 */
@@ -82,7 +82,7 @@ public interface BulkOperations {
 
 	/**
 	 * Add a single update to the bulk operation. For the update request, all matching documents are updated.
-	 * 
+	 *
 	 * @param query Update criteria.
 	 * @param update Update operation to perform.
 	 * @return the current {@link BulkOperations} instance with the update added, will never be {@literal null}.
@@ -91,7 +91,7 @@ public interface BulkOperations {
 
 	/**
 	 * Add a list of updates to the bulk operation. For each update request, all matching documents are updated.
-	 * 
+	 *
 	 * @param updates Update operations to perform.
 	 * @return The bulk operation.
 	 * @return the current {@link BulkOperations} instance with the update added, will never be {@literal null}.
@@ -101,7 +101,7 @@ public interface BulkOperations {
 	/**
 	 * Add a single upsert to the bulk operation. An upsert is an update if the set of matching documents is not empty,
 	 * else an insert.
-	 * 
+	 *
 	 * @param query Update criteria.
 	 * @param update Update operation to perform.
 	 * @return The bulk operation.
@@ -112,7 +112,7 @@ public interface BulkOperations {
 	/**
 	 * Add a list of upserts to the bulk operation. An upsert is an update if the set of matching documents is not empty,
 	 * else an insert.
-	 * 
+	 *
 	 * @param updates Updates/insert operations to perform.
 	 * @return The bulk operation.
 	 * @return the current {@link BulkOperations} instance with the update added, will never be {@literal null}.
@@ -121,7 +121,7 @@ public interface BulkOperations {
 
 	/**
 	 * Add a single remove operation to the bulk operation.
-	 * 
+	 *
 	 * @param remove the {@link Query} to select the documents to be removed, must not be {@literal null}.
 	 * @return the current {@link BulkOperations} instance with the removal added, will never be {@literal null}.
 	 */
@@ -129,7 +129,7 @@ public interface BulkOperations {
 
 	/**
 	 * Add a list of remove operations to the bulk operation.
-	 * 
+	 *
 	 * @param removes the remove operations to perform, must not be {@literal null}.
 	 * @return the current {@link BulkOperations} instance with the removal added, will never be {@literal null}.
 	 */
@@ -137,9 +137,9 @@ public interface BulkOperations {
 
 	/**
 	 * Execute all bulk operations using the default write concern.
-	 * 
+	 *
 	 * @return Result of the bulk operation providing counters for inserts/updates etc.
-	 * @throws {@link BulkOperationException} if an error occurred during bulk processing.
+	 * @throws org.springframework.data.mongodb.BulkOperationException if an error occurred during bulk processing.
 	 */
 	BulkWriteResult execute();
 }

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

@@ -1,44 +1,46 @@
-/*
- * Copyright 2010-2016 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * 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.bson.Document;
-import org.springframework.dao.DataAccessException;
-
-import com.mongodb.MongoException;
-import com.mongodb.client.MongoCollection;
-
-/**
- * Callback interface for executing actions against a {@link MongoCollection}
- *
- * @author Mark Pollak
- * @author Grame Rocher
- * @author Oliver Gierke
- * @author John Brisbin
- * @auhtor Christoph Strobl
- * @since 1.0
- */
-public interface CollectionCallback<T> {
-
-	/**
-	 * @param collection never {@literal null}.
-	 * @return
-	 * @throws MongoException
-	 * @throws DataAccessException
-	 */
-	T doInCollection(MongoCollection<Document> collection) throws MongoException, DataAccessException;
-
-}
+/*
+ * Copyright 2010-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import org.bson.Document;
+import org.springframework.dao.DataAccessException;
+import org.springframework.lang.Nullable;
+
+import com.mongodb.MongoException;
+import com.mongodb.client.MongoCollection;
+
+/**
+ * Callback interface for executing actions against a {@link MongoCollection}.
+ *
+ * @author Mark Pollak
+ * @author Grame Rocher
+ * @author Oliver Gierke
+ * @author John Brisbin
+ * @auhtor Christoph Strobl
+ * @since 1.0
+ */
+public interface CollectionCallback<T> {
+
+	/**
+	 * @param collection never {@literal null}.
+	 * @return can be {@literal null}.
+	 * @throws MongoException
+	 * @throws DataAccessException
+	 */
+	@Nullable
+	T doInCollection(MongoCollection<Document> collection) throws MongoException, DataAccessException;
+
+}

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

@@ -1,70 +1,166 @@
-/*
- * Copyright 2010-2011 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;
-
-/**
- * Provides a simple wrapper to encapsulate the variety of settings you can use when creating a collection.
- * 
- * @author Thomas Risberg
- */
-public class CollectionOptions {
-
-	private Integer maxDocuments;
-
-	private Integer size;
-
-	private Boolean capped;
-
-	/**
-	 * Constructs a new <code>CollectionOptions</code> instance.
-	 * 
-	 * @param size the collection size in bytes, this data space is preallocated
-	 * @param maxDocuments the maximum number of documents in the collection.
-	 * @param capped true to created a "capped" collection (fixed size with auto-FIFO behavior based on insertion order),
-	 *          false otherwise.
-	 */
-	public CollectionOptions(Integer size, Integer maxDocuments, Boolean capped) {
-		super();
-		this.maxDocuments = maxDocuments;
-		this.size = size;
-		this.capped = capped;
-	}
-
-	public Integer getMaxDocuments() {
-		return maxDocuments;
-	}
-
-	public void setMaxDocuments(Integer maxDocuments) {
-		this.maxDocuments = maxDocuments;
-	}
-
-	public Integer getSize() {
-		return size;
-	}
-
-	public void setSize(Integer size) {
-		this.size = size;
-	}
-
-	public Boolean getCapped() {
-		return capped;
-	}
-
-	public void setCapped(Boolean capped) {
-		this.capped = capped;
-	}
-
-}
+/*
+ * Copyright 2010-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import java.util.Optional;
+
+import org.springframework.data.mongodb.core.query.Collation;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+
+/**
+ * Provides a simple wrapper to encapsulate the variety of settings you can use when creating a collection.
+ *
+ * @author Thomas Risberg
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ */
+public class CollectionOptions {
+
+	private @Nullable Long maxDocuments;
+	private @Nullable Long size;
+	private @Nullable Boolean capped;
+	private @Nullable Collation collation;
+
+	/**
+	 * Constructs a new <code>CollectionOptions</code> instance.
+	 *
+	 * @param size the collection size in bytes, this data space is preallocated. Can be {@literal null}.
+	 * @param maxDocuments the maximum number of documents in the collection. Can be {@literal null}.
+	 * @param capped true to created a "capped" collection (fixed size with auto-FIFO behavior based on insertion order),
+	 *          false otherwise. Can be {@literal null}.
+	 * @deprecated since 2.0 please use {@link CollectionOptions#empty()} as entry point.
+	 */
+	@Deprecated
+	public CollectionOptions(@Nullable Long size, @Nullable Long maxDocuments, @Nullable Boolean capped) {
+		this(size, maxDocuments, capped, null);
+	}
+
+	private CollectionOptions(@Nullable Long size, @Nullable Long maxDocuments, @Nullable Boolean capped,
+			@Nullable Collation collation) {
+
+		this.maxDocuments = maxDocuments;
+		this.size = size;
+		this.capped = capped;
+		this.collation = collation;
+	}
+
+	/**
+	 * Create new {@link CollectionOptions} by just providing the {@link Collation} to use.
+	 *
+	 * @param collation must not be {@literal null}.
+	 * @return new {@link CollectionOptions}.
+	 * @since 2.0
+	 */
+	public static CollectionOptions just(Collation collation) {
+
+		Assert.notNull(collation, "Collation must not be null!");
+
+		return new CollectionOptions(null, null, null, collation);
+	}
+
+	/**
+	 * Create new empty {@link CollectionOptions}.
+	 *
+	 * @return new {@link CollectionOptions}.
+	 * @since 2.0
+	 */
+	public static CollectionOptions empty() {
+		return new CollectionOptions(null, null, null, null);
+	}
+
+	/**
+	 * Create new {@link CollectionOptions} with already given settings and capped set to {@literal true}. <br />
+	 * <strong>NOTE</strong> Using capped collections requires defining {@link #size(int)}.
+	 *
+	 * @return new {@link CollectionOptions}.
+	 * @since 2.0
+	 */
+	public CollectionOptions capped() {
+		return new CollectionOptions(size, maxDocuments, true, collation);
+	}
+
+	/**
+	 * Create new {@link CollectionOptions} with already given settings and {@code maxDocuments} set to given value.
+	 *
+	 * @param maxDocuments can be {@literal null}.
+	 * @return new {@link CollectionOptions}.
+	 * @since 2.0
+	 */
+	public CollectionOptions maxDocuments(long maxDocuments) {
+		return new CollectionOptions(size, maxDocuments, capped, collation);
+	}
+
+	/**
+	 * Create new {@link CollectionOptions} with already given settings and {@code size} set to given value.
+	 *
+	 * @param size can be {@literal null}.
+	 * @return new {@link CollectionOptions}.
+	 * @since 2.0
+	 */
+	public CollectionOptions size(long size) {
+		return new CollectionOptions(size, maxDocuments, capped, collation);
+	}
+
+	/**
+	 * Create new {@link CollectionOptions} with already given settings and {@code collation} set to given value.
+	 *
+	 * @param collation can be {@literal null}.
+	 * @return new {@link CollectionOptions}.
+	 * @since 2.0
+	 */
+	public CollectionOptions collation(@Nullable Collation collation) {
+		return new CollectionOptions(size, maxDocuments, capped, collation);
+	}
+
+	/**
+	 * Get the max number of documents the collection should be limited to.
+	 *
+	 * @return {@link Optional#empty()} if not set.
+	 */
+	public Optional<Long> getMaxDocuments() {
+		return Optional.ofNullable(maxDocuments);
+	}
+
+	/**
+	 * Get the {@literal size} in bytes the collection should be limited to.
+	 *
+	 * @return {@link Optional#empty()} if not set.
+	 */
+	public Optional<Long> getSize() {
+		return Optional.ofNullable(size);
+	}
+
+	/**
+	 * Get if the collection should be capped.
+	 *
+	 * @return {@link Optional#empty()} if not set.
+	 * @since 2.0
+	 */
+	public Optional<Boolean> getCapped() {
+		return Optional.ofNullable(capped);
+	}
+
+	/**
+	 * Get the {@link Collation} settings.
+	 *
+	 * @return {@link Optional#empty()} if not set.
+	 * @since 2.0
+	 */
+	public Optional<Collation> getCollation() {
+		return Optional.ofNullable(collation);
+	}
+}

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

@@ -1,30 +1,44 @@
-/*
- * Copyright 2010-2016 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * 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.dao.DataAccessException;
-
-import com.mongodb.MongoException;
-import com.mongodb.client.MongoDatabase;
-
-/**
- *
- * @param <T>
- */
-public interface DbCallback<T> {
-
-	T doInDB(MongoDatabase db) throws MongoException, DataAccessException;
-}
+/*
+ * Copyright 2010-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import org.springframework.dao.DataAccessException;
+import org.springframework.lang.Nullable;
+
+import com.mongodb.MongoException;
+import com.mongodb.client.MongoDatabase;
+
+/**
+ * Callback interface for executing actions against a {@link MongoDatabase}.
+ *
+ * @author Mark Pollak
+ * @author Graeme Rocher
+ * @author Thomas Risberg
+ * @author Oliver Gierke
+ * @author John Brisbin
+ * @author Christoph Strobl
+ */
+public interface DbCallback<T> {
+
+	/**
+	 * @param db must not be {@literal null}.
+	 * @return can be {@literal null}.
+	 * @throws MongoException
+	 * @throws DataAccessException
+	 */
+	@Nullable
+	T doInDB(MongoDatabase db) throws MongoException, DataAccessException;
+}

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

@@ -1,66 +0,0 @@
-package org.springframework.data.mongodb.core;
-
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-import com.mongodb.DB;
-import org.springframework.transaction.support.ResourceHolderSupport;
-import org.springframework.util.Assert;
-
-class DbHolder extends ResourceHolderSupport {
-	private static final Object DEFAULT_KEY = new Object();
-
-	private final Map<Object, DB> dbMap = new ConcurrentHashMap<Object, DB>();
-
-	public DbHolder(DB db) {
-		addDB(db);
-	}
-
-	public DbHolder(Object key, DB db) {
-		addDB(key, db);
-	}
-
-	public DB getDB() {
-		return getDB(DEFAULT_KEY);
-	}
-
-	public DB getDB(Object key) {
-		return this.dbMap.get(key);
-	}
-
-	public DB getAnyDB() {
-		if (!this.dbMap.isEmpty()) {
-			return this.dbMap.values().iterator().next();
-		}
-		return null;
-	}
-
-	public void addDB(DB session) {
-		addDB(DEFAULT_KEY, session);
-	}
-
-	public void addDB(Object key, DB session) {
-		Assert.notNull(key, "Key must not be null");
-		Assert.notNull(session, "DB must not be null");
-		this.dbMap.put(key, session);
-	}
-
-	public DB removeDB(Object key) {
-		return this.dbMap.remove(key);
-	}
-
-	public boolean containsDB(DB session) {
-		return this.dbMap.containsValue(session);
-	}
-
-	public boolean isEmpty() {
-		return this.dbMap.isEmpty();
-	}
-
-	public boolean doesNotHoldNonDefaultDB() {
-		synchronized (this.dbMap) {
-			return this.dbMap.isEmpty() || (this.dbMap.size() == 1 && this.dbMap.containsKey(DEFAULT_KEY));
-		}
-	}
-
-}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2016 the original author or authors.
+ * Copyright 2015-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,16 +15,27 @@
  */
 package org.springframework.data.mongodb.core;
 
+import lombok.NonNull;
+import lombok.Value;
+
 import java.util.ArrayList;
-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.bson.conversions.Bson;
 import org.springframework.dao.DataAccessException;
 import org.springframework.dao.support.PersistenceExceptionTranslator;
+import org.springframework.data.mongodb.core.convert.QueryMapper;
+import org.springframework.data.mongodb.core.convert.UpdateMapper;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
+import org.springframework.data.mongodb.core.query.Collation;
 import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.data.mongodb.core.query.Update;
 import org.springframework.data.util.Pair;
+import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 import com.mongodb.BulkWriteException;
@@ -32,6 +43,8 @@ import com.mongodb.WriteConcern;
 import com.mongodb.client.MongoCollection;
 import com.mongodb.client.model.BulkWriteOptions;
 import com.mongodb.client.model.DeleteManyModel;
+import com.mongodb.client.model.DeleteOneModel;
+import com.mongodb.client.model.DeleteOptions;
 import com.mongodb.client.model.InsertOneModel;
 import com.mongodb.client.model.UpdateManyModel;
 import com.mongodb.client.model.UpdateOneModel;
@@ -40,77 +53,63 @@ import com.mongodb.client.model.WriteModel;
 
 /**
  * Default implementation for {@link BulkOperations}.
- * 
+ *
  * @author Tobias Trelle
  * @author Oliver Gierke
  * @author Christoph Strobl
+ * @author Mark Paluch
  * @since 1.9
  */
 class DefaultBulkOperations implements BulkOperations {
 
 	private final MongoOperations mongoOperations;
-	private final BulkMode bulkMode;
 	private final String collectionName;
+	private final BulkOperationContext bulkOperationContext;
+	private final List<WriteModel<Document>> models = new ArrayList<>();
 
 	private PersistenceExceptionTranslator exceptionTranslator;
-	private WriteConcernResolver writeConcernResolver;
-	private WriteConcern defaultWriteConcern;
+	private @Nullable WriteConcern defaultWriteConcern;
 
 	private BulkWriteOptions bulkOptions;
 
-	List<WriteModel<Document>> models = new ArrayList<WriteModel<Document>>();
-
 	/**
-	 * Creates a new {@link DefaultBulkOperations} for the given {@link MongoOperations}, {@link BulkMode}, collection
-	 * name and {@link WriteConcern}.
-	 * 
-	 * @param mongoOperations The underlying {@link MongoOperations}, must not be {@literal null}.
-	 * @param bulkMode must not be {@literal null}.
-	 * @param collectionName Name of the collection to work on, must not be {@literal null} or empty.
-	 * @param entityType the entity type, can be {@literal null}.
+	 * Creates a new {@link DefaultBulkOperations} for the given {@link MongoOperations}, collection name and
+	 * {@link BulkOperationContext}.
+	 *
+	 * @param mongoOperations must not be {@literal null}.
+	 * @param collectionName must not be {@literal null}.
+	 * @param bulkOperationContext must not be {@literal null}.
+	 * @since 2.0
 	 */
-	DefaultBulkOperations(MongoOperations mongoOperations, BulkMode bulkMode, String collectionName,
-			Class<?> entityType) {
+	DefaultBulkOperations(MongoOperations mongoOperations, String collectionName,
+			BulkOperationContext bulkOperationContext) {
 
 		Assert.notNull(mongoOperations, "MongoOperations must not be null!");
-		Assert.notNull(bulkMode, "BulkMode must not be null!");
-		Assert.hasText(collectionName, "Collection name must not be null or empty!");
+		Assert.hasText(collectionName, "CollectionName must not be null nor empty!");
+		Assert.notNull(bulkOperationContext, "BulkOperationContext must not be null!");
 
 		this.mongoOperations = mongoOperations;
-		this.bulkMode = bulkMode;
 		this.collectionName = collectionName;
-
+		this.bulkOperationContext = bulkOperationContext;
 		this.exceptionTranslator = new MongoExceptionTranslator();
-		this.writeConcernResolver = DefaultWriteConcernResolver.INSTANCE;
-
-		this.bulkOptions = initBulkOperation();
+		this.bulkOptions = getBulkWriteOptions(bulkOperationContext.getBulkMode());
 	}
 
 	/**
 	 * Configures the {@link PersistenceExceptionTranslator} to be used. Defaults to {@link MongoExceptionTranslator}.
-	 * 
+	 *
 	 * @param exceptionTranslator can be {@literal null}.
 	 */
-	public void setExceptionTranslator(PersistenceExceptionTranslator exceptionTranslator) {
+	public void setExceptionTranslator(@Nullable PersistenceExceptionTranslator exceptionTranslator) {
 		this.exceptionTranslator = exceptionTranslator == null ? new MongoExceptionTranslator() : exceptionTranslator;
 	}
 
-	/**
-	 * Configures the {@link WriteConcernResolver} to be used. Defaults to {@link DefaultWriteConcernResolver}.
-	 * 
-	 * @param writeConcernResolver can be {@literal null}.
-	 */
-	public void setWriteConcernResolver(WriteConcernResolver writeConcernResolver) {
-		this.writeConcernResolver = writeConcernResolver == null ? DefaultWriteConcernResolver.INSTANCE
-				: writeConcernResolver;
-	}
-
 	/**
 	 * Configures the default {@link WriteConcern} to be used. Defaults to {@literal null}.
-	 * 
+	 *
 	 * @param defaultWriteConcern can be {@literal null}.
 	 */
-	public void setDefaultWriteConcern(WriteConcern defaultWriteConcern) {
+	void setDefaultWriteConcern(@Nullable WriteConcern defaultWriteConcern) {
 		this.defaultWriteConcern = defaultWriteConcern;
 	}
 
@@ -133,6 +132,7 @@ class DefaultBulkOperations implements BulkOperations {
 		mongoOperations.getConverter().write(document, sink);
 
 		models.add(new InsertOneModel<>(sink));
+
 		return this;
 	}
 
@@ -145,9 +145,7 @@ class DefaultBulkOperations implements BulkOperations {
 
 		Assert.notNull(documents, "Documents must not be null!");
 
-		for (Object document : documents) {
-			insert(document);
-		}
+		documents.forEach(this::insert);
 
 		return this;
 	}
@@ -163,7 +161,7 @@ class DefaultBulkOperations implements BulkOperations {
 		Assert.notNull(query, "Query must not be null!");
 		Assert.notNull(update, "Update must not be null!");
 
-		return updateOne(Arrays.asList(Pair.of(query, update)));
+		return updateOne(Collections.singletonList(Pair.of(query, update)));
 	}
 
 	/*
@@ -193,7 +191,7 @@ class DefaultBulkOperations implements BulkOperations {
 		Assert.notNull(query, "Query must not be null!");
 		Assert.notNull(update, "Update must not be null!");
 
-		return updateMulti(Arrays.asList(Pair.of(query, update)));
+		return updateMulti(Collections.singletonList(Pair.of(query, update)));
 	}
 
 	/*
@@ -244,7 +242,11 @@ class DefaultBulkOperations implements BulkOperations {
 
 		Assert.notNull(query, "Query must not be null!");
 
-		models.add(new DeleteManyModel<Document>(query.getQueryObject()));
+		DeleteOptions deleteOptions = new DeleteOptions();
+		query.getCollation().map(Collation::toMongoCollation).ifPresent(deleteOptions::collation);
+
+		models.add(new DeleteManyModel<>(query.getQueryObject(), deleteOptions));
+
 		return this;
 	}
 
@@ -278,7 +280,7 @@ class DefaultBulkOperations implements BulkOperations {
 				collection = collection.withWriteConcern(defaultWriteConcern);
 			}
 
-			return collection.bulkWrite(models, bulkOptions);
+			return collection.bulkWrite(models.stream().map(this::mapWriteModel).collect(Collectors.toList()), bulkOptions);
 
 		} catch (BulkWriteException o_O) {
 
@@ -286,13 +288,13 @@ class DefaultBulkOperations implements BulkOperations {
 			throw toThrow == null ? o_O : toThrow;
 
 		} finally {
-			this.bulkOptions = initBulkOperation();
+			this.bulkOptions = getBulkWriteOptions(bulkOperationContext.getBulkMode());
 		}
 	}
 
 	/**
 	 * Performs update and upsert bulk operations.
-	 * 
+	 *
 	 * @param query the {@link Query} to determine documents to update.
 	 * @param update the {@link Update} to perform, must not be {@literal null}.
 	 * @param upsert whether to upsert.
@@ -306,24 +308,88 @@ class DefaultBulkOperations implements BulkOperations {
 
 		UpdateOptions options = new UpdateOptions();
 		options.upsert(upsert);
+		query.getCollation().map(Collation::toMongoCollation).ifPresent(options::collation);
 
 		if (multi) {
-			models.add(new UpdateManyModel<Document>(query.getQueryObject(), update.getUpdateObject(), options));
+			models.add(new UpdateManyModel<>(query.getQueryObject(), update.getUpdateObject(), options));
 		} else {
-			models.add(new UpdateOneModel<Document>(query.getQueryObject(), update.getUpdateObject(), options));
+			models.add(new UpdateOneModel<>(query.getQueryObject(), update.getUpdateObject(), options));
 		}
+
 		return this;
 	}
 
-	private final BulkWriteOptions initBulkOperation() {
+	private WriteModel<Document> mapWriteModel(WriteModel<Document> writeModel) {
+
+		if (writeModel instanceof UpdateOneModel) {
+
+			UpdateOneModel<Document> model = (UpdateOneModel<Document>) writeModel;
+
+			return new UpdateOneModel<>(getMappedQuery(model.getFilter()), getMappedUpdate(model.getUpdate()),
+					model.getOptions());
+		}
+
+		if (writeModel instanceof UpdateManyModel) {
+
+			UpdateManyModel<Document> model = (UpdateManyModel<Document>) writeModel;
+
+			return new UpdateManyModel<>(getMappedQuery(model.getFilter()), getMappedUpdate(model.getUpdate()),
+					model.getOptions());
+		}
+
+		if (writeModel instanceof DeleteOneModel) {
+
+			DeleteOneModel<Document> model = (DeleteOneModel<Document>) writeModel;
+
+			return new DeleteOneModel<>(getMappedQuery(model.getFilter()), model.getOptions());
+		}
+
+		if (writeModel instanceof DeleteManyModel) {
+
+			DeleteManyModel<Document> model = (DeleteManyModel<Document>) writeModel;
+
+			return new DeleteManyModel<>(getMappedQuery(model.getFilter()), model.getOptions());
+		}
+
+		return writeModel;
+	}
+
+	private Bson getMappedUpdate(Bson update) {
+		return bulkOperationContext.getUpdateMapper().getMappedObject(update, bulkOperationContext.getEntity());
+	}
+
+	private Bson getMappedQuery(Bson query) {
+		return bulkOperationContext.getQueryMapper().getMappedObject(query, bulkOperationContext.getEntity());
+	}
+
+	private static BulkWriteOptions getBulkWriteOptions(BulkMode bulkMode) {
 
 		BulkWriteOptions options = new BulkWriteOptions();
+
 		switch (bulkMode) {
 			case ORDERED:
 				return options.ordered(true);
 			case UNORDERED:
 				return options.ordered(false);
 		}
+
 		throw new IllegalStateException("BulkMode was null!");
 	}
+
+	/**
+	 * {@link BulkOperationContext} holds information about
+	 * {@link org.springframework.data.mongodb.core.BulkOperations.BulkMode} the entity in use as well as references to
+	 * {@link QueryMapper} and {@link UpdateMapper}.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	@Value
+	static class BulkOperationContext {
+
+		@NonNull BulkMode bulkMode;
+		@NonNull Optional<? extends MongoPersistentEntity<?>> entity;
+		@NonNull QueryMapper queryMapper;
+		@NonNull UpdateMapper updateMapper;
+	}
 }

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

@@ -23,11 +23,13 @@ import java.util.List;
 
 import org.bson.Document;
 import org.springframework.dao.DataAccessException;
-import org.springframework.data.mongodb.core.convert.QueryMapper;
 import org.springframework.data.mongodb.MongoDbFactory;
+import org.springframework.data.mongodb.core.convert.QueryMapper;
 import org.springframework.data.mongodb.core.index.IndexDefinition;
 import org.springframework.data.mongodb.core.index.IndexInfo;
+import org.springframework.data.mongodb.core.index.IndexOperations;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
+import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 import com.mongodb.MongoException;
@@ -37,7 +39,7 @@ import com.mongodb.client.model.IndexOptions;
 
 /**
  * Default implementation of {@link IndexOperations}.
- * 
+ *
  * @author Mark Pollack
  * @author Oliver Gierke
  * @author Komi Innocent
@@ -51,17 +53,16 @@ public class DefaultIndexOperations implements IndexOperations {
 	private final MongoDbFactory mongoDbFactory;
 	private final String collectionName;
 	private final QueryMapper mapper;
-	private final Class<?> type;
+	private final @Nullable Class<?> type;
 
 	/**
 	 * 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}.
 	 */
 	public DefaultIndexOperations(MongoDbFactory mongoDbFactory, String collectionName, QueryMapper queryMapper) {
-
 		this(mongoDbFactory, collectionName, queryMapper, null);
 	}
 
@@ -75,7 +76,7 @@ public class DefaultIndexOperations implements IndexOperations {
 	 * @since 1.10
 	 */
 	public DefaultIndexOperations(MongoDbFactory mongoDbFactory, String collectionName, QueryMapper queryMapper,
-			Class<?> type) {
+			@Nullable Class<?> type) {
 
 		Assert.notNull(mongoDbFactory, "MongoDbFactory must not be null!");
 		Assert.notNull(collectionName, "Collection name can not be null!");
@@ -89,7 +90,7 @@ public class DefaultIndexOperations implements IndexOperations {
 
 	/*
 	 * (non-Javadoc)
-	 * @see org.springframework.data.mongodb.core.IndexOperations#ensureIndex(org.springframework.data.mongodb.core.index.IndexDefinition)
+	 * @see org.springframework.data.mongodb.core.index.IndexOperations#ensureIndex(org.springframework.data.mongodb.core.index.IndexDefinition)
 	 */
 	public String ensureIndex(final IndexDefinition indexDefinition) {
 
@@ -97,27 +98,22 @@ public class DefaultIndexOperations implements IndexOperations {
 
 			Document indexOptions = indexDefinition.getIndexOptions();
 
-			if (indexOptions != null) {
+			IndexOptions ops = IndexConverters.indexDefinitionToIndexOptionsConverter().convert(indexDefinition);
 
-				IndexOptions ops = IndexConverters.indexDefinitionToIndexOptionsConverter().convert(indexDefinition);
+			if (indexOptions.containsKey(PARTIAL_FILTER_EXPRESSION_KEY)) {
 
-				if (indexOptions.containsKey(PARTIAL_FILTER_EXPRESSION_KEY)) {
+				Assert.isInstanceOf(Document.class, indexOptions.get(PARTIAL_FILTER_EXPRESSION_KEY));
 
-					Assert.isInstanceOf(Document.class, indexOptions.get(PARTIAL_FILTER_EXPRESSION_KEY));
-
-					ops.partialFilterExpression( mapper.getMappedObject(
-							(Document) indexOptions.get(PARTIAL_FILTER_EXPRESSION_KEY), lookupPersistentEntity(type, collectionName)));
-				}
-
-				return collection.createIndex(indexDefinition.getIndexKeys(), ops);
+				ops.partialFilterExpression(mapper.getMappedObject((Document) indexOptions.get(PARTIAL_FILTER_EXPRESSION_KEY),
+						lookupPersistentEntity(type, collectionName)));
 			}
-			return collection.createIndex(indexDefinition.getIndexKeys());
-		}
 
-		);
+			return collection.createIndex(indexDefinition.getIndexKeys(), ops);
+		});
 	}
 
-	private MongoPersistentEntity<?> lookupPersistentEntity(Class<?> entityType, String collection) {
+	@Nullable
+	private MongoPersistentEntity<?> lookupPersistentEntity(@Nullable Class<?> entityType, String collection) {
 
 		if (entityType != null) {
 			return mapper.getMappingContext().getRequiredPersistentEntity(entityType);
@@ -136,7 +132,7 @@ public class DefaultIndexOperations implements IndexOperations {
 
 	/*
 	 * (non-Javadoc)
-	 * @see org.springframework.data.mongodb.core.IndexOperations#dropIndex(java.lang.String)
+	 * @see org.springframework.data.mongodb.core.index.IndexOperations#dropIndex(java.lang.String)
 	 */
 	public void dropIndex(final String name) {
 
@@ -149,7 +145,7 @@ public class DefaultIndexOperations implements IndexOperations {
 
 	/*
 	 * (non-Javadoc)
-	 * @see org.springframework.data.mongodb.core.IndexOperations#dropAllIndexes()
+	 * @see org.springframework.data.mongodb.core.index.IndexOperations#dropAllIndexes()
 	 */
 	public void dropAllIndexes() {
 		dropIndex("*");
@@ -157,7 +153,7 @@ public class DefaultIndexOperations implements IndexOperations {
 
 	/*
 	 * (non-Javadoc)
-	 * @see org.springframework.data.mongodb.core.IndexOperations#getIndexInfo()
+	 * @see org.springframework.data.mongodb.core.index.IndexOperations#getIndexInfo()
 	 */
 	public List<IndexInfo> getIndexInfo() {
 
@@ -186,6 +182,7 @@ public class DefaultIndexOperations implements IndexOperations {
 		});
 	}
 
+	@Nullable
 	public <T> T execute(CollectionCallback<T> callback) {
 
 		Assert.notNull(callback, "CollectionCallback must not be null!");

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016 the original author or authors.
+ * Copyright 2016-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,12 +17,14 @@ package org.springframework.data.mongodb.core;
 
 import org.springframework.data.mongodb.MongoDbFactory;
 import org.springframework.data.mongodb.core.convert.QueryMapper;
+import org.springframework.data.mongodb.core.index.IndexOperations;
+import org.springframework.data.mongodb.core.index.IndexOperationsProvider;
 
 /**
- * {@link IndexOperationsProvider} to obtain {@link IndexOperations} from a given {@link MongoDbFactory}. TODO: Review
- * me
+ * {@link IndexOperationsProvider} to obtain {@link IndexOperations} from a given {@link MongoDbFactory}.
  *
  * @author Mark Paluch
+ * @author Christoph Strobl
  * @since 2.0
  */
 class DefaultIndexOperationsProvider implements IndexOperationsProvider {
@@ -32,13 +34,17 @@ class DefaultIndexOperationsProvider implements IndexOperationsProvider {
 
 	/**
 	 * @param mongoDbFactory must not be {@literal null}.
+	 * @param mapper must not be {@literal null}.
 	 */
 	DefaultIndexOperationsProvider(MongoDbFactory mongoDbFactory, QueryMapper mapper) {
-		this.mongoDbFactory = mongoDbFactory; this.mapper = mapper;
+
+		this.mongoDbFactory = mongoDbFactory;
+		this.mapper = mapper;
 	}
 
-	/* (non-Javadoc)
-	 * @see org.springframework.data.mongodb.core.IndexOperationsProvider#reactiveIndexOps(java.lang.String)
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.index.IndexOperationsProvider#reactiveIndexOps(java.lang.String)
 	 */
 	@Override
 	public IndexOperations indexOps(String collectionName) {

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016 the original author or authors.
+ * Copyright 2016-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,88 +15,137 @@
  */
 package org.springframework.data.mongodb.core;
 
-import org.bson.Document;
-import org.springframework.data.mongodb.core.index.IndexDefinition;
-import org.springframework.data.mongodb.core.index.IndexInfo;
-import org.springframework.util.Assert;
-
-import com.mongodb.reactivestreams.client.ListIndexesPublisher;
-
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
+import java.util.Collection;
+import java.util.Optional;
+
+import org.bson.Document;
+import org.springframework.data.mongodb.core.convert.QueryMapper;
+import org.springframework.data.mongodb.core.index.IndexDefinition;
+import org.springframework.data.mongodb.core.index.IndexInfo;
+import org.springframework.data.mongodb.core.index.ReactiveIndexOperations;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+
+import com.mongodb.client.model.IndexOptions;
+
 /**
- * Default implementation of {@link IndexOperations}.
+ * Default implementation of {@link ReactiveIndexOperations}.
  *
  * @author Mark Paluch
- * @since 1.11
+ * @author Christoph Strobl
+ * @since 2.0
  */
 public class DefaultReactiveIndexOperations implements ReactiveIndexOperations {
 
+	private static final String PARTIAL_FILTER_EXPRESSION_KEY = "partialFilterExpression";
+
 	private final ReactiveMongoOperations mongoOperations;
 	private final String collectionName;
+	private final QueryMapper queryMapper;
+	private final Optional<Class<?>> type;
 
 	/**
 	 * Creates a new {@link DefaultReactiveIndexOperations}.
 	 *
 	 * @param mongoOperations must not be {@literal null}.
 	 * @param collectionName must not be {@literal null}.
+	 * @param queryMapper must not be {@literal null}.
 	 */
-	public DefaultReactiveIndexOperations(ReactiveMongoOperations mongoOperations, String collectionName) {
+	public DefaultReactiveIndexOperations(ReactiveMongoOperations mongoOperations, String collectionName,
+			QueryMapper queryMapper) {
+		this(mongoOperations, collectionName, queryMapper, Optional.empty());
+	}
+
+	/**
+	 * Creates a new {@link DefaultReactiveIndexOperations}.
+	 *
+	 * @param mongoOperations must not be {@literal null}.
+	 * @param collectionName must not be {@literal null}.
+	 * @param queryMapper must not be {@literal null}.
+	 * @param type used for mapping potential partial index filter expression, must not be {@literal null}.
+	 */
+	public DefaultReactiveIndexOperations(ReactiveMongoOperations mongoOperations, String collectionName,
+			QueryMapper queryMapper, Class<?> type) {
+		this(mongoOperations, collectionName, queryMapper, Optional.of(type));
+	}
+
+	private DefaultReactiveIndexOperations(ReactiveMongoOperations mongoOperations, String collectionName,
+			QueryMapper queryMapper, Optional<Class<?>> type) {
 
 		Assert.notNull(mongoOperations, "ReactiveMongoOperations must not be null!");
 		Assert.notNull(collectionName, "Collection must not be null!");
+		Assert.notNull(queryMapper, "QueryMapper must not be null!");
 
 		this.mongoOperations = mongoOperations;
 		this.collectionName = collectionName;
+		this.queryMapper = queryMapper;
+		this.type = type;
 	}
 
-	/* (non-Javadoc)
-	 * @see org.springframework.data.mongodb.core.ReactiveIndexOperations#ensureIndex(org.springframework.data.mongodb.core.index.IndexDefinition)
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.index.ReactiveIndexOperations#ensureIndex(org.springframework.data.mongodb.core.index.IndexDefinition)
 	 */
 	public Mono<String> ensureIndex(final IndexDefinition indexDefinition) {
 
-		return mongoOperations.execute(collectionName, (ReactiveCollectionCallback<String>) collection -> {
+		return mongoOperations.execute(collectionName, collection -> {
 
 			Document indexOptions = indexDefinition.getIndexOptions();
 
-			if (indexOptions != null) {
-				return collection.createIndex(indexDefinition.getIndexKeys(),
-						IndexConverters.indexDefinitionToIndexOptionsConverter().convert(indexDefinition));
+			IndexOptions ops = IndexConverters.indexDefinitionToIndexOptionsConverter().convert(indexDefinition);
+
+			if (indexOptions.containsKey(PARTIAL_FILTER_EXPRESSION_KEY)) {
+
+				Assert.isInstanceOf(Document.class, indexOptions.get(PARTIAL_FILTER_EXPRESSION_KEY));
+
+				MongoPersistentEntity<?> entity = type
+						.map(val -> (MongoPersistentEntity) queryMapper.getMappingContext().getRequiredPersistentEntity(val))
+						.orElseGet(() -> lookupPersistentEntity(collectionName));
+
+				ops = ops.partialFilterExpression(
+						queryMapper.getMappedObject(indexOptions.get(PARTIAL_FILTER_EXPRESSION_KEY, Document.class), entity));
 			}
 
-			return collection.createIndex(indexDefinition.getIndexKeys());
+			return collection.createIndex(indexDefinition.getIndexKeys(), ops);
+
 		}).next();
 	}
 
-	/* (non-Javadoc)
-	 * @see org.springframework.data.mongodb.core.ReactiveIndexOperations#dropIndex(java.lang.String)
-	 */
-	public Mono<Void> dropIndex(final String name) {
+	@Nullable
+	private MongoPersistentEntity<?> lookupPersistentEntity(String collection) {
 
-		return mongoOperations.execute(collectionName, collection -> {
+		Collection<? extends MongoPersistentEntity<?>> entities = queryMapper.getMappingContext().getPersistentEntities();
 
-			return Mono.from(collection.dropIndex(name));
-		}).flatMap(success -> Mono.<Void>empty()).next();
+		return entities.stream() //
+				.filter(entity -> entity.getCollection().equals(collection)) //
+				.findFirst() //
+				.orElse(null);
 	}
 
 	/* (non-Javadoc)
-	 * @see org.springframework.data.mongodb.core.ReactiveIndexOperations#dropAllIndexes()
+	 * @see org.springframework.data.mongodb.core.index.ReactiveIndexOperations#dropIndex(java.lang.String)
+	 */
+	public Mono<Void> dropIndex(final String name) {
+		return mongoOperations.execute(collectionName, collection -> collection.dropIndex(name)).then();
+	}
+
+	/* (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.index.ReactiveIndexOperations#dropAllIndexes()
 	 */
 	public Mono<Void> dropAllIndexes() {
 		return dropIndex("*");
 	}
 
 	/* (non-Javadoc)
-	 * @see org.springframework.data.mongodb.core.ReactiveIndexOperations#getIndexInfo()
+	 * @see org.springframework.data.mongodb.core.index.ReactiveIndexOperations#getIndexInfo()
 	 */
 	public Flux<IndexInfo> getIndexInfo() {
 
-		return mongoOperations.execute(collectionName, collection -> {
-
-			ListIndexesPublisher<Document> indexesPublisher = collection.listIndexes(Document.class);
-
-			return Flux.from(indexesPublisher).map(IndexConverters.documentToIndexInfoConverter()::convert);
-		});
+		return mongoOperations.execute(collectionName, collection -> collection.listIndexes(Document.class)) //
+				.map(IndexConverters.documentToIndexInfoConverter()::convert);
 	}
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2016 the original author or authors.
+ * Copyright 2014-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -31,6 +31,7 @@ import org.bson.types.ObjectId;
 import org.springframework.dao.DataAccessException;
 import org.springframework.data.mongodb.core.script.ExecutableMongoScript;
 import org.springframework.data.mongodb.core.script.NamedMongoScript;
+import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.CollectionUtils;
 import org.springframework.util.ObjectUtils;
@@ -56,7 +57,7 @@ class DefaultScriptOperations implements ScriptOperations {
 
 	/**
 	 * Creates new {@link DefaultScriptOperations} using given {@link MongoOperations}.
-	 * 
+	 *
 	 * @param mongoOperations must not be {@literal null}.
 	 */
 	public DefaultScriptOperations(MongoOperations mongoOperations) {

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

@@ -0,0 +1,122 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import org.springframework.data.mongodb.core.aggregation.Aggregation;
+import org.springframework.data.mongodb.core.aggregation.AggregationResults;
+import org.springframework.data.util.CloseableIterator;
+
+/**
+ * {@link ExecutableAggregationOperation} allows creation and execution of MongoDB aggregation operations in a fluent
+ * API style. <br />
+ * The starting {@literal domainType} is used for mapping the {@link Aggregation} provided via {@code by} into the
+ * MongoDB specific representation, as well as mapping back the resulting {@link org.bson.Document}. An alternative
+ * input type for mapping the {@link Aggregation} can be provided by using
+ * {@link org.springframework.data.mongodb.core.aggregation.TypedAggregation}.
+ *
+ * <pre>
+ *     <code>
+ *         aggregateAndReturn(Jedi.class)
+ *             .by(newAggregation(Human.class, project("These are not the droids you are looking for")))
+ *             .all();
+ *     </code>
+ * </pre>
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @since 2.0
+ */
+public interface ExecutableAggregationOperation {
+
+	/**
+	 * Start creating an aggregation operation that returns results mapped to the given domain type. <br />
+	 * Use {@link org.springframework.data.mongodb.core.aggregation.TypedAggregation} to specify a potentially different
+	 * input type for he aggregation.
+	 *
+	 * @param domainType must not be {@literal null}.
+	 * @return new instance of {@link ExecutableAggregation}.
+	 * @throws IllegalArgumentException if domainType is {@literal null}.
+	 */
+	<T> ExecutableAggregation<T> aggregateAndReturn(Class<T> domainType);
+
+	/**
+	 * Collection override (Optional).
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface AggregationWithCollection<T> {
+
+		/**
+		 * Explicitly set the name of the collection to perform the query 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 AggregationWithAggregation}.
+		 * @throws IllegalArgumentException if collection is {@literal null}.
+		 */
+		AggregationWithAggregation<T> inCollection(String collection);
+	}
+
+	/**
+	 * Trigger execution by calling one of the terminating methods.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface TerminatingAggregation<T> {
+
+		/**
+		 * Apply pipeline operations as specified and get all matching elements.
+		 *
+		 * @return never {@literal null}.
+		 */
+		AggregationResults<T> all();
+
+		/**
+		 * Apply pipeline operations as specified and stream all matching elements. <br />
+		 * Returns a {@link CloseableIterator} that wraps the a Mongo DB {@link com.mongodb.Cursor}
+		 *
+		 * @return a {@link CloseableIterator} that wraps the a Mongo DB {@link com.mongodb.Cursor} that needs to be closed.
+		 *         Never {@literal null}.
+		 */
+		CloseableIterator<T> stream();
+	}
+
+	/**
+	 * Define the aggregation with pipeline stages.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface AggregationWithAggregation<T> {
+
+		/**
+		 * Set the aggregation to be used.
+		 *
+		 * @param aggregation must not be {@literal null}.
+		 * @return new instance of {@link TerminatingAggregation}.
+		 * @throws IllegalArgumentException if aggregation is {@literal null}.
+		 */
+		TerminatingAggregation<T> by(Aggregation aggregation);
+	}
+
+	/**
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface ExecutableAggregation<T> extends AggregationWithCollection<T>, AggregationWithAggregation<T> {}
+}

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

@@ -0,0 +1,141 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import lombok.AccessLevel;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+
+import org.springframework.data.mongodb.core.aggregation.Aggregation;
+import org.springframework.data.mongodb.core.aggregation.AggregationResults;
+import org.springframework.data.mongodb.core.aggregation.TypedAggregation;
+import org.springframework.data.util.CloseableIterator;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
+
+/**
+ * Implementation of {@link ExecutableAggregationOperation} operating directly on {@link MongoTemplate}.
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @since 2.0
+ */
+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;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ExecutableAggregationOperation#aggregateAndReturn(java.lang.Class)
+	 */
+	@Override
+	public <T> ExecutableAggregation<T> aggregateAndReturn(Class<T> domainType) {
+
+		Assert.notNull(domainType, "DomainType must not be null!");
+
+		return new ExecutableAggregationSupport<>(template, domainType, null, null);
+	}
+
+	/**
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	@RequiredArgsConstructor
+	@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
+	static class ExecutableAggregationSupport<T>
+			implements AggregationWithAggregation<T>, ExecutableAggregation<T>, TerminatingAggregation<T> {
+
+		@NonNull MongoTemplate template;
+		@NonNull Class<T> domainType;
+		@Nullable Aggregation aggregation;
+		@Nullable String collection;
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableAggregationOperation.AggregationWithCollection#inCollection(java.lang.String)
+		 */
+		@Override
+		public AggregationWithAggregation<T> inCollection(String collection) {
+
+			Assert.hasText(collection, "Collection must not be null nor empty!");
+
+			return new ExecutableAggregationSupport<>(template, domainType, aggregation, collection);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableAggregationOperation.AggregationWithAggregation#by(org.springframework.data.mongodb.core.aggregation.Aggregation)
+		 */
+		@Override
+		public TerminatingAggregation<T> by(Aggregation aggregation) {
+
+			Assert.notNull(aggregation, "Aggregation must not be null!");
+
+			return new ExecutableAggregationSupport<>(template, domainType, aggregation, collection);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableAggregationOperation.TerminatingAggregation#all()
+		 */
+		@Override
+		public AggregationResults<T> all() {
+			return template.aggregate(aggregation, getCollectionName(aggregation), domainType);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableAggregationOperation.TerminatingAggregation#stream()
+		 */
+		@Override
+		public CloseableIterator<T> stream() {
+			return template.aggregateStream(aggregation, getCollectionName(aggregation), domainType);
+		}
+
+		private String getCollectionName(Aggregation aggregation) {
+
+			if (StringUtils.hasText(collection)) {
+				return collection;
+			}
+
+			if (aggregation instanceof TypedAggregation) {
+
+				TypedAggregation<?> typedAggregation = (TypedAggregation<?>) aggregation;
+
+				if (typedAggregation.getInputType() != null) {
+					return template.determineCollectionName(typedAggregation.getInputType());
+				}
+			}
+
+			return template.determineCollectionName(domainType);
+		}
+	}
+}

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

@@ -0,0 +1,226 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import org.springframework.data.geo.GeoResults;
+import org.springframework.data.mongodb.core.query.NearQuery;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.lang.Nullable;
+
+/**
+ * {@link ExecutableFindOperation} allows creation and execution of MongoDB find operations in a fluent API style.
+ * <br />
+ * The starting {@literal domainType} is used for mapping the {@link Query} provided via {@code matching} into the
+ * MongoDB specific representation. By default, the originating {@literal domainType} is also used for mapping back the
+ * result 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>
+ *         query(Human.class)
+ *             .inCollection("star-wars")
+ *             .as(Jedi.class)
+ *             .matching(query(where("firstname").is("luke")))
+ *             .all();
+ *     </code>
+ * </pre>
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @since 2.0
+ */
+public interface ExecutableFindOperation {
+
+	/**
+	 * Start creating a find 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> ExecutableFind<T> query(Class<T> domainType);
+
+	/**
+	 * Trigger find execution by calling one of the terminating methods.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface TerminatingFind<T> {
+
+		/**
+		 * Get exactly zero or one result.
+		 *
+		 * @return {@link Optional#empty()} if no match found.
+		 * @throws org.springframework.dao.IncorrectResultSizeDataAccessException if more than one match found.
+		 */
+		default Optional<T> one() {
+			return Optional.ofNullable(oneValue());
+		}
+
+		/**
+		 * Get exactly zero or one result.
+		 *
+		 * @return {@literal null} if no match found.
+		 * @throws org.springframework.dao.IncorrectResultSizeDataAccessException if more than one match found.
+		 */
+		@Nullable
+		T oneValue();
+
+		/**
+		 * Get the first or no result.
+		 *
+		 * @return {@link Optional#empty()} if no match found.
+		 */
+		default Optional<T> first() {
+			return Optional.ofNullable(firstValue());
+		}
+
+		/**
+		 * Get the first or no result.
+		 *
+		 * @return {@literal null} if no match found.
+		 */
+		@Nullable
+		T firstValue();
+
+		/**
+		 * Get all matching elements.
+		 *
+		 * @return never {@literal null}.
+		 */
+		List<T> all();
+
+		/**
+		 * Stream all matching elements.
+		 *
+		 * @return a {@link Stream} that wraps the a Mongo DB {@link com.mongodb.Cursor} that needs to be closed. Never
+		 *         {@literal null}.
+		 */
+		Stream<T> stream();
+
+		/**
+		 * Get the number of matching elements.
+		 *
+		 * @return total number of matching elements.
+		 */
+		long count();
+
+		/**
+		 * Check for the presence of matching elements.
+		 *
+		 * @return {@literal true} if at least one matching element exists.
+		 */
+		boolean exists();
+	}
+
+	/**
+	 * Trigger geonear execution by calling one of the terminating methods.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface TerminatingFindNear<T> {
+
+		/**
+		 * Find all matching elements and return them as {@link org.springframework.data.geo.GeoResult}.
+		 *
+		 * @return never {@literal null}.
+		 */
+		GeoResults<T> all();
+	}
+
+	/**
+	 * Terminating operations invoking the actual query execution.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface FindWithQuery<T> extends TerminatingFind<T> {
+
+		/**
+		 * Set the filter query to be used.
+		 *
+		 * @param query must not be {@literal null}.
+		 * @return new instance of {@link TerminatingFind}.
+		 * @throws IllegalArgumentException if query is {@literal null}.
+		 */
+		TerminatingFind<T> matching(Query query);
+
+		/**
+		 * Set the filter query for the geoNear execution.
+		 *
+		 * @param nearQuery must not be {@literal null}.
+		 * @return new instance of {@link TerminatingFindNear}.
+		 * @throws IllegalArgumentException if nearQuery is {@literal null}.
+		 */
+		TerminatingFindNear<T> near(NearQuery nearQuery);
+	}
+
+	/**
+	 * Collection override (Optional).
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface FindWithCollection<T> extends FindWithQuery<T> {
+
+		/**
+		 * Explicitly set the name of the collection to perform the query 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 FindWithProjection}.
+		 * @throws IllegalArgumentException if collection is {@literal null}.
+		 */
+		FindWithProjection<T> inCollection(String collection);
+	}
+
+	/**
+	 * Result type override (Optional).
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface FindWithProjection<T> extends FindWithQuery<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 FindWithProjection}.
+		 * @throws IllegalArgumentException if resultType is {@literal null}.
+		 */
+		<R> FindWithQuery<R> as(Class<R> resultType);
+	}
+
+	/**
+	 * {@link ExecutableFind} provides methods for constructing lookup operations in a fluent way.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface ExecutableFind<T> extends FindWithCollection<T>, FindWithProjection<T> {}
+}

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

@@ -0,0 +1,264 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import lombok.AccessLevel;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import org.bson.Document;
+import org.springframework.dao.IncorrectResultSizeDataAccessException;
+import org.springframework.data.mongodb.core.query.NearQuery;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.mongodb.core.query.SerializationUtils;
+import org.springframework.data.util.CloseableIterator;
+import org.springframework.data.util.StreamUtils;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+import org.springframework.util.ObjectUtils;
+import org.springframework.util.StringUtils;
+
+import com.mongodb.client.FindIterable;
+
+/**
+ * Implementation of {@link ExecutableFindOperation}.
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @since 2.0
+ */
+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;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ExecutableFindOperation#query(java.lang.Class)
+	 */
+	@Override
+	public <T> ExecutableFind<T> query(Class<T> domainType) {
+
+		Assert.notNull(domainType, "DomainType must not be null!");
+
+		return new ExecutableFindSupport<>(template, domainType, domainType, null, ALL_QUERY);
+	}
+
+	/**
+	 * @param <T>
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	@RequiredArgsConstructor
+	@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
+	static class ExecutableFindSupport<T>
+			implements ExecutableFind<T>, FindWithCollection<T>, FindWithProjection<T>, FindWithQuery<T> {
+
+		@NonNull MongoTemplate template;
+		@NonNull Class<?> domainType;
+		Class<T> returnType;
+		@Nullable String collection;
+		Query query;
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.FindWithCollection#inCollection(java.lang.String)
+		 */
+		@Override
+		public FindWithProjection<T> inCollection(String collection) {
+
+			Assert.hasText(collection, "Collection name must not be null nor empty!");
+
+			return new ExecutableFindSupport<>(template, domainType, returnType, collection, query);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.FindWithProjection#as(Class)
+		 */
+		@Override
+		public <T1> FindWithQuery<T1> as(Class<T1> returnType) {
+
+			Assert.notNull(returnType, "ReturnType must not be null!");
+
+			return new ExecutableFindSupport<>(template, domainType, returnType, collection, query);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.FindWithQuery#matching(org.springframework.data.mongodb.core.query.Query)
+		 */
+		@Override
+		public TerminatingFind<T> matching(Query query) {
+
+			Assert.notNull(query, "Query must not be null!");
+
+			return new ExecutableFindSupport<>(template, domainType, returnType, collection, query);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.TerminatingFind#oneValue()
+		 */
+		@Override
+		public T oneValue() {
+
+			List<T> result = doFind(new DelegatingQueryCursorPreparer(getCursorPreparer(query, null)).limit(2));
+
+			if (ObjectUtils.isEmpty(result)) {
+				return null;
+			}
+
+			if (result.size() > 1) {
+				throw new IncorrectResultSizeDataAccessException("Query " + asString() + " returned non unique result.", 1);
+			}
+
+			return result.iterator().next();
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.TerminatingFind#firstValue()
+		 */
+		@Override
+		public T firstValue() {
+
+			List<T> result = doFind(new DelegatingQueryCursorPreparer(getCursorPreparer(query, null)).limit(1));
+
+			return ObjectUtils.isEmpty(result) ? null : result.iterator().next();
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.TerminatingFind#all()
+		 */
+		@Override
+		public List<T> all() {
+			return doFind(null);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.TerminatingFind#stream()
+		 */
+		@Override
+		public Stream<T> stream() {
+			return StreamUtils.createStreamFromIterator(doStream());
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.FindWithQuery#near(org.springframework.data.mongodb.core.query.NearQuery)
+		 */
+		@Override
+		public TerminatingFindNear<T> near(NearQuery nearQuery) {
+			return () -> template.geoNear(nearQuery, domainType, getCollectionName(), returnType);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.TerminatingFind#count()
+		 */
+		@Override
+		public long count() {
+			return template.count(query, domainType, getCollectionName());
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.TerminatingFind#exists()
+		 */
+		@Override
+		public boolean exists() {
+			return template.exists(query, domainType, getCollectionName());
+		}
+
+		private List<T> doFind(@Nullable CursorPreparer preparer) {
+
+			Document queryObject = query.getQueryObject();
+			Document fieldsObject = query.getFieldsObject();
+
+			return template.doFind(getCollectionName(), queryObject, fieldsObject, domainType, returnType,
+					getCursorPreparer(query, preparer));
+		}
+
+		private CloseableIterator<T> doStream() {
+			return template.doStream(query, domainType, getCollectionName(), returnType);
+		}
+
+		private CursorPreparer getCursorPreparer(Query query, @Nullable CursorPreparer preparer) {
+			return preparer != null ? preparer : template.new QueryCursorPreparer(query, domainType);
+		}
+
+		private String getCollectionName() {
+			return StringUtils.hasText(collection) ? collection : template.determineCollectionName(domainType);
+		}
+
+		private String asString() {
+			return SerializationUtils.serializeToJsonSafely(query);
+		}
+	}
+
+	/**
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	static class DelegatingQueryCursorPreparer implements CursorPreparer {
+
+		private final @Nullable CursorPreparer delegate;
+		private Optional<Integer> limit = Optional.empty();
+
+		DelegatingQueryCursorPreparer(@Nullable CursorPreparer delegate) {
+			this.delegate = delegate;
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.CursorPreparer#prepare(com.mongodb.clientFindIterable)
+		 */
+		@Override
+		public FindIterable<Document> prepare(FindIterable<Document> cursor) {
+
+			FindIterable<Document> target = delegate != null ? delegate.prepare(cursor) : cursor;
+			return limit.map(target::limit).orElse(target);
+		}
+
+		CursorPreparer limit(int limit) {
+
+			this.limit = Optional.of(limit);
+			return this;
+		}
+	}
+}

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

@@ -0,0 +1,137 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import java.util.Collection;
+
+import org.springframework.data.mongodb.core.BulkOperations.BulkMode;
+
+import com.mongodb.bulk.BulkWriteResult;
+
+/**
+ * {@link ExecutableInsertOperation} allows creation and execution of MongoDB insert and bulk insert operations in a
+ * fluent API style. <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>
+ *         insert(Jedi.class)
+ *             .inCollection("star-wars")
+ *             .one(luke);
+ *     </code>
+ * </pre>
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @since 2.0
+ */
+public interface ExecutableInsertOperation {
+
+	/**
+	 * Start creating an insert operation for given {@literal domainType}.
+	 *
+	 * @param domainType must not be {@literal null}.
+	 * @return new instance of {@link ExecutableInsert}.
+	 * @throws IllegalArgumentException if domainType is {@literal null}.
+	 */
+	<T> ExecutableInsert<T> insert(Class<T> domainType);
+
+	/**
+	 * Trigger insert execution by calling one of the terminating methods.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface TerminatingInsert<T> extends TerminatingBulkInsert<T> {
+
+		/**
+		 * Insert exactly one object.
+		 *
+		 * @param object must not be {@literal null}.
+		 * @throws IllegalArgumentException if object is {@literal null}.
+		 */
+		void one(T object);
+
+		/**
+		 * Insert a collection of objects.
+		 *
+		 * @param objects must not be {@literal null}.
+		 * @throws IllegalArgumentException if objects is {@literal null}.
+		 */
+		void all(Collection<? extends T> objects);
+	}
+
+	/**
+	 * Trigger bulk insert execution by calling one of the terminating methods.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface TerminatingBulkInsert<T> {
+
+		/**
+		 * Bulk write collection of objects.
+		 *
+		 * @param objects must not be {@literal null}.
+		 * @return resulting {@link BulkWriteResult}.
+		 * @throws IllegalArgumentException if objects is {@literal null}.
+		 */
+		BulkWriteResult bulk(Collection<? extends T> objects);
+	}
+
+	/**
+	 * Collection override (optional).
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface InsertWithCollection<T> {
+
+		/**
+		 * Explicitly set the name of the collection. <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 InsertWithBulkMode}.
+		 * @throws IllegalArgumentException if collection is {@literal null}.
+		 */
+		InsertWithBulkMode<T> inCollection(String collection);
+	}
+
+	/**
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface InsertWithBulkMode<T> extends TerminatingInsert<T> {
+
+		/**
+		 * Define the {@link BulkMode} to use for bulk insert operation.
+		 *
+		 * @param bulkMode must not be {@literal null}.
+		 * @return new instance of {@link TerminatingBulkInsert}.
+		 * @throws IllegalArgumentException if bulkMode is {@literal null}.
+		 */
+		TerminatingBulkInsert<T> withBulkMode(BulkMode bulkMode);
+	}
+
+	/**
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface ExecutableInsert<T> extends TerminatingInsert<T>, InsertWithCollection<T>, InsertWithBulkMode<T> {}
+}

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

@@ -0,0 +1,147 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import lombok.AccessLevel;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+import org.springframework.data.mongodb.core.BulkOperations.BulkMode;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
+
+import com.mongodb.bulk.BulkWriteResult;
+
+/**
+ * Implementation of {@link ExecutableInsertOperation}.
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @since 2.0
+ */
+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;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.coreExecutableInsertOperation#insert(java.lan.Class)
+	 */
+	@Override
+	public <T> ExecutableInsert<T> insert(Class<T> domainType) {
+
+		Assert.notNull(domainType, "DomainType must not be null!");
+
+		return new ExecutableInsertSupport<>(template, domainType, null, null);
+	}
+
+	/**
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	@RequiredArgsConstructor
+	@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
+	static class ExecutableInsertSupport<T> implements ExecutableInsert<T> {
+
+		@NonNull MongoTemplate template;
+		@NonNull Class<T> domainType;
+		@Nullable String collection;
+		@Nullable BulkMode bulkMode;
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableInsertOperation.TerminatingInsert#insert(java.lang.Class)
+		 */
+		@Override
+		public void one(T object) {
+
+			Assert.notNull(object, "Object must not be null!");
+
+			template.insert(object, getCollectionName());
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableInsertOperation.TerminatingInsert#all(java.util.Collection)
+		 */
+		@Override
+		public void all(Collection<? extends T> objects) {
+
+			Assert.notNull(objects, "Objects must not be null!");
+
+			template.insert(objects, getCollectionName());
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableInsertOperation.TerminatingBulkInsert#bulk(java.util.Collection)
+		 */
+		@Override
+		public BulkWriteResult bulk(Collection<? extends T> objects) {
+
+			Assert.notNull(objects, "Objects must not be null!");
+
+			return template.bulkOps(bulkMode != null ? bulkMode : BulkMode.ORDERED, domainType, getCollectionName())
+					.insert(new ArrayList<>(objects)).execute();
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableInsertOperation.InsertWithCollection#inCollection(java.lang.String)
+		 */
+		@Override
+		public InsertWithBulkMode<T> inCollection(String collection) {
+
+			Assert.hasText(collection, "Collection must not be null nor empty.");
+
+			return new ExecutableInsertSupport<>(template, domainType, collection, bulkMode);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableInsertOperation.InsertWithBulkMode#withBulkMode(org.springframework.data.mongodb.core.BulkMode)
+		 */
+		@Override
+		public TerminatingBulkInsert<T> withBulkMode(BulkMode bulkMode) {
+
+			Assert.notNull(bulkMode, "BulkMode must not be null!");
+
+			return new ExecutableInsertSupport<>(template, domainType, collection, bulkMode);
+		}
+
+		private String getCollectionName() {
+			return StringUtils.hasText(collection) ? collection : template.determineCollectionName(domainType);
+		}
+	}
+}

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

@@ -0,0 +1,121 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import java.util.List;
+
+import org.springframework.data.mongodb.core.query.Query;
+
+import com.mongodb.client.result.DeleteResult;
+
+/**
+ * {@link ExecutableRemoveOperation} allows creation and execution of MongoDB remove / findAndRemove operations in a
+ * fluent API style. <br />
+ * The starting {@literal domainType} is used for mapping the {@link Query} provided via {@code matching} into the
+ * MongoDB specific representation. 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>
+ *         remove(Jedi.class)
+ *             .inCollection("star-wars")
+ *             .matching(query(where("firstname").is("luke")))
+ *             .all();
+ *     </code>
+ * </pre>
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @since 2.0
+ */
+public interface ExecutableRemoveOperation {
+
+	/**
+	 * Start creating a remove operation for the given {@literal domainType}.
+	 *
+	 * @param domainType must not be {@literal null}.
+	 * @return new instance of {@link ExecutableRemove}.
+	 * @throws IllegalArgumentException if domainType is {@literal null}.
+	 */
+	<T> ExecutableRemove<T> remove(Class<T> domainType);
+
+	/**
+	 * Collection override (optional).
+	 *
+	 * @param <T>
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface RemoveWithCollection<T> extends RemoveWithQuery<T> {
+
+		/**
+		 * Explicitly set the name of the collection to perform the query 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 RemoveWithCollection}.
+		 * @throws IllegalArgumentException if collection is {@literal null}.
+		 */
+		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
+	 * @since 2.0
+	 */
+	interface RemoveWithQuery<T> extends TerminatingRemove<T> {
+
+		/**
+		 * Define the query filtering elements.
+		 *
+		 * @param query must not be {@literal null}.
+		 * @return new instance of {@link TerminatingRemove}.
+		 * @throws IllegalArgumentException if query is {@literal null}.
+		 */
+		TerminatingRemove<T> matching(Query query);
+	}
+
+	/**
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface ExecutableRemove<T> extends RemoveWithCollection<T> {}
+}

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

@@ -0,0 +1,135 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import lombok.AccessLevel;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+
+import java.util.List;
+
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
+
+import com.mongodb.client.result.DeleteResult;
+
+/**
+ * Implementation of {@link ExecutableRemoveOperation}.
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @since 2.0
+ */
+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;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ExecutableRemoveOperation#remove(java.lang.Class)
+	 */
+	@Override
+	public <T> ExecutableRemove<T> remove(Class<T> domainType) {
+
+		Assert.notNull(domainType, "DomainType must not be null!");
+
+		return new ExecutableRemoveSupport<>(tempate, domainType, ALL_QUERY, null);
+	}
+
+	/**
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	@RequiredArgsConstructor
+	@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
+	static class ExecutableRemoveSupport<T> implements ExecutableRemove<T>, RemoveWithCollection<T> {
+
+		@NonNull MongoTemplate template;
+		@NonNull Class<T> domainType;
+		Query query;
+		@Nullable String collection;
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableRemoveOperation.RemoveWithCollection#inCollection(java.lang.String)
+		 */
+		@Override
+		public RemoveWithQuery<T> inCollection(String collection) {
+
+			Assert.hasText(collection, "Collection must not be null nor empty!");
+
+			return new ExecutableRemoveSupport<>(template, domainType, query, collection);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableRemoveOperation.RemoveWithQuery#matching(org.springframework.data.mongodb.core.query.Query)
+		 */
+		@Override
+		public TerminatingRemove<T> matching(Query query) {
+
+			Assert.notNull(query, "Query must not be null!");
+
+			return new ExecutableRemoveSupport<>(template, domainType, query, collection);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableRemoveOperation.TerminatingRemove#all()
+		 */
+		@Override
+		public DeleteResult all() {
+
+			String collectionName = getCollectionName();
+
+			return template.doRemove(collectionName, query, domainType);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableRemoveOperation.TerminatingRemove#findAndRemove()
+		 */
+		@Override
+		public List<T> findAndRemove() {
+
+			String collectionName = getCollectionName();
+
+			return template.doFindAndDelete(collectionName, query, domainType);
+		}
+
+		private String getCollectionName() {
+			return StringUtils.hasText(collection) ? collection : template.determineCollectionName(domainType);
+		}
+	}
+}

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

@@ -0,0 +1,191 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+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;
+
+/**
+ * {@link ExecutableUpdateOperation} allows creation and execution of MongoDB update / findAndModify 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
+ * {@link org.springframework.data.mongodb.core.mapping.Document}. Using {@code inCollection} allows to override the
+ * collection name for the execution.
+ *
+ * <pre>
+ *     <code>
+ *         update(Jedi.class)
+ *             .inCollection("star-wars")
+ *             .matching(query(where("firstname").is("luke")))
+ *             .apply(new Update().set("lastname", "skywalker"))
+ *             .upsert();
+ *     </code>
+ * </pre>
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @since 2.0
+ */
+public interface ExecutableUpdateOperation {
+
+	/**
+	 * Start creating an update operation for the given {@literal domainType}.
+	 *
+	 * @param domainType must not be {@literal null}.
+	 * @return new instance of {@link ExecutableUpdate}.
+	 * @throws IllegalArgumentException if domainType is {@literal null}.
+	 */
+	<T> ExecutableUpdate<T> update(Class<T> domainType);
+
+	/**
+	 * Declare the {@link Update} to apply.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface UpdateWithUpdate<T> {
+
+		/**
+		 * Set the {@link Update} to be applied.
+		 *
+		 * @param update must not be {@literal null}.
+		 * @return new instance of {@link TerminatingUpdate}.
+		 * @throws IllegalArgumentException if update is {@literal null}.
+		 */
+		TerminatingUpdate<T> apply(Update update);
+	}
+
+	/**
+	 * Explicitly define the name of the collection to perform operation in.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface UpdateWithCollection<T> {
+
+		/**
+		 * Explicitly set the name of the collection to perform the query 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 UpdateWithCollection}.
+		 * @throws IllegalArgumentException if collection is {@literal null}.
+		 */
+		UpdateWithQuery<T> inCollection(String collection);
+	}
+
+	/**
+	 * Define a filter query for the {@link Update}.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface UpdateWithQuery<T> extends UpdateWithUpdate<T> {
+
+		/**
+		 * Filter documents by given {@literal query}.
+		 *
+		 * @param query must not be {@literal null}.
+		 * @return new instance of {@link UpdateWithQuery}.
+		 * @throws IllegalArgumentException if query is {@literal null}.
+		 */
+		UpdateWithUpdate<T> matching(Query query);
+	}
+
+	/**
+	 * Define {@link FindAndModifyOptions}.
+	 *
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface FindAndModifyWithOptions<T> {
+
+		/**
+		 * Explicitly define {@link FindAndModifyOptions} for the {@link Update}.
+		 *
+		 * @param options must not be {@literal null}.
+		 * @return new instance of {@link FindAndModifyWithOptions}.
+		 * @throws IllegalArgumentException if options is {@literal null}.
+		 */
+		TerminatingFindAndModify<T> withOptions(FindAndModifyOptions options);
+	}
+
+	/**
+	 * Trigger findAndModify execution by calling one of the terminating methods.
+	 */
+	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 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();
+	}
+
+	/**
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	interface ExecutableUpdate<T> extends UpdateWithCollection<T>, UpdateWithQuery<T>, UpdateWithUpdate<T> {}
+}

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

@@ -0,0 +1,176 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import lombok.AccessLevel;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+
+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.StringUtils;
+
+import com.mongodb.client.result.UpdateResult;
+
+/**
+ * Implementation of {@link ExecutableUpdateOperation}.
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @since 2.0
+ */
+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;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ExecutableUpdateOperation#update(java.lang.Class)
+	 */
+	@Override
+	public <T> ExecutableUpdate<T> update(Class<T> domainType) {
+
+		Assert.notNull(domainType, "DomainType must not be null!");
+
+		return new ExecutableUpdateSupport<>(template, domainType, ALL_QUERY, null, null, null);
+	}
+
+	/**
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	@RequiredArgsConstructor
+	@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
+	static class ExecutableUpdateSupport<T>
+			implements ExecutableUpdate<T>, UpdateWithCollection<T>, UpdateWithQuery<T>, TerminatingUpdate<T> {
+
+		@NonNull MongoTemplate template;
+		@NonNull Class<T> domainType;
+		Query query;
+		@Nullable Update update;
+		@Nullable String collection;
+		@Nullable FindAndModifyOptions options;
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableUpdateOperation.UpdateWithUpdate#apply(Update)
+		 */
+		@Override
+		public TerminatingUpdate<T> apply(Update update) {
+
+			Assert.notNull(update, "Update must not be null!");
+
+			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, options);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableUpdateOperation.UpdateWithCollection#inCollection(java.lang.String)
+		 */
+		@Override
+		public UpdateWithQuery<T> inCollection(String collection) {
+
+			Assert.hasText(collection, "Collection must not be null nor empty!");
+
+			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, options);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableUpdateOperation.FindAndModifyWithOptions#withOptions(org.springframework.data.mongodb.core.FindAndModifyOptions)
+		 */
+		@Override
+		public TerminatingFindAndModify<T> withOptions(FindAndModifyOptions options) {
+
+			Assert.notNull(options, "Options must not be null!");
+
+			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, options);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveUpdateOperation.UpdateWithQuery#matching(org.springframework.data.mongodb.core.query.Query)
+		 */
+		@Override
+		public UpdateWithUpdate<T> matching(Query query) {
+
+			Assert.notNull(query, "Query must not be null!");
+
+			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, options);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableUpdateOperation.TerminatingUpdate#all()
+		 */
+		@Override
+		public UpdateResult all() {
+			return doUpdate(true, false);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableUpdateOperation.TerminatingUpdate#first()
+		 */
+		@Override
+		public UpdateResult first() {
+			return doUpdate(false, false);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableUpdateOperation.TerminatingUpdate#upsert()
+		 */
+		@Override
+		public UpdateResult upsert() {
+			return doUpdate(true, true);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableUpdateOperation.TerminatingFindAndModify#findAndModifyValue()
+		 */
+		@Override
+		public @Nullable T findAndModifyValue() {
+			return template.findAndModify(query, update, options != null ? options : new FindAndModifyOptions(), domainType, getCollectionName());
+		}
+
+		private UpdateResult doUpdate(boolean multi, boolean upsert) {
+			return template.doUpdate(getCollectionName(), query, update, domainType, upsert, multi);
+		}
+
+		private String getCollectionName() {
+			return StringUtils.hasText(collection) ? collection : template.determineCollectionName(domainType);
+		}
+	}
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2011 the original author or authors.
+ * Copyright 2010-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,23 +15,53 @@
  */
 package org.springframework.data.mongodb.core;
 
+import java.util.Optional;
+
+import org.springframework.data.mongodb.core.query.Collation;
+import org.springframework.lang.Nullable;
+
+/**
+ * @author Mark Pollak
+ * @author Oliver Gierke
+ * @author Christoph Strobl
+ */
 public class FindAndModifyOptions {
 
-	boolean returnNew;
+	private boolean returnNew;
+	private boolean upsert;
+	private boolean remove;
 
-	boolean upsert;
-
-	boolean remove;
+	private @Nullable Collation collation;
 
 	/**
 	 * Static factory method to create a FindAndModifyOptions instance
-	 * 
+	 *
 	 * @return a new instance
 	 */
 	public static FindAndModifyOptions options() {
 		return new FindAndModifyOptions();
 	}
 
+	/**
+	 * @param options
+	 * @return
+	 * @since 2.0
+	 */
+	public static FindAndModifyOptions of(@Nullable FindAndModifyOptions source) {
+
+		FindAndModifyOptions options = new FindAndModifyOptions();
+		if (source == null) {
+			return options;
+		}
+
+		options.returnNew = source.returnNew;
+		options.upsert = source.upsert;
+		options.remove = source.remove;
+		options.collation = source.collation;
+
+		return options;
+	}
+
 	public FindAndModifyOptions returnNew(boolean returnNew) {
 		this.returnNew = returnNew;
 		return this;
@@ -47,6 +77,19 @@ public class FindAndModifyOptions {
 		return this;
 	}
 
+	/**
+	 * Define the {@link Collation} specifying language-specific rules for string comparison.
+	 *
+	 * @param collation
+	 * @return
+	 * @since 2.0
+	 */
+	public FindAndModifyOptions collation(@Nullable Collation collation) {
+
+		this.collation = collation;
+		return this;
+	}
+
 	public boolean isReturnNew() {
 		return returnNew;
 	}
@@ -59,4 +102,14 @@ public class FindAndModifyOptions {
 		return remove;
 	}
 
+	/**
+	 * Get the {@link Collation} specifying language-specific rules for string comparison.
+	 *
+	 * @return
+	 * @since 2.0
+	 */
+	public Optional<Collation> getCollation() {
+		return Optional.ofNullable(collation);
+	}
+
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016 the original author or authors.
+ * Copyright 2016-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,7 +15,6 @@
  */
 package org.springframework.data.mongodb.core;
 
-import com.mongodb.DBCursor;
 import com.mongodb.reactivestreams.client.FindPublisher;
 
 /**
@@ -28,7 +27,7 @@ interface FindPublisherPreparer {
 	/**
 	 * Prepare the given cursor (apply limits, skips and so on). Returns the prepared cursor.
 	 *
-	 * @param cursor
+	 * @param findPublisher must not be {@literal null}.
 	 */
 	<T> FindPublisher<T> prepare(FindPublisher<T> findPublisher);
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012-2014 the original author or authors.
+ * Copyright 2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,15 +15,11 @@
  */
 package org.springframework.data.mongodb.core;
 
-import org.springframework.transaction.support.ResourceHolder;
-import org.springframework.transaction.support.ResourceHolderSynchronization;
-
 /**
- * @author Oliver Gierke
+ * Stripped down interface providing access to a fluent API that specifies a basic set of MongoDB operations.
+ *
+ * @author Christoph Strobl
+ * @since 2.0
  */
-class MongoSynchronization extends ResourceHolderSynchronization<ResourceHolder, Object> {
-
-	public MongoSynchronization(ResourceHolder resourceHolder, Object resourceKey) {
-		super(resourceHolder, resourceKey);
-	}
-}
+public interface FluentMongoOperations extends ExecutableFindOperation, ExecutableInsertOperation,
+		ExecutableUpdateOperation, ExecutableRemoveOperation, ExecutableAggregationOperation {}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016 the original author or authors.
+ * Copyright 2016-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,24 +13,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 package org.springframework.data.mongodb.core;
 
-import static org.springframework.data.domain.Sort.Direction.*;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
 import java.util.concurrent.TimeUnit;
 
 import org.bson.Document;
 import org.springframework.core.convert.converter.Converter;
 import org.springframework.data.mongodb.core.index.IndexDefinition;
-import org.springframework.data.mongodb.core.index.IndexField;
 import org.springframework.data.mongodb.core.index.IndexInfo;
+import org.springframework.lang.Nullable;
 import org.springframework.util.ObjectUtils;
 
+import com.mongodb.client.model.Collation;
 import com.mongodb.client.model.IndexOptions;
 
 /**
@@ -45,10 +39,6 @@ abstract class IndexConverters {
 	private static final Converter<IndexDefinition, IndexOptions> DEFINITION_TO_MONGO_INDEX_OPTIONS;
 	private static final Converter<Document, IndexInfo> DOCUMENT_INDEX_INFO;
 
-	private static final Double ONE = Double.valueOf(1);
-	private static final Double MINUS_ONE = Double.valueOf(-1);
-	private static final Collection<String> TWO_D_IDENTIFIERS = Arrays.asList("2d", "2dsphere");
-
 	static {
 
 		DEFINITION_TO_MONGO_INDEX_OPTIONS = getIndexDefinitionIndexOptionsConverter();
@@ -117,18 +107,30 @@ abstract class IndexConverters {
 				}
 			}
 
-			if(indexOptions.containsKey("partialFilterExpression")) {
-				ops = ops.partialFilterExpression((org.bson.Document)indexOptions.get("partialFilterExpression"));
+			if (indexOptions.containsKey("partialFilterExpression")) {
+				ops = ops.partialFilterExpression((org.bson.Document) indexOptions.get("partialFilterExpression"));
+			}
+
+			if (indexOptions.containsKey("collation")) {
+				ops = ops.collation(fromDocument(indexOptions.get("collation", Document.class)));
 			}
 
 			return ops;
 		};
 	}
 
-	private static Converter<Document, IndexInfo> getDocumentIndexInfoConverter() {
+	@Nullable
+	public static Collation fromDocument(@Nullable Document source) {
 
-		return ix -> {
-			return IndexInfo.indexInfoOf(ix);
-		};
+		if (source == null) {
+			return null;
+		}
+
+		return org.springframework.data.mongodb.core.query.Collation.from(source).toMongoCollation();
 	}
+
+	private static Converter<Document, IndexInfo> getDocumentIndexInfoConverter() {
+		return IndexInfo::indexInfoOf;
+	}
+
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2016 the original author or authors.
+ * Copyright 2011-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,6 +16,7 @@
 package org.springframework.data.mongodb.core;
 
 import org.bson.Document;
+import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 import com.mongodb.WriteConcern;
@@ -36,26 +37,28 @@ import com.mongodb.WriteConcern;
 public class MongoAction {
 
 	private final String collectionName;
-	private final WriteConcern defaultWriteConcern;
-	private final Class<?> entityType;
 	private final MongoActionOperation mongoActionOperation;
-	private final Document query;
-	private final Document document;
+
+	private final @Nullable WriteConcern defaultWriteConcern;
+	private final @Nullable Class<?> entityType;
+	private final @Nullable Document query;
+	private final @Nullable Document document;
 
 	/**
 	 * Create an instance of a {@link MongoAction}.
 	 * 
-	 * @param defaultWriteConcern the default write concern.
-	 * @param mongoActionOperation action being taken against the collection
+	 * @param defaultWriteConcern the default write concern. Can be {@literal null}.
+	 * @param mongoActionOperation action being taken against the collection. Must not be {@literal null}.
 	 * @param collectionName the collection name, must not be {@literal null} or empty.
-	 * @param entityType the POJO that is being operated against
-	 * @param document the converted Document from the POJO or Spring Update object
-	 * @param query the converted Document from the Spring Query object
+	 * @param entityType the POJO that is being operated against. Can be {@literal null}.
+	 * @param document the converted Document from the POJO or Spring Update object. Can be {@literal null}.
+	 * @param query the converted Document from the Spring Query object. Can be {@literal null}.
 	 */
-	public MongoAction(WriteConcern defaultWriteConcern, MongoActionOperation mongoActionOperation, String collectionName,
-			Class<?> entityType, Document document, Document query) {
+	public MongoAction(@Nullable WriteConcern defaultWriteConcern, MongoActionOperation mongoActionOperation,
+			String collectionName, @Nullable Class<?> entityType, @Nullable Document document, @Nullable Document query) {
 
 		Assert.hasText(collectionName, "Collection name must not be null or empty!");
+		Assert.notNull(mongoActionOperation, "MongoActionOperation must not be null!");
 
 		this.defaultWriteConcern = defaultWriteConcern;
 		this.mongoActionOperation = mongoActionOperation;
@@ -69,22 +72,27 @@ public class MongoAction {
 		return collectionName;
 	}
 
+	@Nullable
 	public WriteConcern getDefaultWriteConcern() {
 		return defaultWriteConcern;
 	}
 
+	@Nullable
 	public Class<?> getEntityType() {
 		return entityType;
 	}
 
+	@Nullable
 	public MongoActionOperation getMongoActionOperation() {
 		return mongoActionOperation;
 	}
 
+	@Nullable
 	public Document getQuery() {
 		return query;
 	}
 
+	@Nullable
 	public Document getDocument() {
 		return document;
 	}

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

@@ -1,77 +1,78 @@
-/*
- * Copyright 2011-2017 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.mongodb.core;
-
-import com.mongodb.MongoClient;
-import com.mongodb.client.MongoDatabase;
-import org.bson.Document;
-import org.springframework.jmx.export.annotation.ManagedOperation;
-import org.springframework.jmx.export.annotation.ManagedResource;
-import org.springframework.util.Assert;
-
-/**
- * Mongo server administration exposed via JMX annotations
- * 
- * @author Mark Pollack
- * @author Thomas Darimont
- * @author Mark Paluch
- * @author Christoph Strobl
- */
-@ManagedResource(description = "Mongo Admin Operations")
-public class MongoAdmin implements MongoAdminOperations {
-
-	private final MongoClient mongoClient;
-
-	public MongoAdmin(MongoClient mongoClient) {
-
-		Assert.notNull(mongoClient, "MongoClient must not be null!");
-		this.mongoClient = mongoClient;
-	}
-
-	/* (non-Javadoc)
-	  * @see org.springframework.data.mongodb.core.core.MongoAdminOperations#dropDatabase(java.lang.String)
-	  */
-	@ManagedOperation
-	public void dropDatabase(String databaseName) {
-		getDB(databaseName).drop();
-	}
-
-	/* (non-Javadoc)
-	  * @see org.springframework.data.mongodb.core.core.MongoAdminOperations#createDatabase(java.lang.String)
-	  */
-	@ManagedOperation
-	public void createDatabase(String databaseName) {
-		getDB(databaseName);
-	}
-
-	/* (non-Javadoc)
-	  * @see org.springframework.data.mongodb.core.core.MongoAdminOperations#getDatabaseStats(java.lang.String)
-	  */
-	@ManagedOperation
-	public String getDatabaseStats(String databaseName) {
-		return getDB(databaseName).runCommand(new Document("dbStats", 1).append("scale" , 1024)).toJson();
-	}
-
-	@ManagedOperation
-	public String getServerStatus() {
-		return getDB("admin").runCommand(new Document("serverStatus", 1).append("rangeDeleter", 1).append("repl", 1)).toJson();
-	}
-
-
-	MongoDatabase getDB(String databaseName) {
-		return mongoClient.getDatabase(databaseName);
-	}
-}
+/*
+ * Copyright 2011-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import org.bson.Document;
+import org.springframework.jmx.export.annotation.ManagedOperation;
+import org.springframework.jmx.export.annotation.ManagedResource;
+import org.springframework.util.Assert;
+
+import com.mongodb.MongoClient;
+import com.mongodb.client.MongoDatabase;
+
+/**
+ * Mongo server administration exposed via JMX annotations
+ * 
+ * @author Mark Pollack
+ * @author Thomas Darimont
+ * @author Mark Paluch
+ * @author Christoph Strobl
+ */
+@ManagedResource(description = "Mongo Admin Operations")
+public class MongoAdmin implements MongoAdminOperations {
+
+	private final MongoClient mongoClient;
+
+	public MongoAdmin(MongoClient mongoClient) {
+
+		Assert.notNull(mongoClient, "MongoClient must not be null!");
+		this.mongoClient = mongoClient;
+	}
+
+	/* (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.core.MongoAdminOperations#dropDatabase(java.lang.String)
+	 */
+	@ManagedOperation
+	public void dropDatabase(String databaseName) {
+		getDB(databaseName).drop();
+	}
+
+	/* (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.core.MongoAdminOperations#createDatabase(java.lang.String)
+	 */
+	@ManagedOperation
+	public void createDatabase(String databaseName) {
+		getDB(databaseName);
+	}
+
+	/* (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.core.MongoAdminOperations#getDatabaseStats(java.lang.String)
+	 */
+	@ManagedOperation
+	public String getDatabaseStats(String databaseName) {
+		return getDB(databaseName).runCommand(new Document("dbStats", 1).append("scale", 1024)).toJson();
+	}
+
+	@ManagedOperation
+	public String getServerStatus() {
+		return getDB("admin").runCommand(new Document("serverStatus", 1).append("rangeDeleter", 1).append("repl", 1))
+				.toJson();
+	}
+
+	MongoDatabase getDB(String databaseName) {
+		return mongoClient.getDatabase(databaseName);
+	}
+}

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

@@ -1,34 +1,34 @@
-/*
- * Copyright 2011-2014 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.jmx.export.annotation.ManagedOperation;
-
-/**
- * @author Mark Pollack
- * @author Oliver Gierke
- */
-public interface MongoAdminOperations {
-
-	@ManagedOperation
-	void dropDatabase(String databaseName);
-
-	@ManagedOperation
-	void createDatabase(String databaseName);
-
-	@ManagedOperation
-	String getDatabaseStats(String databaseName);
-}
+/*
+ * Copyright 2011-2014 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.jmx.export.annotation.ManagedOperation;
+
+/**
+ * @author Mark Pollack
+ * @author Oliver Gierke
+ */
+public interface MongoAdminOperations {
+
+	@ManagedOperation
+	void dropDatabase(String databaseName);
+
+	@ManagedOperation
+	void createDatabase(String databaseName);
+
+	@ManagedOperation
+	String getDatabaseStats(String databaseName);
+}

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

@@ -23,6 +23,7 @@ import java.util.List;
 import org.springframework.beans.factory.config.AbstractFactoryBean;
 import org.springframework.dao.DataAccessException;
 import org.springframework.dao.support.PersistenceExceptionTranslator;
+import org.springframework.lang.Nullable;
 import org.springframework.util.CollectionUtils;
 import org.springframework.util.StringUtils;
 
@@ -33,61 +34,62 @@ import com.mongodb.ServerAddress;
 
 /**
  * Convenient factory for configuring MongoDB.
- * 
+ *
  * @author Christoph Strobl
+ * @author Mark Paluch
  * @since 1.7
  */
 public class MongoClientFactoryBean extends AbstractFactoryBean<MongoClient> implements PersistenceExceptionTranslator {
 
 	private static final PersistenceExceptionTranslator DEFAULT_EXCEPTION_TRANSLATOR = new MongoExceptionTranslator();
 
-	private MongoClientOptions mongoClientOptions;
-	private String host;
-	private Integer port;
-	private List<ServerAddress> replicaSetSeeds;
-	private List<MongoCredential> credentials;
+	private @Nullable MongoClientOptions mongoClientOptions;
+	private @Nullable String host;
+	private @Nullable Integer port;
+	private List<ServerAddress> replicaSetSeeds = Collections.emptyList();
+	private List<MongoCredential> credentials = Collections.emptyList();
 
 	private PersistenceExceptionTranslator exceptionTranslator = DEFAULT_EXCEPTION_TRANSLATOR;
 
 	/**
 	 * Set the {@link MongoClientOptions} to be used when creating {@link MongoClient}.
-	 * 
+	 *
 	 * @param mongoClientOptions
 	 */
-	public void setMongoClientOptions(MongoClientOptions mongoClientOptions) {
+	public void setMongoClientOptions(@Nullable MongoClientOptions mongoClientOptions) {
 		this.mongoClientOptions = mongoClientOptions;
 	}
 
 	/**
 	 * Set the list of credentials to be used when creating {@link MongoClient}.
-	 * 
+	 *
 	 * @param credentials can be {@literal null}.
 	 */
-	public void setCredentials(MongoCredential[] credentials) {
+	public void setCredentials(@Nullable MongoCredential[] credentials) {
 		this.credentials = filterNonNullElementsAsList(credentials);
 	}
 
 	/**
 	 * Set the list of {@link ServerAddress} to build up a replica set for.
-	 * 
+	 *
 	 * @param replicaSetSeeds can be {@literal null}.
 	 */
-	public void setReplicaSetSeeds(ServerAddress[] replicaSetSeeds) {
+	public void setReplicaSetSeeds(@Nullable ServerAddress[] replicaSetSeeds) {
 		this.replicaSetSeeds = filterNonNullElementsAsList(replicaSetSeeds);
 	}
 
 	/**
 	 * Configures the host to connect to.
-	 * 
+	 *
 	 * @param host
 	 */
-	public void setHost(String host) {
+	public void setHost(@Nullable String host) {
 		this.host = host;
 	}
 
 	/**
 	 * Configures the port to connect to.
-	 * 
+	 *
 	 * @param port
 	 */
 	public void setPort(int port) {
@@ -96,10 +98,10 @@ public class MongoClientFactoryBean extends AbstractFactoryBean<MongoClient> imp
 
 	/**
 	 * Configures the {@link PersistenceExceptionTranslator} to use.
-	 * 
+	 *
 	 * @param exceptionTranslator
 	 */
-	public void setExceptionTranslator(PersistenceExceptionTranslator exceptionTranslator) {
+	public void setExceptionTranslator(@Nullable PersistenceExceptionTranslator exceptionTranslator) {
 		this.exceptionTranslator = exceptionTranslator == null ? DEFAULT_EXCEPTION_TRANSLATOR : exceptionTranslator;
 	}
 
@@ -115,11 +117,12 @@ public class MongoClientFactoryBean extends AbstractFactoryBean<MongoClient> imp
 	 * (non-Javadoc)
 	 * @see org.springframework.dao.support.PersistenceExceptionTranslator#translateExceptionIfPossible(java.lang.RuntimeException)
 	 */
+	@Nullable
 	public DataAccessException translateExceptionIfPossible(RuntimeException ex) {
 		return exceptionTranslator.translateExceptionIfPossible(ex);
 	}
 
-	/* 
+	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.beans.factory.config.AbstractFactoryBean#createInstance()
 	 */
@@ -130,20 +133,19 @@ public class MongoClientFactoryBean extends AbstractFactoryBean<MongoClient> imp
 			mongoClientOptions = MongoClientOptions.builder().build();
 		}
 
-		if (credentials == null) {
-			credentials = Collections.emptyList();
-		}
-
 		return createMongoClient();
 	}
 
-	/* 
+	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.beans.factory.config.AbstractFactoryBean#destroyInstance(java.lang.Object)
 	 */
 	@Override
-	protected void destroyInstance(MongoClient instance) throws Exception {
-		instance.close();
+	protected void destroyInstance(@Nullable MongoClient instance) throws Exception {
+
+		if (instance != null) {
+			instance.close();
+		}
 	}
 
 	private MongoClient createMongoClient() throws UnknownHostException {
@@ -165,11 +167,11 @@ public class MongoClientFactoryBean extends AbstractFactoryBean<MongoClient> imp
 
 	/**
 	 * Returns the given array as {@link List} with all {@literal null} elements removed.
-	 * 
+	 *
 	 * @param elements the elements to filter <T>, can be {@literal null}.
 	 * @return a new unmodifiable {@link List#} from the given elements without {@literal null}s.
 	 */
-	private static <T> List<T> filterNonNullElementsAsList(T[] elements) {
+	private static <T> List<T> filterNonNullElementsAsList(@Nullable T[] elements) {
 
 		if (elements == null) {
 			return Collections.emptyList();

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

@@ -20,6 +20,7 @@ import javax.net.ssl.SSLSocketFactory;
 
 import org.springframework.beans.factory.config.AbstractFactoryBean;
 import org.springframework.data.mongodb.MongoDbFactory;
+import org.springframework.lang.Nullable;
 
 import com.mongodb.DBDecoderFactory;
 import com.mongodb.DBEncoderFactory;
@@ -40,7 +41,7 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 
 	private static final MongoClientOptions DEFAULT_MONGO_OPTIONS = MongoClientOptions.builder().build();
 
-	private String description = DEFAULT_MONGO_OPTIONS.getDescription();
+	private @Nullable String description = DEFAULT_MONGO_OPTIONS.getDescription();
 	private int minConnectionsPerHost = DEFAULT_MONGO_OPTIONS.getMinConnectionsPerHost();
 	private int connectionsPerHost = DEFAULT_MONGO_OPTIONS.getConnectionsPerHost();
 	private int threadsAllowedToBlockForConnectionMultiplier = DEFAULT_MONGO_OPTIONS
@@ -51,11 +52,11 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 	private int connectTimeout = DEFAULT_MONGO_OPTIONS.getConnectTimeout();
 	private int socketTimeout = DEFAULT_MONGO_OPTIONS.getSocketTimeout();
 	private boolean socketKeepAlive = DEFAULT_MONGO_OPTIONS.isSocketKeepAlive();
-	private ReadPreference readPreference = DEFAULT_MONGO_OPTIONS.getReadPreference();
+	private @Nullable ReadPreference readPreference = DEFAULT_MONGO_OPTIONS.getReadPreference();
 	private DBDecoderFactory dbDecoderFactory = DEFAULT_MONGO_OPTIONS.getDbDecoderFactory();
 	private DBEncoderFactory dbEncoderFactory = DEFAULT_MONGO_OPTIONS.getDbEncoderFactory();
-	private WriteConcern writeConcern = DEFAULT_MONGO_OPTIONS.getWriteConcern();
-	private SocketFactory socketFactory = DEFAULT_MONGO_OPTIONS.getSocketFactory();
+	private @Nullable WriteConcern writeConcern = DEFAULT_MONGO_OPTIONS.getWriteConcern();
+	private @Nullable SocketFactory socketFactory = DEFAULT_MONGO_OPTIONS.getSocketFactory();
 	private boolean cursorFinalizerEnabled = DEFAULT_MONGO_OPTIONS.isCursorFinalizerEnabled();
 	private boolean alwaysUseMBeans = DEFAULT_MONGO_OPTIONS.isAlwaysUseMBeans();
 	private int heartbeatFrequency = DEFAULT_MONGO_OPTIONS.getHeartbeatFrequency();
@@ -66,14 +67,14 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 	private int serverSelectionTimeout = DEFAULT_MONGO_OPTIONS.getServerSelectionTimeout();
 
 	private boolean ssl;
-	private SSLSocketFactory sslSocketFactory;
+	private @Nullable SSLSocketFactory sslSocketFactory;
 
 	/**
 	 * Set the {@link MongoClient} description.
 	 *
 	 * @param description
 	 */
-	public void setDescription(String description) {
+	public void setDescription(@Nullable String description) {
 		this.description = description;
 	}
 
@@ -166,7 +167,7 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 	 *
 	 * @param readPreference
 	 */
-	public void setReadPreference(ReadPreference readPreference) {
+	public void setReadPreference(@Nullable ReadPreference readPreference) {
 		this.readPreference = readPreference;
 	}
 
@@ -176,14 +177,14 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 	 *
 	 * @param writeConcern
 	 */
-	public void setWriteConcern(WriteConcern writeConcern) {
+	public void setWriteConcern(@Nullable WriteConcern writeConcern) {
 		this.writeConcern = writeConcern;
 	}
 
 	/**
 	 * @param socketFactory
 	 */
-	public void setSocketFactory(SocketFactory socketFactory) {
+	public void setSocketFactory(@Nullable SocketFactory socketFactory) {
 		this.socketFactory = socketFactory;
 	}
 
@@ -248,7 +249,7 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 	 *
 	 * @param sslSocketFactory
 	 */
-	public void setSslSocketFactory(SSLSocketFactory sslSocketFactory) {
+	public void setSslSocketFactory(@Nullable SSLSocketFactory sslSocketFactory) {
 
 		this.sslSocketFactory = sslSocketFactory;
 		this.ssl = sslSocketFactory != null;
@@ -269,11 +270,13 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 	 * (non-Javadoc)
 	 * @see org.springframework.beans.factory.config.AbstractFactoryBean#createInstance()
 	 */
+	@SuppressWarnings("ConstantConditions")
 	@Override
 	protected MongoClientOptions createInstance() throws Exception {
 
 		SocketFactory socketFactoryToUse = ssl
-				? (sslSocketFactory != null ? sslSocketFactory : SSLSocketFactory.getDefault()) : this.socketFactory;
+				? (sslSocketFactory != null ? sslSocketFactory : SSLSocketFactory.getDefault())
+				: this.socketFactory;
 
 		return MongoClientOptions.builder() //
 				.alwaysUseMBeans(this.alwaysUseMBeans) //

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013 the original author or authors.
+ * Copyright 2013-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,6 +16,7 @@
 package org.springframework.data.mongodb.core;
 
 import org.springframework.dao.DataIntegrityViolationException;
+import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 import com.mongodb.WriteResult;
@@ -40,7 +41,7 @@ public class MongoDataIntegrityViolationException extends DataIntegrityViolation
 	 * @param actionOperation the {@link MongoActionOperation} that caused the exception, must not be {@literal null}.
 	 */
 	public MongoDataIntegrityViolationException(String message, WriteResult writeResult,
-			MongoActionOperation actionOperation) {
+												MongoActionOperation actionOperation) {
 
 		super(message);
 

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2016 the original author or authors.
+ * Copyright 2010-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -31,6 +31,7 @@ import org.springframework.dao.support.PersistenceExceptionTranslator;
 import org.springframework.data.mongodb.BulkOperationException;
 import org.springframework.data.mongodb.UncategorizedMongoDbException;
 import org.springframework.data.mongodb.util.MongoDbErrorCodes;
+import org.springframework.lang.Nullable;
 import org.springframework.util.ClassUtils;
 
 import com.mongodb.BulkWriteException;
@@ -67,6 +68,7 @@ public class MongoExceptionTranslator implements PersistenceExceptionTranslator
 	 * (non-Javadoc)
 	 * @see org.springframework.dao.support.PersistenceExceptionTranslator#translateExceptionIfPossible(java.lang.RuntimeException)
 	 */
+	@Nullable
 	public DataAccessException translateExceptionIfPossible(RuntimeException ex) {
 
 		// Check for well-known MongoException subclasses.

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

@@ -0,0 +1,101 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import reactor.core.publisher.Flux;
+
+import org.springframework.data.mongodb.core.aggregation.Aggregation;
+
+/**
+ * {@link ReactiveAggregationOperation} allows creation and execution of reactive MongoDB aggregation operations in a
+ * fluent API style. <br />
+ * The starting {@literal domainType} is used for mapping the {@link Aggregation} provided via {@code by} into the
+ * MongoDB specific representation, as well as mapping back the resulting {@link org.bson.Document}. An alternative
+ * input type for mapping the {@link Aggregation} can be provided by using
+ * {@link org.springframework.data.mongodb.core.aggregation.TypedAggregation}.
+ *
+ * <pre>
+ *     <code>
+ *         aggregateAndReturn(Jedi.class)
+ *             .by(newAggregation(Human.class, project("These are not the droids you are looking for")))
+ *             .all();
+ *     </code>
+ * </pre>
+ *
+ * @author Mark Paluch
+ * @author Christoph Strobl
+ * @since 2.0
+ */
+public interface ReactiveAggregationOperation {
+
+	/**
+	 * Start creating an aggregation operation that returns results mapped to the given domain type. <br />
+	 * Use {@link org.springframework.data.mongodb.core.aggregation.TypedAggregation} to specify a potentially different
+	 * input type for he aggregation.
+	 *
+	 * @param domainType must not be {@literal null}.
+	 * @return new instance of {@link ReactiveAggregation}. Never {@literal null}.
+	 * @throws IllegalArgumentException if domainType is {@literal null}.
+	 */
+	<T> ReactiveAggregation<T> aggregateAndReturn(Class<T> domainType);
+
+	/**
+	 * Collection override (optional).
+	 */
+	interface AggregationOperationWithCollection<T> {
+
+		/**
+		 * Explicitly set the name of the collection to perform the query 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 AggregationOperationWithAggregation}. Never {@literal null}.
+		 * @throws IllegalArgumentException if collection is {@literal null} or empty.
+		 */
+		AggregationOperationWithAggregation<T> inCollection(String collection);
+	}
+
+	/**
+	 * Trigger execution by calling one of the terminating methods.
+	 */
+	interface TerminatingAggregationOperation<T> {
+
+		/**
+		 * Apply pipeline operations as specified and stream all matching elements. <br />
+		 *
+		 * @return a {@link Flux} streaming all matching elements. Never {@literal null}.
+		 */
+		Flux<T> all();
+	}
+
+	/**
+	 * Define the aggregation with pipeline stages.
+	 */
+	interface AggregationOperationWithAggregation<T> {
+
+		/**
+		 * Set the aggregation to be used.
+		 *
+		 * @param aggregation must not be {@literal null}.
+		 * @return new instance of {@link TerminatingAggregationOperation}. Never {@literal null}.
+		 * @throws IllegalArgumentException if aggregation is {@literal null}.
+		 */
+		TerminatingAggregationOperation<T> by(Aggregation aggregation);
+	}
+
+	interface ReactiveAggregation<T>
+			extends AggregationOperationWithCollection<T>, AggregationOperationWithAggregation<T> {}
+}

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

@@ -0,0 +1,126 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import lombok.AccessLevel;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+import reactor.core.publisher.Flux;
+
+import org.springframework.data.mongodb.core.aggregation.Aggregation;
+import org.springframework.data.mongodb.core.aggregation.TypedAggregation;
+import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
+
+/**
+ * Implementation of {@link ReactiveAggregationOperation} operating directly on {@link ReactiveMongoTemplate}.
+ *
+ * @author Mark Paluch
+ * @autor Christoph Strobl
+ * @since 2.0
+ */
+class ReactiveAggregationOperationSupport implements ReactiveAggregationOperation {
+
+	private final ReactiveMongoTemplate template;
+
+	/**
+	 * Create new instance of {@link ReactiveAggregationOperationSupport}.
+	 *
+	 * @param template must not be {@literal null}.
+	 * @throws IllegalArgumentException if template is {@literal null}.
+	 */
+	ReactiveAggregationOperationSupport(ReactiveMongoTemplate template) {
+
+		Assert.notNull(template, "Template must not be null!");
+
+		this.template = template;
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ReactiveAggregationOperation#aggregateAndReturn(java.lang.Class)
+	 */
+	@Override
+	public <T> ReactiveAggregation<T> aggregateAndReturn(Class<T> domainType) {
+
+		Assert.notNull(domainType, "DomainType must not be null!");
+
+		return new ReactiveAggregationSupport<>(template, domainType, null, null);
+	}
+
+	@RequiredArgsConstructor
+	@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
+	static class ReactiveAggregationSupport<T>
+			implements AggregationOperationWithAggregation<T>, ReactiveAggregation<T>, TerminatingAggregationOperation<T> {
+
+		@NonNull ReactiveMongoTemplate template;
+		@NonNull Class<T> domainType;
+		Aggregation aggregation;
+		String collection;
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveAggregationOperation.AggregationOperationWithCollection#inCollection(java.lang.String)
+		 */
+		@Override
+		public AggregationOperationWithAggregation<T> inCollection(String collection) {
+
+			Assert.hasText(collection, "Collection must not be null nor empty!");
+
+			return new ReactiveAggregationSupport<>(template, domainType, aggregation, collection);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveAggregationOperation.AggregationOperationWithAggregation#by(org.springframework.data.mongodb.core.Aggregation)
+		 */
+		@Override
+		public TerminatingAggregationOperation<T> by(Aggregation aggregation) {
+
+			Assert.notNull(aggregation, "Aggregation must not be null!");
+
+			return new ReactiveAggregationSupport<>(template, domainType, aggregation, collection);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveAggregationOperation.TerminatingAggregationOperation#all()
+		 */
+		@Override
+		public Flux<T> all() {
+			return template.aggregate(aggregation, getCollectionName(aggregation), domainType);
+		}
+
+		private String getCollectionName(Aggregation aggregation) {
+
+			if (StringUtils.hasText(collection)) {
+				return collection;
+			}
+
+			if (aggregation instanceof TypedAggregation) {
+
+				TypedAggregation<?> typedAggregation = (TypedAggregation<?>) aggregation;
+
+				if (typedAggregation.getInputType() != null) {
+					return template.determineCollectionName(typedAggregation.getInputType());
+				}
+			}
+
+			return template.determineCollectionName(domainType);
+		}
+	}
+}

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

@@ -1,34 +1,34 @@
-/*
- * Copyright 2016 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.mongodb.core;
-
-import org.springframework.dao.DataAccessException;
-
-import com.mongodb.MongoException;
-import com.mongodb.reactivestreams.client.MongoCollection;
-import org.bson.Document;
-import org.reactivestreams.Publisher;
-
-/**
- * @author Mark Paluch
- * @param <T>
- * @since 2.0
- */
-public interface ReactiveCollectionCallback<T> {
-
-	Publisher<T> doInCollection(MongoCollection<Document> collection) throws MongoException, DataAccessException;
-
-}
+/*
+ * Copyright 2016-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import org.bson.Document;
+import org.reactivestreams.Publisher;
+import org.springframework.dao.DataAccessException;
+
+import com.mongodb.MongoException;
+import com.mongodb.reactivestreams.client.MongoCollection;
+
+/**
+ * @author Mark Paluch
+ * @param <T>
+ * @since 2.0
+ */
+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

@@ -0,0 +1,177 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import org.springframework.data.geo.GeoResult;
+import org.springframework.data.mongodb.core.query.NearQuery;
+import org.springframework.data.mongodb.core.query.Query;
+
+/**
+ * {@link ReactiveFindOperation} allows creation and execution of reactive MongoDB find operations in a fluent API
+ * style. <br />
+ * The starting {@literal domainType} is used for mapping the {@link Query} provided via {@code matching} into the
+ * MongoDB specific representation. By default, the originating {@literal domainType} is also used for mapping back the
+ * result 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>
+ *         query(Human.class)
+ *             .inCollection("star-wars")
+ *             .as(Jedi.class)
+ *             .matching(query(where("firstname").is("luke")))
+ *             .all();
+ *     </code>
+ * </pre>
+ *
+ * @author Mark Paluch
+ * @author Christoph Strobl
+ * @since 2.0
+ */
+public interface ReactiveFindOperation {
+
+	/**
+	 * Start creating a find operation for the given {@literal domainType}.
+	 *
+	 * @param domainType must not be {@literal null}.
+	 * @return new instance of {@link ReactiveFind}. Never {@literal null}.
+	 * @throws IllegalArgumentException if domainType is {@literal null}.
+	 */
+	<T> ReactiveFind<T> query(Class<T> domainType);
+
+	/**
+	 * Compose find execution by calling one of the terminating methods.
+	 */
+	interface TerminatingFind<T> {
+
+		/**
+		 * Get exactly zero or one result.
+		 *
+		 * @return {@link Mono#empty()} if no match found. Never {@literal null}.
+		 * @throws org.springframework.dao.IncorrectResultSizeDataAccessException if more than one match found.
+		 */
+		Mono<T> one();
+
+		/**
+		 * Get the first or no result.
+		 *
+		 * @return {@link Mono#empty()} if no match found. Never {@literal null}.
+		 */
+		Mono<T> first();
+
+		/**
+		 * Get all matching elements.
+		 *
+		 * @return never {@literal null}.
+		 */
+		Flux<T> all();
+
+		/**
+		 * Get the number of matching elements.
+		 *
+		 * @return {@link Mono} emitting total number of matching elements. Never {@literal null}.
+		 */
+		Mono<Long> count();
+
+		/**
+		 * Check for the presence of matching elements.
+		 *
+		 * @return {@link Mono} emitting {@literal true} if at least one matching element exists. Never {@literal null}.
+		 */
+		Mono<Boolean> exists();
+	}
+
+	/**
+	 * Compose geonear execution by calling one of the terminating methods.
+	 */
+	interface TerminatingFindNear<T> {
+
+		/**
+		 * Find all matching elements and return them as {@link org.springframework.data.geo.GeoResult}.
+		 *
+		 * @return never {@literal null}.
+		 */
+		Flux<GeoResult<T>> all();
+	}
+
+	/**
+	 * Provide a {@link Query} override (optional).
+	 */
+	interface FindWithQuery<T> extends TerminatingFind<T> {
+
+		/**
+		 * Set the filter query to be used.
+		 *
+		 * @param query must not be {@literal null}.
+		 * @return new instance of {@link TerminatingFind}.
+		 * @throws IllegalArgumentException if query is {@literal null}.
+		 */
+		TerminatingFind<T> matching(Query query);
+
+		/**
+		 * Set the filter query for the geoNear execution.
+		 *
+		 * @param nearQuery must not be {@literal null}.
+		 * @return new instance of {@link TerminatingFindNear}.
+		 * @throws IllegalArgumentException if nearQuery is {@literal null}.
+		 */
+		TerminatingFindNear<T> near(NearQuery nearQuery);
+	}
+
+	/**
+	 * Collection override (optional).
+	 */
+	interface FindWithCollection<T> extends FindWithQuery<T> {
+
+		/**
+		 * Explicitly set the name of the collection to perform the query 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 FindWithProjection}.
+		 * @throws IllegalArgumentException if collection is {@literal null}.
+		 */
+		FindWithProjection<T> inCollection(String collection);
+	}
+
+	/**
+	 * Result type override (optional).
+	 */
+	interface FindWithProjection<T> extends FindWithQuery<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 FindWithProjection}.
+		 * @throws IllegalArgumentException if resultType is {@literal null}.
+		 */
+		<R> FindWithQuery<R> as(Class<R> resultType);
+	}
+
+	/**
+	 * {@link ReactiveFind} provides methods for constructing lookup operations in a fluent way.
+	 */
+	interface ReactiveFind<T> extends FindWithCollection<T>, FindWithProjection<T> {}
+}

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

@@ -0,0 +1,220 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import lombok.AccessLevel;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+import org.springframework.lang.Nullable;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import org.bson.Document;
+import org.springframework.dao.IncorrectResultSizeDataAccessException;
+import org.springframework.data.mongodb.core.query.NearQuery;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.mongodb.core.query.SerializationUtils;
+import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
+
+import com.mongodb.reactivestreams.client.FindPublisher;
+
+/**
+ * Implementation of {@link ReactiveFindOperation}.
+ *
+ * @author Mark Paluch
+ * @author Christoph Strobl
+ * @since 2.0
+ */
+@RequiredArgsConstructor
+class ReactiveFindOperationSupport implements ReactiveFindOperation {
+
+	private static final Query ALL_QUERY = new Query();
+
+	private final @NonNull ReactiveMongoTemplate template;
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ReactiveFindOperation#query(java.lang.Class)
+	 */
+	@Override
+	public <T> ReactiveFind<T> query(Class<T> domainType) {
+
+		Assert.notNull(domainType, "DomainType must not be null!");
+
+		return new ReactiveFindSupport<>(template, domainType, domainType, null, ALL_QUERY);
+	}
+
+	/**
+	 * @param <T>
+	 * @author Mark Paluch
+	 * @author Christoph Strobl
+	 * @since 2.0
+	 */
+	@RequiredArgsConstructor
+	@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
+	static class ReactiveFindSupport<T>
+			implements ReactiveFind<T>, FindWithCollection<T>, FindWithProjection<T>, FindWithQuery<T> {
+
+		@NonNull ReactiveMongoTemplate template;
+		@NonNull Class<?> domainType;
+		Class<T> returnType;
+		String collection;
+		Query query;
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.FindWithCollection#inCollection(java.lang.String)
+		 */
+		@Override
+		public FindWithProjection<T> inCollection(String collection) {
+
+			Assert.hasText(collection, "Collection name must not be null nor empty!");
+
+			return new ReactiveFindSupport<>(template, domainType, returnType, collection, query);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.FindWithProjection#as(java.lang.Class)
+		 */
+		@Override
+		public <T1> FindWithQuery<T1> as(Class<T1> returnType) {
+
+			Assert.notNull(returnType, "ReturnType must not be null!");
+
+			return new ReactiveFindSupport<>(template, domainType, returnType, collection, query);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.FindWithQuery#matching(org.springframework.data.mongodb.core.query.Query)
+		 */
+		@Override
+		public TerminatingFind<T> matching(Query query) {
+
+			Assert.notNull(query, "Query must not be null!");
+
+			return new ReactiveFindSupport<>(template, domainType, returnType, collection, query);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.TerminatingFind#first()
+		 */
+		@Override
+		public Mono<T> first() {
+
+			FindPublisherPreparer preparer = getCursorPreparer(query);
+			Flux<T> result = doFind(new FindPublisherPreparer() {
+				@Override
+				public <D> FindPublisher<D> prepare(FindPublisher<D> publisher) {
+					return preparer.prepare(publisher).limit(1);
+				}
+			});
+
+			return result.next();
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.TerminatingFind#one()
+		 */
+		@Override
+		public Mono<T> one() {
+
+			FindPublisherPreparer preparer = getCursorPreparer(query);
+			Flux<T> result = doFind(new FindPublisherPreparer() {
+				@Override
+				public <D> FindPublisher<D> prepare(FindPublisher<D> publisher) {
+					return preparer.prepare(publisher).limit(2);
+				}
+			});
+
+			return result.collectList().flatMap(it -> {
+
+				if (it.isEmpty()) {
+					return Mono.empty();
+				}
+
+				if (it.size() > 1) {
+					return Mono.error(
+							new IncorrectResultSizeDataAccessException("Query " + asString() + " returned non unique result.", 1));
+				}
+
+				return Mono.just(it.get(0));
+			});
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.TerminatingFind#all()
+		 */
+		@Override
+		public Flux<T> all() {
+			return doFind(null);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.FindWithQuery#near(org.springframework.data.mongodb.core.query.NearQuery)
+		 */
+		@Override
+		public TerminatingFindNear<T> near(NearQuery nearQuery) {
+			return () -> template.geoNear(nearQuery, domainType, getCollectionName(), returnType);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.TerminatingFind#count()
+		 */
+		@Override
+		public Mono<Long> count() {
+			return template.count(query, domainType, getCollectionName());
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.TerminatingFind#exists()
+		 */
+		@Override
+		public Mono<Boolean> exists() {
+			return template.exists(query, domainType, getCollectionName());
+		}
+
+		private Flux<T> doFind(@Nullable FindPublisherPreparer preparer) {
+
+			Document queryObject = query.getQueryObject();
+			Document fieldsObject = query.getFieldsObject();
+
+			return template.doFind(getCollectionName(), queryObject, fieldsObject, domainType, returnType,
+					preparer != null ? preparer : getCursorPreparer(query));
+		}
+
+		private FindPublisherPreparer getCursorPreparer(Query query) {
+			return template.new QueryFindPublisherPreparer(query, domainType);
+		}
+
+		private String getCollectionName() {
+			return StringUtils.hasText(collection) ? collection : template.determineCollectionName(domainType);
+		}
+
+		private String asString() {
+			return SerializationUtils.serializeToJsonSafely(query);
+		}
+	}
+}

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

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+/**
+ * Stripped down interface providing access to a fluent API that specifies a basic set of reactive MongoDB operations.
+ *
+ * @author Mark Paluch
+ * @since 2.0
+ */
+public interface ReactiveFluentMongoOperations extends ReactiveFindOperation, ReactiveInsertOperation,
+		ReactiveUpdateOperation, ReactiveRemoveOperation, ReactiveAggregationOperation {}

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

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.util.Collection;
+
+/**
+ * {@link ReactiveInsertOperation} allows creation and execution of reactive MongoDB insert and bulk insert operations
+ * in a fluent API style. <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>
+ *         insert(Jedi.class)
+ *             .inCollection("star-wars")
+ *             .one(luke);
+ *     </code>
+ * </pre>
+ *
+ * @author Mark Paluch
+ * @author Christoph Strobl
+ * @since 2.0
+ */
+public interface ReactiveInsertOperation {
+
+	/**
+	 * Start creating an insert operation for given {@literal domainType}.
+	 *
+	 * @param domainType must not be {@literal null}.
+	 * @return new instance of {@link ReactiveInsert}. Never {@literal null}.
+	 * @throws IllegalArgumentException if domainType is {@literal null}.
+	 */
+	<T> ReactiveInsert<T> insert(Class<T> domainType);
+
+	/**
+	 * Compose insert execution by calling one of the terminating methods.
+	 */
+	interface TerminatingInsert<T> {
+
+		/**
+		 * Insert exactly one object.
+		 *
+		 * @param object must not be {@literal null}.
+		 * @return {@link Mono} emitting the inserted {@code object} when operation has completed. Never {@literal null}.
+		 * @throws IllegalArgumentException if object is {@literal null}.
+		 */
+		Mono<T> one(T object);
+
+		/**
+		 * Insert a collection of objects.
+		 *
+		 * @param objects must not be {@literal null}.
+		 * @return {@literal Flux} emitting the inserted {@code objects} ony by one. Never {@literal null}.
+		 * @throws IllegalArgumentException if objects is {@literal null}.
+		 */
+		Flux<T> all(Collection<? extends T> objects);
+	}
+
+	/**
+	 * Collection override (optional).
+	 */
+	interface InsertWithCollection<T> {
+
+		/**
+		 * Explicitly set the name of the collection. <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 TerminatingInsert}. Never {@literal null}.
+		 * @throws IllegalArgumentException if collection is {@literal null}.
+		 */
+		TerminatingInsert<T> inCollection(String collection);
+	}
+
+	interface ReactiveInsert<T> extends TerminatingInsert<T>, InsertWithCollection<T> {}
+}

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

@@ -0,0 +1,102 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import lombok.AccessLevel;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import java.util.Collection;
+
+import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
+
+/**
+ * Implementation of {@link ReactiveInsertOperation}.
+ *
+ * @author Mark Paluch
+ * @author Christoph Strobl
+ * @since 2.0
+ */
+@RequiredArgsConstructor
+class ReactiveInsertOperationSupport implements ReactiveInsertOperation {
+
+	private final @NonNull ReactiveMongoTemplate template;
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ReactiveInsertOperation#insert(java.lang.Class)
+	 */
+	@Override
+	public <T> ReactiveInsert<T> insert(Class<T> domainType) {
+
+		Assert.notNull(domainType, "DomainType must not be null!");
+
+		return new ReactiveInsertSupport<>(template, domainType, null);
+	}
+
+	@RequiredArgsConstructor
+	@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
+	static class ReactiveInsertSupport<T> implements ReactiveInsert<T> {
+
+		@NonNull ReactiveMongoTemplate template;
+		@NonNull Class<T> domainType;
+		String collection;
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveInsertOperation.TerminatingInsert#one(java.lang.Object)
+		 */
+		@Override
+		public Mono<T> one(T object) {
+
+			Assert.notNull(object, "Object must not be null!");
+
+			return template.insert(object, getCollectionName());
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveInsertOperation.TerminatingInsert#all(java.util.Collection)
+		 */
+		@Override
+		public Flux<T> all(Collection<? extends T> objects) {
+
+			Assert.notNull(objects, "Objects must not be null!");
+
+			return template.insert(objects, getCollectionName());
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveInsertOperation.InsertWithCollection#inCollection(java.lang.String)
+		 */
+		@Override
+		public ReactiveInsert<T> inCollection(String collection) {
+
+			Assert.hasText(collection, "Collection must not be null nor empty.");
+
+			return new ReactiveInsertSupport<>(template, domainType, collection);
+		}
+
+		private String getCollectionName() {
+			return StringUtils.hasText(collection) ? collection : template.determineCollectionName(domainType);
+		}
+	}
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016 the original author or authors.
+ * Copyright 2016-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,6 +19,7 @@ package org.springframework.data.mongodb.core;
 import org.springframework.beans.factory.config.AbstractFactoryBean;
 import org.springframework.dao.DataAccessException;
 import org.springframework.dao.support.PersistenceExceptionTranslator;
+import org.springframework.lang.Nullable;
 import org.springframework.util.StringUtils;
 
 import com.mongodb.async.client.MongoClientSettings;
@@ -37,10 +38,10 @@ public class ReactiveMongoClientFactoryBean extends AbstractFactoryBean<MongoCli
 
 	private static final PersistenceExceptionTranslator DEFAULT_EXCEPTION_TRANSLATOR = new MongoExceptionTranslator();
 
-	private String connectionString;
-	private String host;
-	private Integer port;
-	private MongoClientSettings mongoClientSettings;
+	private @Nullable String connectionString;
+	private @Nullable String host;
+	private @Nullable Integer port;
+	private @Nullable MongoClientSettings mongoClientSettings;
 	private PersistenceExceptionTranslator exceptionTranslator = DEFAULT_EXCEPTION_TRANSLATOR;
 
 	/**
@@ -48,7 +49,7 @@ public class ReactiveMongoClientFactoryBean extends AbstractFactoryBean<MongoCli
 	 *
 	 * @param host
 	 */
-	public void setHost(String host) {
+	public void setHost(@Nullable String host) {
 		this.host = host;
 	}
 
@@ -66,7 +67,7 @@ public class ReactiveMongoClientFactoryBean extends AbstractFactoryBean<MongoCli
 	 *
 	 * @param connectionString
 	 */
-	public void setConnectionString(String connectionString) {
+	public void setConnectionString(@Nullable String connectionString) {
 		this.connectionString = connectionString;
 	}
 
@@ -75,7 +76,7 @@ public class ReactiveMongoClientFactoryBean extends AbstractFactoryBean<MongoCli
 	 *
 	 * @param mongoClientSettings
 	 */
-	public void setMongoClientSettings(MongoClientSettings mongoClientSettings) {
+	public void setMongoClientSettings(@Nullable MongoClientSettings mongoClientSettings) {
 		this.mongoClientSettings = mongoClientSettings;
 	}
 
@@ -84,7 +85,7 @@ public class ReactiveMongoClientFactoryBean extends AbstractFactoryBean<MongoCli
 	 *
 	 * @param exceptionTranslator
 	 */
-	public void setExceptionTranslator(PersistenceExceptionTranslator exceptionTranslator) {
+	public void setExceptionTranslator(@Nullable PersistenceExceptionTranslator exceptionTranslator) {
 		this.exceptionTranslator = exceptionTranslator == null ? DEFAULT_EXCEPTION_TRANSLATOR : exceptionTranslator;
 	}
 
@@ -118,7 +119,7 @@ public class ReactiveMongoClientFactoryBean extends AbstractFactoryBean<MongoCli
 	}
 
 	@Override
-	protected void destroyInstance(MongoClient instance) throws Exception {
+	protected void destroyInstance(@Nullable MongoClient instance) throws Exception {
 		instance.close();
 	}
 

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

@@ -1,51 +0,0 @@
-/*
- * Copyright 2016 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.mongodb.core;
-
-import com.mongodb.reactivestreams.client.MongoClient;
-import com.mongodb.reactivestreams.client.MongoDatabase;
-
-/**
- * Helper class featuring helper methods for internal MongoDb classes. Mainly intended for internal use within the
- * framework.
- *
- * @author Mark Paluch
- * @author Christoph Strobl
- * @since 2.0
- */
-public abstract class ReactiveMongoDbUtils {
-
-	/**
-	 * Private constructor to prevent instantiation.
-	 */
-	private ReactiveMongoDbUtils() {}
-
-	/**
-	 * Obtains a {@link MongoDatabase} connection for the given {@link MongoClient} instance and database name
-	 *
-	 * @param mongo the {@link MongoClient} instance, must not be {@literal null}.
-	 * @param databaseName the database name, must not be {@literal null} or empty.
-	 * @return the {@link MongoDatabase} connection
-	 */
-	public static MongoDatabase getMongoDatabase(MongoClient mongo, String databaseName) {
-		return doGetMongoDatabase(mongo, databaseName, true);
-	}
-
-	private static MongoDatabase doGetMongoDatabase(MongoClient mongo, String databaseName, boolean allowCreate) {
-		return mongo.getDatabase(databaseName);
-	}
-
-}

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

@@ -0,0 +1,112 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import org.springframework.data.mongodb.core.query.Query;
+
+import com.mongodb.client.result.DeleteResult;
+
+/**
+ * {@link ReactiveRemoveOperation} allows creation and execution of reactive MongoDB remove / findAndRemove operations
+ * in a fluent API style. <br />
+ * The starting {@literal domainType} is used for mapping the {@link Query} provided via {@code matching} into the
+ * MongoDB specific representation. 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>
+ *         remove(Jedi.class)
+ *             .inCollection("star-wars")
+ *             .matching(query(where("firstname").is("luke")))
+ *             .all();
+ *     </code>
+ * </pre>
+ *
+ * @author Mark Paluch
+ * @author Christoph Strobl
+ * @since 2.0
+ */
+public interface ReactiveRemoveOperation {
+
+	/**
+	 * Start creating a remove operation for the given {@literal domainType}.
+	 *
+	 * @param domainType must not be {@literal null}.
+	 * @return new instance of {@link ReactiveRemove}. Never {@literal null}.
+	 * @throws IllegalArgumentException if domainType is {@literal null}.
+	 */
+	<T> ReactiveRemove<T> remove(Class<T> domainType);
+
+	/**
+	 * Compose remove execution by calling one of the terminating methods.
+	 */
+	interface TerminatingRemove<T> {
+
+		/**
+		 * Remove all documents matching.
+		 *
+		 * @return {@link Mono} emitting the {@link DeleteResult}. Never {@literal null}.
+		 */
+		Mono<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 Flux} if no match found. Never {@literal null}.
+		 */
+		Flux<T> findAndRemove();
+	}
+
+	/**
+	 * Collection override (optional).
+	 */
+	interface RemoveWithCollection<T> extends RemoveWithQuery<T> {
+
+		/**
+		 * Explicitly set the name of the collection to perform the query 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 RemoveWithCollection}. Never {@literal null}.
+		 * @throws IllegalArgumentException if collection is {@literal null} or empty.
+		 */
+		RemoveWithQuery<T> inCollection(String collection);
+	}
+
+	/**
+	 * Provide a {@link Query} override (optional).
+	 */
+	interface RemoveWithQuery<T> extends TerminatingRemove<T> {
+
+		/**
+		 * Define the query filtering elements.
+		 *
+		 * @param query must not be {@literal null}.
+		 * @return new instance of {@link TerminatingRemove}. Never {@literal null}.
+		 * @throws IllegalArgumentException if query is {@literal null}.
+		 */
+		TerminatingRemove<T> matching(Query query);
+	}
+
+	interface ReactiveRemove<T> extends RemoveWithCollection<T> {}
+}

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

@@ -0,0 +1,119 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import lombok.AccessLevel;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
+
+import com.mongodb.client.result.DeleteResult;
+
+/**
+ * Implementation of {@link ReactiveRemoveOperation}.
+ *
+ * @author Mark Paluch
+ * @author Christoph Strobl
+ * @since 2.0
+ */
+@RequiredArgsConstructor
+class ReactiveRemoveOperationSupport implements ReactiveRemoveOperation {
+
+	private static final Query ALL_QUERY = new Query();
+
+	private final @NonNull ReactiveMongoTemplate tempate;
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ReactiveRemoveOperation#remove(java.lang.Class)
+	 */
+	@Override
+	public <T> ReactiveRemove<T> remove(Class<T> domainType) {
+
+		Assert.notNull(domainType, "DomainType must not be null!");
+
+		return new ReactiveRemoveSupport<>(tempate, domainType, ALL_QUERY, null);
+	}
+
+	@RequiredArgsConstructor
+	@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
+	static class ReactiveRemoveSupport<T> implements ReactiveRemove<T>, RemoveWithCollection<T> {
+
+		@NonNull ReactiveMongoTemplate template;
+		@NonNull Class<T> domainType;
+		Query query;
+		String collection;
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveRemoveOperation.RemoveWithCollection#inCollection(String)
+		 */
+		@Override
+		public RemoveWithQuery<T> inCollection(String collection) {
+
+			Assert.hasText(collection, "Collection must not be null nor empty!");
+
+			return new ReactiveRemoveSupport<>(template, domainType, query, collection);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveRemoveOperation.RemoveWithQuery#matching(org.springframework.data.mongodb.core.Query)
+		 */
+		@Override
+		public TerminatingRemove<T> matching(Query query) {
+
+			Assert.notNull(query, "Query must not be null!");
+
+			return new ReactiveRemoveSupport<>(template, domainType, query, collection);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveRemoveOperation.TerminatingRemove#all()
+		 */
+		@Override
+		public Mono<DeleteResult> all() {
+
+			String collectionName = getCollectionName();
+
+			return template.doRemove(collectionName, query, domainType);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveRemoveOperation.TerminatingRemove#findAndRemove()
+		 */
+		@Override
+		public Flux<T> findAndRemove() {
+
+			String collectionName = getCollectionName();
+
+			return template.doFindAndDelete(collectionName, query, domainType);
+		}
+
+		private String getCollectionName() {
+			return StringUtils.hasText(collection) ? collection : template.determineCollectionName(domainType);
+		}
+
+	}
+}

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

@@ -0,0 +1,161 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import reactor.core.publisher.Mono;
+
+import org.springframework.data.mongodb.core.query.Query;
+
+import com.mongodb.client.result.UpdateResult;
+
+/**
+ * {@link ReactiveUpdateOperation} allows creation and execution of reactive MongoDB update / findAndModify 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
+ * 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>
+ *         update(Jedi.class)
+ *             .inCollection("star-wars")
+ *             .matching(query(where("firstname").is("luke")))
+ *             .apply(new Update().set("lastname", "skywalker"))
+ *             .upsert();
+ *     </code>
+ * </pre>
+ *
+ * @author Mark Paluch
+ * @author Christoph Strobl
+ * @since 2.0
+ */
+public interface ReactiveUpdateOperation {
+
+	/**
+	 * Start creating an update operation for the given {@literal domainType}.
+	 *
+	 * @param domainType must not be {@literal null}.
+	 * @return new instance of {@link ReactiveUpdate}. Never {@literal null}.
+	 * @throws IllegalArgumentException if domainType is {@literal null}.
+	 */
+	<T> ReactiveUpdate<T> update(Class<T> domainType);
+
+	/**
+	 * Compose findAndModify execution by calling one of the terminating methods.
+	 */
+	interface TerminatingFindAndModify<T> {
+
+		/**
+		 * Find, modify and return the first matching document.
+		 *
+		 * @return {@link Mono#empty()} if nothing found. Never {@literal null}.
+		 */
+		Mono<T> findAndModify();
+	}
+
+	/**
+	 * Compose update execution by calling one of the terminating methods.
+	 */
+	interface TerminatingUpdate<T> extends TerminatingFindAndModify<T>, FindAndModifyWithOptions<T> {
+
+		/**
+		 * Update all matching documents in the collection.
+		 *
+		 * @return never {@literal null}.
+		 */
+		Mono<UpdateResult> all();
+
+		/**
+		 * Update the first document in the collection.
+		 *
+		 * @return never {@literal null}.
+		 */
+		Mono<UpdateResult> first();
+
+		/**
+		 * Creates a new document if no documents match the filter query or updates the matching ones.
+		 *
+		 * @return never {@literal null}.
+		 */
+		Mono<UpdateResult> upsert();
+	}
+
+	/**
+	 * Declare the {@link org.springframework.data.mongodb.core.query.Update} to apply.
+	 */
+	interface UpdateWithUpdate<T> {
+
+		/**
+		 * Set the {@link org.springframework.data.mongodb.core.query.Update} to be applied.
+		 *
+		 * @param update must not be {@literal null}.
+		 * @return new instance of {@link TerminatingUpdate}. Never {@literal null}.
+		 * @throws IllegalArgumentException if update is {@literal null}.
+		 */
+		TerminatingUpdate<T> apply(org.springframework.data.mongodb.core.query.Update update);
+	}
+
+	/**
+	 * Explicitly define the name of the collection to perform operation in (optional).
+	 */
+	interface UpdateWithCollection<T> {
+
+		/**
+		 * Explicitly set the name of the collection to perform the query 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 UpdateWithCollection}. Never {@literal null}.
+		 * @throws IllegalArgumentException if collection is {@literal null} or empty.
+		 */
+		UpdateWithQuery<T> inCollection(String collection);
+	}
+
+	/**
+	 * Define a filter query for the {@link org.springframework.data.mongodb.core.query.Update} (optional).
+	 */
+	interface UpdateWithQuery<T> extends UpdateWithUpdate<T> {
+
+		/**
+		 * Filter documents by given {@literal query}.
+		 *
+		 * @param query must not be {@literal null}.
+		 * @return new instance of {@link UpdateWithQuery}. Never {@literal null}.
+		 * @throws IllegalArgumentException if query is {@literal null}.
+		 */
+		UpdateWithUpdate<T> matching(Query query);
+	}
+
+	/**
+	 * Define {@link FindAndModifyOptions} (optional).
+	 */
+	interface FindAndModifyWithOptions<T> {
+
+		/**
+		 * Explicitly define {@link FindAndModifyOptions} for the
+		 * {@link org.springframework.data.mongodb.core.query.Update}.
+		 *
+		 * @param options must not be {@literal null}.
+		 * @return new instance of {@link TerminatingFindAndModify}. Never {@literal null}.
+		 * @throws IllegalArgumentException if options is {@literal null}.
+		 */
+		TerminatingFindAndModify<T> withOptions(FindAndModifyOptions options);
+	}
+
+	interface ReactiveUpdate<T> extends UpdateWithCollection<T>, UpdateWithQuery<T>, UpdateWithUpdate<T> {}
+}

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

@@ -0,0 +1,163 @@
+/*
+ * Copyright 2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import lombok.AccessLevel;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.FieldDefaults;
+import reactor.core.publisher.Mono;
+
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
+
+import com.mongodb.client.result.UpdateResult;
+
+/**
+ * Implementation of {@link ReactiveUpdateOperation}.
+ *
+ * @author Mark Paluch
+ * @author Christoph Strobl
+ * @since 2.0
+ */
+@RequiredArgsConstructor
+class ReactiveUpdateOperationSupport implements ReactiveUpdateOperation {
+
+	private static final Query ALL_QUERY = new Query();
+
+	private final @NonNull ReactiveMongoTemplate template;
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ReactiveUpdateOperation#update(java.lang.Class)
+	 */
+	@Override
+	public <T> ReactiveUpdate<T> update(Class<T> domainType) {
+
+		Assert.notNull(domainType, "DomainType must not be null!");
+
+		return new ReactiveUpdateSupport<>(template, domainType, ALL_QUERY, null, null, null);
+	}
+
+	@RequiredArgsConstructor
+	@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
+	static class ReactiveUpdateSupport<T>
+			implements ReactiveUpdate<T>, UpdateWithCollection<T>, UpdateWithQuery<T>, TerminatingUpdate<T> {
+
+		@NonNull ReactiveMongoTemplate template;
+		@NonNull Class<T> domainType;
+		Query query;
+		org.springframework.data.mongodb.core.query.Update update;
+		String collection;
+		FindAndModifyOptions options;
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveUpdateOperation.UpdateWithUpdate#apply(org.springframework.data.mongodb.core.query.Update)
+		 */
+		@Override
+		public TerminatingUpdate<T> apply(org.springframework.data.mongodb.core.query.Update update) {
+
+			Assert.notNull(update, "Update must not be null!");
+
+			return new ReactiveUpdateSupport<>(template, domainType, query, update, collection, options);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveUpdateOperation.UpdateWithCollection#inCollection(java.lang.String)
+		 */
+		@Override
+		public UpdateWithQuery<T> inCollection(String collection) {
+
+			Assert.hasText(collection, "Collection must not be null nor empty!");
+
+			return new ReactiveUpdateSupport<>(template, domainType, query, update, collection, options);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveUpdateOperation.TerminatingUpdate#first()
+		 */
+		@Override
+		public Mono<UpdateResult> first() {
+			return doUpdate(false, false);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveUpdateOperation.TerminatingUpdate#upsert()
+		 */
+		@Override
+		public Mono<UpdateResult> upsert() {
+			return doUpdate(true, true);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveUpdateOperation.TerminatingFindAndModify#findAndModify()
+		 */
+		@Override
+		public Mono<T> findAndModify() {
+
+			String collectionName = getCollectionName();
+
+			return template.findAndModify(query, update, options, domainType, collectionName);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveUpdateOperation.UpdateWithQuery#matching(org.springframework.data.mongodb.core.Query)
+		 */
+		@Override
+		public UpdateWithUpdate<T> matching(Query query) {
+
+			Assert.notNull(query, "Query must not be null!");
+
+			return new ReactiveUpdateSupport<>(template, domainType, query, update, collection, options);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveUpdateOperation.TerminatingUpdate#all()
+		 */
+		@Override
+		public Mono<UpdateResult> all() {
+			return doUpdate(true, false);
+		}
+
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveUpdateOperation.FindAndModifyWithOptions#withOptions(org.springframework.data.mongodb.core.FindAndModifyOptions)
+		 */
+		@Override
+		public TerminatingFindAndModify<T> withOptions(FindAndModifyOptions options) {
+
+			Assert.notNull(options, "Options must not be null!");
+
+			return new ReactiveUpdateSupport<>(template, domainType, query, update, collection, options);
+		}
+
+		private Mono<UpdateResult> doUpdate(boolean multi, boolean upsert) {
+			return template.doUpdate(getCollectionName(), query, update, domainType, upsert, multi);
+		}
+
+		private String getCollectionName() {
+			return StringUtils.hasText(collection) ? collection : template.determineCollectionName(domainType);
+		}
+	}
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2014-2015 the original author or authors.
+ * Copyright 2014-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,6 +19,7 @@ import java.util.Set;
 
 import org.springframework.data.mongodb.core.script.ExecutableMongoScript;
 import org.springframework.data.mongodb.core.script.NamedMongoScript;
+import org.springframework.lang.Nullable;
 
 import com.mongodb.DB;
 
@@ -56,6 +57,7 @@ public interface ScriptOperations {
 	 * @return the script evaluation result.
 	 * @throws org.springframework.dao.DataAccessException
 	 */
+	@Nullable
 	Object execute(ExecutableMongoScript script, Object... args);
 
 	/**
@@ -65,6 +67,7 @@ public interface ScriptOperations {
 	 * @param args
 	 * @return
 	 */
+	@Nullable
 	Object call(String scriptName, Object... args);
 
 	/**

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

@@ -1,149 +1,150 @@
-/*
- * Copyright 2011-2017 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.mongodb.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.util.Assert;
-
-import com.mongodb.DB;
-import com.mongodb.MongoClient;
-import com.mongodb.MongoClientURI;
-import com.mongodb.WriteConcern;
-import com.mongodb.client.MongoDatabase;
-
-/**
- * Factory to create {@link DB} instances from a {@link MongoClient} instance.
- * 
- * @author Mark Pollack
- * @author Oliver Gierke
- * @author Thomas Darimont
- * @author Christoph Strobl
- */
-public class SimpleMongoDbFactory implements DisposableBean, MongoDbFactory {
-
-	private final MongoClient mongoClient;
-	private final String databaseName;
-	private final boolean mongoInstanceCreated;
-	private final PersistenceExceptionTranslator exceptionTranslator;
-
-	private WriteConcern writeConcern;
-
-	/**
-	 * Creates a new {@link SimpleMongoDbFactory} instance from the given {@link MongoClientURI}.
-	 * 
-	 * @param uri must not be {@literal null}.
-	 * @throws UnknownHostException
-	 * @since 1.7
-	 */
-	public SimpleMongoDbFactory(MongoClientURI uri) {
-		this(new MongoClient(uri), uri.getDatabase(), true);
-	}
-
-	/**
-	 * 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}.
-	 * @since 1.7
-	 */
-	public SimpleMongoDbFactory(MongoClient mongoClient, String databaseName) {
-		this(mongoClient, databaseName, false);
-	}
-
-	/**
-	 * @param client
-	 * @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();
-	}
-
-	/**
-	 * 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()
-	 */
-	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);
-	}
-}
+/*
+ * Copyright 2011-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.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.DB;
+import com.mongodb.MongoClient;
+import com.mongodb.MongoClientURI;
+import com.mongodb.WriteConcern;
+import com.mongodb.client.MongoDatabase;
+
+/**
+ * Factory to create {@link DB} instances from a {@link MongoClient} instance.
+ * 
+ * @author Mark Pollack
+ * @author Oliver Gierke
+ * @author Thomas Darimont
+ * @author Christoph Strobl
+ */
+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;
+
+	/**
+	 * Creates a new {@link SimpleMongoDbFactory} instance from the given {@link MongoClientURI}.
+	 * 
+	 * @param uri must not be {@literal null}.
+	 * @throws UnknownHostException
+	 * @since 1.7
+	 */
+	public SimpleMongoDbFactory(MongoClientURI uri) {
+		this(new MongoClient(uri), uri.getDatabase(), true);
+	}
+
+	/**
+	 * 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}.
+	 * @since 1.7
+	 */
+	public SimpleMongoDbFactory(MongoClient mongoClient, String databaseName) {
+		this(mongoClient, databaseName, false);
+	}
+
+	/**
+	 * @param client
+	 * @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();
+	}
+
+	/**
+	 * 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()
+	 */
+	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);
+	}
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016 the original author or authors.
+ * Copyright 2016-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,6 +21,7 @@ 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.lang.Nullable;
 import org.springframework.util.Assert;
 
 import com.mongodb.ConnectionString;
@@ -33,6 +34,7 @@ import com.mongodb.reactivestreams.client.MongoDatabase;
  * Factory to create {@link MongoDatabase} instances from a {@link MongoClient} instance.
  *
  * @author Mark Paluch
+ * @author Christoph Strobl
  * @since 2.0
  */
 public class SimpleReactiveMongoDatabaseFactory implements DisposableBean, ReactiveMongoDatabaseFactory {
@@ -40,9 +42,10 @@ public class SimpleReactiveMongoDatabaseFactory implements DisposableBean, React
 	private final MongoClient mongo;
 	private final String databaseName;
 	private final boolean mongoInstanceCreated;
+
 	private final PersistenceExceptionTranslator exceptionTranslator;
 
-	private WriteConcern writeConcern;
+	private @Nullable WriteConcern writeConcern;
 
 	/**
 	 * Creates a new {@link SimpleReactiveMongoDatabaseFactory} instance from the given {@link ConnectionString}.
@@ -103,14 +106,8 @@ public class SimpleReactiveMongoDatabaseFactory implements DisposableBean, React
 
 		Assert.hasText(dbName, "Database name must not be empty.");
 
-		MongoDatabase db = ReactiveMongoDbUtils.getMongoDatabase(mongo, dbName);
-
-		if (writeConcern != null) {
-
-			db = db.withWriteConcern(writeConcern);
-		}
-
-		return db;
+		MongoDatabase db = mongo.getDatabase(dbName);
+		return writeConcern != null ? db.withWriteConcern(writeConcern) : db;
 	}
 
 	/**
@@ -119,6 +116,7 @@ public class SimpleReactiveMongoDatabaseFactory implements DisposableBean, React
 	 * @see DisposableBean#destroy()
 	 */
 	public void destroy() throws Exception {
+
 		if (mongoInstanceCreated) {
 			mongo.close();
 		}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2012 the original author or authors.
+ * Copyright 2011-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,6 +15,8 @@
  */
 package org.springframework.data.mongodb.core;
 
+import org.springframework.lang.Nullable;
+
 import com.mongodb.WriteConcern;
 
 /**
@@ -33,5 +35,6 @@ public interface WriteConcernResolver {
 	 *          should not be resolved.
 	 * @return a {@link WriteConcern} based on the passed in {@link MongoAction} value, maybe {@literal null}.
 	 */
+	@Nullable
 	WriteConcern resolve(MongoAction action);
 }

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

@@ -17,7 +17,6 @@ package org.springframework.data.mongodb.core.aggregation;
 
 import static org.springframework.data.mongodb.core.aggregation.Fields.*;
 
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
@@ -25,19 +24,15 @@ import org.bson.Document;
 import org.springframework.data.domain.Sort;
 import org.springframework.data.domain.Sort.Direction;
 import org.springframework.data.mongodb.core.aggregation.CountOperation.CountOperationBuilder;
-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.FacetOperation.FacetOperationBuilder;
-import org.springframework.data.mongodb.core.aggregation.FieldsExposingAggregationOperation.InheritsFieldsAggregationOperation;
 import org.springframework.data.mongodb.core.aggregation.GraphLookupOperation.StartWithBuilder;
 import org.springframework.data.mongodb.core.aggregation.ReplaceRootOperation.ReplaceRootDocumentOperationBuilder;
 import org.springframework.data.mongodb.core.aggregation.ReplaceRootOperation.ReplaceRootOperationBuilder;
-import org.springframework.data.mongodb.core.aggregation.Fields.*;
 import org.springframework.data.mongodb.core.query.Criteria;
 import org.springframework.data.mongodb.core.query.CriteriaDefinition;
 import org.springframework.data.mongodb.core.query.NearQuery;
 import org.springframework.data.mongodb.core.query.SerializationUtils;
+import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 /**
@@ -51,6 +46,7 @@ import org.springframework.util.Assert;
  * @author Alessio Fachechi
  * @author Christoph Strobl
  * @author Nikolay Bogdanov
+ * @author Gustavo de Geus
  * @since 1.3
  */
 public class Aggregation {
@@ -348,7 +344,7 @@ public class Aggregation {
 	 * @return
 	 */
 	public static SortOperation sort(Direction direction, String... fields) {
-		return new SortOperation(new Sort(direction, fields));
+		return new SortOperation(Sort.by(direction, fields));
 	}
 
 	/**
@@ -382,6 +378,17 @@ public class Aggregation {
 		return new LimitOperation(maxElements);
 	}
 
+	/**
+	 * Creates a new {@link SampleOperation} to select the specified number of documents from its input randomly.
+	 *
+	 * @param sampleSize must not be less than zero.
+	 * @return
+	 * @since 2.0
+	 */
+	public static SampleOperation sample(long sampleSize) {
+		return new SampleOperation(sampleSize);
+	}
+
 	/**
 	 * Creates a new {@link MatchOperation} using the given {@link Criteria}.
 	 *
@@ -585,7 +592,7 @@ public class Aggregation {
 		return command;
 	}
 
-	/* 
+	/*
 	 * (non-Javadoc)
 	 * @see java.lang.Object#toString()
 	 */
@@ -613,7 +620,7 @@ public class Aggregation {
 		 * @param fieldRef may be {@literal null}.
 		 * @return
 		 */
-		public static boolean isReferingToSystemVariable(String fieldRef) {
+		public static boolean isReferingToSystemVariable(@Nullable String fieldRef) {
 
 			if (fieldRef == null || !fieldRef.startsWith(PREFIX) || fieldRef.length() <= 2) {
 				return false;

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013 the original author or authors.
+ * Copyright 2013-2017 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,14 +21,16 @@ import org.springframework.data.mongodb.core.aggregation.ExposedFields.FieldRefe
 import org.springframework.data.mongodb.core.spel.ExpressionNode;
 import org.springframework.data.mongodb.core.spel.ExpressionTransformationContextSupport;
 import org.springframework.data.mongodb.core.spel.ExpressionTransformer;
+import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 /**
  * Interface to type an {@link ExpressionTransformer} to the contained
  * {@link AggregationExpressionTransformationContext}.
- * 
+ *
  * @author Oliver Gierke
  * @author Christoph Strobl
+ * @author Mark Paluch
  * @since 1.4
  */
 interface AggregationExpressionTransformer
@@ -36,7 +38,7 @@ interface AggregationExpressionTransformer
 
 	/**
 	 * A special {@link ExpressionTransformationContextSupport} to be aware of the {@link AggregationOperationContext}.
-	 * 
+	 *
 	 * @author Oliver Gierke
 	 * @author Thomas Darimont
 	 */
@@ -47,14 +49,14 @@ interface AggregationExpressionTransformer
 
 		/**
 		 * Creates an {@link AggregationExpressionTransformationContext}.
-		 * 
+		 *
 		 * @param currentNode must not be {@literal null}.
-		 * @param parentNode
-		 * @param previousOperationObject
+		 * @param parentNode may be {@literal null}.
+		 * @param previousOperationObject may be {@literal null}.
 		 * @param aggregationContext must not be {@literal null}.
 		 */
-		public AggregationExpressionTransformationContext(T currentNode, ExpressionNode parentNode,
-				Document previousOperationObject, AggregationOperationContext context) {
+		public AggregationExpressionTransformationContext(T currentNode, @Nullable ExpressionNode parentNode,
+				@Nullable Document previousOperationObject, AggregationOperationContext context) {
 
 			super(currentNode, parentNode, previousOperationObject);
 
@@ -64,7 +66,7 @@ interface AggregationExpressionTransformer
 
 		/**
 		 * Returns the underlying {@link AggregationOperationContext}.
-		 * 
+		 *
 		 * @return
 		 */
 		public AggregationOperationContext getAggregationContext() {
@@ -73,7 +75,7 @@ interface AggregationExpressionTransformer
 
 		/**
 		 * Returns the {@link FieldReference} for the current {@link ExpressionNode}.
-		 * 
+		 *
 		 * @return
 		 */
 		public FieldReference getFieldReference() {

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

@@ -15,7 +15,11 @@
  */
 package org.springframework.data.mongodb.core.aggregation;
 
+import java.util.Optional;
+
 import org.bson.Document;
+import org.springframework.data.mongodb.core.query.Collation;
+import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 import com.mongodb.DBObject;
@@ -39,10 +43,12 @@ public class AggregationOptions {
 	private static final String CURSOR = "cursor";
 	private static final String EXPLAIN = "explain";
 	private static final String ALLOW_DISK_USE = "allowDiskUse";
+	private static final String COLLATION = "collation";
 
 	private final boolean allowDiskUse;
 	private final boolean explain;
-	private final Document cursor;
+	private final Optional<Document> cursor;
+	private final Optional<Collation> collation;
 
 	/**
 	 * Creates a new {@link AggregationOptions}.
@@ -52,10 +58,26 @@ public class AggregationOptions {
 	 * @param cursor can be {@literal null}, used to pass additional options to the aggregation.
 	 */
 	public AggregationOptions(boolean allowDiskUse, boolean explain, Document cursor) {
+		this(allowDiskUse, explain, cursor, null);
+	}
+
+	/**
+	 * Creates a new {@link AggregationOptions}.
+	 *
+	 * @param allowDiskUse whether to off-load intensive sort-operations to disk.
+	 * @param explain whether to get the execution plan for the aggregation instead of the actual results.
+	 * @param cursor can be {@literal null}, used to pass additional options (such as {@code batchSize}) to the
+	 *          aggregation.
+	 * @param collation collation for string comparison. Can be {@literal null}.
+	 * @since 2.0
+	 */
+	public AggregationOptions(boolean allowDiskUse, boolean explain, @Nullable Document cursor,
+			@Nullable Collation collation) {
 
 		this.allowDiskUse = allowDiskUse;
 		this.explain = explain;
-		this.cursor = cursor;
+		this.cursor = Optional.ofNullable(cursor);
+		this.collation = Optional.ofNullable(collation);
 	}
 
 	/**
@@ -67,7 +89,7 @@ public class AggregationOptions {
 	 * @since 2.0
 	 */
 	public AggregationOptions(boolean allowDiskUse, boolean explain, int cursorBatchSize) {
-		this(allowDiskUse, explain, createCursor(cursorBatchSize));
+		this(allowDiskUse, explain, createCursor(cursorBatchSize), null);
 	}
 
 	/**
@@ -81,23 +103,23 @@ public class AggregationOptions {
 
 		Assert.notNull(document, "Document must not be null!");
 
-		boolean allowDiskUse = false;
-		boolean explain = false;
-		Document cursor = null;
+		boolean allowDiskUse = document.getBoolean(ALLOW_DISK_USE, false);
+		boolean explain = document.getBoolean(EXPLAIN, false);
+		Document cursor = document.get(CURSOR, Document.class);
+		Collation collation = document.containsKey(COLLATION) ? Collation.from(document.get(COLLATION, Document.class))
+				: null;
 
-		if (document.containsKey(ALLOW_DISK_USE)) {
-			allowDiskUse = document.get(ALLOW_DISK_USE, Boolean.class);
-		}
+		return new AggregationOptions(allowDiskUse, explain, cursor, collation);
+	}
 
-		if (document.containsKey(EXPLAIN)) {
-			explain = (Boolean) document.get(EXPLAIN);
-		}
-
-		if (document.containsKey(CURSOR)) {
-			cursor = document.get(CURSOR, Document.class);
-		}
-
-		return new AggregationOptions(allowDiskUse, explain, cursor);
+	/**
+	 * Obtain a new {@link Builder} for constructing {@link AggregationOptions}.
+	 *
+	 * @return never {@literal null}.
+	 * @since 2.0
+	 */
+	public static Builder builder() {
+		return new Builder();
 	}
 
 	/**
@@ -127,8 +149,8 @@ public class AggregationOptions {
 	 */
 	public Integer getCursorBatchSize() {
 
-		if (cursor != null && cursor.containsKey("batchSize")) {
-			return cursor.get("batchSize", Integer.class);
+		if (cursor.filter(val -> val.containsKey(BATCH_SIZE)).isPresent()) {
+			return cursor.get().get(BATCH_SIZE, Integer.class);
 		}
 
 		return null;
@@ -139,10 +161,20 @@ public class AggregationOptions {
 	 *
 	 * @return
 	 */
-	public Document getCursor() {
+	public Optional<Document> getCursor() {
 		return cursor;
 	}
 
+	/**
+	 * Get collation settings for string comparison.
+	 *
+	 * @return
+	 * @since 2.0
+	 */
+	public Optional<Collation> getCollation() {
+		return collation;
+	}
+
 	/**
 	 * Returns a new potentially adjusted copy for the given {@code aggregationCommandObject} with the configuration
 	 * applied.
@@ -162,8 +194,12 @@ public class AggregationOptions {
 			result.put(EXPLAIN, explain);
 		}
 
-		if (cursor != null && !result.containsKey(CURSOR)) {
-			result.put(CURSOR, cursor);
+		if (!result.containsKey(CURSOR)) {
+			cursor.ifPresent(val -> result.put(CURSOR, val));
+		}
+
+		if (!result.containsKey(COLLATION)) {
+			collation.map(Collation::toDocument).ifPresent(val -> result.append(COLLATION, val));
 		}
 
 		return result;
@@ -179,7 +215,9 @@ public class AggregationOptions {
 		Document document = new Document();
 		document.put(ALLOW_DISK_USE, allowDiskUse);
 		document.put(EXPLAIN, explain);
-		document.put(CURSOR, cursor);
+
+		cursor.ifPresent(val -> document.put(CURSOR, val));
+		collation.ifPresent(val -> document.append(COLLATION, val.toDocument()));
 
 		return document;
 	}
@@ -206,7 +244,8 @@ public class AggregationOptions {
 
 		private boolean allowDiskUse;
 		private boolean explain;
-		private Document cursor;
+		private @Nullable Document cursor;
+		private @Nullable Collation collation;
 
 		/**
 		 * Defines whether to off-load intensive sort-operations to disk.
@@ -257,13 +296,25 @@ public class AggregationOptions {
 			return this;
 		}
 
+		/**
+		 * Define collation settings for string comparison.
+		 *
+		 * @param collation can be {@literal null}.
+		 * @return
+		 */
+		public Builder collation(@Nullable Collation collation) {
+
+			this.collation = collation;
+			return this;
+		}
+
 		/**
 		 * Returns a new {@link AggregationOptions} instance with the given configuration.
 		 *
 		 * @return
 		 */
 		public AggregationOptions build() {
-			return new AggregationOptions(allowDiskUse, explain, cursor);
+			return new AggregationOptions(allowDiskUse, explain, cursor, collation);
 		}
 	}
 }

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

@@ -20,11 +20,12 @@ import java.util.Iterator;
 import java.util.List;
 
 import org.bson.Document;
+import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 
 /**
  * Collects the results of executing an aggregation operation.
- * 
+ *
  * @author Tobias Trelle
  * @author Oliver Gierke
  * @author Thomas Darimont
@@ -37,11 +38,11 @@ public class AggregationResults<T> implements Iterable<T> {
 
 	private final List<T> mappedResults;
 	private final Document rawResults;
-	private final String serverUsed;
+	private final @Nullable String serverUsed;
 
 	/**
 	 * Creates a new {@link AggregationResults} instance from the given mapped and raw results.
-	 * 
+	 *
 	 * @param mappedResults must not be {@literal null}.
 	 * @param rawResults must not be {@literal null}.
 	 */
@@ -57,7 +58,7 @@ public class AggregationResults<T> implements Iterable<T> {
 
 	/**
 	 * Returns the aggregation results.
-	 * 
+	 *
 	 * @return
 	 */
 	public List<T> getMappedResults() {
@@ -66,10 +67,11 @@ public class AggregationResults<T> implements Iterable<T> {
 
 	/**
 	 * Returns the unique mapped result. Assumes no result or exactly one.
-	 * 
+	 *
 	 * @return
 	 * @throws IllegalArgumentException in case more than one result is available.
 	 */
+	@Nullable
 	public T getUniqueMappedResult() {
 		Assert.isTrue(mappedResults.size() < 2, "Expected unique result or null, but got more than one!");
 		return mappedResults.size() == 1 ? mappedResults.get(0) : null;
@@ -85,16 +87,17 @@ public class AggregationResults<T> implements Iterable<T> {
 
 	/**
 	 * Returns the server that has been used to perform the aggregation.
-	 * 
+	 *
 	 * @return
 	 */
+	@Nullable
 	public String getServerUsed() {
 		return serverUsed;
 	}
 
 	/**
 	 * Returns the raw result that was returned by the server.
-	 * 
+	 *
 	 * @return
 	 * @since 1.6
 	 */
@@ -102,6 +105,7 @@ public class AggregationResults<T> implements Iterable<T> {
 		return rawResults;
 	}
 
+	@Nullable
 	private String parseServerUsed() {
 
 		Object object = rawResults.get("serverUsed");