DATAMONGO-2143 - Release version 1.10.18 (Ingalls SR18).

We now no longer try to convert the actual slice parameters into a DBRef.

Original pull request: #623.

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,9 +1,12 @@
+<!--
+
 Thank you for proposing a pull request. This template will guide you through the essential steps necessary for a pull request.
 Make sure that:
 
+-->
+
 - [ ] You have read the [Spring Data contribution guidelines](https://github.com/spring-projects/spring-data-build/blob/master/CONTRIBUTING.adoc).
 - [ ] There is a ticket in the bug tracker for the project in our [JIRA](https://jira.spring.io/browse/DATAMONGO).
 - [ ] You use the code formatters provided [here](https://github.com/spring-projects/spring-data-build/tree/master/etc/ide) and have them applied to your changes. Don’t submit any formatting related changes.
 - [ ] You submit test cases (unit or integration tests) that back your changes.
 - [ ] You added yourself as author in the headers of the classes you touched. Amend the date range in the Apache license header if needed. For new types, add the license header (copy from another file and set the current year only).
-- [ ] You provide your full name and an email address registered with your GitHub account. If you’re a first-time submitter, make sure you have completed the [Contributor’s License Agreement form](https://support.springsource.com/spring_committer_signup).

.travis.yml

@@ -6,6 +6,9 @@ jdk:
 before_script:
   - mongod --version
 
+services:
+  - mongodb
+
 env:
   matrix:
     - PROFILE=ci
@@ -15,6 +18,7 @@ env:
     - PROFILE=mongo31
     - PROFILE=mongo32
     - PROFILE=mongo33
+    - PROFILE=mongo34
     - PROFILE=mongo34-next
 
 # Current MongoDB version is 2.4.2 as of 2016-04, see https://github.com/travis-ci/travis-ci/issues/3694
@@ -22,10 +26,11 @@ env:
 addons:
   apt:
     sources:
-    - mongodb-3.2-precise
+      - mongodb-3.4-precise
     packages:
     - mongodb-org-server
     - mongodb-org-shell
+    - oracle-java8-installer
 
 sudo: false
 
@@ -33,6 +38,8 @@ cache:
   directories:
     - $HOME/.m2
 
-install: true
+install:
+  - |-
+    mongo admin --eval  "db.adminCommand({setFeatureCompatibilityVersion: '3.4'});"
 
 script: "mvn clean dependency:list test -P${PROFILE} -Dsort"

README.md

@@ -143,8 +143,8 @@ public class MyService {
 Here are some ways for you to get involved in the community:
 
 * Get involved with the Spring community on Stackoverflow and help out on the [spring-data-mongodb](http://stackoverflow.com/questions/tagged/spring-data-mongodb) tag by responding to questions and joining the debate.
-* Create [JIRA](https://jira.springframework.org/browse/DATADOC) tickets for bugs and new features and comment and vote on the ones that you are interested in.  
+* Create [JIRA](https://jira.spring.io/browse/DATAMONGO) tickets for bugs and new features and comment and vote on the ones that you are interested in.  
 * Github is for social coding: if you want to write code, we encourage contributions through pull requests from [forks of this repository](http://help.github.com/forking/). If you want to contribute code this way, please reference a JIRA ticket as well covering the specific issue you are addressing.
 * Watch for upcoming articles on Spring by [subscribing](http://spring.io/blog) to spring.io.
 
-Before we accept a non-trivial patch or pull request we will need you to sign the [contributor's agreement](https://support.springsource.com/spring_committer_signup).  Signing the contributor's agreement does not grant anyone commit rights to the main repository, but it does mean that we can accept your contributions, and you will get an author credit if we do.  Active contributors might be asked to join the core team, and given the ability to merge pull requests.
+Before we accept a non-trivial patch or pull request we will need you to [sign the Contributor License Agreement](https://cla.pivotal.io/sign/spring). Signing the contributor’s agreement does not grant anyone commit rights to the main repository, but it does mean that we can accept your contributions, and you will get an author credit if we do. If you forget to do so, you'll be reminded when you submit a pull request. Active contributors might be asked to join the core team, and given the ability to merge pull requests.

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>1.10.0.BUILD-SNAPSHOT</version>
+	<version>1.10.18.RELEASE</version>
 	<packaging>pom</packaging>
 
 	<name>Spring Data MongoDB</name>
@@ -15,7 +15,7 @@
 	<parent>
 		<groupId>org.springframework.data.build</groupId>
 		<artifactId>spring-data-parent</artifactId>
-		<version>1.9.0.BUILD-SNAPSHOT</version>
+		<version>1.9.18.RELEASE</version>
 	</parent>
 
 	<modules>
@@ -28,9 +28,10 @@
 	<properties>
 		<project.type>multi</project.type>
 		<dist.id>spring-data-mongodb</dist.id>
-		<springdata.commons>1.13.0.BUILD-SNAPSHOT</springdata.commons>
+		<springdata.commons>1.13.18.RELEASE</springdata.commons>
 		<mongo>2.14.3</mongo>
 		<mongo.osgi>2.13.0</mongo.osgi>
+		<jmh.version>1.19</jmh.version>
 	</properties>
 
 	<developers>
@@ -178,11 +179,20 @@
 
 		</profile>
 
+		<profile>
+
+			<id>mongo34</id>
+			<properties>
+				<mongo>3.4.0</mongo>
+			</properties>
+
+		</profile>
+
 		<profile>
 
 			<id>mongo34-next</id>
 			<properties>
-				<mongo>3.4.0-SNAPSHOT</mongo>
+				<mongo>3.4.1-SNAPSHOT</mongo>
 			</properties>
 
 			<repositories>
@@ -207,6 +217,17 @@
 			</build>
 		</profile>
 
+		<profile>
+			<id>benchmarks</id>
+			<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>
+				<module>spring-data-mongodb-benchmarks</module>
+			</modules>
+		</profile>
+
 	</profiles>
 
 	<dependencies>
@@ -220,8 +241,8 @@
 
 	<repositories>
 		<repository>
-			<id>spring-libs-snapshot</id>
-			<url>https://repo.spring.io/libs-snapshot</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,112 @@
+<?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>1.10.18.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>
+		<bundlor.enabled>false</bundlor.enabled>
+	</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/convert/DbRefMappingBenchmark.java

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2017-2019 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<RefObject>();
+		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,182 @@
+/*
+ * Copyright 2017-2019 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.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.BasicDBObject;
+import com.mongodb.MongoClient;
+import com.mongodb.ServerAddress;
+import com.mongodb.util.JSON;
+
+/**
+ * @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 BasicDBObject documentWith2Properties, documentWith2PropertiesAnd1Nested;
+	private Customer objectWith2PropertiesAnd1Nested;
+
+	private BasicDBObject 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 CustomConversions(Collections.emptyList()));
+		this.converter.afterPropertiesSet();
+
+		// just a flat document
+		this.documentWith2Properties = new BasicDBObject("firstname", "Dave").append("lastname", "Matthews");
+
+		// document with a nested one
+		BasicDBObject address = new BasicDBObject("zipCode", "ABCDE").append("city", "Some Place");
+		this.documentWith2PropertiesAnd1Nested = new BasicDBObject("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<String, Customer>();
+		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 = (BasicDBObject) JSON.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 BasicDBObject writeObjectWith2PropertiesAnd1NestedObject() {
+
+		BasicDBObject sink = new BasicDBObject();
+		converter.write(objectWith2PropertiesAnd1Nested, sink);
+		return sink;
+	}
+
+	@Benchmark // DATAMONGO-1720
+	public Object readObjectWithListAndMapsOfComplexType() {
+		return converter.read(SlightlyMoreComplexObject.class, documentWithFlatAndComplexPropertiesPlusListAndMap);
+	}
+
+	@Benchmark // DATAMONGO-1720
+	public Object writeObjectWithListAndMapsOfComplexType() {
+
+		BasicDBObject sink = new BasicDBObject();
+		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,329 @@
+/*
+ * Copyright 2017-2019 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.data.mongodb.microbenchmark.ResultsWriter.Utils;
+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 {
+			Utils.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,86 @@
+/*
+ * Copyright 2017-2019 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.Charset;
+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(1000);
+		connection.setReadTimeout(1000);
+		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);
+
+		OutputStream output = null;
+		try {
+			output = connection.getOutputStream();
+			output.write(ResultsWriter.Utils.jsonifyResults(results).getBytes(Charset.forName("UTF-8")));
+		} finally {
+			if (output != null) {
+				output.close();
+			}
+		}
+
+		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,135 @@
+/*
+ * Copyright 2017-2019 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.net.UnknownHostException;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+
+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.DB;
+import com.mongodb.MongoClient;
+import com.mongodb.MongoClientURI;
+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 = null;
+
+		try {
+			client = new MongoClient(uri);
+		} catch (UnknownHostException e) {
+			throw new RuntimeException(e);
+		}
+
+		String dbName = StringUtils.hasText(uri.getDatabase()) ? uri.getDatabase() : "spring-data-mongodb-benchmarks";
+		DB db = client.getDB(dbName);
+
+		for (BasicDBObject dbo : (List<BasicDBObject>) JSON.parse(Utils.jsonifyResults(results))) {
+
+			String collectionName = extractClass(dbo.get("benchmark").toString());
+
+			BasicDBObject sink = new BasicDBObject();
+			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.toMap());
+
+			db.getCollection(collectionName).insert(fixDocumentKeys(sink));
+		}
+
+		client.close();
+	}
+
+	/**
+	 * Replace {@code .} by {@code ,}.
+	 *
+	 * @param doc
+	 * @return
+	 */
+	private BasicDBObject fixDocumentKeys(BasicDBObject doc) {
+
+		BasicDBObject sanitized = new BasicDBObject();
+
+		for (Object key : doc.keySet()) {
+
+			Object value = doc.get(key);
+			if (value instanceof BasicDBObject) {
+				value = fixDocumentKeys((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,71 @@
+/*
+ * Copyright 2017-2019 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.Charset;
+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);
+
+	/* non Java8 hack */
+	class Utils {
+
+		/**
+		 * 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(), Charset.forName("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>1.10.0.BUILD-SNAPSHOT</version>
+		<version>1.10.18.RELEASE</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 
@@ -16,6 +16,7 @@
 	<properties>
 		<jpa>2.0.0</jpa>
 		<hibernate>3.6.10.Final</hibernate>
+		<project.root>${basedir}/..</project.root>
 	</properties>
 
 	<dependencies>
@@ -48,7 +49,7 @@
 		<dependency>
 			<groupId>org.springframework.data</groupId>
 			<artifactId>spring-data-mongodb</artifactId>
-			<version>1.10.0.BUILD-SNAPSHOT</version>
+			<version>1.10.18.RELEASE</version>
 		</dependency>
 
 		<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-2019 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

spring-data-mongodb-distribution/pom.xml

@@ -13,7 +13,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>1.10.0.BUILD-SNAPSHOT</version>
+		<version>1.10.18.RELEASE</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 

spring-data-mongodb-log4j/pom.xml

@@ -5,7 +5,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>1.10.0.BUILD-SNAPSHOT</version>
+		<version>1.10.18.RELEASE</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2016 the original author or authors.
+ * Copyright 2011-2019 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,6 +18,8 @@ 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;
@@ -31,14 +33,17 @@ 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
- * @auhtor Christoph Strobl
+ * @author Christoph Strobl
+ * @author Ricardo Espirito Santo
  */
 public class MongoLog4jAppender extends AppenderSkeleton {
 
@@ -56,6 +61,9 @@ public class MongoLog4jAppender extends AppenderSkeleton {
 
 	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);
@@ -65,8 +73,7 @@ public class MongoLog4jAppender extends AppenderSkeleton {
 	protected Mongo mongo;
 	protected DB db;
 
-	public MongoLog4jAppender() {
-	}
+	public MongoLog4jAppender() {}
 
 	public MongoLog4jAppender(boolean isActive) {
 		super(isActive);
@@ -88,6 +95,53 @@ public class MongoLog4jAppender extends AppenderSkeleton {
 		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;
 	}
@@ -113,14 +167,14 @@ public class MongoLog4jAppender extends AppenderSkeleton {
 		this.applicationId = applicationId;
 	}
 
-	public void setWarnOrHigherWriteConcern(String wc) {
-		this.warnOrHigherWriteConcern = WriteConcern.valueOf(wc);
-	}
-
 	public String getWarnOrHigherWriteConcern() {
 		return warnOrHigherWriteConcern.toString();
 	}
 
+	public void setWarnOrHigherWriteConcern(String wc) {
+		this.warnOrHigherWriteConcern = WriteConcern.valueOf(wc);
+	}
+
 	public String getInfoOrLowerWriteConcern() {
 		return infoOrLowerWriteConcern.toString();
 	}
@@ -130,10 +184,26 @@ public class MongoLog4jAppender extends AppenderSkeleton {
 	}
 
 	protected void connectToMongo() throws UnknownHostException {
-		this.mongo = new MongoClient(host, port);
+
+		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)

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

@@ -0,0 +1,114 @@
+/*
+ * Copyright 2016-2019 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,5 +1,5 @@
 /*
- * Copyright 2011-2016 the original author or authors.
+ * Copyright 2011-2019 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,8 +20,10 @@ 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;
@@ -30,31 +32,34 @@ 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 {
 
-	static final String NAME = MongoLog4jAppenderIntegrationTests.class.getName();
-
-	private static final Logger log = Logger.getLogger(NAME);
 	MongoClient mongo;
 	DB db;
 	String collection;
+	ServerAddress serverLocation;
+	Logger log;
 
 	@Before
 	public void setUp() throws Exception {
+		serverLocation = new ServerAddress("localhost", 27017);
 
-		mongo = new MongoClient("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
@@ -76,7 +81,6 @@ public class MongoLog4jAppenderIntegrationTests {
 
 	@Test
 	public void testProperties() {
-
 		MDC.put("property", "one");
 		log.debug("DEBUG message");
 	}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013 the original author or authors.
+ * Copyright 2013-2019 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.
@@ -24,10 +24,7 @@ import org.junit.Test;
  */
 public class MongoLog4jAppenderUnitTests {
 
-	/**
-	 * @see DATAMONGO-641
-	 */
-	@Test
+	@Test // DATAMONGO-641
 	public void closesWithoutMongoInstancePresent() {
 		new MongoLog4jAppender().close();
 	}

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

@@ -0,0 +1,16 @@
+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 +1,13 @@
-log4j.rootCategory=INFO, stdout
+log4j.rootCategory=INFO, mongo
 
-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 = %X{year}%X{month}
-log4j.appender.stdout.applicationId = my.application
-log4j.appender.stdout.warnOrHigherWriteConcern = FSYNC_SAFE
+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>1.10.0.BUILD-SNAPSHOT</version>
+		<version>1.10.18.RELEASE</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 
 	<properties>
 		<objenesis>1.3</objenesis>
 		<equalsverifier>1.5</equalsverifier>
+		<project.root>${basedir}/..</project.root>
 	</properties>
 
 	<dependencies>
@@ -147,7 +148,6 @@
 		<dependency>
 			<groupId>com.fasterxml.jackson.core</groupId>
 			<artifactId>jackson-databind</artifactId>
-			<version>${jackson}</version>
 			<optional>true</optional>
 		</dependency>
 

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

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

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

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

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

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

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

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

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

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

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2013 the original author or authors.
+ * Copyright 2011-2019 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,7 +23,7 @@ import com.mongodb.DB;
 
 /**
  * Interface for factories creating {@link DB} instances.
- * 
+ *
  * @author Mark Pollack
  * @author Thomas Darimont
  */
@@ -31,7 +31,7 @@ public interface MongoDbFactory {
 
 	/**
 	 * Creates a default {@link DB} instance.
-	 * 
+	 *
 	 * @return
 	 * @throws DataAccessException
 	 */
@@ -39,7 +39,7 @@ public interface MongoDbFactory {
 
 	/**
 	 * Creates a {@link DB} instance to access the database with the given name.
-	 * 
+	 *
 	 * @param dbName must not be {@literal null} or empty.
 	 * @return
 	 * @throws DataAccessException
@@ -48,7 +48,7 @@ public interface MongoDbFactory {
 
 	/**
 	 * Exposes a shared {@link MongoExceptionTranslator}.
-	 * 
+	 *
 	 * @return will never be {@literal null}.
 	 */
 	PersistenceExceptionTranslator getExceptionTranslator();

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

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

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

@@ -1,297 +1,297 @@
-/*
- * 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.config;
-
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Set;
-
-import org.springframework.beans.factory.config.BeanDefinition;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
-import org.springframework.context.annotation.Configuration;
-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.mapping.context.MappingContextIsNewStrategyFactory;
-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.mapping.Document;
-import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
-import org.springframework.data.support.CachingIsNewStrategyFactory;
-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 configuration using JavaConfig.
- * 
- * @author Mark Pollack
- * @author Oliver Gierke
- * @author Thomas Darimont
- * @author Ryan Tenney
- * @author Christoph Strobl
- */
-@Configuration
-public abstract class AbstractMongoConfiguration {
-
-	/**
-	 * Return the name of the database to connect to.
-	 * 
-	 * @return must not be {@literal null}.
-	 */
-	protected abstract String getDatabaseName();
-
-	/**
-	 * Return the name of the authentication database to use. Defaults to {@literal null} and will turn into the value
-	 * returned by {@link #getDatabaseName()} later on effectively.
-	 * 
-	 * @return
-	 * @deprecated since 1.7. {@link MongoClient} should hold authentication data within
-	 *             {@link MongoClient#getCredentialsList()}
-	 */
-	@Deprecated
-	protected String getAuthenticationDatabaseName() {
-		return null;
-	}
-
-	/**
-	 * Return the {@link Mongo} instance to connect to. Annotate with {@link Bean} in case you want to expose a
-	 * {@link Mongo} instance to the {@link org.springframework.context.ApplicationContext}.
-	 * 
-	 * @return
-	 * @throws Exception
-	 */
-	public abstract Mongo mongo() throws Exception;
-
-	/**
-	 * Creates a {@link MongoTemplate}.
-	 * 
-	 * @return
-	 * @throws Exception
-	 */
-	@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 Mongo} instance
-	 * configured in {@link #mongo()}.
-	 * 
-	 * @see #mongo()
-	 * @see #mongoTemplate()
-	 * @return
-	 * @throws Exception
-	 */
-	@Bean
-	public MongoDbFactory mongoDbFactory() throws Exception {
-		return new SimpleMongoDbFactory(mongo(), getDatabaseName(), getUserCredentials(), getAuthenticationDatabaseName());
-	}
-
-	/**
-	 * 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();
-	}
-
-	/**
-	 * Returns the base packages to scan for MongoDB mapped entities at startup. 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 packages to scan for mapped {@link Document} classes or an empty collection to not enable scanning
-	 *         for entities.
-	 * @since 1.10
-	 */
-	protected Collection<String> getMappingBasePackages() {
-		return Collections.singleton(getMappingBasePackage());
-	}
-
-	/**
-	 * Return {@link UserCredentials} to be used when connecting to the MongoDB instance or {@literal null} if none shall
-	 * be used.
-	 * 
-	 * @return
-	 * @deprecated since 1.7. {@link MongoClient} should hold authentication data within
-	 *             {@link MongoClient#getCredentialsList()}
-	 */
-	@Deprecated
-	protected UserCredentials getUserCredentials() {
-		return null;
-	}
-
-	/**
-	 * Creates a {@link MongoMappingContext} equipped with entity classes scanned from the mapping base package.
-	 * 
-	 * @see #getMappingBasePackage()
-	 * @return
-	 * @throws ClassNotFoundException
-	 */
-	@Bean
-	public MongoMappingContext mongoMappingContext() throws ClassNotFoundException {
-
-		MongoMappingContext mappingContext = new MongoMappingContext();
-		mappingContext.setInitialEntitySet(getInitialEntitySet());
-		mappingContext.setSimpleTypeHolder(customConversions().getSimpleTypeHolder());
-		mappingContext.setFieldNamingStrategy(fieldNamingStrategy());
-
-		return mappingContext;
-	}
-
-	/**
-	 * Returns a {@link MappingContextIsNewStrategyFactory} wrapped into a {@link CachingIsNewStrategyFactory}.
-	 * 
-	 * @return
-	 * @throws ClassNotFoundException
-	 */
-	@Bean
-	public IsNewStrategyFactory isNewStrategyFactory() throws ClassNotFoundException {
-		return new CachingIsNewStrategyFactory(new MappingContextIsNewStrategyFactory(mongoMappingContext()));
-	}
-
-	/**
-	 * 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.
-	 * 
-	 * @return must not be {@literal null}.
-	 */
-	@Bean
-	public CustomConversions customConversions() {
-		return new CustomConversions(Collections.emptyList());
-	}
-
-	/**
-	 * 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;
-	}
-
-	/**
-	 * Scans the mapping base package for classes annotated with {@link Document}. By default, it scans for entities in
-	 * all packages returned by {@link #getMappingBasePackages()}.
-	 * 
-	 * @see #getMappingBasePackages()
-	 * @return
-	 * @throws ClassNotFoundException
-	 */
-	protected Set<Class<?>> getInitialEntitySet() throws ClassNotFoundException {
-
-		Set<Class<?>> initialEntitySet = new HashSet<Class<?>>();
-
-		for (String basePackage : getMappingBasePackages()) {
-			initialEntitySet.addAll(scanForEntities(basePackage));
-		}
-
-		return initialEntitySet;
-	}
-
-	/**
-	 * Scans the given base package for entities, i.e. MongoDB specific types annotated with {@link Document} and
-	 * {@link Persistent}.
-	 * 
-	 * @param basePackage must not be {@literal null}.
-	 * @return
-	 * @throws ClassNotFoundException
-	 * @since 1.10
-	 */
-	protected Set<Class<?>> scanForEntities(String basePackage) throws ClassNotFoundException {
-
-		if (!StringUtils.hasText(basePackage)) {
-			return Collections.emptySet();
-		}
-
-		Set<Class<?>> initialEntitySet = new HashSet<Class<?>>();
-
-		if (StringUtils.hasText(basePackage)) {
-
-			ClassPathScanningCandidateComponentProvider componentProvider = new ClassPathScanningCandidateComponentProvider(
-					false);
-			componentProvider.addIncludeFilter(new AnnotationTypeFilter(Document.class));
-			componentProvider.addIncludeFilter(new AnnotationTypeFilter(Persistent.class));
-
-			for (BeanDefinition candidate : componentProvider.findCandidateComponents(basePackage)) {
-
-				initialEntitySet
-						.add(ClassUtils.forName(candidate.getBeanClassName(), AbstractMongoConfiguration.class.getClassLoader()));
-			}
-		}
-
-		return initialEntitySet;
-	}
-
-	/**
-	 * Configures whether to abbreviate field names for domain objects by configuring a
-	 * {@link CamelCaseAbbreviatingFieldNamingStrategy} on the {@link MongoMappingContext} instance created. For advanced
-	 * customization needs, consider overriding {@link #mappingMongoConverter()}.
-	 * 
-	 * @return
-	 */
-	protected boolean abbreviateFieldNames() {
-		return false;
-	}
-
-	/**
-	 * Configures a {@link FieldNamingStrategy} on the {@link MongoMappingContext} instance created.
-	 * 
-	 * @return
-	 * @since 1.5
-	 */
-	protected FieldNamingStrategy fieldNamingStrategy() {
-		return abbreviateFieldNames() ? new CamelCaseAbbreviatingFieldNamingStrategy()
-				: PropertyNameFieldNamingStrategy.INSTANCE;
-	}
-}
+/*
+ * Copyright 2011-2019 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 java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
+
+import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
+import org.springframework.context.annotation.Configuration;
+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.mapping.context.MappingContextIsNewStrategyFactory;
+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.mapping.Document;
+import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
+import org.springframework.data.support.CachingIsNewStrategyFactory;
+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 configuration using JavaConfig.
+ * 
+ * @author Mark Pollack
+ * @author Oliver Gierke
+ * @author Thomas Darimont
+ * @author Ryan Tenney
+ * @author Christoph Strobl
+ */
+@Configuration
+public abstract class AbstractMongoConfiguration {
+
+	/**
+	 * Return the name of the database to connect to.
+	 * 
+	 * @return must not be {@literal null}.
+	 */
+	protected abstract String getDatabaseName();
+
+	/**
+	 * Return the name of the authentication database to use. Defaults to {@literal null} and will turn into the value
+	 * returned by {@link #getDatabaseName()} later on effectively.
+	 * 
+	 * @return
+	 * @deprecated since 1.7. {@link MongoClient} should hold authentication data within
+	 *             {@link MongoClient#getCredentialsList()}
+	 */
+	@Deprecated
+	protected String getAuthenticationDatabaseName() {
+		return null;
+	}
+
+	/**
+	 * Return the {@link Mongo} instance to connect to. Annotate with {@link Bean} in case you want to expose a
+	 * {@link Mongo} instance to the {@link org.springframework.context.ApplicationContext}.
+	 * 
+	 * @return
+	 * @throws Exception
+	 */
+	public abstract Mongo mongo() throws Exception;
+
+	/**
+	 * Creates a {@link MongoTemplate}.
+	 * 
+	 * @return
+	 * @throws Exception
+	 */
+	@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 Mongo} instance
+	 * configured in {@link #mongo()}.
+	 * 
+	 * @see #mongo()
+	 * @see #mongoTemplate()
+	 * @return
+	 * @throws Exception
+	 */
+	@Bean
+	public MongoDbFactory mongoDbFactory() throws Exception {
+		return new SimpleMongoDbFactory(mongo(), getDatabaseName(), getUserCredentials(), getAuthenticationDatabaseName());
+	}
+
+	/**
+	 * 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();
+	}
+
+	/**
+	 * Returns the base packages to scan for MongoDB mapped entities at startup. 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 packages to scan for mapped {@link Document} classes or an empty collection to not enable scanning
+	 *         for entities.
+	 * @since 1.10
+	 */
+	protected Collection<String> getMappingBasePackages() {
+		return Collections.singleton(getMappingBasePackage());
+	}
+
+	/**
+	 * Return {@link UserCredentials} to be used when connecting to the MongoDB instance or {@literal null} if none shall
+	 * be used.
+	 * 
+	 * @return
+	 * @deprecated since 1.7. {@link MongoClient} should hold authentication data within
+	 *             {@link MongoClient#getCredentialsList()}
+	 */
+	@Deprecated
+	protected UserCredentials getUserCredentials() {
+		return null;
+	}
+
+	/**
+	 * Creates a {@link MongoMappingContext} equipped with entity classes scanned from the mapping base package.
+	 * 
+	 * @see #getMappingBasePackage()
+	 * @return
+	 * @throws ClassNotFoundException
+	 */
+	@Bean
+	public MongoMappingContext mongoMappingContext() throws ClassNotFoundException {
+
+		MongoMappingContext mappingContext = new MongoMappingContext();
+		mappingContext.setInitialEntitySet(getInitialEntitySet());
+		mappingContext.setSimpleTypeHolder(customConversions().getSimpleTypeHolder());
+		mappingContext.setFieldNamingStrategy(fieldNamingStrategy());
+
+		return mappingContext;
+	}
+
+	/**
+	 * Returns a {@link MappingContextIsNewStrategyFactory} wrapped into a {@link CachingIsNewStrategyFactory}.
+	 * 
+	 * @return
+	 * @throws ClassNotFoundException
+	 */
+	@Bean
+	public IsNewStrategyFactory isNewStrategyFactory() throws ClassNotFoundException {
+		return new CachingIsNewStrategyFactory(new MappingContextIsNewStrategyFactory(mongoMappingContext()));
+	}
+
+	/**
+	 * 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.
+	 * 
+	 * @return must not be {@literal null}.
+	 */
+	@Bean
+	public CustomConversions customConversions() {
+		return new CustomConversions(Collections.emptyList());
+	}
+
+	/**
+	 * 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;
+	}
+
+	/**
+	 * Scans the mapping base package for classes annotated with {@link Document}. By default, it scans for entities in
+	 * all packages returned by {@link #getMappingBasePackages()}.
+	 * 
+	 * @see #getMappingBasePackages()
+	 * @return
+	 * @throws ClassNotFoundException
+	 */
+	protected Set<Class<?>> getInitialEntitySet() throws ClassNotFoundException {
+
+		Set<Class<?>> initialEntitySet = new HashSet<Class<?>>();
+
+		for (String basePackage : getMappingBasePackages()) {
+			initialEntitySet.addAll(scanForEntities(basePackage));
+		}
+
+		return initialEntitySet;
+	}
+
+	/**
+	 * Scans the given base package for entities, i.e. MongoDB specific types annotated with {@link Document} and
+	 * {@link Persistent}.
+	 * 
+	 * @param basePackage must not be {@literal null}.
+	 * @return
+	 * @throws ClassNotFoundException
+	 * @since 1.10
+	 */
+	protected Set<Class<?>> scanForEntities(String basePackage) throws ClassNotFoundException {
+
+		if (!StringUtils.hasText(basePackage)) {
+			return Collections.emptySet();
+		}
+
+		Set<Class<?>> initialEntitySet = new HashSet<Class<?>>();
+
+		if (StringUtils.hasText(basePackage)) {
+
+			ClassPathScanningCandidateComponentProvider componentProvider = new ClassPathScanningCandidateComponentProvider(
+					false);
+			componentProvider.addIncludeFilter(new AnnotationTypeFilter(Document.class));
+			componentProvider.addIncludeFilter(new AnnotationTypeFilter(Persistent.class));
+
+			for (BeanDefinition candidate : componentProvider.findCandidateComponents(basePackage)) {
+
+				initialEntitySet
+						.add(ClassUtils.forName(candidate.getBeanClassName(), AbstractMongoConfiguration.class.getClassLoader()));
+			}
+		}
+
+		return initialEntitySet;
+	}
+
+	/**
+	 * Configures whether to abbreviate field names for domain objects by configuring a
+	 * {@link CamelCaseAbbreviatingFieldNamingStrategy} on the {@link MongoMappingContext} instance created. For advanced
+	 * customization needs, consider overriding {@link #mappingMongoConverter()}.
+	 * 
+	 * @return
+	 */
+	protected boolean abbreviateFieldNames() {
+		return false;
+	}
+
+	/**
+	 * Configures a {@link FieldNamingStrategy} on the {@link MongoMappingContext} instance created.
+	 * 
+	 * @return
+	 * @since 1.5
+	 */
+	protected FieldNamingStrategy fieldNamingStrategy() {
+		return abbreviateFieldNames() ? new CamelCaseAbbreviatingFieldNamingStrategy()
+				: PropertyNameFieldNamingStrategy.INSTANCE;
+	}
+}

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

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

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

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

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

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

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2014 the original author or authors.
+ * Copyright 2011-2019 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.
@@ -361,7 +361,9 @@ public class MappingMongoConverterParser implements BeanDefinitionParser {
 		 * @param filters
 		 */
 		public NegatingFilter(TypeFilter... filters) {
-			Assert.notNull(filters);
+
+			Assert.notNull(filters, "TypeFilters must not be null");
+
 			this.delegates = new HashSet<TypeFilter>(Arrays.asList(filters));
 		}
 

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

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

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

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

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

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

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015 the original author or authors.
+ * Copyright 2015-2019 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.config;
 
 import java.beans.PropertyEditorSupport;
+import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -23,15 +24,18 @@ import java.util.Properties;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
+import org.springframework.util.ReflectionUtils;
 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
+ * @author Stephen Tyler Conrad
+ * @author Mark Paluch
  * @since 1.7
  */
 public class MongoCredentialPropertyEditor extends PropertyEditorSupport {
@@ -95,6 +99,20 @@ public class MongoCredentialPropertyEditor extends PropertyEditorSupport {
 						verifyDatabasePresent(database);
 						credentials.add(MongoCredential.createScramSha1Credential(userNameAndPassword[0], database,
 								userNameAndPassword[1].toCharArray()));
+					} else if ("SCRAM-SHA-256".equals(authMechanism)) {
+
+						Method createScramSha256Credential = ReflectionUtils.findMethod(MongoCredential.class,
+								"createScramSha256Credential", String.class, String.class, char[].class);
+
+						if (createScramSha256Credential == null) {
+							throw new IllegalArgumentException(
+									"SCRAM-SHA-256 auth mechanism is available as of MongoDB 4 and MongoDB Java Driver 3.8! Please make sure to use at least those versions.");
+						}
+
+						verifyUsernameAndPasswordPresent(userNameAndPassword);
+						verifyDatabasePresent(database);
+						credentials.add(MongoCredential.class.cast(ReflectionUtils.invokeMethod(createScramSha256Credential, null,
+								userNameAndPassword[0], database, userNameAndPassword[1].toCharArray())));
 					} else {
 						throw new IllegalArgumentException(
 								String.format("Cannot create MongoCredentials for unknown auth mechanism '%s'!", authMechanism));
@@ -156,7 +174,7 @@ public class MongoCredentialPropertyEditor extends PropertyEditorSupport {
 	private static Properties extractOptions(String text) {
 
 		int optionsSeperationIndex = text.lastIndexOf(OPTIONS_DELIMINATOR);
-		int dbSeperationIndex = text.lastIndexOf(OPTIONS_DELIMINATOR);
+		int dbSeperationIndex = text.lastIndexOf(DATABASE_DELIMINATOR);
 
 		if (optionsSeperationIndex == -1 || dbSeperationIndex > optionsSeperationIndex) {
 			return new Properties();
@@ -166,6 +184,11 @@ public class MongoCredentialPropertyEditor extends PropertyEditorSupport {
 
 		for (String option : text.substring(optionsSeperationIndex + 1).split(OPTION_VALUE_DELIMINATOR)) {
 			String[] optionArgs = option.split("=");
+
+			if (optionArgs.length == 1) {
+				throw new IllegalArgumentException(String.format("Query parameter '%s' has no value!", optionArgs[0]));
+			}
+
 			properties.put(optionArgs[0], optionArgs[1]);
 		}
 

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

@@ -1,69 +1,69 @@
-/*
- * Copyright 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.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;
-
-public class MongoJmxParser implements BeanDefinitionParser {
-
-	public BeanDefinition parse(Element element, ParserContext parserContext) {
-		String name = element.getAttribute("mongo-ref");
-		if (!StringUtils.hasText(name)) {
-			name = "mongo";
-		}
-		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-2019 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;
+
+public class MongoJmxParser implements BeanDefinitionParser {
+
+	public BeanDefinition parse(Element element, ParserContext parserContext) {
+		String name = element.getAttribute("mongo-ref");
+		if (!StringUtils.hasText(name)) {
+			name = "mongo";
+		}
+		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/MongoNamespaceHandler.java

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

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

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

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

@@ -1,206 +1,207 @@
-/*
- * Copyright 2011-2015 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * 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.data.mongodb.core.MongoOptionsFactoryBean;
-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:options} sub-element. Populates the given attribute factory with the proper attributes.
-	 * 
-	 * @return true if parsing actually occured, {@literal false} otherwise
-	 */
-	static boolean parseMongoOptions(Element element, BeanDefinitionBuilder mongoBuilder) {
-
-		Element optionsElement = DomUtils.getChildElementByTagName(element, "options");
-
-		if (optionsElement == null) {
-			return false;
-		}
-
-		BeanDefinitionBuilder optionsDefBuilder = BeanDefinitionBuilder
-				.genericBeanDefinition(MongoOptionsFactoryBean.class);
-
-		setPropertyValue(optionsDefBuilder, optionsElement, "connections-per-host", "connectionsPerHost");
-		setPropertyValue(optionsDefBuilder, optionsElement, "threads-allowed-to-block-for-connection-multiplier",
-				"threadsAllowedToBlockForConnectionMultiplier");
-		setPropertyValue(optionsDefBuilder, optionsElement, "max-wait-time", "maxWaitTime");
-		setPropertyValue(optionsDefBuilder, optionsElement, "connect-timeout", "connectTimeout");
-		setPropertyValue(optionsDefBuilder, optionsElement, "socket-timeout", "socketTimeout");
-		setPropertyValue(optionsDefBuilder, optionsElement, "socket-keep-alive", "socketKeepAlive");
-		setPropertyValue(optionsDefBuilder, optionsElement, "auto-connect-retry", "autoConnectRetry");
-		setPropertyValue(optionsDefBuilder, optionsElement, "max-auto-connect-retry-time", "maxAutoConnectRetryTime");
-		setPropertyValue(optionsDefBuilder, optionsElement, "write-number", "writeNumber");
-		setPropertyValue(optionsDefBuilder, optionsElement, "write-timeout", "writeTimeout");
-		setPropertyValue(optionsDefBuilder, optionsElement, "write-fsync", "writeFsync");
-		setPropertyValue(optionsDefBuilder, optionsElement, "slave-ok", "slaveOk");
-		setPropertyValue(optionsDefBuilder, optionsElement, "ssl", "ssl");
-		setPropertyReference(optionsDefBuilder, optionsElement, "ssl-socket-factory-ref", "sslSocketFactory");
-
-		mongoBuilder.addPropertyValue("mongoOptions", optionsDefBuilder.getBeanDefinition());
-		return true;
-	}
-
-	/**
-	 * 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");
-
-		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-2019 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.data.mongodb.core.MongoOptionsFactoryBean;
+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:options} sub-element. Populates the given attribute factory with the proper attributes.
+	 * 
+	 * @return true if parsing actually occured, {@literal false} otherwise
+	 */
+	static boolean parseMongoOptions(Element element, BeanDefinitionBuilder mongoBuilder) {
+
+		Element optionsElement = DomUtils.getChildElementByTagName(element, "options");
+
+		if (optionsElement == null) {
+			return false;
+		}
+
+		BeanDefinitionBuilder optionsDefBuilder = BeanDefinitionBuilder
+				.genericBeanDefinition(MongoOptionsFactoryBean.class);
+
+		setPropertyValue(optionsDefBuilder, optionsElement, "connections-per-host", "connectionsPerHost");
+		setPropertyValue(optionsDefBuilder, optionsElement, "threads-allowed-to-block-for-connection-multiplier",
+				"threadsAllowedToBlockForConnectionMultiplier");
+		setPropertyValue(optionsDefBuilder, optionsElement, "max-wait-time", "maxWaitTime");
+		setPropertyValue(optionsDefBuilder, optionsElement, "connect-timeout", "connectTimeout");
+		setPropertyValue(optionsDefBuilder, optionsElement, "socket-timeout", "socketTimeout");
+		setPropertyValue(optionsDefBuilder, optionsElement, "socket-keep-alive", "socketKeepAlive");
+		setPropertyValue(optionsDefBuilder, optionsElement, "auto-connect-retry", "autoConnectRetry");
+		setPropertyValue(optionsDefBuilder, optionsElement, "max-auto-connect-retry-time", "maxAutoConnectRetryTime");
+		setPropertyValue(optionsDefBuilder, optionsElement, "write-number", "writeNumber");
+		setPropertyValue(optionsDefBuilder, optionsElement, "write-timeout", "writeTimeout");
+		setPropertyValue(optionsDefBuilder, optionsElement, "write-fsync", "writeFsync");
+		setPropertyValue(optionsDefBuilder, optionsElement, "slave-ok", "slaveOk");
+		setPropertyValue(optionsDefBuilder, optionsElement, "ssl", "ssl");
+		setPropertyReference(optionsDefBuilder, optionsElement, "ssl-socket-factory-ref", "sslSocketFactory");
+
+		mongoBuilder.addPropertyValue("mongoOptions", optionsDefBuilder.getBeanDefinition());
+		return true;
+	}
+
+	/**
+	 * 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/MongoTemplateParser.java

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,121 @@
+/*
+ * Copyright 2018-2019 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import lombok.AllArgsConstructor;
+
+import java.util.List;
+
+import org.springframework.data.mapping.context.MappingContext;
+import org.springframework.data.mongodb.core.aggregation.Aggregation;
+import org.springframework.data.mongodb.core.aggregation.AggregationOperationContext;
+import org.springframework.data.mongodb.core.aggregation.TypeBasedAggregationOperationContext;
+import org.springframework.data.mongodb.core.aggregation.TypedAggregation;
+import org.springframework.data.mongodb.core.convert.QueryMapper;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
+import org.springframework.util.ObjectUtils;
+
+import com.mongodb.BasicDBList;
+import com.mongodb.DBObject;
+
+/**
+ * Utility methods to map {@link org.springframework.data.mongodb.core.aggregation.Aggregation} pipeline definitions and
+ * create type-bound {@link AggregationOperationContext}.
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @since 1.10.13
+ */
+@AllArgsConstructor
+class AggregationUtil {
+
+	QueryMapper queryMapper;
+	MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext;
+
+	/**
+	 * Prepare the {@link AggregationOperationContext} for a given aggregation by either returning the context itself it
+	 * is not {@literal null}, create a {@link TypeBasedAggregationOperationContext} if the aggregation contains type
+	 * information (is a {@link TypedAggregation}) or use the {@link Aggregation#DEFAULT_CONTEXT}.
+	 *
+	 * @param aggregation must not be {@literal null}.
+	 * @param context can be {@literal null}.
+	 * @return the root {@link AggregationOperationContext} to use.
+	 */
+	AggregationOperationContext prepareAggregationContext(Aggregation aggregation, AggregationOperationContext context) {
+
+		if (context != null) {
+			return context;
+		}
+
+		if (aggregation instanceof TypedAggregation) {
+			return new TypeBasedAggregationOperationContext(((TypedAggregation) aggregation).getInputType(), mappingContext,
+					queryMapper);
+		}
+
+		return Aggregation.DEFAULT_CONTEXT;
+	}
+
+	/**
+	 * Extract and map the aggregation pipeline into a {@link List} of {@link Document}.
+	 *
+	 * @param aggregation
+	 * @param context
+	 * @return
+	 */
+	DBObject createPipeline(String collectionName, Aggregation aggregation, AggregationOperationContext context) {
+
+		if (!ObjectUtils.nullSafeEquals(context, Aggregation.DEFAULT_CONTEXT)) {
+			return aggregation.toDbObject(collectionName, context);
+		}
+
+		DBObject command = aggregation.toDbObject(collectionName, context);
+		command.put("pipeline", mapAggregationPipeline((List) command.get("pipeline")));
+
+		return command;
+	}
+
+	/**
+	 * Extract the command and map the aggregation pipeline.
+	 *
+	 * @param aggregation
+	 * @param context
+	 * @return
+	 */
+	DBObject createCommand(String collection, Aggregation aggregation, AggregationOperationContext context) {
+
+		DBObject command = aggregation.toDbObject(collection, context);
+
+		if (!ObjectUtils.nullSafeEquals(context, Aggregation.DEFAULT_CONTEXT)) {
+			return command;
+		}
+
+		command.put("pipeline", mapAggregationPipeline((List) command.get("pipeline")));
+
+		return command;
+	}
+
+	private BasicDBList mapAggregationPipeline(List<DBObject> pipeline) {
+
+		BasicDBList mapped = new BasicDBList();
+
+		for (DBObject stage : pipeline) {
+			mapped.add(queryMapper.getMappedObject(stage, null));
+		}
+
+		return mapped;
+	}
+}

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-2019 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.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,26 +1,26 @@
-/*
- * 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;
-
-import com.mongodb.DBCollection;
-import com.mongodb.MongoException;
-import org.springframework.dao.DataAccessException;
-
-public interface CollectionCallback<T> {
-
-	T doInCollection(DBCollection collection) throws MongoException, DataAccessException;
-
-}
+/*
+ * Copyright 2010-2019 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.DBCollection;
+import com.mongodb.MongoException;
+import org.springframework.dao.DataAccessException;
+
+public interface CollectionCallback<T> {
+
+	T doInCollection(DBCollection collection) throws MongoException, DataAccessException;
+
+}

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

@@ -1,70 +1,70 @@
-/*
- * 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-2019 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;
+	}
+
+}

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

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

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

@@ -1,25 +1,25 @@
-/*
- * 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;
-
-import com.mongodb.DB;
-import com.mongodb.MongoException;
-import org.springframework.dao.DataAccessException;
-
-public interface DbCallback<T> {
-
-	T doInDB(DB db) throws MongoException, DataAccessException;
-}
+/*
+ * Copyright 2010-2019 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.DB;
+import com.mongodb.MongoException;
+import org.springframework.dao.DataAccessException;
+
+public interface DbCallback<T> {
+
+	T doInDB(DB db) throws MongoException, DataAccessException;
+}

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-2019 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,23 @@
  */
 package org.springframework.data.mongodb.core;
 
-import java.util.Arrays;
+import lombok.NonNull;
+import lombok.Value;
+
+import java.util.Collections;
 import java.util.List;
 
 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.Query;
 import org.springframework.data.mongodb.core.query.Update;
 import org.springframework.data.util.Pair;
 import org.springframework.util.Assert;
 
+import com.mongodb.BasicDBObject;
 import com.mongodb.BulkWriteException;
 import com.mongodb.BulkWriteOperation;
 import com.mongodb.BulkWriteRequestBuilder;
@@ -35,17 +42,18 @@ import com.mongodb.WriteConcern;
 
 /**
  * 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 Class<?> entityType;
+	private final BulkOperationContext bulkOperationContext;
 
 	private PersistenceExceptionTranslator exceptionTranslator;
 	private WriteConcernResolver writeConcernResolver;
@@ -54,35 +62,32 @@ class DefaultBulkOperations implements BulkOperations {
 	private BulkWriteOperation bulk;
 
 	/**
-	 * Creates a new {@link DefaultBulkOperations} for the given {@link MongoOperations}, {@link BulkMode}, collection
-	 * name and {@link WriteConcern}.
-	 * 
-	 * @param mongoOperations The underlying {@link MongoOperations}, must not be {@literal null}.
-	 * @param bulkMode must not be {@literal null}.
-	 * @param collectionName Name of the collection to work on, must not be {@literal null} or empty.
-	 * @param entityType the entity type, can be {@literal null}.
+	 * 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 1.10.5
 	 */
-	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.entityType = entityType;
-
+		this.bulkOperationContext = bulkOperationContext;
 		this.exceptionTranslator = new MongoExceptionTranslator();
 		this.writeConcernResolver = DefaultWriteConcernResolver.INSTANCE;
-
-		this.bulk = initBulkOperation();
+		this.bulk = 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) {
@@ -91,7 +96,7 @@ class DefaultBulkOperations implements BulkOperations {
 
 	/**
 	 * Configures the {@link WriteConcernResolver} to be used. Defaults to {@link DefaultWriteConcernResolver}.
-	 * 
+	 *
 	 * @param writeConcernResolver can be {@literal null}.
 	 */
 	public void setWriteConcernResolver(WriteConcernResolver writeConcernResolver) {
@@ -101,10 +106,10 @@ class DefaultBulkOperations implements BulkOperations {
 
 	/**
 	 * 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(WriteConcern defaultWriteConcern) {
 		this.defaultWriteConcern = defaultWriteConcern;
 	}
 
@@ -117,7 +122,15 @@ class DefaultBulkOperations implements BulkOperations {
 
 		Assert.notNull(document, "Document must not be null!");
 
-		bulk.insert((DBObject) mongoOperations.getConverter().convertToMongoType(document));
+		if (document instanceof DBObject) {
+
+			bulk.insert((DBObject) document);
+			return this;
+		}
+
+		DBObject sink = new BasicDBObject();
+		mongoOperations.getConverter().write(document, sink);
+		bulk.insert(sink);
 		return this;
 	}
 
@@ -148,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)));
 	}
 
 	/*
@@ -178,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)));
 	}
 
 	/*
@@ -229,7 +242,7 @@ class DefaultBulkOperations implements BulkOperations {
 
 		Assert.notNull(query, "Query must not be null!");
 
-		bulk.find(query.getQueryObject()).remove();
+		bulk.find(getMappedQuery(query.getQueryObject())).remove();
 
 		return this;
 	}
@@ -257,27 +270,25 @@ class DefaultBulkOperations implements BulkOperations {
 	@Override
 	public BulkWriteResult execute() {
 
-		MongoAction action = new MongoAction(defaultWriteConcern, MongoActionOperation.BULK, collectionName, entityType,
-				null, null);
+		MongoAction action = new MongoAction(defaultWriteConcern, MongoActionOperation.BULK, collectionName,
+				bulkOperationContext.getEntityType(), null, null);
 		WriteConcern writeConcern = writeConcernResolver.resolve(action);
 
 		try {
-
 			return writeConcern == null ? bulk.execute() : bulk.execute(writeConcern);
-
 		} catch (BulkWriteException o_O) {
 
 			DataAccessException toThrow = exceptionTranslator.translateExceptionIfPossible(o_O);
 			throw toThrow == null ? o_O : toThrow;
 
 		} finally {
-			this.bulk = initBulkOperation();
+			this.bulk = 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.
@@ -289,29 +300,37 @@ class DefaultBulkOperations implements BulkOperations {
 		Assert.notNull(query, "Query must not be null!");
 		Assert.notNull(update, "Update must not be null!");
 
-		BulkWriteRequestBuilder builder = bulk.find(query.getQueryObject());
+		BulkWriteRequestBuilder builder = bulk.find(getMappedQuery(query.getQueryObject()));
 
 		if (upsert) {
 
 			if (multi) {
-				builder.upsert().update(update.getUpdateObject());
+				builder.upsert().update(getMappedUpdate(update.getUpdateObject()));
 			} else {
-				builder.upsert().updateOne(update.getUpdateObject());
+				builder.upsert().updateOne(getMappedUpdate(update.getUpdateObject()));
 			}
 
 		} else {
 
 			if (multi) {
-				builder.update(update.getUpdateObject());
+				builder.update(getMappedUpdate(update.getUpdateObject()));
 			} else {
-				builder.updateOne(update.getUpdateObject());
+				builder.updateOne(getMappedUpdate(update.getUpdateObject()));
 			}
 		}
 
 		return this;
 	}
 
-	private final BulkWriteOperation initBulkOperation() {
+	private DBObject getMappedUpdate(DBObject update) {
+		return bulkOperationContext.getUpdateMapper().getMappedObject(update, bulkOperationContext.getEntity());
+	}
+
+	private DBObject getMappedQuery(DBObject query) {
+		return bulkOperationContext.getQueryMapper().getMappedObject(query, bulkOperationContext.getEntity());
+	}
+
+	private BulkWriteOperation getBulkWriteOptions(BulkMode bulkMode) {
 
 		DBCollection collection = mongoOperations.getCollection(collectionName);
 
@@ -324,4 +343,25 @@ class DefaultBulkOperations implements BulkOperations {
 
 		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;
+		MongoPersistentEntity<?> entity;
+		@NonNull QueryMapper queryMapper;
+		@NonNull UpdateMapper updateMapper;
+
+		Class<?> getEntityType() {
+			return entity != null ? entity.getType() : null;
+		}
+	}
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2015 the original author or authors.
+ * Copyright 2011-2019 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,17 +15,15 @@
  */
 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 org.springframework.dao.DataAccessException;
+import org.springframework.data.mongodb.core.convert.QueryMapper;
 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.data.mongodb.core.mapping.MongoPersistentEntity;
 import org.springframework.util.Assert;
 
 import com.mongodb.DBCollection;
@@ -42,12 +40,12 @@ import com.mongodb.MongoException;
  */
 public class DefaultIndexOperations implements IndexOperations {
 
-	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");
+	private static final String PARTIAL_FILTER_EXPRESSION_KEY = "partialFilterExpression";
 
 	private final MongoOperations mongoOperations;
 	private final String collectionName;
+	private final QueryMapper mapper;
+	private final Class<?> type;
 
 	/**
 	 * Creates a new {@link DefaultIndexOperations}.
@@ -56,12 +54,26 @@ public class DefaultIndexOperations implements IndexOperations {
 	 * @param collectionName must not be {@literal null}.
 	 */
 	public DefaultIndexOperations(MongoOperations mongoOperations, String collectionName) {
+		this(mongoOperations, collectionName, null);
+	}
+
+	/**
+	 * Creates a new {@link DefaultIndexOperations}.
+	 *
+	 * @param mongoOperations must not be {@literal null}.
+	 * @param collectionName must not be {@literal null}.
+	 * @param type Type used for mapping potential partial index filter expression. Can be {@literal null}.
+	 * @since 1.10
+	 */
+	public DefaultIndexOperations(MongoOperations mongoOperations, String collectionName, Class<?> type) {
 
 		Assert.notNull(mongoOperations, "MongoOperations must not be null!");
 		Assert.notNull(collectionName, "Collection name can not be null!");
 
 		this.mongoOperations = mongoOperations;
 		this.collectionName = collectionName;
+		this.mapper = new QueryMapper(mongoOperations.getConverter());
+		this.type = type;
 	}
 
 	/*
@@ -69,9 +81,20 @@ public class DefaultIndexOperations implements IndexOperations {
 	 * @see org.springframework.data.mongodb.core.IndexOperations#ensureIndex(org.springframework.data.mongodb.core.index.IndexDefinition)
 	 */
 	public void ensureIndex(final IndexDefinition indexDefinition) {
+
 		mongoOperations.execute(collectionName, new CollectionCallback<Object>() {
 			public Object doInCollection(DBCollection collection) throws MongoException, DataAccessException {
 				DBObject indexOptions = indexDefinition.getIndexOptions();
+
+				if (indexOptions != null && indexOptions.containsField(PARTIAL_FILTER_EXPRESSION_KEY)) {
+
+					Assert.isInstanceOf(DBObject.class, indexOptions.get(PARTIAL_FILTER_EXPRESSION_KEY));
+
+					indexOptions.put(PARTIAL_FILTER_EXPRESSION_KEY,
+							mapper.getMappedObject((DBObject) indexOptions.get(PARTIAL_FILTER_EXPRESSION_KEY),
+									lookupPersistentEntity(type, collectionName)));
+				}
+
 				if (indexOptions != null) {
 					collection.createIndex(indexDefinition.getIndexKeys(), indexOptions);
 				} else {
@@ -79,6 +102,24 @@ public class DefaultIndexOperations implements IndexOperations {
 				}
 				return null;
 			}
+
+			private MongoPersistentEntity<?> lookupPersistentEntity(Class<?> entityType, String collection) {
+
+				if (entityType != null) {
+					return mongoOperations.getConverter().getMappingContext().getPersistentEntity(entityType);
+				}
+
+				Collection<? extends MongoPersistentEntity<?>> entities = mongoOperations.getConverter().getMappingContext()
+						.getPersistentEntities();
+
+				for (MongoPersistentEntity<?> entity : entities) {
+					if (entity.getCollection().equals(collection)) {
+						return entity;
+					}
+				}
+
+				return null;
+			}
 		});
 	}
 
@@ -126,7 +167,9 @@ public class DefaultIndexOperations implements IndexOperations {
 	public List<IndexInfo> getIndexInfo() {
 
 		return mongoOperations.execute(collectionName, new CollectionCallback<List<IndexInfo>>() {
+
 			public List<IndexInfo> doInCollection(DBCollection collection) throws MongoException, DataAccessException {
+
 				List<DBObject> dbObjectList = collection.getIndexInfo();
 				return getIndexData(dbObjectList);
 			}
@@ -136,44 +179,7 @@ public class DefaultIndexOperations implements IndexOperations {
 				List<IndexInfo> indexInfoList = new ArrayList<IndexInfo>();
 
 				for (DBObject ix : dbObjectList) {
-
-					DBObject keyDbObject = (DBObject) ix.get("key");
-					int numberOfElements = keyDbObject.keySet().size();
-
-					List<IndexField> indexFields = new ArrayList<IndexField>(numberOfElements);
-
-					for (String key : keyDbObject.keySet()) {
-
-						Object value = keyDbObject.get(key);
-
-						if (TWO_D_IDENTIFIERS.contains(value)) {
-							indexFields.add(IndexField.geo(key));
-						} else if ("text".equals(value)) {
-
-							DBObject weights = (DBObject) ix.get("weights");
-							for (String fieldName : weights.keySet()) {
-								indexFields.add(IndexField.text(fieldName, Float.valueOf(weights.get(fieldName).toString())));
-							}
-
-						} else {
-
-							Double keyValue = new Double(value.toString());
-
-							if (ONE.equals(keyValue)) {
-								indexFields.add(IndexField.create(key, ASC));
-							} else if (MINUS_ONE.equals(keyValue)) {
-								indexFields.add(IndexField.create(key, DESC));
-							}
-						}
-					}
-
-					String name = ix.get("name").toString();
-
-					boolean unique = ix.containsField("unique") ? (Boolean) ix.get("unique") : false;
-					boolean dropDuplicates = ix.containsField("dropDups") ? (Boolean) ix.get("dropDups") : false;
-					boolean sparse = ix.containsField("sparse") ? (Boolean) ix.get("sparse") : false;
-					String language = ix.containsField("default_language") ? (String) ix.get("default_language") : "";
-					indexInfoList.add(new IndexInfo(indexFields, name, unique, dropDuplicates, sparse, language));
+					indexInfoList.add(IndexInfo.indexInfoOf(ix));
 				}
 
 				return indexInfoList;

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-2019 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

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

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

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

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

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

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016 the original author or authors.
+ * Copyright 2016-2019 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.
@@ -62,7 +62,7 @@ class GeoCommandStatistics {
 	 * didn't return any result introduced in MongoDB 3.2 RC1.
 	 * 
 	 * @return
-	 * @see https://jira.mongodb.org/browse/SERVER-21024
+	 * @see <a href="https://jira.mongodb.org/browse/SERVER-21024">MongoDB Jira SERVER-21024</a>
 	 */
 	public double getAverageDistance() {
 

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015 the original author or authors.
+ * Copyright 2015-2019 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,15 +17,14 @@ package org.springframework.data.mongodb.core;
 
 import org.springframework.context.annotation.Bean;
 import org.springframework.data.mongodb.core.geo.GeoJsonModule;
-import org.springframework.data.web.config.SpringDataWebConfigurationMixin;
+import org.springframework.data.web.config.SpringDataJacksonModules;
 
 /**
  * Configuration class to expose {@link GeoJsonModule} as a Spring bean.
  * 
  * @author Oliver Gierke
  */
-@SpringDataWebConfigurationMixin
-public class GeoJsonConfiguration {
+public class GeoJsonConfiguration implements SpringDataJacksonModules {
 
 	@Bean
 	public GeoJsonModule geoJsonModule() {

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

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

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

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

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

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

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

@@ -1,89 +1,91 @@
-/*
- * Copyright 2011-2013 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.authentication.UserCredentials;
-import org.springframework.jmx.export.annotation.ManagedOperation;
-import org.springframework.jmx.export.annotation.ManagedResource;
-import org.springframework.util.Assert;
-
-import com.mongodb.DB;
-import com.mongodb.Mongo;
-
-/**
- * Mongo server administration exposed via JMX annotations
- * 
- * @author Mark Pollack
+/*
+ * Copyright 2011-2019 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.authentication.UserCredentials;
+import org.springframework.jmx.export.annotation.ManagedOperation;
+import org.springframework.jmx.export.annotation.ManagedResource;
+import org.springframework.util.Assert;
+
+import com.mongodb.DB;
+import com.mongodb.Mongo;
+
+/**
+ * Mongo server administration exposed via JMX annotations
+ * 
+ * @author Mark Pollack
  * @author Thomas Darimont
- */
-@ManagedResource(description = "Mongo Admin Operations")
-public class MongoAdmin implements MongoAdminOperations {
-
-	private final Mongo mongo;
-	private String username;
-	private String password;
+ * @author Mark Paluch
+ */
+@ManagedResource(description = "Mongo Admin Operations")
+public class MongoAdmin implements MongoAdminOperations {
+
+	private final Mongo mongo;
+	private String username;
+	private String password;
 	private String authenticationDatabaseName;
-
-	public MongoAdmin(Mongo mongo) {
-		Assert.notNull(mongo);
-		this.mongo = mongo;
-	}
-
-	/* (non-Javadoc)
-	  * @see org.springframework.data.mongodb.core.core.MongoAdminOperations#dropDatabase(java.lang.String)
-	  */
-	@ManagedOperation
-	public void dropDatabase(String databaseName) {
-		getDB(databaseName).dropDatabase();
-	}
-
-	/* (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).getStats().toString();
-	}
-
-	/**
-	 * Sets the username to use to connect to the Mongo database
-	 * 
-	 * @param username The username to use
-	 */
-	public void setUsername(String username) {
-		this.username = username;
-	}
-
-	/**
-	 * Sets the password to use to authenticate with the Mongo database.
-	 * 
-	 * @param password The password to use
-	 */
-	public void setPassword(String password) {
-		this.password = password;
-	}
-
+
+	public MongoAdmin(Mongo mongo) {
+
+		Assert.notNull(mongo, "Mongo must not be null!");
+		this.mongo = mongo;
+	}
+
+	/* (non-Javadoc)
+	  * @see org.springframework.data.mongodb.core.core.MongoAdminOperations#dropDatabase(java.lang.String)
+	  */
+	@ManagedOperation
+	public void dropDatabase(String databaseName) {
+		getDB(databaseName).dropDatabase();
+	}
+
+	/* (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).getStats().toString();
+	}
+
+	/**
+	 * Sets the username to use to connect to the Mongo database
+	 * 
+	 * @param username The username to use
+	 */
+	public void setUsername(String username) {
+		this.username = username;
+	}
+
+	/**
+	 * Sets the password to use to authenticate with the Mongo database.
+	 * 
+	 * @param password The password to use
+	 */
+	public void setPassword(String password) {
+		this.password = password;
+	}
+
 	/**
 	 * Sets the authenticationDatabaseName to use to authenticate with the Mongo database.
 	 * 
@@ -93,7 +95,7 @@ public class MongoAdmin implements MongoAdminOperations {
 		this.authenticationDatabaseName = authenticationDatabaseName;
 	}
 
-	DB getDB(String databaseName) {
+	DB getDB(String databaseName) {
 		return MongoDbUtils.getDB(mongo, databaseName, new UserCredentials(username, password), authenticationDatabaseName);
-	}
-}
+	}
+}

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

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

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015 the original author or authors.
+ * Copyright 2015-2019 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,8 +18,10 @@ package org.springframework.data.mongodb.core;
 import javax.net.SocketFactory;
 import javax.net.ssl.SSLSocketFactory;
 
+import org.springframework.beans.DirectFieldAccessor;
 import org.springframework.beans.factory.config.AbstractFactoryBean;
 import org.springframework.data.mongodb.MongoDbFactory;
+import org.springframework.data.mongodb.util.MongoClientVersion;
 
 import com.mongodb.DBDecoderFactory;
 import com.mongodb.DBEncoderFactory;
@@ -30,7 +32,7 @@ import com.mongodb.WriteConcern;
 
 /**
  * A factory bean for construction of a {@link MongoClientOptions} instance.
- * 
+ *
  * @author Christoph Strobl
  * @author Oliver Gierke
  * @since 1.7
@@ -62,13 +64,14 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 	private int heartbeatConnectTimeout = DEFAULT_MONGO_OPTIONS.getHeartbeatConnectTimeout();
 	private int heartbeatSocketTimeout = DEFAULT_MONGO_OPTIONS.getHeartbeatSocketTimeout();
 	private String requiredReplicaSetName = DEFAULT_MONGO_OPTIONS.getRequiredReplicaSetName();
+	private int serverSelectionTimeout = Integer.MIN_VALUE;
 
 	private boolean ssl;
 	private SSLSocketFactory sslSocketFactory;
 
 	/**
 	 * Set the {@link MongoClient} description.
-	 * 
+	 *
 	 * @param description
 	 */
 	public void setDescription(String description) {
@@ -77,7 +80,7 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 
 	/**
 	 * Set the minimum number of connections per host.
-	 * 
+	 *
 	 * @param minConnectionsPerHost
 	 */
 	public void setMinConnectionsPerHost(int minConnectionsPerHost) {
@@ -87,7 +90,7 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 	/**
 	 * Set the number of connections allowed per host. Will block if run out. Default is 10. System property
 	 * {@code MONGO.POOLSIZE} can override
-	 * 
+	 *
 	 * @param connectionsPerHost
 	 */
 	public void setConnectionsPerHost(int connectionsPerHost) {
@@ -98,7 +101,7 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 	 * Set the multiplier for connectionsPerHost for # of threads that can block. Default is 5. If connectionsPerHost is
 	 * 10, and threadsAllowedToBlockForConnectionMultiplier is 5, then 50 threads can block more than that and an
 	 * exception will be thrown.
-	 * 
+	 *
 	 * @param threadsAllowedToBlockForConnectionMultiplier
 	 */
 	public void setThreadsAllowedToBlockForConnectionMultiplier(int threadsAllowedToBlockForConnectionMultiplier) {
@@ -107,7 +110,7 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 
 	/**
 	 * Set the max wait time of a blocking thread for a connection. Default is 12000 ms (2 minutes)
-	 * 
+	 *
 	 * @param maxWaitTime
 	 */
 	public void setMaxWaitTime(int maxWaitTime) {
@@ -116,7 +119,7 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 
 	/**
 	 * The maximum idle time for a pooled connection.
-	 * 
+	 *
 	 * @param maxConnectionIdleTime
 	 */
 	public void setMaxConnectionIdleTime(int maxConnectionIdleTime) {
@@ -125,7 +128,7 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 
 	/**
 	 * Set the maximum life time for a pooled connection.
-	 * 
+	 *
 	 * @param maxConnectionLifeTime
 	 */
 	public void setMaxConnectionLifeTime(int maxConnectionLifeTime) {
@@ -134,7 +137,7 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 
 	/**
 	 * Set the connect timeout in milliseconds. 0 is default and infinite.
-	 * 
+	 *
 	 * @param connectTimeout
 	 */
 	public void setConnectTimeout(int connectTimeout) {
@@ -143,7 +146,7 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 
 	/**
 	 * Set the socket timeout. 0 is default and infinite.
-	 * 
+	 *
 	 * @param socketTimeout
 	 */
 	public void setSocketTimeout(int socketTimeout) {
@@ -152,7 +155,7 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 
 	/**
 	 * Set the keep alive flag, controls whether or not to have socket keep alive timeout. Defaults to false.
-	 * 
+	 *
 	 * @param socketKeepAlive
 	 */
 	public void setSocketKeepAlive(boolean socketKeepAlive) {
@@ -161,7 +164,7 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 
 	/**
 	 * Set the {@link ReadPreference}.
-	 * 
+	 *
 	 * @param readPreference
 	 */
 	public void setReadPreference(ReadPreference readPreference) {
@@ -171,7 +174,7 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 	/**
 	 * Set the {@link WriteConcern} that will be the default value used when asking the {@link MongoDbFactory} for a DB
 	 * object.
-	 * 
+	 *
 	 * @param writeConcern
 	 */
 	public void setWriteConcern(WriteConcern writeConcern) {
@@ -187,7 +190,7 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 
 	/**
 	 * Set the frequency that the driver will attempt to determine the current state of each server in the cluster.
-	 * 
+	 *
 	 * @param heartbeatFrequency
 	 */
 	public void setHeartbeatFrequency(int heartbeatFrequency) {
@@ -197,7 +200,7 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 	/**
 	 * In the event that the driver has to frequently re-check a server's availability, it will wait at least this long
 	 * since the previous check to avoid wasted effort.
-	 * 
+	 *
 	 * @param minHeartbeatFrequency
 	 */
 	public void setMinHeartbeatFrequency(int minHeartbeatFrequency) {
@@ -206,7 +209,7 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 
 	/**
 	 * Set the connect timeout for connections used for the cluster heartbeat.
-	 * 
+	 *
 	 * @param heartbeatConnectTimeout
 	 */
 	public void setHeartbeatConnectTimeout(int heartbeatConnectTimeout) {
@@ -215,7 +218,7 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 
 	/**
 	 * Set the socket timeout for connections used for the cluster heartbeat.
-	 * 
+	 *
 	 * @param heartbeatSocketTimeout
 	 */
 	public void setHeartbeatSocketTimeout(int heartbeatSocketTimeout) {
@@ -224,7 +227,7 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 
 	/**
 	 * Configures the name of the replica set.
-	 * 
+	 *
 	 * @param requiredReplicaSetName
 	 */
 	public void setRequiredReplicaSetName(String requiredReplicaSetName) {
@@ -233,7 +236,7 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 
 	/**
 	 * This controls if the driver should us an SSL connection. Defaults to |@literal false}.
-	 * 
+	 *
 	 * @param ssl
 	 */
 	public void setSsl(boolean ssl) {
@@ -243,24 +246,41 @@ public class MongoClientOptionsFactoryBean extends AbstractFactoryBean<MongoClie
 	/**
 	 * Set the {@link SSLSocketFactory} to use for the {@literal SSL} connection. If none is configured here,
 	 * {@link SSLSocketFactory#getDefault()} will be used.
-	 * 
+	 *
 	 * @param sslSocketFactory
 	 */
 	public void setSslSocketFactory(SSLSocketFactory sslSocketFactory) {
 		this.sslSocketFactory = sslSocketFactory;
 	}
 
-	/* 
+	/**
+	 * Set the {@literal server selection timeout} in msec for a 3.x MongoDB Java driver. If not set the default value of
+	 * 30 sec will be used. A value of 0 means that it will timeout immediately if no server is available. A negative
+	 * value means to wait indefinitely.
+	 *
+	 * @param serverSelectionTimeout in msec.
+	 */
+	public void setServerSelectionTimeout(int serverSelectionTimeout) {
+		this.serverSelectionTimeout = serverSelectionTimeout;
+	}
+
+	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.beans.factory.config.AbstractFactoryBean#createInstance()
 	 */
 	@Override
 	protected MongoClientOptions createInstance() throws Exception {
 
-		SocketFactory socketFactoryToUse = ssl ? (sslSocketFactory != null ? sslSocketFactory : SSLSocketFactory
-				.getDefault()) : this.socketFactory;
+		SocketFactory socketFactoryToUse = ssl
+				? (sslSocketFactory != null ? sslSocketFactory : SSLSocketFactory.getDefault()) : this.socketFactory;
 
-		return MongoClientOptions.builder() //
+		MongoClientOptions.Builder builder = MongoClientOptions.builder();
+
+		if (MongoClientVersion.isMongo3Driver() && serverSelectionTimeout != Integer.MIN_VALUE) {
+			new DirectFieldAccessor(builder).setPropertyValue("serverSelectionTimeout", serverSelectionTimeout);
+		}
+
+		return builder //
 				.alwaysUseMBeans(this.alwaysUseMBeans) //
 				.connectionsPerHost(this.connectionsPerHost) //
 				.connectTimeout(connectTimeout) //

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-2019 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 /*
- * Copyright 2011-2015 the original author or authors.
- * 
+ * Copyright 2011-2019 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
@@ -48,7 +48,7 @@ import com.mongodb.WriteResult;
  * Interface that specifies a basic set of MongoDB operations. Implemented by {@link MongoTemplate}. Not often used but
  * a useful option for extensibility and testability (as it can be easily mocked, stubbed, or be the target of a JDK
  * proxy).
- * 
+ *
  * @author Thomas Risberg
  * @author Mark Pollack
  * @author Oliver Gierke
@@ -61,7 +61,7 @@ public interface MongoOperations {
 
 	/**
 	 * The collection name used for the specified class by this template.
-	 * 
+	 *
 	 * @param entityClass must not be {@literal null}.
 	 * @return
 	 */
@@ -71,7 +71,7 @@ public interface MongoOperations {
 	 * Execute the a MongoDB command expressed as a JSON string. This will call the method JSON.parse that is part of the
 	 * MongoDB driver to convert the JSON string to a DBObject. Any errors that result from executing this command will be
 	 * converted into Spring's DAO exception hierarchy.
-	 * 
+	 *
 	 * @param jsonCommand a MongoDB command expressed as a JSON string.
 	 */
 	CommandResult executeCommand(String jsonCommand);
@@ -79,7 +79,7 @@ public interface MongoOperations {
 	/**
 	 * Execute a MongoDB command. Any errors that result from executing this command will be converted into Spring's DAO
 	 * exception hierarchy.
-	 * 
+	 *
 	 * @param command a MongoDB command
 	 */
 	CommandResult executeCommand(DBObject command);
@@ -87,7 +87,7 @@ public interface MongoOperations {
 	/**
 	 * Execute a MongoDB command. Any errors that result from executing this command will be converted into Spring's DAO
 	 * exception hierarchy.
-	 * 
+	 *
 	 * @param command a MongoDB command
 	 * @param options query options to use
 	 * @deprecated since 1.7. Please use {@link #executeCommand(DBObject, ReadPreference)}, as the MongoDB Java driver
@@ -99,7 +99,7 @@ public interface MongoOperations {
 	/**
 	 * Execute a MongoDB command. Any errors that result from executing this command will be converted into Spring's data
 	 * access exception hierarchy.
-	 * 
+	 *
 	 * @param command a MongoDB command, must not be {@literal null}.
 	 * @param readPreference read preferences to use, can be {@literal null}.
 	 * @return
@@ -109,7 +109,7 @@ public interface MongoOperations {
 
 	/**
 	 * Execute a MongoDB query and iterate over the query results on a per-document basis with a DocumentCallbackHandler.
-	 * 
+	 *
 	 * @param query the query class that specifies the criteria used to find a record and also an optional fields
 	 *          specification
 	 * @param collectionName name of the collection to retrieve the objects from
@@ -121,7 +121,7 @@ public interface MongoOperations {
 	 * Executes a {@link DbCallback} translating any exceptions as necessary.
 	 * <p/>
 	 * Allows for returning a result object, that is a domain object or a collection of domain objects.
-	 * 
+	 *
 	 * @param <T> return type
 	 * @param action callback object that specifies the MongoDB actions to perform on the passed in DB instance.
 	 * @return a result object returned by the action or <tt>null</tt>
@@ -132,7 +132,7 @@ public interface MongoOperations {
 	 * Executes the given {@link CollectionCallback} on the entity collection of the specified class.
 	 * <p/>
 	 * Allows for returning a result object, that is a domain object or a collection of domain objects.
-	 * 
+	 *
 	 * @param entityClass class that determines the collection to use
 	 * @param <T> return type
 	 * @param action callback object that specifies the MongoDB action
@@ -144,7 +144,7 @@ public interface MongoOperations {
 	 * Executes the given {@link CollectionCallback} on the collection of the given name.
 	 * <p/>
 	 * Allows for returning a result object, that is a domain object or a collection of domain objects.
-	 * 
+	 *
 	 * @param <T> return type
 	 * @param collectionName the name of the collection that specifies which DBCollection instance will be passed into
 	 * @param action callback object that specifies the MongoDB action the callback action.
@@ -158,7 +158,7 @@ public interface MongoOperations {
 	 * href=http://www.mongodb.org/display/DOCS/Java+Driver+Concurrency>Java Driver Concurrency</a>}
 	 * <p/>
 	 * Allows for returning a result object, that is a domain object or a collection of domain objects.
-	 * 
+	 *
 	 * @param <T> return type
 	 * @param action callback that specified the MongoDB actions to perform on the DB instance
 	 * @return a result object returned by the action or <tt>null</tt>
@@ -173,7 +173,7 @@ public interface MongoOperations {
 	 * {@link Cursor}.
 	 * <p>
 	 * Returns a {@link CloseableIterator} that wraps the a Mongo DB {@link Cursor} that needs to be closed.
-	 * 
+	 *
 	 * @param <T> element return type
 	 * @param query must not be {@literal null}.
 	 * @param entityType must not be {@literal null}.
@@ -187,7 +187,7 @@ public interface MongoOperations {
 	 * by a Mongo DB {@link Cursor}.
 	 * <p>
 	 * Returns a {@link CloseableIterator} that wraps the a Mongo DB {@link Cursor} that needs to be closed.
-	 * 
+	 *
 	 * @param <T> element return type
 	 * @param query must not be {@literal null}.
 	 * @param entityType must not be {@literal null}.
@@ -199,7 +199,7 @@ public interface MongoOperations {
 
 	/**
 	 * Create an uncapped collection with a name based on the provided entity class.
-	 * 
+	 *
 	 * @param entityClass class that determines the collection to create
 	 * @return the created collection
 	 */
@@ -207,7 +207,7 @@ public interface MongoOperations {
 
 	/**
 	 * Create a collection with a name based on the provided entity class using the options.
-	 * 
+	 *
 	 * @param entityClass class that determines the collection to create
 	 * @param collectionOptions options to use when creating the collection.
 	 * @return the created collection
@@ -216,7 +216,7 @@ public interface MongoOperations {
 
 	/**
 	 * Create an uncapped collection with the provided name.
-	 * 
+	 *
 	 * @param collectionName name of the collection
 	 * @return the created collection
 	 */
@@ -224,7 +224,7 @@ public interface MongoOperations {
 
 	/**
 	 * Create a collection with the provided name and options.
-	 * 
+	 *
 	 * @param collectionName name of the collection
 	 * @param collectionOptions options to use when creating the collection.
 	 * @return the created collection
@@ -233,7 +233,7 @@ public interface MongoOperations {
 
 	/**
 	 * A set of collection names.
-	 * 
+	 *
 	 * @return list of collection names
 	 */
 	Set<String> getCollectionNames();
@@ -242,7 +242,7 @@ public interface MongoOperations {
 	 * Get a collection by name, creating it if it doesn't exist.
 	 * <p/>
 	 * Translate any exceptions as necessary.
-	 * 
+	 *
 	 * @param collectionName name of the collection
 	 * @return an existing collection or a newly created one.
 	 */
@@ -252,7 +252,7 @@ public interface MongoOperations {
 	 * Check to see if a collection with a name indicated by the entity class exists.
 	 * <p/>
 	 * Translate any exceptions as necessary.
-	 * 
+	 *
 	 * @param entityClass class that determines the name of the collection
 	 * @return true if a collection with the given name is found, false otherwise.
 	 */
@@ -262,7 +262,7 @@ public interface MongoOperations {
 	 * Check to see if a collection with a given name exists.
 	 * <p/>
 	 * Translate any exceptions as necessary.
-	 * 
+	 *
 	 * @param collectionName name of the collection
 	 * @return true if a collection with the given name is found, false otherwise.
 	 */
@@ -272,7 +272,7 @@ public interface MongoOperations {
 	 * Drop the collection with the name indicated by the entity class.
 	 * <p/>
 	 * Translate any exceptions as necessary.
-	 * 
+	 *
 	 * @param entityClass class that determines the collection to drop/delete.
 	 */
 	<T> void dropCollection(Class<T> entityClass);
@@ -281,36 +281,39 @@ public interface MongoOperations {
 	 * Drop the collection with the given name.
 	 * <p/>
 	 * Translate any exceptions as necessary.
-	 * 
+	 *
 	 * @param collectionName name of the collection to drop/delete.
 	 */
 	void dropCollection(String collectionName);
 
 	/**
 	 * Returns the operations that can be performed on indexes
-	 * 
+	 *
 	 * @return index operations on the named collection
 	 */
 	IndexOperations indexOps(String collectionName);
 
 	/**
 	 * Returns the operations that can be performed on indexes
-	 * 
+	 *
 	 * @return index operations on the named collection associated with the given entity class
 	 */
 	IndexOperations indexOps(Class<?> entityClass);
 
 	/**
 	 * Returns the {@link ScriptOperations} that can be performed on {@link com.mongodb.DB} level.
-	 * 
+	 *
 	 * @return
 	 * @since 1.7
 	 */
 	ScriptOperations scriptOps();
 
 	/**
-	 * Returns a new {@link BulkOperations} for the given collection.
-	 * 
+	 * Returns a new {@link BulkOperations} for the given collection. <br />
+	 * <strong>NOTE:</strong> Any additional support for field mapping, etc. is not available for {@literal update} or
+	 * {@literal remove} operations in bulk mode due to the lack of domain type information. Use
+	 * {@link #bulkOps(BulkMode, Class, String)} to get full type specific support.
+	 *
 	 * @param mode the {@link BulkMode} to use for bulk operations, must not be {@literal null}.
 	 * @param collectionName the name of the collection to work on, must not be {@literal null} or empty.
 	 * @return {@link BulkOperations} on the named collection
@@ -319,7 +322,7 @@ public interface MongoOperations {
 
 	/**
 	 * Returns a new {@link BulkOperations} for the given entity type.
-	 * 
+	 *
 	 * @param mode the {@link BulkMode} to use for bulk operations, must not be {@literal null}.
 	 * @param entityType the name of the entity class, must not be {@literal null}.
 	 * @return {@link BulkOperations} on the named collection associated of the given entity class.
@@ -328,7 +331,7 @@ public interface MongoOperations {
 
 	/**
 	 * Returns a new {@link BulkOperations} for the given entity type and collection name.
-	 * 
+	 *
 	 * @param mode the {@link BulkMode} to use for bulk operations, must not be {@literal null}.
 	 * @param entityClass the name of the entity class, must not be {@literal null}.
 	 * @param collectionName the name of the collection to work on, must not be {@literal null} or empty.
@@ -344,7 +347,7 @@ public interface MongoOperations {
 	 * <p/>
 	 * If your collection does not contain a homogeneous collection of types, this operation will not be an efficient way
 	 * to map objects since the test for class type is done in the client and not on the server.
-	 * 
+	 *
 	 * @param entityClass the parameterized type of the returned list
 	 * @return the converted collection
 	 */
@@ -358,7 +361,7 @@ public interface MongoOperations {
 	 * <p/>
 	 * If your collection does not contain a homogeneous collection of types, this operation will not be an efficient way
 	 * to map objects since the test for class type is done in the client and not on the server.
-	 * 
+	 *
 	 * @param entityClass the parameterized type of the returned list.
 	 * @param collectionName name of the collection to retrieve the objects from
 	 * @return the converted collection
@@ -368,7 +371,7 @@ public interface MongoOperations {
 	/**
 	 * Execute a group operation over the entire collection. The group operation entity class should match the 'shape' of
 	 * the returned object that takes int account the initial document structure as well as any finalize functions.
-	 * 
+	 *
 	 * @param criteria The criteria that restricts the row that are considered for grouping. If not specified all rows are
 	 *          considered.
 	 * @param inputCollectionName the collection where the group operation will read from
@@ -383,7 +386,7 @@ public interface MongoOperations {
 	 * Execute a group operation restricting the rows to those which match the provided Criteria. The group operation
 	 * entity class should match the 'shape' of the returned object that takes int account the initial document structure
 	 * as well as any finalize functions.
-	 * 
+	 *
 	 * @param criteria The criteria that restricts the row that are considered for grouping. If not specified all rows are
 	 *          considered.
 	 * @param inputCollectionName the collection where the group operation will read from
@@ -397,7 +400,7 @@ public interface MongoOperations {
 	/**
 	 * Execute an aggregation operation. The raw results will be mapped to the given entity class. The name of the
 	 * inputCollection is derived from the inputType of the aggregation.
-	 * 
+	 *
 	 * @param aggregation The {@link TypedAggregation} specification holding the aggregation operations, must not be
 	 *          {@literal null}.
 	 * @param collectionName The name of the input collection to use for the aggreation.
@@ -410,7 +413,7 @@ public interface MongoOperations {
 	/**
 	 * Execute an aggregation operation. The raw results will be mapped to the given entity class. The name of the
 	 * inputCollection is derived from the inputType of the aggregation.
-	 * 
+	 *
 	 * @param aggregation The {@link TypedAggregation} specification holding the aggregation operations, must not be
 	 *          {@literal null}.
 	 * @param outputType The parameterized type of the returned list, must not be {@literal null}.
@@ -421,7 +424,7 @@ public interface MongoOperations {
 
 	/**
 	 * Execute an aggregation operation. The raw results will be mapped to the given entity class.
-	 * 
+	 *
 	 * @param aggregation The {@link Aggregation} specification holding the aggregation operations, must not be
 	 *          {@literal null}.
 	 * @param inputType the inputType where the aggregation operation will read from, must not be {@literal null} or
@@ -434,7 +437,7 @@ public interface MongoOperations {
 
 	/**
 	 * Execute an aggregation operation. The raw results will be mapped to the given entity class.
-	 * 
+	 *
 	 * @param aggregation The {@link Aggregation} specification holding the aggregation operations, must not be
 	 *          {@literal null}.
 	 * @param collectionName the collection where the aggregation operation will read from, must not be {@literal null} or
@@ -447,7 +450,7 @@ public interface MongoOperations {
 
 	/**
 	 * Execute a map-reduce operation. The map-reduce operation will be formed with an output type of INLINE
-	 * 
+	 *
 	 * @param inputCollectionName the collection where the map-reduce will read from
 	 * @param mapFunction The JavaScript map function
 	 * @param reduceFunction The JavaScript reduce function
@@ -460,7 +463,7 @@ public interface MongoOperations {
 
 	/**
 	 * Execute a map-reduce operation that takes additional map-reduce options.
-	 * 
+	 *
 	 * @param inputCollectionName the collection where the map-reduce will read from
 	 * @param mapFunction The JavaScript map function
 	 * @param reduceFunction The JavaScript reduce function
@@ -474,7 +477,7 @@ public interface MongoOperations {
 	/**
 	 * Execute a map-reduce operation that takes a query. The map-reduce operation will be formed with an output type of
 	 * INLINE
-	 * 
+	 *
 	 * @param query The query to use to select the data for the map phase
 	 * @param inputCollectionName the collection where the map-reduce will read from
 	 * @param mapFunction The JavaScript map function
@@ -488,7 +491,7 @@ public interface MongoOperations {
 
 	/**
 	 * Execute a map-reduce operation that takes a query and additional map-reduce options
-	 * 
+	 *
 	 * @param query The query to use to select the data for the map phase
 	 * @param inputCollectionName the collection where the map-reduce will read from
 	 * @param mapFunction The JavaScript map function
@@ -505,7 +508,7 @@ public interface MongoOperations {
 	 * information to determine the collection the query is ran against. Note, that MongoDB limits the number of results
 	 * by default. Make sure to add an explicit limit to the {@link NearQuery} if you expect a particular number of
 	 * results.
-	 * 
+	 *
 	 * @param near must not be {@literal null}.
 	 * @param entityClass must not be {@literal null}.
 	 * @return
@@ -516,7 +519,7 @@ public interface MongoOperations {
 	 * Returns {@link GeoResults} for all entities matching the given {@link NearQuery}. Note, that MongoDB limits the
 	 * number of results by default. Make sure to add an explicit limit to the {@link NearQuery} if you expect a
 	 * particular number of results.
-	 * 
+	 *
 	 * @param near must not be {@literal null}.
 	 * @param entityClass must not be {@literal null}.
 	 * @param collectionName the collection to trigger the query against. If no collection name is given the entity class
@@ -534,7 +537,7 @@ public interface MongoOperations {
 	 * <p/>
 	 * The query is specified as a {@link Query} which can be created either using the {@link BasicQuery} or the more
 	 * feature rich {@link Query}.
-	 * 
+	 *
 	 * @param query the query class that specifies the criteria used to find a record and also an optional fields
 	 *          specification
 	 * @param entityClass the parameterized type of the returned list.
@@ -551,7 +554,7 @@ public interface MongoOperations {
 	 * <p/>
 	 * The query is specified as a {@link Query} which can be created either using the {@link BasicQuery} or the more
 	 * feature rich {@link Query}.
-	 * 
+	 *
 	 * @param query the query class that specifies the criteria used to find a record and also an optional fields
 	 *          specification
 	 * @param entityClass the parameterized type of the returned list.
@@ -561,8 +564,10 @@ public interface MongoOperations {
 	<T> T findOne(Query query, Class<T> entityClass, String collectionName);
 
 	/**
-	 * Determine result of given {@link Query} contains at least one element.
-	 * 
+	 * Determine result of given {@link Query} contains at least one element. <br />
+	 * <strong>NOTE:</strong> Any additional support for query/field mapping, etc. is not available due to the lack of
+	 * domain type information. Use {@link #exists(Query, Class, String)} to get full type specific support.
+	 *
 	 * @param query the {@link Query} class that specifies the criteria used to find a record.
 	 * @param collectionName name of the collection to check for objects.
 	 * @return
@@ -571,7 +576,7 @@ public interface MongoOperations {
 
 	/**
 	 * Determine result of given {@link Query} contains at least one element.
-	 * 
+	 *
 	 * @param query the {@link Query} class that specifies the criteria used to find a record.
 	 * @param entityClass the parameterized type.
 	 * @return
@@ -580,7 +585,7 @@ public interface MongoOperations {
 
 	/**
 	 * Determine result of given {@link Query} contains at least one element.
-	 * 
+	 *
 	 * @param query the {@link Query} class that specifies the criteria used to find a record.
 	 * @param entityClass the parameterized type.
 	 * @param collectionName name of the collection to check for objects.
@@ -596,7 +601,7 @@ public interface MongoOperations {
 	 * <p/>
 	 * The query is specified as a {@link Query} which can be created either using the {@link BasicQuery} or the more
 	 * feature rich {@link Query}.
-	 * 
+	 *
 	 * @param query the query class that specifies the criteria used to find a record and also an optional fields
 	 *          specification
 	 * @param entityClass the parameterized type of the returned list.
@@ -612,7 +617,7 @@ public interface MongoOperations {
 	 * <p/>
 	 * The query is specified as a {@link Query} which can be created either using the {@link BasicQuery} or the more
 	 * feature rich {@link Query}.
-	 * 
+	 *
 	 * @param query the query class that specifies the criteria used to find a record and also an optional fields
 	 *          specification
 	 * @param entityClass the parameterized type of the returned list.
@@ -624,7 +629,7 @@ public interface MongoOperations {
 	/**
 	 * Returns a document with the given id mapped onto the given class. The collection the query is ran against will be
 	 * derived from the given target class as well.
-	 * 
+	 *
 	 * @param <T>
 	 * @param id the id of the document to return.
 	 * @param entityClass the type the document shall be converted into.
@@ -634,7 +639,7 @@ public interface MongoOperations {
 
 	/**
 	 * Returns the document with the given id from the given collection mapped onto the given target class.
-	 * 
+	 *
 	 * @param id the id of the document to return
 	 * @param entityClass the type to convert the document to
 	 * @param collectionName the collection to query for the document
@@ -644,9 +649,9 @@ public interface MongoOperations {
 	<T> T findById(Object id, Class<T> entityClass, String collectionName);
 
 	/**
-	 * Triggers <a href="http://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify
-	 * <a/> to apply provided {@link Update} on documents matching {@link Criteria} of given {@link Query}.
-	 * 
+	 * Triggers <a href="http://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify <a/>
+	 * to apply provided {@link Update} on documents matching {@link Criteria} of given {@link Query}.
+	 *
 	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
 	 *          fields specification.
 	 * @param update the {@link Update} to apply on matching documents.
@@ -656,9 +661,9 @@ public interface MongoOperations {
 	<T> T findAndModify(Query query, Update update, Class<T> entityClass);
 
 	/**
-	 * Triggers <a href="http://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify
-	 * <a/> to apply provided {@link Update} on documents matching {@link Criteria} of given {@link Query}.
-	 * 
+	 * Triggers <a href="http://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify <a/>
+	 * to apply provided {@link Update} on documents matching {@link Criteria} of given {@link Query}.
+	 *
 	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
 	 *          fields specification.
 	 * @param update the {@link Update} to apply on matching documents.
@@ -669,10 +674,10 @@ public interface MongoOperations {
 	<T> T findAndModify(Query query, Update update, Class<T> entityClass, String collectionName);
 
 	/**
-	 * Triggers <a href="http://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify
-	 * <a/> to apply provided {@link Update} on documents matching {@link Criteria} of given {@link Query} taking
+	 * Triggers <a href="http://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify <a/>
+	 * to apply provided {@link Update} on documents matching {@link Criteria} of given {@link Query} taking
 	 * {@link FindAndModifyOptions} into account.
-	 * 
+	 *
 	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
 	 *          fields specification.
 	 * @param update the {@link Update} to apply on matching documents.
@@ -683,10 +688,10 @@ public interface MongoOperations {
 	<T> T findAndModify(Query query, Update update, FindAndModifyOptions options, Class<T> entityClass);
 
 	/**
-	 * Triggers <a href="http://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify
-	 * <a/> to apply provided {@link Update} on documents matching {@link Criteria} of given {@link Query} taking
+	 * Triggers <a href="http://docs.mongodb.org/manual/reference/method/db.collection.findAndModify/">findAndModify <a/>
+	 * to apply provided {@link Update} on documents matching {@link Criteria} of given {@link Query} taking
 	 * {@link FindAndModifyOptions} into account.
-	 * 
+	 *
 	 * @param query the {@link Query} class that specifies the {@link Criteria} used to find a record and also an optional
 	 *          fields specification.
 	 * @param update the {@link Update} to apply on matching documents.
@@ -707,7 +712,7 @@ public interface MongoOperations {
 	 * <p/>
 	 * The query is specified as a {@link Query} which can be created either using the {@link BasicQuery} or the more
 	 * feature rich {@link Query}.
-	 * 
+	 *
 	 * @param query the query class that specifies the criteria used to find a record and also an optional fields
 	 *          specification
 	 * @param entityClass the parameterized type of the returned list.
@@ -724,7 +729,7 @@ public interface MongoOperations {
 	 * <p/>
 	 * The query is specified as a {@link Query} which can be created either using the {@link BasicQuery} or the more
 	 * feature rich {@link Query}.
-	 * 
+	 *
 	 * @param query the query class that specifies the criteria used to find a record and also an optional fields
 	 *          specification
 	 * @param entityClass the parameterized type of the returned list.
@@ -735,7 +740,7 @@ public interface MongoOperations {
 
 	/**
 	 * Returns the number of documents for the given {@link Query} by querying the collection of the given entity class.
-	 * 
+	 *
 	 * @param query
 	 * @param entityClass must not be {@literal null}.
 	 * @return
@@ -745,8 +750,8 @@ public interface MongoOperations {
 	/**
 	 * Returns the number of documents for the given {@link Query} querying the given collection. The given {@link Query}
 	 * must solely consist of document field references as we lack type information to map potential property references
-	 * onto document fields. TO make sure the query gets mapped, use {@link #count(Query, Class, String)}.
-	 * 
+	 * onto document fields. Use {@link #count(Query, Class, String)} to get full type specific support.
+	 *
 	 * @param query
 	 * @param collectionName must not be {@literal null} or empty.
 	 * @return
@@ -757,7 +762,7 @@ public interface MongoOperations {
 	/**
 	 * Returns the number of documents for the given {@link Query} by querying the given collection using the given entity
 	 * class to map the given {@link Query}.
-	 * 
+	 *
 	 * @param query
 	 * @param entityClass must not be {@literal null}.
 	 * @param collectionName must not be {@literal null} or empty.
@@ -778,7 +783,7 @@ public interface MongoOperations {
 	 * <p/>
 	 * <p/>
 	 * Insert is used to initially store the object into the database. To update an existing object use the save method.
-	 * 
+	 *
 	 * @param objectToSave the object to store in the collection.
 	 */
 	void insert(Object objectToSave);
@@ -790,7 +795,7 @@ public interface MongoOperations {
 	 * configured otherwise, an instance of MappingMongoConverter will be used.
 	 * <p/>
 	 * Insert is used to initially store the object into the database. To update an existing object use the save method.
-	 * 
+	 *
 	 * @param objectToSave the object to store in the collection
 	 * @param collectionName name of the collection to store the object in
 	 */
@@ -798,7 +803,7 @@ public interface MongoOperations {
 
 	/**
 	 * Insert a Collection of objects into a collection in a single batch write to the database.
-	 * 
+	 *
 	 * @param batchToSave the list of objects to save.
 	 * @param entityClass class that determines the collection to use
 	 */
@@ -806,7 +811,7 @@ public interface MongoOperations {
 
 	/**
 	 * Insert a list of objects into the specified collection in a single batch write to the database.
-	 * 
+	 *
 	 * @param batchToSave the list of objects to save.
 	 * @param collectionName name of the collection to store the object in
 	 */
@@ -815,8 +820,8 @@ public interface MongoOperations {
 	/**
 	 * Insert a mixed Collection of objects into a database collection determining the collection name to use based on the
 	 * class.
-	 * 
-	 * @param collectionToSave the list of objects to save.
+	 *
+	 * @param objectsToSave the list of objects to save.
 	 */
 	void insertAll(Collection<? extends Object> objectsToSave);
 
@@ -832,7 +837,7 @@ public interface MongoOperations {
 	 * property type will be handled by Spring's BeanWrapper class that leverages Type Conversion API. See
 	 * <a href="http://docs.spring.io/spring/docs/current/spring-framework-reference/html/validation.html#core-convert" >
 	 * Spring's Type Conversion"</a> for more details.
-	 * 
+	 *
 	 * @param objectToSave the object to store in the collection
 	 */
 	void save(Object objectToSave);
@@ -849,7 +854,7 @@ public interface MongoOperations {
 	 * property type will be handled by Spring's BeanWrapper class that leverages Type Cobnversion API. See <a
 	 * http://docs.spring.io/spring/docs/current/spring-framework-reference/html/validation.html#core-convert">Spring's
 	 * Type Conversion"</a> for more details.
-	 * 
+	 *
 	 * @param objectToSave the object to store in the collection
 	 * @param collectionName name of the collection to store the object in
 	 */
@@ -858,7 +863,7 @@ public interface MongoOperations {
 	/**
 	 * Performs an upsert. If no document is found that matches the query, a new document is created and inserted by
 	 * combining the query document and the update document.
-	 * 
+	 *
 	 * @param query the query document that specifies the criteria used to select a record to be upserted
 	 * @param update the update document that contains the updated object or $ operators to manipulate the existing object
 	 * @param entityClass class that determines the collection to use
@@ -868,8 +873,10 @@ public interface MongoOperations {
 
 	/**
 	 * Performs an upsert. If no document is found that matches the query, a new document is created and inserted by
-	 * combining the query document and the update document.
-	 * 
+	 * combining the query document and the update document. <br />
+	 * <strong>NOTE:</strong> Any additional support for field mapping, versions, etc. is not available due to the lack of
+	 * domain type information. Use {@link #upsert(Query, Update, Class, String)} to get full type specific support.
+	 *
 	 * @param query the query document that specifies the criteria used to select a record to be updated
 	 * @param update the update document that contains the updated object or $ operators to manipulate the existing
 	 *          object.
@@ -881,7 +888,7 @@ public interface MongoOperations {
 	/**
 	 * Performs an upsert. If no document is found that matches the query, a new document is created and inserted by
 	 * combining the query document and the update document.
-	 * 
+	 *
 	 * @param query the query document that specifies the criteria used to select a record to be upserted
 	 * @param update the update document that contains the updated object or $ operators to manipulate the existing object
 	 * @param entityClass class of the pojo to be operated on
@@ -893,7 +900,7 @@ public interface MongoOperations {
 	/**
 	 * Updates the first object that is found in the collection of the entity class that matches the query document with
 	 * the provided update document.
-	 * 
+	 *
 	 * @param query the query document that specifies the criteria used to select a record to be updated
 	 * @param update the update document that contains the updated object or $ operators to manipulate the existing
 	 *          object.
@@ -904,8 +911,10 @@ public interface MongoOperations {
 
 	/**
 	 * Updates the first object that is found in the specified collection that matches the query document criteria with
-	 * the provided updated document.
-	 * 
+	 * the provided updated document. <br />
+	 * <strong>NOTE:</strong> Any additional support for field mapping, versions, etc. is not available due to the lack of
+	 * domain type information. Use {@link #updateFirst(Query, Update, Class, String)} to get full type specific support.
+	 *
 	 * @param query the query document that specifies the criteria used to select a record to be updated
 	 * @param update the update document that contains the updated object or $ operators to manipulate the existing
 	 *          object.
@@ -917,7 +926,7 @@ public interface MongoOperations {
 	/**
 	 * Updates the first object that is found in the specified collection that matches the query document criteria with
 	 * the provided updated document.
-	 * 
+	 *
 	 * @param query the query document that specifies the criteria used to select a record to be updated
 	 * @param update the update document that contains the updated object or $ operators to manipulate the existing
 	 *          object.
@@ -930,7 +939,7 @@ public interface MongoOperations {
 	/**
 	 * Updates all objects that are found in the collection for the entity class that matches the query document criteria
 	 * with the provided updated document.
-	 * 
+	 *
 	 * @param query the query document that specifies the criteria used to select a record to be updated
 	 * @param update the update document that contains the updated object or $ operators to manipulate the existing
 	 *          object.
@@ -941,8 +950,10 @@ public interface MongoOperations {
 
 	/**
 	 * Updates all objects that are found in the specified collection that matches the query document criteria with the
-	 * provided updated document.
-	 * 
+	 * provided updated document. <br />
+	 * <strong>NOTE:</strong> Any additional support for field mapping, versions, etc. is not available due to the lack of
+	 * domain type information. Use {@link #updateMulti(Query, Update, Class, String)} to get full type specific support.
+	 *
 	 * @param query the query document that specifies the criteria used to select a record to be updated
 	 * @param update the update document that contains the updated object or $ operators to manipulate the existing
 	 *          object.
@@ -954,7 +965,7 @@ public interface MongoOperations {
 	/**
 	 * Updates all objects that are found in the collection for the entity class that matches the query document criteria
 	 * with the provided updated document.
-	 * 
+	 *
 	 * @param query the query document that specifies the criteria used to select a record to be updated
 	 * @param update the update document that contains the updated object or $ operators to manipulate the existing
 	 *          object.
@@ -966,14 +977,14 @@ public interface MongoOperations {
 
 	/**
 	 * Remove the given object from the collection by id.
-	 * 
+	 *
 	 * @param object
 	 */
 	WriteResult remove(Object object);
 
 	/**
 	 * Removes the given object from the given collection.
-	 * 
+	 *
 	 * @param object
 	 * @param collection must not be {@literal null} or empty.
 	 */
@@ -982,36 +993,44 @@ public interface MongoOperations {
 	/**
 	 * Remove all documents that match the provided query document criteria from the the collection used to store the
 	 * entityClass. The Class parameter is also used to help convert the Id of the object if it is present in the query.
-	 * 
-	 * @param query
-	 * @param entityClass
+	 *
+	 * @param query must not be {@literal null}.
+	 * @param entityClass must not be {@literal null}.
+	 * @throws IllegalArgumentException when {@literal query} or {@literal entityClass} is {@literal null}.
 	 */
 	WriteResult remove(Query query, Class<?> entityClass);
 
 	/**
 	 * Remove all documents that match the provided query document criteria from the the collection used to store the
 	 * entityClass. The Class parameter is also used to help convert the Id of the object if it is present in the query.
-	 * 
+	 *
 	 * @param query
 	 * @param entityClass
 	 * @param collectionName
+	 * @throws IllegalArgumentException when {@literal query}, {@literal entityClass} or {@literal collectionName} is
+	 *           {@literal null}.
 	 */
 	WriteResult remove(Query query, Class<?> entityClass, String collectionName);
 
 	/**
 	 * Remove all documents from the specified collection that match the provided query document criteria. There is no
-	 * conversion/mapping done for any criteria using the id field.
-	 * 
+	 * conversion/mapping done for any criteria using the id field. <br />
+	 * <strong>NOTE:</strong> Any additional support for field mapping is not available due to the lack of domain type
+	 * information. Use {@link #remove(Query, Class, String)} to get full type specific support.
+	 *
 	 * @param query the query document that specifies the criteria used to remove a record
 	 * @param collectionName name of the collection where the objects will removed
+	 * @throws IllegalArgumentException when {@literal query} or {@literal collectionName} is {@literal null}.
 	 */
 	WriteResult remove(Query query, String collectionName);
 
 	/**
-	 * Returns and removes all documents form the specified collection that match the provided query.
-	 * 
-	 * @param query
-	 * @param collectionName
+	 * Returns and removes all documents form the specified collection that match the provided query. <br />
+	 * <strong>NOTE:</strong> Any additional support for field mapping is not available due to the lack of domain type
+	 * information. Use {@link #findAllAndRemove(Query, Class, String)} to get full type specific support.
+	 *
+	 * @param query must not be {@literal null}.
+	 * @param collectionName must not be {@literal null}.
 	 * @return
 	 * @since 1.5
 	 */
@@ -1019,7 +1038,7 @@ public interface MongoOperations {
 
 	/**
 	 * Returns and removes all documents matching the given query form the collection used to store the entityClass.
-	 * 
+	 *
 	 * @param query
 	 * @param entityClass
 	 * @return
@@ -1031,7 +1050,7 @@ public interface MongoOperations {
 	 * Returns and removes all documents that match the provided query document criteria from the the collection used to
 	 * store the entityClass. The Class parameter is also used to help convert the Id of the object if it is present in
 	 * the query.
-	 * 
+	 *
 	 * @param query
 	 * @param entityClass
 	 * @param collectionName
@@ -1042,7 +1061,7 @@ public interface MongoOperations {
 
 	/**
 	 * Returns the underlying {@link MongoConverter}.
-	 * 
+	 *
 	 * @return
 	 */
 	MongoConverter getConverter();

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

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

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

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

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2016 the original author or authors.
+ * Copyright 2010-2019 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,17 +19,8 @@ import static org.springframework.data.mongodb.core.query.Criteria.*;
 import static org.springframework.data.mongodb.core.query.SerializationUtils.*;
 
 import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.Map.Entry;
-import java.util.Scanner;
-import java.util.Set;
 
 import org.bson.types.ObjectId;
 import org.slf4j.Logger;
@@ -61,12 +52,14 @@ import org.springframework.data.mapping.model.ConvertingPropertyAccessor;
 import org.springframework.data.mapping.model.MappingException;
 import org.springframework.data.mongodb.MongoDbFactory;
 import org.springframework.data.mongodb.core.BulkOperations.BulkMode;
+import org.springframework.data.mongodb.core.DefaultBulkOperations.BulkOperationContext;
 import org.springframework.data.mongodb.core.aggregation.Aggregation;
 import org.springframework.data.mongodb.core.aggregation.AggregationOperationContext;
 import org.springframework.data.mongodb.core.aggregation.AggregationResults;
 import org.springframework.data.mongodb.core.aggregation.Fields;
 import org.springframework.data.mongodb.core.aggregation.TypeBasedAggregationOperationContext;
 import org.springframework.data.mongodb.core.aggregation.TypedAggregation;
+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;
@@ -106,27 +99,13 @@ import org.springframework.util.ObjectUtils;
 import org.springframework.util.ResourceUtils;
 import org.springframework.util.StringUtils;
 
-import com.mongodb.BasicDBObject;
-import com.mongodb.Bytes;
-import com.mongodb.CommandResult;
-import com.mongodb.Cursor;
-import com.mongodb.DB;
-import com.mongodb.DBCollection;
-import com.mongodb.DBCursor;
-import com.mongodb.DBObject;
-import com.mongodb.MapReduceCommand;
-import com.mongodb.MapReduceOutput;
-import com.mongodb.Mongo;
-import com.mongodb.MongoException;
-import com.mongodb.ReadPreference;
-import com.mongodb.WriteConcern;
-import com.mongodb.WriteResult;
+import com.mongodb.*;
 import com.mongodb.util.JSON;
 import com.mongodb.util.JSONParseException;
 
 /**
  * Primary implementation of {@link MongoOperations}.
- * 
+ *
  * @author Thomas Risberg
  * @author Graeme Rocher
  * @author Mark Pollack
@@ -141,6 +120,8 @@ import com.mongodb.util.JSONParseException;
  * @author Doménique Tilleuil
  * @author Niko Schmuck
  * @author Mark Paluch
+ * @author Laszlo Csontos
+ * @author Borislav Rangelov
  */
 @SuppressWarnings("deprecation")
 public class MongoTemplate implements MongoOperations, ApplicationContextAware {
@@ -177,7 +158,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 	/**
 	 * Constructor used for a basic template configuration
-	 * 
+	 *
 	 * @param mongo must not be {@literal null}.
 	 * @param databaseName must not be {@literal null} or empty.
 	 */
@@ -188,7 +169,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	/**
 	 * Constructor used for a template configuration with user credentials in the form of
 	 * {@link org.springframework.data.authentication.UserCredentials}
-	 * 
+	 *
 	 * @param mongo must not be {@literal null}.
 	 * @param databaseName must not be {@literal null} or empty.
 	 * @param userCredentials
@@ -199,7 +180,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 	/**
 	 * Constructor used for a basic template configuration.
-	 * 
+	 *
 	 * @param mongoDbFactory must not be {@literal null}.
 	 */
 	public MongoTemplate(MongoDbFactory mongoDbFactory) {
@@ -208,13 +189,13 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 	/**
 	 * Constructor used for a basic template configuration.
-	 * 
+	 *
 	 * @param mongoDbFactory must not be {@literal null}.
 	 * @param mongoConverter
 	 */
 	public MongoTemplate(MongoDbFactory mongoDbFactory, MongoConverter mongoConverter) {
 
-		Assert.notNull(mongoDbFactory);
+		Assert.notNull(mongoDbFactory, "MongoDbFactory must not be null!");
 
 		this.mongoDbFactory = mongoDbFactory;
 		this.exceptionTranslator = mongoDbFactory.getExceptionTranslator();
@@ -237,7 +218,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	/**
 	 * Configures the {@link WriteResultChecking} to be used with the template. Setting {@literal null} will reset the
 	 * default of {@value #DEFAULT_WRITE_RESULT_CHECKING}.
-	 * 
+	 *
 	 * @param resultChecking
 	 */
 	public void setWriteResultChecking(WriteResultChecking resultChecking) {
@@ -248,7 +229,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	 * Configures the {@link WriteConcern} to be used with the template. If none is configured the {@link WriteConcern}
 	 * configured on the {@link MongoDbFactory} will apply. If you configured a {@link Mongo} instance no
 	 * {@link WriteConcern} will be used.
-	 * 
+	 *
 	 * @param writeConcern
 	 */
 	public void setWriteConcern(WriteConcern writeConcern) {
@@ -257,7 +238,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 	/**
 	 * Configures the {@link WriteConcernResolver} to be used with the template.
-	 * 
+	 *
 	 * @param writeConcernResolver
 	 */
 	public void setWriteConcernResolver(WriteConcernResolver writeConcernResolver) {
@@ -267,7 +248,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	/**
 	 * Used by @{link {@link #prepareCollection(DBCollection)} to set the {@link ReadPreference} before any operations are
 	 * performed.
-	 * 
+	 *
 	 * @param readPreference
 	 */
 	public void setReadPreference(ReadPreference readPreference) {
@@ -294,7 +275,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	 * they were registered for the current {@link MappingContext}. If no creator for the current {@link MappingContext}
 	 * can be found we manually add the internally created one as {@link ApplicationListener} to make sure indexes get
 	 * created appropriately for entity types persisted through this {@link MongoTemplate} instance.
-	 * 
+	 *
 	 * @param context must not be {@literal null}.
 	 */
 	private void prepareIndexCreator(ApplicationContext context) {
@@ -314,15 +295,15 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	}
 
 	/**
-	 * Returns the default {@link org.springframework.data.mongodb.core.core.convert.MongoConverter}.
-	 * 
+	 * Returns the default {@link org.springframework.data.mongodb.core.convert.MongoConverter}.
+	 *
 	 * @return
 	 */
 	public MongoConverter getConverter() {
 		return this.mongoConverter;
 	}
 
-	/* 
+	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.mongodb.core.MongoOperations#executeAsStream(org.springframework.data.mongodb.core.query.Query, java.lang.Class)
 	 */
@@ -332,7 +313,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 		return stream(query, entityType, determineCollectionName(entityType));
 	}
 
-	/* 
+	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.mongodb.core.MongoOperations#stream(org.springframework.data.mongodb.core.query.Query, java.lang.Class, java.lang.String)
 	 */
@@ -428,7 +409,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	/**
 	 * Execute a MongoDB query and iterate over the query results on a per-document basis with a
 	 * {@link DocumentCallbackHandler} using the provided CursorPreparer.
-	 * 
+	 *
 	 * @param query the query class that specifies the criteria used to find a record and also an optional fields
 	 *          specification, must not be {@literal null}.
 	 * @param collectionName name of the collection to retrieve the objects from
@@ -439,7 +420,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	protected void executeQuery(Query query, String collectionName, DocumentCallbackHandler dch,
 			CursorPreparer preparer) {
 
-		Assert.notNull(query);
+		Assert.notNull(query, "Query must not be null!");
 
 		DBObject queryObject = queryMapper.getMappedObject(query.getQueryObject(), null);
 		DBObject sortObject = query.getSortObject();
@@ -455,7 +436,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 	public <T> T execute(DbCallback<T> action) {
 
-		Assert.notNull(action);
+		Assert.notNull(action, "DbCallbackmust not be null!");
 
 		try {
 			DB db = this.getDb();
@@ -471,7 +452,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 	public <T> T execute(String collectionName, CollectionCallback<T> callback) {
 
-		Assert.notNull(callback);
+		Assert.notNull(callback, "CollectionCallback must not be null!");
 
 		try {
 			DBCollection collection = getAndPrepareCollection(getDb(), collectionName);
@@ -557,7 +538,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	}
 
 	public IndexOperations indexOps(Class<?> entityClass) {
-		return new DefaultIndexOperations(this, determineCollectionName(entityClass));
+		return new DefaultIndexOperations(this, determineCollectionName(entityClass), entityClass);
 	}
 
 	public BulkOperations bulkOps(BulkMode bulkMode, String collectionName) {
@@ -573,10 +554,10 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 		Assert.notNull(mode, "BulkMode must not be null!");
 		Assert.hasText(collectionName, "Collection name must not be null or empty!");
 
-		DefaultBulkOperations operations = new DefaultBulkOperations(this, mode, collectionName, entityType);
+		DefaultBulkOperations operations = new DefaultBulkOperations(this, collectionName,
+				new BulkOperationContext(mode, getPersistentEntity(entityType), queryMapper, updateMapper));
 
 		operations.setExceptionTranslator(exceptionTranslator);
-		operations.setWriteConcernResolver(writeConcernResolver);
 		operations.setDefaultWriteConcern(writeConcern);
 
 		return operations;
@@ -699,8 +680,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 			/*
 			 * As MongoDB currently (2.4.4) doesn't support the skipping of elements in near queries
 			 * we skip the elements ourselves to avoid at least the document 2 object mapping overhead.
-			 * 
-			 * @see https://jira.mongodb.org/browse/SERVER-3925
+			 *
+			 * @see <a href="https://jira.mongodb.org/browse/SERVER-3925">MongoDB Jira: SERVER-3925</a>
 			 */
 			if (index >= elementsToSkip) {
 				result.add(callback.doWith((DBObject) element));
@@ -749,7 +730,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	}
 
 	public long count(Query query, Class<?> entityClass) {
-		Assert.notNull(entityClass);
+
+		Assert.notNull(entityClass, "Entity class must not be null!");
 		return count(query, entityClass, determineCollectionName(entityClass));
 	}
 
@@ -763,7 +745,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	 */
 	public long count(Query query, Class<?> entityClass, String collectionName) {
 
-		Assert.hasText(collectionName);
+		Assert.hasText(collectionName, "Collection name must not be null or empty!");
+
 		final DBObject dbObject = query == null ? null
 				: queryMapper.getMappedObject(query.getQueryObject(),
 						entityClass == null ? null : mappingContext.getPersistentEntity(entityClass));
@@ -804,7 +787,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	/**
 	 * Prepare the collection before any processing is done using it. This allows a convenient way to apply settings like
 	 * slaveOk() etc. Can be overridden in sub-classes.
-	 * 
+	 *
 	 * @param collection
 	 */
 	protected void prepareCollection(DBCollection collection) {
@@ -818,7 +801,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	 * settings in sub-classes. <br />
 	 * In case of using MongoDB Java driver version 3 the returned {@link WriteConcern} will be defaulted to
 	 * {@link WriteConcern#ACKNOWLEDGED} when {@link WriteResultChecking} is set to {@link WriteResultChecking#EXCEPTION}.
-	 * 
+	 *
 	 * @param writeConcern any WriteConcern already configured or null
 	 * @return The prepared WriteConcern or null
 	 */
@@ -842,11 +825,9 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 	protected <T> void doInsert(String collectionName, T objectToSave, MongoWriter<T> writer) {
 
-		assertUpdateableIdIfNotSet(objectToSave);
-
 		initializeVersionProperty(objectToSave);
-
 		maybeEmitEvent(new BeforeConvertEvent<T>(objectToSave, collectionName));
+		assertUpdateableIdIfNotSet(objectToSave);
 
 		DBObject dbDoc = toDbObject(objectToSave, writer);
 
@@ -934,15 +915,16 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 	protected <T> void doInsertBatch(String collectionName, Collection<? extends T> batchToSave, MongoWriter<T> writer) {
 
-		Assert.notNull(writer);
+		Assert.notNull(writer, "MongoWriter must not be null!");
 
 		List<DBObject> dbObjectList = new ArrayList<DBObject>();
+
 		for (T o : batchToSave) {
 
 			initializeVersionProperty(o);
-			BasicDBObject dbDoc = new BasicDBObject();
-
 			maybeEmitEvent(new BeforeConvertEvent<T>(o, collectionName));
+
+			BasicDBObject dbDoc = new BasicDBObject();
 			writer.write(o, dbDoc);
 
 			maybeEmitEvent(new BeforeSaveEvent<T>(o, dbDoc, collectionName));
@@ -963,14 +945,14 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 	public void save(Object objectToSave) {
 
-		Assert.notNull(objectToSave);
+		Assert.notNull(objectToSave, "Object to save must not be null!");
 		save(objectToSave, determineEntityCollectionName(objectToSave));
 	}
 
 	public void save(Object objectToSave, String collectionName) {
 
-		Assert.notNull(objectToSave);
-		Assert.hasText(collectionName);
+		Assert.notNull(objectToSave, "Object to save must not be null!");
+		Assert.hasText(collectionName, "Collection name must not be null or empty!");
 
 		MongoPersistentEntity<?> mongoPersistentEntity = getPersistentEntity(objectToSave.getClass());
 
@@ -999,23 +981,23 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 			doInsert(collectionName, objectToSave, this.mongoConverter);
 		} else {
 
-			assertUpdateableIdIfNotSet(objectToSave);
-
-			// Create query for entity with the id and old version
-			Object id = convertingAccessor.getProperty(idProperty);
-			Query query = new Query(Criteria.where(idProperty.getName()).is(id).and(versionProperty.getName()).is(version));
-
 			// Bump version number
 			convertingAccessor.setProperty(versionProperty, versionNumber.longValue() + 1);
 
+			maybeEmitEvent(new BeforeConvertEvent<T>(objectToSave, collectionName));
+			assertUpdateableIdIfNotSet(objectToSave);
+
 			BasicDBObject dbObject = new BasicDBObject();
 
-			maybeEmitEvent(new BeforeConvertEvent<T>(objectToSave, collectionName));
 			this.mongoConverter.write(objectToSave, dbObject);
 
 			maybeEmitEvent(new BeforeSaveEvent<T>(objectToSave, dbObject, collectionName));
 			Update update = Update.fromDBObject(dbObject, ID_FIELD);
 
+			// Create query for entity with the id and old version
+			Object id = convertingAccessor.getProperty(idProperty);
+			Query query = new Query(Criteria.where(idProperty.getName()).is(id).and(versionProperty.getName()).is(version));
+
 			doUpdate(collectionName, query, update, objectToSave.getClass(), false, false);
 			maybeEmitEvent(new AfterSaveEvent<T>(objectToSave, dbObject, collectionName));
 		}
@@ -1023,9 +1005,8 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 	protected <T> void doSave(String collectionName, T objectToSave, MongoWriter<T> writer) {
 
-		assertUpdateableIdIfNotSet(objectToSave);
-
 		maybeEmitEvent(new BeforeConvertEvent<T>(objectToSave, collectionName));
+		assertUpdateableIdIfNotSet(objectToSave);
 
 		DBObject dbDoc = toDbObject(objectToSave, writer);
 
@@ -1216,7 +1197,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 	public WriteResult remove(Object object, String collection) {
 
-		Assert.hasText(collection);
+		Assert.hasText(collection, "Collection name must not be null or empty!");
 
 		if (object == null) {
 			return null;
@@ -1228,7 +1209,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	/**
 	 * Returns {@link Entry} containing the field name of the id property as {@link Entry#getKey()} and the {@link Id}s
 	 * property value as its {@link Entry#getValue()}.
-	 * 
+	 *
 	 * @param object
 	 * @return
 	 */
@@ -1255,7 +1236,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 	/**
 	 * Returns a {@link Query} for the given entity by its id.
-	 * 
+	 *
 	 * @param object must not be {@literal null}.
 	 * @return
 	 */
@@ -1267,7 +1248,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 	/**
 	 * Returns a {@link Query} for the given entities by their ids.
-	 * 
+	 *
 	 * @param objects must not be {@literal null} or {@literal empty}.
 	 * @return
 	 */
@@ -1320,35 +1301,46 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 	protected <T> WriteResult doRemove(final String collectionName, final Query query, final Class<T> entityClass) {
 
-		if (query == null) {
-			throw new InvalidDataAccessApiUsageException("Query passed in to remove can't be null!");
-		}
-
+		Assert.notNull(query, "Query must not be null!");
 		Assert.hasText(collectionName, "Collection name must not be null or empty!");
 
-		final DBObject queryObject = query.getQueryObject();
 		final MongoPersistentEntity<?> entity = getPersistentEntity(entityClass);
+		final DBObject queryObject = queryMapper.getMappedObject(query.getQueryObject(), entity);
 
 		return execute(collectionName, new CollectionCallback<WriteResult>() {
 			public WriteResult doInCollection(DBCollection collection) throws MongoException, DataAccessException {
 
 				maybeEmitEvent(new BeforeDeleteEvent<T>(queryObject, entityClass, collectionName));
 
-				DBObject dboq = queryMapper.getMappedObject(queryObject, entity);
+				DBObject removeQuery = queryObject;
 
 				MongoAction mongoAction = new MongoAction(writeConcern, MongoActionOperation.REMOVE, collectionName,
-						entityClass, null, queryObject);
+						entityClass, null, removeQuery);
 				WriteConcern writeConcernToUse = prepareWriteConcern(mongoAction);
 
 				if (LOGGER.isDebugEnabled()) {
 					LOGGER.debug("Remove using query: {} in collection: {}.",
-							new Object[] { serializeToJsonSafely(dboq), collectionName });
+							new Object[] { serializeToJsonSafely(removeQuery), collectionName });
 				}
 
-				WriteResult wr = writeConcernToUse == null ? collection.remove(dboq)
-						: collection.remove(dboq, writeConcernToUse);
+				if (query.getLimit() > 0 || query.getSkip() > 0) {
 
-				handleAnyWriteResultErrors(wr, dboq, MongoActionOperation.REMOVE);
+					DBCursor cursor = new QueryCursorPreparer(query, entityClass)
+							.prepare(collection.find(removeQuery, new BasicDBObject(ID_FIELD, 1)));
+
+					Set<Object> ids = new LinkedHashSet<Object>();
+					Iterator<DBObject> it = cursor.iterator();
+					while (it.hasNext()) {
+						ids.add(it.next().get(ID_FIELD));
+					}
+
+					removeQuery = new BasicDBObject(ID_FIELD, new BasicDBObject("$in", ids));
+				}
+
+				WriteResult wr = writeConcernToUse == null ? collection.remove(removeQuery)
+						: collection.remove(removeQuery, writeConcernToUse);
+
+				handleAnyWriteResultErrors(wr, removeQuery, MongoActionOperation.REMOVE);
 
 				maybeEmitEvent(new AfterDeleteEvent<T>(queryObject, entityClass, collectionName));
 
@@ -1513,7 +1505,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	 */
 	@Override
 	public <T> List<T> findAllAndRemove(Query query, String collectionName) {
-		return findAndRemove(query, null, collectionName);
+		return (List<T>) findAllAndRemove(query, Object.class, collectionName);
 	}
 
 	/*
@@ -1538,7 +1530,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	 * Retrieve and remove all documents matching the given {@code query} by calling {@link #find(Query, Class, String)}
 	 * and {@link #remove(Query, Class, String)}, whereas the {@link Query} for {@link #remove(Query, Class, String)} is
 	 * constructed out of the find result.
-	 * 
+	 *
 	 * @param collectionName
 	 * @param query
 	 * @param entityClass
@@ -1562,15 +1554,9 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 		Assert.notNull(aggregation, "Aggregation pipeline must not be null!");
 		Assert.notNull(outputType, "Output type must not be null!");
 
-		AggregationOperationContext rootContext = context == null ? Aggregation.DEFAULT_CONTEXT : context;
-		DBObject command = aggregation.toDbObject(collectionName, rootContext);
-
-		if (LOGGER.isDebugEnabled()) {
-			LOGGER.debug("Executing aggregation: {}", serializeToJsonSafely(command));
-		}
-
-		CommandResult commandResult = executeCommand(command, this.readPreference);
-		handleCommandError(commandResult, command);
+		DBObject commandResult = new BatchAggregationLoader(this, queryMapper, mappingContext, readPreference,
+				Integer.MAX_VALUE)
+				.aggregate(collectionName, aggregation, context);
 
 		return new AggregationResults<O>(returnPotentiallyMappedResults(outputType, commandResult, collectionName),
 				commandResult);
@@ -1578,12 +1564,12 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 	/**
 	 * Returns the potentially mapped results of the given {@commandResult} contained some.
-	 * 
+	 *
 	 * @param outputType
 	 * @param commandResult
 	 * @return
 	 */
-	private <O> List<O> returnPotentiallyMappedResults(Class<O> outputType, CommandResult commandResult,
+	private <O> List<O> returnPotentiallyMappedResults(Class<O> outputType, DBObject commandResult,
 			String collectionName) {
 
 		@SuppressWarnings("unchecked")
@@ -1690,7 +1676,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 	/**
 	 * Create the specified collection using the provided options
-	 * 
+	 *
 	 * @param collectionName
 	 * @param collectionOptions
 	 * @return the collection that was created
@@ -1711,7 +1697,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	/**
 	 * Map the results of an ad-hoc query on the default MongoDB collection to an object using the template's converter.
 	 * The query document is specified as a standard {@link DBObject} and so is the fields specification.
-	 * 
+	 *
 	 * @param collectionName name of the collection to retrieve the objects from.
 	 * @param query the query document that specifies the criteria used to find a record.
 	 * @param fields the document that specifies the fields to be returned.
@@ -1736,7 +1722,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	/**
 	 * Map the results of an ad-hoc query on the default MongoDB collection to a List using the template's converter. The
 	 * query document is specified as a standard DBObject and so is the fields specification.
-	 * 
+	 *
 	 * @param collectionName name of the collection to retrieve the objects from
 	 * @param query the query document that specifies the criteria used to find a record
 	 * @param fields the document that specifies the fields to be returned
@@ -1752,7 +1738,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	 * Map the results of an ad-hoc query on the default MongoDB collection to a List of the specified type. The object is
 	 * converted from the MongoDB native representation using an instance of {@see MongoConverter}. The query document is
 	 * specified as a standard DBObject and so is the fields specification.
-	 * 
+	 *
 	 * @param collectionName name of the collection to retrieve the objects from.
 	 * @param query the query document that specifies the criteria used to find a record.
 	 * @param fields the document that specifies the fields to be returned.
@@ -1805,7 +1791,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	 * The first document that matches the query is returned and also removed from the collection in the database.
 	 * <p/>
 	 * The query document is specified as a standard DBObject and so is the fields specification.
-	 * 
+	 *
 	 * @param collectionName name of the collection to retrieve the objects from
 	 * @param query the query document that specifies the criteria used to find a record
 	 * @param entityClass the parameterized type of the returned list.
@@ -1856,7 +1842,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 	/**
 	 * Populates the id property of the saved object, if it's not set already.
-	 * 
+	 *
 	 * @param savedObject
 	 * @param id
 	 */
@@ -1906,7 +1892,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	 * <li>Execute the given {@link ConnectionCallback} for a {@link DBObject}.</li>
 	 * <li>Apply the given {@link DbObjectCallback} to each of the {@link DBObject}s to obtain the result.</li>
 	 * <ol>
-	 * 
+	 *
 	 * @param <T>
 	 * @param collectionCallback the callback to retrieve the {@link DBObject} with
 	 * @param objectCallback the {@link DbObjectCallback} to transform {@link DBObject}s into the actual domain type
@@ -1935,7 +1921,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	 * <li>Iterate over the {@link DBCursor} and applies the given {@link DbObjectCallback} to each of the
 	 * {@link DBObject}s collecting the actual result {@link List}.</li>
 	 * <ol>
-	 * 
+	 *
 	 * @param <T>
 	 * @param collectionCallback the callback to retrieve the {@link DBCursor} with
 	 * @param preparer the {@link CursorPreparer} to potentially modify the {@link DBCursor} before ireating over it
@@ -2042,7 +2028,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 	/**
 	 * Handles {@link WriteResult} errors based on the configured {@link WriteResultChecking}.
-	 * 
+	 *
 	 * @param writeResult
 	 * @param query
 	 * @param operation
@@ -2086,11 +2072,11 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	/**
 	 * Inspects the given {@link CommandResult} for erros and potentially throws an
 	 * {@link InvalidDataAccessApiUsageException} for that error.
-	 * 
+	 *
 	 * @param result must not be {@literal null}.
 	 * @param source must not be {@literal null}.
 	 */
-	private void handleCommandError(CommandResult result, DBObject source) {
+	private static void handleCommandError(CommandResult result, DBObject source) {
 
 		try {
 			result.throwOnError();
@@ -2107,8 +2093,16 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	private static final MongoConverter getDefaultMongoConverter(MongoDbFactory factory) {
 
 		DbRefResolver dbRefResolver = new DefaultDbRefResolver(factory);
-		MappingMongoConverter converter = new MappingMongoConverter(dbRefResolver, new MongoMappingContext());
+		CustomConversions conversions = new CustomConversions(Collections.emptyList());
+
+		MongoMappingContext mappingContext = new MongoMappingContext();
+		mappingContext.setSimpleTypeHolder(conversions.getSimpleTypeHolder());
+		mappingContext.afterPropertiesSet();
+
+		MappingMongoConverter converter = new MappingMongoConverter(dbRefResolver, mappingContext);
+		converter.setCustomConversions(conversions);
 		converter.afterPropertiesSet();
+
 		return converter;
 	}
 
@@ -2124,7 +2118,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	/**
 	 * Tries to convert the given {@link RuntimeException} into a {@link DataAccessException} but returns the original
 	 * exception if the conversation failed. Thus allows safe re-throwing of the return value.
-	 * 
+	 *
 	 * @param ex the exception to translate
 	 * @param exceptionTranslator the {@link PersistenceExceptionTranslator} to be used for translation
 	 * @return
@@ -2139,7 +2133,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	 * Returns all identifiers for the given documents. Will augment the given identifiers and fill in only the ones that
 	 * are {@literal null} currently. This would've been better solved in {@link #insertDBObjectList(String, List)}
 	 * directly but would require a signature change of that method.
-	 * 
+	 *
 	 * @param ids
 	 * @param documents
 	 * @return TODO: Remove for 2.0 and change method signature of {@link #insertDBObjectList(String, List)}.
@@ -2162,7 +2156,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	/**
 	 * Simple {@link CollectionCallback} that takes a query {@link DBObject} plus an optional fields specification
 	 * {@link DBObject} and executes that against the {@link DBCollection}.
-	 * 
+	 *
 	 * @author Oliver Gierke
 	 * @author Thomas Risberg
 	 */
@@ -2196,7 +2190,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	/**
 	 * Simple {@link CollectionCallback} that takes a query {@link DBObject} plus an optional fields specification
 	 * {@link DBObject} and executes that against the {@link DBCollection}.
-	 * 
+	 *
 	 * @author Oliver Gierke
 	 * @author Thomas Risberg
 	 */
@@ -2227,7 +2221,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	/**
 	 * Simple {@link CollectionCallback} that takes a query {@link DBObject} plus an optional fields specification
 	 * {@link DBObject} and executes that against the {@link DBCollection}.
-	 * 
+	 *
 	 * @author Thomas Risberg
 	 */
 	private static class FindAndRemoveCallback implements CollectionCallback<DBObject> {
@@ -2272,7 +2266,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 	/**
 	 * Simple internal callback to allow operations on a {@link DBObject}.
-	 * 
+	 *
 	 * @author Oliver Gierke
 	 * @author Thomas Darimont
 	 */
@@ -2285,7 +2279,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	/**
 	 * Simple {@link DbObjectCallback} that will transform {@link DBObject} into the given target type using the given
 	 * {@link MongoReader}.
-	 * 
+	 *
 	 * @author Oliver Gierke
 	 * @author Christoph Strobl
 	 */
@@ -2297,8 +2291,9 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 		public ReadDbObjectCallback(EntityReader<? super T, DBObject> reader, Class<T> type, String collectionName) {
 
-			Assert.notNull(reader);
-			Assert.notNull(type);
+			Assert.notNull(reader, "EntityReader must not be null!");
+			Assert.notNull(type, "Entity type must not be null!");
+
 			this.reader = reader;
 			this.type = type;
 			this.collectionName = collectionName;
@@ -2431,7 +2426,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 	/**
 	 * {@link DbObjectCallback} that assumes a {@link GeoResult} to be created, delegates actual content unmarshalling to
 	 * a delegate and creates a {@link GeoResult} from the result.
-	 * 
+	 *
 	 * @author Oliver Gierke
 	 */
 	static class GeoNearResultDbObjectCallback<T> implements DbObjectCallback<GeoResult<T>> {
@@ -2442,11 +2437,13 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 		/**
 		 * Creates a new {@link GeoNearResultDbObjectCallback} using the given {@link DbObjectCallback} delegate for
 		 * {@link GeoResult} content unmarshalling.
-		 * 
+		 *
 		 * @param delegate must not be {@literal null}.
 		 */
 		public GeoNearResultDbObjectCallback(DbObjectCallback<T> delegate, Metric metric) {
-			Assert.notNull(delegate);
+
+			Assert.notNull(delegate, "DocumentCallback must not be null!");
+
 			this.delegate = delegate;
 			this.metric = metric;
 		}
@@ -2464,7 +2461,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 	/**
 	 * A {@link CloseableIterator} that is backed by a MongoDB {@link Cursor}.
-	 * 
+	 *
 	 * @since 1.7
 	 * @author Thomas Darimont
 	 */
@@ -2476,7 +2473,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 		/**
 		 * Creates a new {@link CloseableIterableCursorAdapter} backed by the given {@link Cursor}.
-		 * 
+		 *
 		 * @param cursor
 		 * @param exceptionTranslator
 		 * @param objectReadCallback
@@ -2524,7 +2521,11 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 
 			Cursor c = cursor;
 			try {
-				c.close();
+
+				if (c != null) {
+					c.close();
+				}
+
 			} catch (RuntimeException ex) {
 				throw potentiallyConvertRuntimeException(ex, exceptionTranslator);
 			} finally {
@@ -2534,4 +2535,156 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware {
 			}
 		}
 	}
+
+	/**
+	 * {@link BatchAggregationLoader} is a little helper that can process cursor results returned by an aggregation
+	 * command execution. On presence of a {@literal nextBatch} indicated by presence of an {@code id} field in the
+	 * {@code cursor} another {@code getMore} command gets executed reading the next batch of documents until all results
+	 * are loaded.
+	 *
+	 * @author Christoph Strobl
+	 * @since 1.10
+	 */
+	static class BatchAggregationLoader {
+
+		private static final String CURSOR_FIELD = "cursor";
+		private static final String RESULT_FIELD = "result";
+		private static final String BATCH_SIZE_FIELD = "batchSize";
+		private static final String FIRST_BATCH = "firstBatch";
+		private static final String NEXT_BATCH = "nextBatch";
+		private static final String SERVER_USED = "serverUsed";
+		private static final String OK = "ok";
+
+		private final MongoTemplate template;
+		private final QueryMapper queryMapper;
+		private final MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext;
+		private final ReadPreference readPreference;
+		private final int batchSize;
+
+		BatchAggregationLoader(MongoTemplate template, QueryMapper queryMapper,
+				MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext,
+				ReadPreference readPreference, int batchSize) {
+
+			this.template = template;
+			this.queryMapper = queryMapper;
+			this.mappingContext = mappingContext;
+			this.readPreference = readPreference;
+			this.batchSize = batchSize;
+		}
+
+		/**
+		 * Run aggregation command and fetch all results.
+		 */
+		DBObject aggregate(String collectionName, Aggregation aggregation, AggregationOperationContext context) {
+
+			DBObject command = prepareAggregationCommand(collectionName, aggregation, context, batchSize);
+
+			if (LOGGER.isDebugEnabled()) {
+				LOGGER.debug("Executing aggregation: {}", serializeToJsonSafely(command));
+			}
+
+			return mergeAggregationResults(aggregateBatched(command, collectionName, batchSize));
+		}
+
+		/**
+		 * Pre process the aggregation command sent to the server by adding {@code cursor} options to match execution on
+		 * different server versions.
+		 */
+		private DBObject prepareAggregationCommand(String collectionName, Aggregation aggregation,
+				 AggregationOperationContext context, int batchSize) {
+
+			AggregationUtil aggregationUtil = new AggregationUtil(queryMapper, mappingContext);
+
+			AggregationOperationContext rootContext = aggregationUtil.prepareAggregationContext(aggregation, context);
+			DBObject command = aggregationUtil.createCommand(collectionName, aggregation, rootContext);
+
+			if (!aggregation.getOptions().isExplain()) {
+				command.put(CURSOR_FIELD, new BasicDBObject(BATCH_SIZE_FIELD, batchSize));
+			}
+
+			return command;
+		}
+
+		private List<DBObject> aggregateBatched(DBObject command, String collectionName, int batchSize) {
+
+			List<DBObject> results = new ArrayList<DBObject>();
+
+			CommandResult commandResult = template.executeCommand(command, readPreference);
+			results.add(postProcessResult(command, commandResult));
+
+			while (hasNext(commandResult)) {
+
+				DBObject getMore = new BasicDBObject("getMore", getNextBatchId(commandResult)) //
+						.append("collection", collectionName) //
+						.append(BATCH_SIZE_FIELD, batchSize);
+
+				commandResult = template.executeCommand(getMore, this.readPreference);
+				results.add(postProcessResult(command, commandResult));
+			}
+
+			return results;
+		}
+
+		private static DBObject postProcessResult(DBObject command, CommandResult commandResult) {
+
+			handleCommandError(commandResult, command);
+
+			if (!commandResult.containsField(CURSOR_FIELD)) {
+				return commandResult;
+			}
+
+			DBObject resultObject = new BasicDBObject(SERVER_USED, commandResult.get(SERVER_USED));
+			resultObject.put(OK, commandResult.get(OK));
+
+			DBObject cursor = (DBObject) commandResult.get(CURSOR_FIELD);
+			if (cursor.containsField(FIRST_BATCH)) {
+				resultObject.put(RESULT_FIELD, cursor.get(FIRST_BATCH));
+			} else {
+				resultObject.put(RESULT_FIELD, cursor.get(NEXT_BATCH));
+			}
+
+			return resultObject;
+		}
+
+		private static DBObject mergeAggregationResults(List<DBObject> batchResults) {
+
+			if (batchResults.size() == 1) {
+				return batchResults.iterator().next();
+			}
+
+			DBObject commandResult = new BasicDBObject(3);
+			List<Object> allResults = new ArrayList<Object>();
+
+			for (DBObject batchResult : batchResults) {
+
+				Collection documents = (Collection<?>) batchResult.get(RESULT_FIELD);
+				if (!CollectionUtils.isEmpty(documents)) {
+					allResults.addAll(documents);
+				}
+			}
+
+			// take general info from first batch
+			commandResult.put(SERVER_USED, batchResults.iterator().next().get(SERVER_USED));
+			commandResult.put(OK, batchResults.iterator().next().get(OK));
+
+			// and append the merged batchResults
+			commandResult.put(RESULT_FIELD, allResults);
+
+			return commandResult;
+		}
+
+		private static boolean hasNext(DBObject commandResult) {
+
+			if (!commandResult.containsField(CURSOR_FIELD)) {
+				return false;
+			}
+
+			Object next = getNextBatchId(commandResult);
+			return next != null && ((Number) next).longValue() != 0L;
+		}
+
+		private static Object getNextBatchId(DBObject commandResult) {
+			return ((DBObject) commandResult.get(CURSOR_FIELD)).get("id");
+		}
+	}
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,235 +1,243 @@
-/*
- * Copyright 2011-2015 the original author or authors.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * 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.InvalidDataAccessApiUsageException;
-import org.springframework.dao.support.PersistenceExceptionTranslator;
-import org.springframework.data.authentication.UserCredentials;
-import org.springframework.data.mongodb.MongoDbFactory;
-import org.springframework.util.Assert;
-import org.springframework.util.StringUtils;
-
-import com.mongodb.DB;
-import com.mongodb.Mongo;
-import com.mongodb.MongoClient;
-import com.mongodb.MongoClientURI;
-import com.mongodb.MongoException;
-import com.mongodb.MongoURI;
-import com.mongodb.WriteConcern;
-
-/**
- * Factory to create {@link DB} instances from a {@link Mongo} instance.
- * 
- * @author Mark Pollack
- * @author Oliver Gierke
- * @author Thomas Darimont
- * @author Christoph Strobl
- */
-public class SimpleMongoDbFactory implements DisposableBean, MongoDbFactory {
-
-	private final Mongo mongo;
-	private final String databaseName;
-	private final boolean mongoInstanceCreated;
-	private final UserCredentials credentials;
-	private final PersistenceExceptionTranslator exceptionTranslator;
-	private final String authenticationDatabaseName;
-
-	private WriteConcern writeConcern;
-
-	/**
-	 * Create an instance of {@link SimpleMongoDbFactory} given the {@link Mongo} instance and database name.
-	 * 
-	 * @param mongo Mongo instance, must not be {@literal null}.
-	 * @param databaseName database name, not be {@literal null} or empty.
-	 * @deprecated since 1.7. Please use {@link #SimpleMongoDbFactory(MongoClient, String)}.
-	 */
-	@Deprecated
-	public SimpleMongoDbFactory(Mongo mongo, String databaseName) {
-		this(mongo, databaseName, null);
-	}
-
-	/**
-	 * Create an instance of SimpleMongoDbFactory given the Mongo instance, database name, and username/password
-	 * 
-	 * @param mongo Mongo instance, must not be {@literal null}.
-	 * @param databaseName Database name, must not be {@literal null} or empty.
-	 * @param credentials username and password.
-	 * @deprecated since 1.7. The credentials used should be provided by {@link MongoClient#getCredentialsList()}.
-	 */
-	@Deprecated
-	public SimpleMongoDbFactory(Mongo mongo, String databaseName, UserCredentials credentials) {
-		this(mongo, databaseName, credentials, false, null);
-	}
-
-	/**
-	 * Create an instance of SimpleMongoDbFactory given the Mongo instance, database name, and username/password
-	 * 
-	 * @param mongo Mongo instance, must not be {@literal null}.
-	 * @param databaseName Database name, must not be {@literal null} or empty.
-	 * @param credentials username and password.
-	 * @param authenticationDatabaseName the database name to use for authentication
-	 * @deprecated since 1.7. The credentials used should be provided by {@link MongoClient#getCredentialsList()}.
-	 */
-	@Deprecated
-	public SimpleMongoDbFactory(Mongo mongo, String databaseName, UserCredentials credentials,
-			String authenticationDatabaseName) {
-		this(mongo, databaseName, credentials, false, authenticationDatabaseName);
-	}
-
-	/**
-	 * Creates a new {@link SimpleMongoDbFactory} instance from the given {@link MongoURI}.
-	 * 
-	 * @param uri must not be {@literal null}.
-	 * @throws MongoException
-	 * @throws UnknownHostException
-	 * @see MongoURI
-	 * @deprecated since 1.7. Please use {@link #SimpleMongoDbFactory(MongoClientURI)} instead.
-	 */
-	@Deprecated
-	public SimpleMongoDbFactory(MongoURI uri) throws MongoException, UnknownHostException {
-		this(new Mongo(uri), uri.getDatabase(), new UserCredentials(uri.getUsername(), parseChars(uri.getPassword())), true,
-				uri.getDatabase());
-	}
-
-	/**
-	 * 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) throws UnknownHostException {
-		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);
-	}
-
-	private SimpleMongoDbFactory(Mongo mongo, String databaseName, UserCredentials credentials,
-			boolean mongoInstanceCreated, String authenticationDatabaseName) {
-
-		if (mongo instanceof MongoClient && (credentials != null && !UserCredentials.NO_CREDENTIALS.equals(credentials))) {
-			throw new InvalidDataAccessApiUsageException(
-					"Usage of 'UserCredentials' with 'MongoClient' is no longer supported. Please use 'MongoCredential' for 'MongoClient' or just 'Mongo'.");
-		}
-
-		Assert.notNull(mongo, "Mongo must not be null");
-		Assert.hasText(databaseName, "Database name must not be empty");
-		Assert.isTrue(databaseName.matches("[\\w-]+"),
-				"Database name must only contain letters, numbers, underscores and dashes!");
-
-		this.mongo = mongo;
-		this.databaseName = databaseName;
-		this.mongoInstanceCreated = mongoInstanceCreated;
-		this.credentials = credentials == null ? UserCredentials.NO_CREDENTIALS : credentials;
-		this.exceptionTranslator = new MongoExceptionTranslator();
-		this.authenticationDatabaseName = StringUtils.hasText(authenticationDatabaseName) ? authenticationDatabaseName
-				: databaseName;
-
-		Assert.isTrue(this.authenticationDatabaseName.matches("[\\w-]+"),
-				"Authentication database name must only contain letters, numbers, underscores and dashes!");
-	}
-
-	/**
-	 * @param client
-	 * @param databaseName
-	 * @param mongoInstanceCreated
-	 * @since 1.7
-	 */
-	private SimpleMongoDbFactory(MongoClient client, String databaseName, boolean mongoInstanceCreated) {
-
-		Assert.notNull(client, "MongoClient must not be null!");
-		Assert.hasText(databaseName, "Database name must not be empty!");
-
-		this.mongo = client;
-		this.databaseName = databaseName;
-		this.mongoInstanceCreated = mongoInstanceCreated;
-		this.exceptionTranslator = new MongoExceptionTranslator();
-		this.credentials = UserCredentials.NO_CREDENTIALS;
-		this.authenticationDatabaseName = databaseName;
-	}
-
-	/**
-	 * 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 DB getDb() throws DataAccessException {
-		return getDb(databaseName);
-	}
-
-	/*
-	 * (non-Javadoc)
-	 * @see org.springframework.data.mongodb.MongoDbFactory#getDb(java.lang.String)
-	 */
-	@SuppressWarnings("deprecation")
-	public DB getDb(String dbName) throws DataAccessException {
-
-		Assert.hasText(dbName, "Database name must not be empty.");
-
-		DB db = MongoDbUtils.getDB(mongo, dbName, credentials, authenticationDatabaseName);
-
-		if (writeConcern != null) {
-			db.setWriteConcern(writeConcern);
-		}
-
-		return db;
-	}
-
-	/**
-	 * Clean up the Mongo instance if it was created by the factory itself.
-	 * 
-	 * @see DisposableBean#destroy()
-	 */
-	public void destroy() throws Exception {
-		if (mongoInstanceCreated) {
-			mongo.close();
-		}
-	}
-
-	private static String parseChars(char[] chars) {
-		return chars == null ? null : String.valueOf(chars);
-	}
-
-	/* 
-	 * (non-Javadoc)
-	 * @see org.springframework.data.mongodb.MongoDbFactory#getExceptionTranslator()
-	 */
-	@Override
-	public PersistenceExceptionTranslator getExceptionTranslator() {
-		return this.exceptionTranslator;
-	}
-}
+/*
+ * Copyright 2011-2019 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.InvalidDataAccessApiUsageException;
+import org.springframework.dao.support.PersistenceExceptionTranslator;
+import org.springframework.data.authentication.UserCredentials;
+import org.springframework.data.mongodb.MongoDbFactory;
+import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
+
+import com.mongodb.DB;
+import com.mongodb.Mongo;
+import com.mongodb.MongoClient;
+import com.mongodb.MongoClientURI;
+import com.mongodb.MongoException;
+import com.mongodb.MongoURI;
+import com.mongodb.WriteConcern;
+
+/**
+ * Factory to create {@link DB} instances from a {@link Mongo} instance.
+ *
+ * @author Mark Pollack
+ * @author Oliver Gierke
+ * @author Thomas Darimont
+ * @author Christoph Strobl
+ * @author George Moraitis
+ * @author Mark Paluch
+ */
+public class SimpleMongoDbFactory implements DisposableBean, MongoDbFactory {
+
+	private final Mongo mongo;
+	private final String databaseName;
+	private final boolean mongoInstanceCreated;
+	private final UserCredentials credentials;
+	private final PersistenceExceptionTranslator exceptionTranslator;
+	private final String authenticationDatabaseName;
+
+	private WriteConcern writeConcern;
+
+	/**
+	 * Create an instance of {@link SimpleMongoDbFactory} given the {@link Mongo} instance and database name.
+	 *
+	 * @param mongo Mongo instance, must not be {@literal null}.
+	 * @param databaseName database name, not be {@literal null} or empty.
+	 * @deprecated since 1.7. Please use {@link #SimpleMongoDbFactory(MongoClient, String)}.
+	 */
+	@Deprecated
+	public SimpleMongoDbFactory(Mongo mongo, String databaseName) {
+		this(mongo, databaseName, null);
+	}
+
+	/**
+	 * Create an instance of SimpleMongoDbFactory given the Mongo instance, database name, and username/password
+	 *
+	 * @param mongo Mongo instance, must not be {@literal null}.
+	 * @param databaseName Database name, must not be {@literal null} or empty.
+	 * @param credentials username and password.
+	 * @deprecated since 1.7. The credentials used should be provided by {@link MongoClient#getCredentialsList()}.
+	 */
+	@Deprecated
+	public SimpleMongoDbFactory(Mongo mongo, String databaseName, UserCredentials credentials) {
+		this(mongo, databaseName, credentials, false, null);
+	}
+
+	/**
+	 * Create an instance of SimpleMongoDbFactory given the Mongo instance, database name, and username/password
+	 *
+	 * @param mongo Mongo instance, must not be {@literal null}.
+	 * @param databaseName Database name, must not be {@literal null} or empty.
+	 * @param credentials username and password.
+	 * @param authenticationDatabaseName the database name to use for authentication
+	 * @deprecated since 1.7. The credentials used should be provided by {@link MongoClient#getCredentialsList()}.
+	 */
+	@Deprecated
+	public SimpleMongoDbFactory(Mongo mongo, String databaseName, UserCredentials credentials,
+			String authenticationDatabaseName) {
+		this(mongo, databaseName, credentials, false, authenticationDatabaseName);
+	}
+
+	/**
+	 * Creates a new {@link SimpleMongoDbFactory} instance from the given {@link MongoURI}.
+	 *
+	 * @param uri must not be {@literal null}.
+	 * @throws MongoException
+	 * @throws UnknownHostException
+	 * @see MongoURI
+	 * @deprecated since 1.7. Please use {@link #SimpleMongoDbFactory(MongoClientURI)} instead.
+	 */
+	@Deprecated
+	public SimpleMongoDbFactory(MongoURI uri) throws MongoException, UnknownHostException {
+		this(new Mongo(uri), uri.getDatabase(), new UserCredentials(uri.getUsername(), parseChars(uri.getPassword())), true,
+				uri.getDatabase());
+	}
+
+	/**
+	 * 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) throws UnknownHostException {
+		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);
+	}
+
+	private SimpleMongoDbFactory(Mongo mongo, String databaseName, UserCredentials credentials,
+			boolean mongoInstanceCreated, String authenticationDatabaseName) {
+
+		if (mongo instanceof MongoClient && (credentials != null && !UserCredentials.NO_CREDENTIALS.equals(credentials))) {
+			throw new InvalidDataAccessApiUsageException(
+					"Usage of 'UserCredentials' with 'MongoClient' is no longer supported. Please use 'MongoCredential' for 'MongoClient' or just 'Mongo'.");
+		}
+
+		Assert.notNull(mongo, "Mongo must not be null");
+		Assert.hasText(databaseName, "Database name must not be empty");
+		assertDatabaseName(databaseName);
+
+		this.mongo = mongo;
+		this.databaseName = databaseName;
+		this.mongoInstanceCreated = mongoInstanceCreated;
+		this.credentials = credentials == null ? UserCredentials.NO_CREDENTIALS : credentials;
+		this.exceptionTranslator = new MongoExceptionTranslator();
+		this.authenticationDatabaseName = StringUtils.hasText(authenticationDatabaseName) ? authenticationDatabaseName
+				: databaseName;
+
+		Assert.isTrue(this.authenticationDatabaseName.matches("[\\w-]+"),
+				"Authentication database name must only contain letters, numbers, underscores and dashes!");
+	}
+
+	/**
+	 * @param client
+	 * @param databaseName
+	 * @param mongoInstanceCreated
+	 * @since 1.7
+	 */
+	private SimpleMongoDbFactory(MongoClient client, String databaseName, boolean mongoInstanceCreated) {
+
+		Assert.notNull(client, "MongoClient must not be null!");
+		Assert.hasText(databaseName, "Database name must not be empty!");
+		assertDatabaseName(databaseName);
+
+		this.mongo = client;
+		this.databaseName = databaseName;
+		this.mongoInstanceCreated = mongoInstanceCreated;
+		this.exceptionTranslator = new MongoExceptionTranslator();
+		this.credentials = UserCredentials.NO_CREDENTIALS;
+		this.authenticationDatabaseName = databaseName;
+	}
+
+	/**
+	 * 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 DB getDb() throws DataAccessException {
+		return getDb(databaseName);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.MongoDbFactory#getDb(java.lang.String)
+	 */
+	@SuppressWarnings("deprecation")
+	public DB getDb(String dbName) throws DataAccessException {
+
+		Assert.hasText(dbName, "Database name must not be empty.");
+
+		DB db = MongoDbUtils.getDB(mongo, dbName, credentials, authenticationDatabaseName);
+
+		if (writeConcern != null) {
+			db.setWriteConcern(writeConcern);
+		}
+
+		return db;
+	}
+
+	/**
+	 * Clean up the Mongo instance if it was created by the factory itself.
+	 *
+	 * @see DisposableBean#destroy()
+	 */
+	public void destroy() throws Exception {
+		if (mongoInstanceCreated) {
+			mongo.close();
+		}
+	}
+
+	private static String parseChars(char[] chars) {
+		return chars == null ? null : String.valueOf(chars);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.MongoDbFactory#getExceptionTranslator()
+	 */
+	@Override
+	public PersistenceExceptionTranslator getExceptionTranslator() {
+		return this.exceptionTranslator;
+	}
+
+	private static void assertDatabaseName(String databaseName) {
+
+		Assert.isTrue(databaseName.matches("[^/\\\\.$\"\\s]+"),
+				"Database name must not contain slashes, dots, spaces, quotes, or dollar signs!");
+	}
+}

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-2019 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.

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

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

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

@@ -0,0 +1,201 @@
+/*
+ * Copyright 2016-2018. the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core.aggregation;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.springframework.util.Assert;
+import org.springframework.util.ObjectUtils;
+
+import com.mongodb.BasicDBObject;
+import com.mongodb.DBObject;
+
+/**
+ * @author Christoph Strobl
+ * @author Matt Morrissette
+ * @since 1.10
+ */
+abstract class AbstractAggregationExpression implements AggregationExpression {
+
+	private final Object value;
+
+	protected AbstractAggregationExpression(Object value) {
+		this.value = value;
+	}
+
+	/* (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.aggregation.AggregationExpression#toDbObject(org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)
+	 */
+	@Override
+	public DBObject toDbObject(AggregationOperationContext context) {
+		return toDbObject(this.value, context);
+	}
+
+	@SuppressWarnings("unchecked")
+	public DBObject toDbObject(Object value, AggregationOperationContext context) {
+		return new BasicDBObject(getMongoMethod(), unpack(value, context));
+	}
+
+	protected static List<Field> asFields(String... fieldRefs) {
+
+		if (ObjectUtils.isEmpty(fieldRefs)) {
+			return Collections.emptyList();
+		}
+
+		return Fields.fields(fieldRefs).asList();
+	}
+
+	@SuppressWarnings("unchecked")
+	private Object unpack(Object value, AggregationOperationContext context) {
+
+		if (value instanceof AggregationExpression) {
+			return ((AggregationExpression) value).toDbObject(context);
+		}
+
+		if (value instanceof Field) {
+			return context.getReference((Field) value).toString();
+		}
+
+		if (value instanceof List) {
+
+			List<Object> sourceList = (List<Object>) value;
+			List<Object> mappedList = new ArrayList<Object>(sourceList.size());
+
+			for (Object item : sourceList) {
+				mappedList.add(unpack(item, context));
+			}
+
+			return mappedList;
+		} else if (value instanceof java.util.Map) {
+
+			DBObject targetDbo = new BasicDBObject();
+			for (Entry<String, Object> item : ((Map<String, Object>) value).entrySet()) {
+				targetDbo.put(item.getKey(), unpack(item.getValue(), context));
+			}
+
+			return targetDbo;
+		}
+
+		return value;
+	}
+
+	protected List<Object> append(Object value) {
+
+		if (this.value instanceof List) {
+
+			List<Object> clone = new ArrayList<Object>((List) this.value);
+
+			if (value instanceof List) {
+				clone.addAll((List) value);
+			} else {
+				clone.add(value);
+			}
+			return clone;
+		}
+
+		return Arrays.asList(this.value, value);
+	}
+
+	@SuppressWarnings("unchecked")
+	protected java.util.Map<String, Object> append(String key, Object value) {
+
+		Assert.isInstanceOf(Map.class, this.value, "Value must be a type of Map!");
+
+		java.util.Map<String, Object> clone = new LinkedHashMap<String, Object>((java.util.Map) this.value);
+		clone.put(key, value);
+		return clone;
+
+	}
+
+	protected List<Object> values() {
+
+		if (value instanceof List) {
+			return new ArrayList<Object>((List) value);
+		}
+		if (value instanceof java.util.Map) {
+			return new ArrayList<Object>(((java.util.Map) value).values());
+		}
+		return new ArrayList<Object>(Collections.singletonList(value));
+	}
+
+	/**
+	 * Get the value at a given index.
+	 *
+	 * @param index
+	 * @param <T>
+	 * @return
+	 * @since 2.1
+	 */
+	@SuppressWarnings("unchecked")
+	protected <T> T get(int index) {
+		return (T) values().get(index);
+	}
+
+	/**
+	 * Get the value for a given key.
+	 *
+	 * @param key
+	 * @param <T>
+	 * @return
+	 * @since 2.1
+	 */
+	@SuppressWarnings("unchecked")
+	protected <T> T get(Object key) {
+
+		Assert.isInstanceOf(Map.class, this.value, "Value must be a type of Map!");
+
+		return (T) ((java.util.Map<String, Object>) this.value).get(key);
+	}
+
+	/**
+	 * Get the argument map.
+	 *
+	 * @since 2.1
+	 * @return
+	 */
+	@SuppressWarnings("unchecked")
+	protected java.util.Map<String, Object> argumentMap() {
+
+		Assert.isInstanceOf(Map.class, this.value, "Value must be a type of Map!");
+
+		return Collections.unmodifiableMap((java.util.Map) value);
+	}
+
+	/**
+	 * Check if the given key is available.
+	 *
+	 * @param key
+	 * @return
+	 * @since 2.1
+	 */
+	@SuppressWarnings("unchecked")
+	protected boolean contains(Object key) {
+
+		if (!(this.value instanceof java.util.Map)) {
+			return false;
+		}
+
+		return ((java.util.Map<String, Object>) this.value).containsKey(key);
+	}
+
+	protected abstract String getMongoMethod();
+}

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

@@ -0,0 +1,648 @@
+/*
+ * 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.aggregation;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.springframework.util.Assert;
+
+import com.mongodb.DBObject;
+
+/**
+ * Gateway to {@literal accumulator} aggregation operations.
+ *
+ * @author Christoph Strobl
+ * @since 1.10
+ * @soundtrack Rage Against The Machine - Killing In The Name
+ */
+public class AccumulatorOperators {
+
+	/**
+	 * Take the numeric value referenced by given {@literal fieldReference}.
+	 *
+	 * @param fieldReference must not be {@literal null}.
+	 * @return
+	 */
+	public static AccumulatorOperatorFactory valueOf(String fieldReference) {
+		return new AccumulatorOperatorFactory(fieldReference);
+	}
+
+	/**
+	 * Take the numeric value referenced resulting from given {@link AggregationExpression}.
+	 *
+	 * @param expression must not be {@literal null}.
+	 * @return
+	 */
+	public static AccumulatorOperatorFactory valueOf(AggregationExpression expression) {
+		return new AccumulatorOperatorFactory(expression);
+	}
+
+	/**
+	 * @author Christoph Strobl
+	 */
+	public static class AccumulatorOperatorFactory {
+
+		private final String fieldReference;
+		private final AggregationExpression expression;
+
+		/**
+		 * Creates new {@link AccumulatorOperatorFactory} for given {@literal fieldReference}.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 */
+		public AccumulatorOperatorFactory(String fieldReference) {
+
+			Assert.notNull(fieldReference, "FieldReference must not be null!");
+			this.fieldReference = fieldReference;
+			this.expression = null;
+		}
+
+		/**
+		 * Creates new {@link AccumulatorOperatorFactory} for given {@link AggregationExpression}.
+		 *
+		 * @param expression must not be {@literal null}.
+		 */
+		public AccumulatorOperatorFactory(AggregationExpression expression) {
+
+			Assert.notNull(expression, "Expression must not be null!");
+			this.fieldReference = null;
+			this.expression = expression;
+		}
+
+		/**
+		 * Creates new {@link AggregationExpression} that takes the associated numeric value expression and calculates and
+		 * returns the sum.
+		 *
+		 * @return
+		 */
+		public Sum sum() {
+			return usesFieldRef() ? Sum.sumOf(fieldReference) : Sum.sumOf(expression);
+		}
+
+		/**
+		 * Creates new {@link AggregationExpression} that takes the associated numeric value expression and returns the
+		 * average value.
+		 *
+		 * @return
+		 */
+		public Avg avg() {
+			return usesFieldRef() ? Avg.avgOf(fieldReference) : Avg.avgOf(expression);
+		}
+
+		/**
+		 * Creates new {@link AggregationExpression} that takes the associated numeric value expression and returns the
+		 * maximum value.
+		 *
+		 * @return
+		 */
+		public Max max() {
+			return usesFieldRef() ? Max.maxOf(fieldReference) : Max.maxOf(expression);
+		}
+
+		/**
+		 * Creates new {@link AggregationExpression} that takes the associated numeric value expression and returns the
+		 * minimum value.
+		 *
+		 * @return
+		 */
+		public Min min() {
+			return usesFieldRef() ? Min.minOf(fieldReference) : Min.minOf(expression);
+		}
+
+		/**
+		 * Creates new {@link AggregationExpression} that takes the associated numeric value expression and calculates the
+		 * population standard deviation of the input values.
+		 *
+		 * @return
+		 */
+		public StdDevPop stdDevPop() {
+			return usesFieldRef() ? StdDevPop.stdDevPopOf(fieldReference) : StdDevPop.stdDevPopOf(expression);
+		}
+
+		/**
+		 * Creates new {@link AggregationExpression} that takes the associated numeric value expression and calculates the
+		 * sample standard deviation of the input values.
+		 *
+		 * @return
+		 */
+		public StdDevSamp stdDevSamp() {
+			return usesFieldRef() ? StdDevSamp.stdDevSampOf(fieldReference) : StdDevSamp.stdDevSampOf(expression);
+		}
+
+		private boolean usesFieldRef() {
+			return fieldReference != null;
+		}
+	}
+
+	/**
+	 * {@link AggregationExpression} for {@code $sum}.
+	 *
+	 * @author Christoph Strobl
+	 */
+	public static class Sum extends AbstractAggregationExpression {
+
+		private Sum(Object value) {
+			super(value);
+		}
+
+		@Override
+		protected String getMongoMethod() {
+			return "$sum";
+		}
+
+		/**
+		 * Creates new {@link Sum}.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return
+		 */
+		public static Sum sumOf(String fieldReference) {
+
+			Assert.notNull(fieldReference, "FieldReference must not be null!");
+			return new Sum(asFields(fieldReference));
+		}
+
+		/**
+		 * Creates new {@link Sum}.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return
+		 */
+		public static Sum sumOf(AggregationExpression expression) {
+
+			Assert.notNull(expression, "Expression must not be null!");
+			return new Sum(Collections.singletonList(expression));
+		}
+
+		/**
+		 * Creates new {@link Sum} with all previously added arguments appending the given one. <br />
+		 * <strong>NOTE:</strong> Only possible in {@code $project} stage.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return
+		 */
+		public Sum and(String fieldReference) {
+
+			Assert.notNull(fieldReference, "FieldReference must not be null!");
+			return new Sum(append(Fields.field(fieldReference)));
+		}
+
+		/**
+		 * Creates new {@link Sum} with all previously added arguments appending the given one. <br />
+		 * <strong>NOTE:</strong> Only possible in {@code $project} stage.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return
+		 */
+		public Sum and(AggregationExpression expression) {
+
+			Assert.notNull(expression, "Expression must not be null!");
+			return new Sum(append(expression));
+		}
+
+		/* (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.aggregation.AccumulatorOperators.AbstractAggregationExpression#toDbObject(java.lang.Object, org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)
+		 */
+		@Override
+		@SuppressWarnings("unchecked")
+		public DBObject toDbObject(Object value, AggregationOperationContext context) {
+
+			if (value instanceof List) {
+				if (((List) value).size() == 1) {
+					return super.toDbObject(((List<Object>) value).iterator().next(), context);
+				}
+			}
+
+			return super.toDbObject(value, context);
+		}
+	}
+
+	/**
+	 * {@link AggregationExpression} for {@code $avg}.
+	 *
+	 * @author Christoph Strobl
+	 */
+	public static class Avg extends AbstractAggregationExpression {
+
+		private Avg(Object value) {
+			super(value);
+		}
+
+		@Override
+		protected String getMongoMethod() {
+			return "$avg";
+		}
+
+		/**
+		 * Creates new {@link Avg}.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return
+		 */
+		public static Avg avgOf(String fieldReference) {
+
+			Assert.notNull(fieldReference, "FieldReference must not be null!");
+			return new Avg(asFields(fieldReference));
+		}
+
+		/**
+		 * Creates new {@link Avg}.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return
+		 */
+		public static Avg avgOf(AggregationExpression expression) {
+
+			Assert.notNull(expression, "Expression must not be null!");
+			return new Avg(Collections.singletonList(expression));
+		}
+
+		/**
+		 * Creates new {@link Avg} with all previously added arguments appending the given one. <br />
+		 * <strong>NOTE:</strong> Only possible in {@code $project} stage.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return
+		 */
+		public Avg and(String fieldReference) {
+
+			Assert.notNull(fieldReference, "FieldReference must not be null!");
+			return new Avg(append(Fields.field(fieldReference)));
+		}
+
+		/**
+		 * Creates new {@link Avg} with all previously added arguments appending the given one. <br />
+		 * <strong>NOTE:</strong> Only possible in {@code $project} stage.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return
+		 */
+		public Avg and(AggregationExpression expression) {
+
+			Assert.notNull(expression, "Expression must not be null!");
+			return new Avg(append(expression));
+		}
+
+		/* (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.aggregation.AccumulatorOperators.AbstractAggregationExpression#toDbObject(java.lang.Object, org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)
+		 */
+		@Override
+		@SuppressWarnings("unchecked")
+		public DBObject toDbObject(Object value, AggregationOperationContext context) {
+
+			if (value instanceof List) {
+				if (((List) value).size() == 1) {
+					return super.toDbObject(((List<Object>) value).iterator().next(), context);
+				}
+			}
+
+			return super.toDbObject(value, context);
+		}
+	}
+
+	/**
+	 * {@link AggregationExpression} for {@code $max}.
+	 *
+	 * @author Christoph Strobl
+	 */
+	public static class Max extends AbstractAggregationExpression {
+
+		private Max(Object value) {
+			super(value);
+		}
+
+		@Override
+		protected String getMongoMethod() {
+			return "$max";
+		}
+
+		/**
+		 * Creates new {@link Max}.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return
+		 */
+		public static Max maxOf(String fieldReference) {
+
+			Assert.notNull(fieldReference, "FieldReference must not be null!");
+			return new Max(asFields(fieldReference));
+		}
+
+		/**
+		 * Creates new {@link Max}.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return
+		 */
+		public static Max maxOf(AggregationExpression expression) {
+
+			Assert.notNull(expression, "Expression must not be null!");
+			return new Max(Collections.singletonList(expression));
+		}
+
+		/**
+		 * Creates new {@link Max} with all previously added arguments appending the given one. <br />
+		 * <strong>NOTE:</strong> Only possible in {@code $project} stage.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return
+		 */
+		public Max and(String fieldReference) {
+
+			Assert.notNull(fieldReference, "FieldReference must not be null!");
+			return new Max(append(Fields.field(fieldReference)));
+		}
+
+		/**
+		 * Creates new {@link Max} with all previously added arguments appending the given one. <br />
+		 * <strong>NOTE:</strong> Only possible in {@code $project} stage.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return
+		 */
+		public Max and(AggregationExpression expression) {
+
+			Assert.notNull(expression, "Expression must not be null!");
+			return new Max(append(expression));
+		}
+
+		/* (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.aggregation.AccumulatorOperators.AbstractAggregationExpression#toDbObject(java.lang.Object, org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)
+		 */
+		@Override
+		@SuppressWarnings("unchecked")
+		public DBObject toDbObject(Object value, AggregationOperationContext context) {
+
+			if (value instanceof List) {
+				if (((List) value).size() == 1) {
+					return super.toDbObject(((List<Object>) value).iterator().next(), context);
+				}
+			}
+
+			return super.toDbObject(value, context);
+		}
+	}
+
+	/**
+	 * {@link AggregationExpression} for {@code $min}.
+	 *
+	 * @author Christoph Strobl
+	 */
+	public static class Min extends AbstractAggregationExpression {
+
+		private Min(Object value) {
+			super(value);
+		}
+
+		@Override
+		protected String getMongoMethod() {
+			return "$min";
+		}
+
+		/**
+		 * Creates new {@link Min}.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return
+		 */
+		public static Min minOf(String fieldReference) {
+
+			Assert.notNull(fieldReference, "FieldReference must not be null!");
+			return new Min(asFields(fieldReference));
+		}
+
+		/**
+		 * Creates new {@link Min}.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return
+		 */
+		public static Min minOf(AggregationExpression expression) {
+
+			Assert.notNull(expression, "Expression must not be null!");
+			return new Min(Collections.singletonList(expression));
+		}
+
+		/**
+		 * Creates new {@link Min} with all previously added arguments appending the given one. <br />
+		 * <strong>NOTE:</strong> Only possible in {@code $project} stage.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return
+		 */
+		public Min and(String fieldReference) {
+
+			Assert.notNull(fieldReference, "FieldReference must not be null!");
+			return new Min(append(Fields.field(fieldReference)));
+		}
+
+		/**
+		 * Creates new {@link Min} with all previously added arguments appending the given one. <br />
+		 * <strong>NOTE:</strong> Only possible in {@code $project} stage.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return
+		 */
+		public Min and(AggregationExpression expression) {
+
+			Assert.notNull(expression, "Expression must not be null!");
+			return new Min(append(expression));
+		}
+
+		/* (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.aggregation.AccumulatorOperators.AbstractAggregationExpression#toDbObject(java.lang.Object, org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)
+		 */
+		@Override
+		@SuppressWarnings("unchecked")
+		public DBObject toDbObject(Object value, AggregationOperationContext context) {
+
+			if (value instanceof List) {
+				if (((List) value).size() == 1) {
+					return super.toDbObject(((List<Object>) value).iterator().next(), context);
+				}
+			}
+
+			return super.toDbObject(value, context);
+		}
+	}
+
+	/**
+	 * {@link AggregationExpression} for {@code $stdDevPop}.
+	 *
+	 * @author Christoph Strobl
+	 */
+	public static class StdDevPop extends AbstractAggregationExpression {
+
+		private StdDevPop(Object value) {
+			super(value);
+		}
+
+		@Override
+		protected String getMongoMethod() {
+			return "$stdDevPop";
+		}
+
+		/**
+		 * Creates new {@link StdDevPop}.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return
+		 */
+		public static StdDevPop stdDevPopOf(String fieldReference) {
+
+			Assert.notNull(fieldReference, "FieldReference must not be null!");
+			return new StdDevPop(asFields(fieldReference));
+		}
+
+		/**
+		 * Creates new {@link StdDevPop} with all previously added arguments appending the given one.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return
+		 */
+		public static StdDevPop stdDevPopOf(AggregationExpression expression) {
+
+			Assert.notNull(expression, "Expression must not be null!");
+			return new StdDevPop(Collections.singletonList(expression));
+		}
+
+		/**
+		 * Creates new {@link StdDevPop} with all previously added arguments appending the given one. <br/>
+		 * <strong>NOTE:</strong> Only possible in {@code $project} stage.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return
+		 */
+		public StdDevPop and(String fieldReference) {
+
+			Assert.notNull(fieldReference, "FieldReference must not be null!");
+			return new StdDevPop(append(Fields.field(fieldReference)));
+		}
+
+		/**
+		 * Creates new {@link StdDevSamp} with all previously added arguments appending the given one. <br />
+		 * <strong>NOTE:</strong> Only possible in {@code $project} stage.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return
+		 */
+		public StdDevPop and(AggregationExpression expression) {
+
+			Assert.notNull(expression, "Expression must not be null!");
+			return new StdDevPop(append(expression));
+		}
+
+		/* (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.aggregation.AccumulatorOperators.AbstractAggregationExpression#toDbObject(java.lang.Object, org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)
+		 */
+		@Override
+		@SuppressWarnings("unchecked")
+		public DBObject toDbObject(Object value, AggregationOperationContext context) {
+
+			if (value instanceof List) {
+				if (((List) value).size() == 1) {
+					return super.toDbObject(((List<Object>) value).iterator().next(), context);
+				}
+			}
+
+			return super.toDbObject(value, context);
+		}
+	}
+
+	/**
+	 * {@link AggregationExpression} for {@code $stdDevSamp}.
+	 *
+	 * @author Christoph Strobl
+	 */
+	public static class StdDevSamp extends AbstractAggregationExpression {
+
+		private StdDevSamp(Object value) {
+			super(value);
+		}
+
+		@Override
+		protected String getMongoMethod() {
+			return "$stdDevSamp";
+		}
+
+		/**
+		 * Creates new {@link StdDevSamp}.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return
+		 */
+		public static StdDevSamp stdDevSampOf(String fieldReference) {
+
+			Assert.notNull(fieldReference, "FieldReference must not be null!");
+			return new StdDevSamp(asFields(fieldReference));
+		}
+
+		/**
+		 * Creates new {@link StdDevSamp}.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return
+		 */
+		public static StdDevSamp stdDevSampOf(AggregationExpression expression) {
+
+			Assert.notNull(expression, "Expression must not be null!");
+			return new StdDevSamp(Collections.singletonList(expression));
+		}
+
+		/**
+		 * Creates new {@link StdDevSamp} with all previously added arguments appending the given one. <br />
+		 * <strong>NOTE:</strong> Only possible in {@code $project} stage.
+		 *
+		 * @param fieldReference must not be {@literal null}.
+		 * @return
+		 */
+		public StdDevSamp and(String fieldReference) {
+
+			Assert.notNull(fieldReference, "FieldReference must not be null!");
+			return new StdDevSamp(append(Fields.field(fieldReference)));
+		}
+
+		/**
+		 * Creates new {@link StdDevSamp} with all previously added arguments appending the given one. <br />
+		 * <strong>NOTE:</strong> Only possible in {@code $project} stage.
+		 *
+		 * @param expression must not be {@literal null}.
+		 * @return
+		 */
+		public StdDevSamp and(AggregationExpression expression) {
+
+			Assert.notNull(expression, "Expression must not be null!");
+			return new StdDevSamp(append(expression));
+		}
+
+		/* (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.aggregation.AccumulatorOperators.AbstractAggregationExpression#toDbObject(java.lang.Object, org.springframework.data.mongodb.core.aggregation.AggregationOperationContext)
+		 */
+		@Override
+		@SuppressWarnings("unchecked")
+		public DBObject toDbObject(Object value, AggregationOperationContext context) {
+
+			if (value instanceof List) {
+				if (((List) value).size() == 1) {
+					return super.toDbObject(((List<Object>) value).iterator().next(), context);
+				}
+			}
+
+			return super.toDbObject(value, context);
+		}
+	}
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2013-2016 the original author or authors.
+ * Copyright 2013-2019 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,11 +23,18 @@ import java.util.List;
 
 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.Fields.AggregationField;
+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.util.Assert;
@@ -62,7 +69,7 @@ public class Aggregation {
 	 */
 	public static final String CURRENT = SystemVariable.CURRENT.toString();
 
-	public static final AggregationOperationContext DEFAULT_CONTEXT = new NoOpAggregationOperationContext();
+	public static final AggregationOperationContext DEFAULT_CONTEXT = AggregationOperationRenderer.DEFAULT_CONTEXT;
 	public static final AggregationOptions DEFAULT_OPTIONS = newAggregationOptions().build();
 
 	protected final List<AggregationOperation> operations;
@@ -196,7 +203,7 @@ public class Aggregation {
 	}
 
 	/**
-	 * Creates a new {@link ProjectionOperation} includeing the given {@link Fields}.
+	 * Creates a new {@link ProjectionOperation} including the given {@link Fields}.
 	 *
 	 * @param fields must not be {@literal null}.
 	 * @return
@@ -215,6 +222,40 @@ public class Aggregation {
 		return new UnwindOperation(field(field));
 	}
 
+	/**
+	 * Factory method to create a new {@link ReplaceRootOperation} for the field with the given name.
+	 *
+	 * @param fieldName must not be {@literal null} or empty.
+	 * @return
+	 * @since 1.10
+	 */
+	public static ReplaceRootOperation replaceRoot(String fieldName) {
+		return ReplaceRootOperation.builder().withValueOf(fieldName);
+	}
+
+	/**
+	 * Factory method to create a new {@link ReplaceRootOperation} for the field with the given
+	 * {@link AggregationExpression}.
+	 *
+	 * @param aggregationExpression must not be {@literal null}.
+	 * @return
+	 * @since 1.10
+	 */
+	public static ReplaceRootOperation replaceRoot(AggregationExpression aggregationExpression) {
+		return ReplaceRootOperation.builder().withValueOf(aggregationExpression);
+	}
+
+	/**
+	 * Factory method to create a new {@link ReplaceRootDocumentOperationBuilder} to configure a
+	 * {@link ReplaceRootOperation}.
+	 *
+	 * @return the {@literal ReplaceRootDocumentOperationBuilder}.
+	 * @since 1.10
+	 */
+	public static ReplaceRootOperationBuilder replaceRoot() {
+		return ReplaceRootOperation.builder();
+	}
+
 	/**
 	 * Factory method to create a new {@link UnwindOperation} for the field with the given name and
 	 * {@code preserveNullAndEmptyArrays}. Note that extended unwind is supported in MongoDB version 3.2+.
@@ -279,6 +320,18 @@ public class Aggregation {
 		return new GroupOperation(fields);
 	}
 
+	/**
+	 * Creates a new {@link GraphLookupOperation.GraphLookupOperationFromBuilder} to construct a
+	 * {@link GraphLookupOperation} given {@literal fromCollection}.
+	 *
+	 * @param fromCollection must not be {@literal null} or empty.
+	 * @return
+	 * @since 1.10
+	 */
+	public static StartWithBuilder graphLookup(String fromCollection) {
+		return GraphLookupOperation.builder().from(fromCollection);
+	}
+
 	/**
 	 * Factory method to create a new {@link SortOperation} for the given {@link Sort}.
 	 *
@@ -341,6 +394,17 @@ public class Aggregation {
 		return new MatchOperation(criteria);
 	}
 
+	/**
+	 * Creates a new {@link MatchOperation} using the given {@link CriteriaDefinition}.
+	 *
+	 * @param criteria must not be {@literal null}.
+	 * @return
+	 * @since 1.10
+	 */
+	public static MatchOperation match(CriteriaDefinition criteria) {
+		return new MatchOperation(criteria);
+	}
+
 	/**
 	 * Creates a new {@link OutOperation} using the given collection name. This operation must be the last operation in
 	 * the pipeline.
@@ -355,6 +419,73 @@ public class Aggregation {
 		return new OutOperation(outCollectionName);
 	}
 
+	/**
+	 * Creates a new {@link BucketOperation} given {@literal groupByField}.
+	 *
+	 * @param groupByField must not be {@literal null} or empty.
+	 * @return
+	 * @since 1.10
+	 */
+	public static BucketOperation bucket(String groupByField) {
+		return new BucketOperation(field(groupByField));
+	}
+
+	/**
+	 * Creates a new {@link BucketOperation} given {@link AggregationExpression group-by expression}.
+	 *
+	 * @param groupByExpression must not be {@literal null}.
+	 * @return
+	 * @since 1.10
+	 */
+	public static BucketOperation bucket(AggregationExpression groupByExpression) {
+		return new BucketOperation(groupByExpression);
+	}
+
+	/**
+	 * Creates a new {@link BucketAutoOperation} given {@literal groupByField}.
+	 *
+	 * @param groupByField must not be {@literal null} or empty.
+	 * @param buckets number of buckets, must be a positive integer.
+	 * @return
+	 * @since 1.10
+	 */
+	public static BucketAutoOperation bucketAuto(String groupByField, int buckets) {
+		return new BucketAutoOperation(field(groupByField), buckets);
+	}
+
+	/**
+	 * Creates a new {@link BucketAutoOperation} given {@link AggregationExpression group-by expression}.
+	 *
+	 * @param groupByExpression must not be {@literal null}.
+	 * @param buckets number of buckets, must be a positive integer.
+	 * @return
+	 * @since 1.10
+	 */
+	public static BucketAutoOperation bucketAuto(AggregationExpression groupByExpression, int buckets) {
+		return new BucketAutoOperation(groupByExpression, buckets);
+	}
+
+	/**
+	 * Creates a new {@link FacetOperation}.
+	 *
+	 * @return
+	 * @since 1.10
+	 */
+	public static FacetOperation facet() {
+		return FacetOperation.EMPTY;
+	}
+
+	/**
+	 * Creates a new {@link FacetOperationBuilder} given {@link Aggregation}.
+	 *
+	 * @param aggregationOperations the sub-pipeline, must not be {@literal null}.
+	 * @return
+	 * @since 1.10
+	 */
+	public static FacetOperationBuilder facet(AggregationOperation... aggregationOperations) {
+		return facet().and(aggregationOperations);
+	}
+
 	/**
 	 * Creates a new {@link LookupOperation}.
 	 *
@@ -384,65 +515,13 @@ public class Aggregation {
 	}
 
 	/**
-	 * Creates a new {@link IfNullOperator} for the given {@code field} and {@code replacement} value.
+	 * Creates a new {@link CountOperationBuilder}.
 	 *
-	 * @param field must not be {@literal null}.
-	 * @param replacement must not be {@literal null}.
 	 * @return never {@literal null}.
 	 * @since 1.10
 	 */
-	public static IfNullOperator ifNull(String field, Object replacement) {
-		return IfNullOperator.newBuilder().ifNull(field).thenReplaceWith(replacement);
-	}
-
-	/**
-	 * Creates a new {@link IfNullOperator} for the given {@link Field} and {@link Field} to obtain a value from.
-	 *
-	 * @param field must not be {@literal null}.
-	 * @param replacement must not be {@literal null}.
-	 * @return never {@literal null}.
-	 * @since 1.10
-	 */
-	public static IfNullOperator ifNull(Field field, Field replacement) {
-		return IfNullOperator.newBuilder().ifNull(field).thenReplaceWith(replacement);
-	}
-
-	/**
-	 * Creates a new {@link IfNullOperator} for the given {@link Field} and {@code replacement} value.
-	 *
-	 * @param field must not be {@literal null}.
-	 * @param replacement must not be {@literal null}.
-	 * @return never {@literal null}.
-	 * @since 1.10
-	 */
-	public static IfNullOperator ifNull(Field field, Object replacement) {
-		return IfNullOperator.newBuilder().ifNull(field).thenReplaceWith(replacement);
-	}
-
-	/**
-	 * Creates a new {@link ConditionalOperator} for the given {@link Field} that holds a {@literal boolean} value.
-	 *
-	 * @param booleanField must not be {@literal null}.
-	 * @param then must not be {@literal null}.
-	 * @param otherwise must not be {@literal null}.
-	 * @return never {@literal null}.
-	 * @since 1.10
-	 */
-	public static ConditionalOperator conditional(Field booleanField, Object then, Object otherwise) {
-		return ConditionalOperator.newBuilder().when(booleanField).then(then).otherwise(otherwise);
-	}
-
-	/**
-	 * Creates a new {@link ConditionalOperator} for the given {@link Criteria}.
-	 *
-	 * @param criteria must not be {@literal null}.
-	 * @param then must not be {@literal null}.
-	 * @param otherwise must not be {@literal null}.
-	 * @return never {@literal null}.
-	 * @since 1.10
-	 */
-	public static ConditionalOperator conditional(Criteria criteria, Object then, Object otherwise) {
-		return ConditionalOperator.newBuilder().when(criteria).then(then).otherwise(otherwise);
+	public static CountOperationBuilder count() {
+		return new CountOperationBuilder();
 	}
 
 	/**
@@ -498,24 +577,7 @@ public class Aggregation {
 	 */
 	public DBObject toDbObject(String inputCollectionName, AggregationOperationContext rootContext) {
 
-		AggregationOperationContext context = rootContext;
-		List<DBObject> operationDocuments = new ArrayList<DBObject>(operations.size());
-
-		for (AggregationOperation operation : operations) {
-
-			operationDocuments.add(operation.toDBObject(context));
-
-			if (operation instanceof FieldsExposingAggregationOperation) {
-
-				FieldsExposingAggregationOperation exposedFieldsOperation = (FieldsExposingAggregationOperation) operation;
-
-				if (operation instanceof InheritsFieldsAggregationOperation) {
-					context = new InheritingExposedFieldsAggregationOperationContext(exposedFieldsOperation.getFields(), context);
-				} else {
-					context = new ExposedFieldsAggregationOperationContext(exposedFieldsOperation.getFields(), context);
-				}
-			}
-		}
+		List<DBObject> operationDocuments = AggregationOperationRenderer.toDBObject(operations, rootContext);
 
 		DBObject command = new BasicDBObject("aggregate", inputCollectionName);
 		command.put("pipeline", operationDocuments);
@@ -531,50 +593,24 @@ public class Aggregation {
 	 */
 	@Override
 	public String toString() {
-		return SerializationUtils
-				.serializeToJsonSafely(toDbObject("__collection__", new NoOpAggregationOperationContext()));
+		return SerializationUtils.serializeToJsonSafely(toDbObject("__collection__", DEFAULT_CONTEXT));
 	}
 
 	/**
-	 * Simple {@link AggregationOperationContext} that just returns {@link FieldReference}s as is.
+	 * Get {@link AggregationOptions} to apply.
 	 *
-	 * @author Oliver Gierke
+	 * @return never {@literal null}.
+	 * @since 1.10.10
 	 */
-	private static class NoOpAggregationOperationContext implements AggregationOperationContext {
-
-		/* 
-		 * (non-Javadoc)
-		 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperationContext#getMappedObject(com.mongodb.DBObject)
-		 */
-		@Override
-		public DBObject getMappedObject(DBObject dbObject) {
-			return dbObject;
-		}
-
-		/* 
-		 * (non-Javadoc)
-		 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperationContext#getReference(org.springframework.data.mongodb.core.aggregation.ExposedFields.AvailableField)
-		 */
-		@Override
-		public FieldReference getReference(Field field) {
-			return new FieldReference(new ExposedField(field, true));
-		}
-
-		/* 
-		 * (non-Javadoc)
-		 * @see org.springframework.data.mongodb.core.aggregation.AggregationOperationContext#getReference(java.lang.String)
-		 */
-		@Override
-		public FieldReference getReference(String name) {
-			return new FieldReference(new ExposedField(new AggregationField(name), true));
-		}
+	public AggregationOptions getOptions() {
+		return options;
 	}
 
 	/**
 	 * Describes the system variables available in MongoDB aggregation framework pipeline expressions.
 	 *
 	 * @author Thomas Darimont
-	 * @see http://docs.mongodb.org/manual/reference/aggregation-variables
+	 * @see <a href="https://docs.mongodb.org/manual/reference/aggregation-variables">Aggregation Variables</a>
 	 */
 	enum SystemVariable {
 
@@ -607,7 +643,7 @@ public class Aggregation {
 			return false;
 		}
 
-		/* 
+		/*
 		 * (non-Javadoc)
 		 * @see java.lang.Enum#toString()
 		 */

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2016 the original author or authors.
+ * Copyright 2015-2019 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.