Release version 3.3.7 (2021.1.7).

See #4115

.mvn/wrapper/maven-wrapper.properties

@@ -1,2 +1,2 @@
-#Fri Jun 03 09:32:40 CEST 2022
+#Fri Jun 03 09:42:19 CEST 2022
 distributionUrl=https\://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.8.5/apache-maven-3.8.5-bin.zip

Jenkinsfile

@@ -9,7 +9,7 @@ pipeline {
 
 	triggers {
 		pollSCM 'H/10 * * * *'
-		upstream(upstreamProjects: "spring-data-commons/main", threshold: hudson.model.Result.SUCCESS)
+		upstream(upstreamProjects: "spring-data-commons/2.6.x", threshold: hudson.model.Result.SUCCESS)
 	}
 
 	options {
@@ -20,7 +20,64 @@ pipeline {
 	stages {
 		stage("Docker images") {
 			parallel {
-				stage('Publish JDK (Java 17) + MongoDB 4.4') {
+				stage('Publish JDK (main) + MongoDB 4.0') {
+					when {
+						anyOf {
+							changeset "ci/openjdk8-mongodb-4.0/**"
+							changeset "ci/pipeline.properties"
+						}
+					}
+					agent { label 'data' }
+					options { timeout(time: 30, unit: 'MINUTES') }
+
+					steps {
+						script {
+							def image = docker.build("springci/spring-data-with-mongodb-4.0:${p['java.main.tag']}", "--build-arg BASE=${p['docker.java.main.image']} --build-arg MONGODB=${p['docker.mongodb.4.0.version']} ci/openjdk8-mongodb-4.0/")
+							docker.withRegistry(p['docker.registry'], p['docker.credentials']) {
+								image.push()
+							}
+						}
+					}
+				}
+				stage('Publish JDK (main) + MongoDB 4.4') {
+					when {
+						anyOf {
+							changeset "ci/openjdk8-mongodb-4.4/**"
+							changeset "ci/pipeline.properties"
+						}
+					}
+					agent { label 'data' }
+					options { timeout(time: 30, unit: 'MINUTES') }
+
+					steps {
+						script {
+							def image = docker.build("springci/spring-data-with-mongodb-4.4:${p['java.main.tag']}", "--build-arg BASE=${p['docker.java.main.image']} --build-arg MONGODB=${p['docker.mongodb.4.4.version']} ci/openjdk8-mongodb-4.4/")
+							docker.withRegistry(p['docker.registry'], p['docker.credentials']) {
+								image.push()
+							}
+						}
+					}
+				}
+				stage('Publish JDK (main) + MongoDB 5.0') {
+					when {
+						anyOf {
+							changeset "ci/openjdk8-mongodb-5.0/**"
+							changeset "ci/pipeline.properties"
+						}
+					}
+					agent { label 'data' }
+					options { timeout(time: 30, unit: 'MINUTES') }
+
+					steps {
+						script {
+							def image = docker.build("springci/spring-data-with-mongodb-5.0:${p['java.main.tag']}", "--build-arg BASE=${p['docker.java.main.image']} --build-arg MONGODB=${p['docker.mongodb.5.0.version']} ci/openjdk8-mongodb-5.0/")
+							docker.withRegistry(p['docker.registry'], p['docker.credentials']) {
+								image.push()
+							}
+						}
+					}
+				}
+				stage('Publish JDK (LTS) + MongoDB 4.4') {
 					when {
 						anyOf {
 							changeset "ci/openjdk17-mongodb-4.4/**"
@@ -32,45 +89,7 @@ pipeline {
 
 					steps {
 						script {
-							def image = docker.build("springci/spring-data-with-mongodb-4.4:${p['java.main.tag']}", "--build-arg BASE=${p['docker.java.main.image']} --build-arg MONGODB=${p['docker.mongodb.4.4.version']} ci/openjdk17-mongodb-4.4/")
-							docker.withRegistry(p['docker.registry'], p['docker.credentials']) {
-								image.push()
-							}
-						}
-					}
-				}
-				stage('Publish JDK (Java 17) + MongoDB 5.0') {
-					when {
-						anyOf {
-							changeset "ci/openjdk17-mongodb-5.0/**"
-							changeset "ci/pipeline.properties"
-						}
-					}
-					agent { label 'data' }
-					options { timeout(time: 30, unit: 'MINUTES') }
-
-					steps {
-						script {
-							def image = docker.build("springci/spring-data-with-mongodb-5.0:${p['java.main.tag']}", "--build-arg BASE=${p['docker.java.main.image']} --build-arg MONGODB=${p['docker.mongodb.5.0.version']} ci/openjdk17-mongodb-5.0/")
-							docker.withRegistry(p['docker.registry'], p['docker.credentials']) {
-								image.push()
-							}
-						}
-					}
-				}
-				stage('Publish JDK (Java 17) + MongoDB 6.0') {
-					when {
-						anyOf {
-							changeset "ci/openjdk17-mongodb-6.0/**"
-							changeset "ci/pipeline.properties"
-						}
-					}
-					agent { label 'data' }
-					options { timeout(time: 30, unit: 'MINUTES') }
-
-					steps {
-						script {
-							def image = docker.build("springci/spring-data-with-mongodb-6.0:${p['java.main.tag']}", "--build-arg BASE=${p['docker.java.main.image']} --build-arg MONGODB=${p['docker.mongodb.6.0.version']} ci/openjdk17-mongodb-6.0/")
+							def image = docker.build("springci/spring-data-with-mongodb-4.4:${p['java.lts.tag']}", "--build-arg BASE=${p['docker.java.lts.image']} --build-arg MONGODB=${p['docker.mongodb.4.4.version']} ci/openjdk17-mongodb-4.4/")
 							docker.withRegistry(p['docker.registry'], p['docker.credentials']) {
 								image.push()
 							}
@@ -80,7 +99,7 @@ pipeline {
 			}
 		}
 
-		stage("test: baseline (Java 17)") {
+		stage("test: baseline (main)") {
 			when {
 				beforeAgent(true)
 				anyOf {
@@ -97,7 +116,7 @@ pipeline {
 			}
 			steps {
 				script {
-					docker.image("harbor-repo.vmware.com/dockerhub-proxy-cache/springci/spring-data-with-mongodb-4.4:${p['java.main.tag']}").inside(p['docker.java.inside.basic']) {
+					docker.image("harbor-repo.vmware.com/dockerhub-proxy-cache/springci/spring-data-with-mongodb-4.0:${p['java.main.tag']}").inside(p['docker.java.inside.basic']) {
 						sh 'mkdir -p /tmp/mongodb/db /tmp/mongodb/log'
 						sh 'mongod --setParameter transactionLifetimeLimitSeconds=90 --setParameter maxTransactionLockRequestTimeoutMillis=10000 --dbpath /tmp/mongodb/db --replSet rs0 --fork --logpath /tmp/mongodb/log/mongod.log &'
 						sh 'sleep 10'
@@ -118,8 +137,29 @@ pipeline {
 				}
 			}
 			parallel {
+				stage("test: mongodb 4.4 (main)") {
+					agent {
+						label 'data'
+					}
+					options { timeout(time: 30, unit: 'MINUTES') }
+					environment {
+						ARTIFACTORY = credentials("${p['artifactory.credentials']}")
+					}
+					steps {
+						script {
+							docker.image("harbor-repo.vmware.com/dockerhub-proxy-cache/springci/spring-data-with-mongodb-4.4:${p['java.main.tag']}").inside(p['docker.java.inside.basic']) {
+								sh 'mkdir -p /tmp/mongodb/db /tmp/mongodb/log'
+								sh 'mongod --setParameter transactionLifetimeLimitSeconds=90 --setParameter maxTransactionLockRequestTimeoutMillis=10000 --dbpath /tmp/mongodb/db --replSet rs0 --fork --logpath /tmp/mongodb/log/mongod.log &'
+								sh 'sleep 10'
+								sh 'mongo --eval "rs.initiate({_id: \'rs0\', members:[{_id: 0, host: \'127.0.0.1:27017\'}]});"'
+								sh 'sleep 15'
+								sh 'MAVEN_OPTS="-Duser.name=jenkins -Duser.home=/tmp/jenkins-home" ./mvnw -s settings.xml clean dependency:list test -Duser.name=jenkins -Dsort -U -B'
+							}
+						}
+					}
+				}
 
-				stage("test: MongoDB 5.0 (Java 17)") {
+				stage("test: mongodb 5.0 (main)") {
 					agent {
 						label 'data'
 					}
@@ -141,7 +181,7 @@ pipeline {
 					}
 				}
 
-				stage("test: MongoDB 6.0 (Java 17)") {
+				stage("test: baseline (LTS)") {
 					agent {
 						label 'data'
 					}
@@ -151,11 +191,11 @@ pipeline {
 					}
 					steps {
 						script {
-							docker.image("harbor-repo.vmware.com/dockerhub-proxy-cache/springci/spring-data-with-mongodb-6.0:${p['java.main.tag']}").inside(p['docker.java.inside.basic']) {
+							docker.image("harbor-repo.vmware.com/dockerhub-proxy-cache/springci/spring-data-with-mongodb-4.4:${p['java.lts.tag']}").inside(p['docker.java.inside.basic']) {
 								sh 'mkdir -p /tmp/mongodb/db /tmp/mongodb/log'
 								sh 'mongod --setParameter transactionLifetimeLimitSeconds=90 --setParameter maxTransactionLockRequestTimeoutMillis=10000 --dbpath /tmp/mongodb/db --replSet rs0 --fork --logpath /tmp/mongodb/log/mongod.log &'
 								sh 'sleep 10'
-								sh 'mongosh --eval "rs.initiate({_id: \'rs0\', members:[{_id: 0, host: \'127.0.0.1:27017\'}]});"'
+								sh 'mongo --eval "rs.initiate({_id: \'rs0\', members:[{_id: 0, host: \'127.0.0.1:27017\'}]});"'
 								sh 'sleep 15'
 								sh 'MAVEN_OPTS="-Duser.name=jenkins -Duser.home=/tmp/jenkins-home" ./mvnw -s settings.xml clean dependency:list test -Duser.name=jenkins -Dsort -U -B'
 							}
@@ -185,7 +225,6 @@ pipeline {
 			steps {
 				script {
 					docker.image(p['docker.java.main.image']).inside(p['docker.java.inside.basic']) {
-						sh 'MAVEN_OPTS="-Duser.name=jenkins -Duser.home=/tmp/jenkins-home" ./mvnw -v'
 						sh 'MAVEN_OPTS="-Duser.name=jenkins -Duser.home=/tmp/jenkins-home" ./mvnw -s settings.xml -Pci,artifactory ' +
 								'-Dartifactory.server=https://repo.spring.io ' +
 								"-Dartifactory.username=${ARTIFACTORY_USR} " +

README.adoc

@@ -271,27 +271,26 @@ The https://spring.io/[spring.io] site contains several guides that show how to
 [[building-from-source]]
 == Building from Source
 
-You do not need to build from source to use Spring Data. Binaries are available in https://repo.spring.io[repo.spring.io]
+You do not need to build from source to use Spring Data. Binaries are available in https://repo.spring.io[repo.spring.io].
 and accessible from Maven using the Maven configuration noted <<maven-configuration,above>>.
 
 NOTE: Configuration for Gradle is similar to Maven.
 
 The best way to get started is by creating a Spring Boot project using MongoDB on https://start.spring.io[start.spring.io].
-Follow this https://start.spring.io/#type=maven-project&language=java&platformVersion=3.0.0&packaging=jar&jvmVersion=17&groupId=com.example&artifactId=demo&name=demo&description=Demo%20project%20for%20Spring%20Boot&packageName=com.example.demo&dependencies=data-mongodb[link]
-to build an imperative application and this https://start.spring.io/#type=maven-project&language=java&platformVersion=3.0.0&packaging=jar&jvmVersion=17&groupId=com.example&artifactId=demo&name=demo&description=Demo%20project%20for%20Spring%20Boot&packageName=com.example.demo&dependencies=data-mongodb-reactive[link]
+Follow this https://start.spring.io/#type=maven-project&language=java&platformVersion=2.5.4&packaging=jar&jvmVersion=1.8&groupId=com.example&artifactId=demo&name=demo&description=Demo%20project%20for%20Spring%20Boot&packageName=com.example.demo&dependencies=data-mongodb[link]
+to build an imperative application and this https://start.spring.io/#type=maven-project&language=java&platformVersion=2.5.4&packaging=jar&jvmVersion=1.8&groupId=com.example&artifactId=demo&name=demo&description=Demo%20project%20for%20Spring%20Boot&packageName=com.example.demo&dependencies=data-mongodb-reactive[link]
 to build a reactive one.
 
-However, if you want to try out the latest and greatest, Spring Data MongoDB can be easily built with the https://github.com/takari/maven-wrapper[Maven wrapper]
-and minimally, JDK 17 (https://www.oracle.com/java/technologies/downloads/[JDK downloads]).
+However, if you want to try out the latest and greatest, Spring Data can be easily built with the https://github.com/takari/maven-wrapper[maven wrapper]
+and minimally JDK 8 (https://www.oracle.com/java/technologies/downloads/[JDK downloads]).
 
-In order to build Spring Data MongoDB, you will need to https://www.mongodb.com/try/download/community[download]
+In order to build Spring Data MongoDB, first you will need to https://www.mongodb.com/try/download/community[download]
 and https://docs.mongodb.com/manual/installation/[install a MongoDB distribution].
 
 Once you have installed MongoDB, you need to start a MongoDB server. It is convenient to set an environment variable to
-your MongoDB installation directory (e.g. `MONGODB_HOME`).
+your MongoDB installation (e.g. `MONGODB_HOME`).
 
-To run the full test suite, a https://docs.mongodb.com/manual/tutorial/deploy-replica-set/[MongoDB Replica Set]
-is required.
+To run the full test suite a https://docs.mongodb.com/manual/tutorial/deploy-replica-set/[MongoDB Replica Set] is required.
 
 To run the MongoDB server enter the following command from a command-line:
 
@@ -332,7 +331,7 @@ In case you need to, you can adjust the `ulimit` with the following command (327
 $ ulimit -n 32768
 ----
 
-You can use `ulimit -a` again to verify the `ulimit` for "_open files_" was set appropriately.
+You can use `ulimit -a` again to verify the `ulimit` on "_open files_" was set appropriately.
 
 Now you are ready to build Spring Data MongoDB. Simply enter the following `mvnw` (Maven Wrapper) command:
 
@@ -341,7 +340,7 @@ Now you are ready to build Spring Data MongoDB. Simply enter the following `mvnw
  $ ./mvnw clean install
 ----
 
-If you want to build with the regular `mvn` command, you will need https://maven.apache.org/run-maven/index.html[Maven v3.8.0 or above].
+If you want to build with the regular `mvn` command, you will need https://maven.apache.org/run-maven/index.html[Maven v3.5.0 or above].
 
 _Also see link:CONTRIBUTING.adoc[CONTRIBUTING.adoc] if you wish to submit pull requests, and in particular, please sign
 the https://cla.pivotal.io/sign/spring[Contributor’s Agreement] before your first non-trivial change._

ci/openjdk11-mongodb-4.4/Dockerfile

@@ -0,0 +1,21 @@
+ARG BASE
+FROM ${BASE}
+# Any ARG statements before FROM are cleared.
+ARG MONGODB
+
+ENV TZ=Etc/UTC
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN set -eux; \
+	sed -i -e 's/archive.ubuntu.com/mirror.one.com/g' /etc/apt/sources.list; \
+	sed -i -e 's/security.ubuntu.com/mirror.one.com/g' /etc/apt/sources.list; \
+	sed -i -e 's/http/https/g' /etc/apt/sources.list ; \
+	apt-get update && apt-get install -y apt-transport-https apt-utils gnupg2 ; \
+	apt-key adv --keyserver hkps://keyserver.ubuntu.com:443 --recv 656408E390CFB1F5 ; \
+	echo "deb [ arch=amd64 ] https://repo.mongodb.org/apt/ubuntu bionic/mongodb-org/4.4 multiverse" | tee /etc/apt/sources.list.d/mongodb-org-4.4.list; \
+	echo ${TZ} > /etc/timezone;
+
+RUN apt-get update ; \
+	apt-get install -y mongodb-org=${MONGODB} mongodb-org-server=${MONGODB} mongodb-org-shell=${MONGODB} mongodb-org-mongos=${MONGODB} mongodb-org-tools=${MONGODB} ; \
+	apt-get clean; \
+	rm -rf /var/lib/apt/lists/*;

ci/openjdk17-mongodb-4.4/Dockerfile

@@ -7,16 +7,15 @@ ENV TZ=Etc/UTC
 ENV DEBIAN_FRONTEND=noninteractive
 
 RUN set -eux; \
-	sed -i -e 's/archive.ubuntu.com/mirror.one.com/g' /etc/apt/sources.list && \
-	sed -i -e 's/security.ubuntu.com/mirror.one.com/g' /etc/apt/sources.list && \
-	sed -i -e 's/ports.ubuntu.com/mirrors.ocf.berkeley.edu/g' /etc/apt/sources.list && \
-	sed -i -e 's/http/https/g' /etc/apt/sources.list && \
-	apt-get update && apt-get install -y apt-transport-https apt-utils gnupg2 && \
-	apt-key adv --keyserver hkps://keyserver.ubuntu.com:443 --recv 656408E390CFB1F5 && \
-	echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/4.4 multiverse" | tee /etc/apt/sources.list.d/mongodb-org-4.4.list && \
-	echo ${TZ} > /etc/timezone
+	sed -i -e 's/archive.ubuntu.com/mirror.one.com/g' /etc/apt/sources.list; \
+	sed -i -e 's/security.ubuntu.com/mirror.one.com/g' /etc/apt/sources.list; \
+	sed -i -e 's/http/https/g' /etc/apt/sources.list ; \
+	apt-get update && apt-get install -y apt-transport-https apt-utils gnupg2 ; \
+	apt-key adv --keyserver hkps://keyserver.ubuntu.com:443 --recv 656408E390CFB1F5 ; \
+	echo "deb [ arch=amd64 ] https://repo.mongodb.org/apt/ubuntu bionic/mongodb-org/4.4 multiverse" | tee /etc/apt/sources.list.d/mongodb-org-4.4.list; \
+	echo ${TZ} > /etc/timezone;
 
-RUN apt-get update && \
-	apt-get install -y mongodb-org=${MONGODB} mongodb-org-server=${MONGODB} mongodb-org-shell=${MONGODB} mongodb-org-mongos=${MONGODB} mongodb-org-tools=${MONGODB} && \
-	apt-get clean && \
-	rm -rf /var/lib/apt/lists/*
+RUN apt-get update ; \
+	apt-get install -y mongodb-org=${MONGODB} mongodb-org-server=${MONGODB} mongodb-org-shell=${MONGODB} mongodb-org-mongos=${MONGODB} mongodb-org-tools=${MONGODB} ; \
+	apt-get clean; \
+	rm -rf /var/lib/apt/lists/*;

ci/openjdk17-mongodb-6.0/Dockerfile

@@ -1,24 +0,0 @@
-ARG BASE
-FROM ${BASE}
-# Any ARG statements before FROM are cleared.
-ARG MONGODB
-
-ENV TZ=Etc/UTC
-ENV DEBIAN_FRONTEND=noninteractive
-
-RUN set -eux; \
-	sed -i -e 's/archive.ubuntu.com/mirror.one.com/g' /etc/apt/sources.list && \
-	sed -i -e 's/security.ubuntu.com/mirror.one.com/g' /etc/apt/sources.list && \
-    sed -i -e 's/ports.ubuntu.com/mirrors.ocf.berkeley.edu/g' /etc/apt/sources.list && \
-	sed -i -e 's/http/https/g' /etc/apt/sources.list && \
-	apt-get update && apt-get install -y apt-transport-https apt-utils gnupg2 wget && \
-	# MongoDB 6.0 release signing key
-	wget -qO - https://www.mongodb.org/static/pgp/server-6.0.asc | apt-key add - && \
-	# Needed when MongoDB creates a 6.0 folder.
-	echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/6.0 multiverse" | tee /etc/apt/sources.list.d/mongodb-org-6.0.list && \
-	echo ${TZ} > /etc/timezone
-
-RUN apt-get update && \
-	apt-get install -y mongodb-org=${MONGODB} mongodb-org-server=${MONGODB} mongodb-org-shell=${MONGODB} mongodb-org-mongos=${MONGODB} mongodb-org-tools=${MONGODB} && \
-	apt-get clean && \
-	rm -rf /var/lib/apt/lists/*

ci/openjdk8-mongodb-4.0/Dockerfile

@@ -0,0 +1,21 @@
+ARG BASE
+FROM ${BASE}
+# Any ARG statements before FROM are cleared.
+ARG MONGODB
+
+ENV TZ=Etc/UTC
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN RUN set -eux; \
+	sed -i -e 's/archive.ubuntu.com/mirror.one.com/g' /etc/apt/sources.list; \
+	sed -i -e 's/security.ubuntu.com/mirror.one.com/g' /etc/apt/sources.list; \
+	sed -i -e 's/http/https/g' /etc/apt/sources.list ; \
+	apt-get update && apt-get install -y apt-transport-https apt-utils gnupg2 ; \
+	apt-key adv --keyserver hkps://keyserver.ubuntu.com:443 --recv 9DA31620334BD75D9DCB49F368818C72E52529D4 ; \
+	echo "deb [ arch=amd64 ] https://repo.mongodb.org/apt/ubuntu bionic/mongodb-org/4.0 multiverse" | tee /etc/apt/sources.list.d/mongodb-org-4.0.list; \
+	echo ${TZ} > /etc/timezone;
+
+RUN apt-get update ; \
+	apt-get install -y mongodb-org=${MONGODB} mongodb-org-server=${MONGODB} mongodb-org-shell=${MONGODB} mongodb-org-mongos=${MONGODB} mongodb-org-tools=${MONGODB} ; \
+	apt-get clean; \
+	rm -rf /var/lib/apt/lists/*;

ci/openjdk8-mongodb-4.4/Dockerfile

@@ -0,0 +1,23 @@
+ARG BASE
+FROM ${BASE}
+# Any ARG statements before FROM are cleared.
+ARG MONGODB
+
+ENV TZ=Etc/UTC
+ENV DEBIAN_FRONTEND=noninteractive
+
+RUN set -eux; \
+	sed -i -e 's/archive.ubuntu.com/mirror.one.com/g' /etc/apt/sources.list; \
+	sed -i -e 's/security.ubuntu.com/mirror.one.com/g' /etc/apt/sources.list; \
+	sed -i -e 's/http/https/g' /etc/apt/sources.list ; \
+	apt-get update && apt-get install -y apt-transport-https apt-utils gnupg2 ; \
+	apt-key adv --keyserver hkps://keyserver.ubuntu.com:443 --recv 656408E390CFB1F5 ; \
+	echo "deb [ arch=amd64 ] https://repo.mongodb.org/apt/ubuntu bionic/mongodb-org/4.4 multiverse" | tee /etc/apt/sources.list.d/mongodb-org-4.4.list; \
+	echo ${TZ} > /etc/timezone;
+
+RUN apt-get update ; \
+	ln -T /bin/true /usr/bin/systemctl ; \
+	apt-get install -y mongodb-org=${MONGODB} mongodb-org-server=${MONGODB} mongodb-org-shell=${MONGODB} mongodb-org-mongos=${MONGODB} mongodb-org-tools=${MONGODB} ; \
+    rm /usr/bin/systemctl ; \
+	apt-get clean ; \
+	rm -rf /var/lib/apt/lists/* ;

ci/openjdk8-mongodb-5.0/Dockerfile

@@ -7,18 +7,17 @@ ENV TZ=Etc/UTC
 ENV DEBIAN_FRONTEND=noninteractive
 
 RUN set -eux; \
-	sed -i -e 's/archive.ubuntu.com/mirror.one.com/g' /etc/apt/sources.list && \
-	sed -i -e 's/security.ubuntu.com/mirror.one.com/g' /etc/apt/sources.list && \
-    sed -i -e 's/ports.ubuntu.com/mirrors.ocf.berkeley.edu/g' /etc/apt/sources.list && \
-	sed -i -e 's/http/https/g' /etc/apt/sources.list && \
-	apt-get update && apt-get install -y apt-transport-https apt-utils gnupg2 wget && \
+	sed -i -e 's/archive.ubuntu.com/mirror.one.com/g' /etc/apt/sources.list; \
+	sed -i -e 's/security.ubuntu.com/mirror.one.com/g' /etc/apt/sources.list; \
+	sed -i -e 's/http/https/g' /etc/apt/sources.list ; \
+	apt-get update && apt-get install -y apt-transport-https apt-utils gnupg2 wget ; \
 	# MongoDB 5.0 release signing key
-	apt-key adv --keyserver hkps://keyserver.ubuntu.com:443 --recv B00A0BD1E2C63C11 && \
+	apt-key adv --keyserver hkps://keyserver.ubuntu.com:443 --recv B00A0BD1E2C63C11 ; \
 	# Needed when MongoDB creates a 5.0 folder.
-	echo "deb [ arch=amd64,arm64 ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/5.0 multiverse" | tee /etc/apt/sources.list.d/mongodb-org-5.0.list && \
-	echo ${TZ} > /etc/timezone
+	echo "deb [ arch=amd64 ] https://repo.mongodb.org/apt/ubuntu bionic/mongodb-org/5.0 multiverse" | tee /etc/apt/sources.list.d/mongodb-org-5.0.list; \
+	echo ${TZ} > /etc/timezone;
 
-RUN apt-get update && \
-	apt-get install -y mongodb-org=${MONGODB} mongodb-org-server=${MONGODB} mongodb-org-shell=${MONGODB} mongodb-org-mongos=${MONGODB} mongodb-org-tools=${MONGODB} && \
-	apt-get clean && \
-	rm -rf /var/lib/apt/lists/*
+RUN apt-get update; \
+	apt-get install -y mongodb-org=${MONGODB} mongodb-org-server=${MONGODB} mongodb-org-shell=${MONGODB} mongodb-org-mongos=${MONGODB} mongodb-org-tools=${MONGODB} ; \
+	apt-get clean; \
+	rm -rf /var/lib/apt/lists/*;

ci/pipeline.properties

@@ -1,19 +1,23 @@
 # Java versions
-java.main.tag=17.0.4.1_1-jdk-focal
+java.main.tag=8u322-b06-jdk
+java.next.tag=11.0.14.1_1-jdk
+java.lts.tag=17.0.2_8-jdk
 
 # Docker container images - standard
 docker.java.main.image=harbor-repo.vmware.com/dockerhub-proxy-cache/library/eclipse-temurin:${java.main.tag}
+docker.java.next.image=harbor-repo.vmware.com/dockerhub-proxy-cache/library/eclipse-temurin:${java.next.tag}
+docker.java.lts.image=harbor-repo.vmware.com/dockerhub-proxy-cache/library/eclipse-temurin:${java.lts.tag}
 
 # Supported versions of MongoDB
-docker.mongodb.4.4.version=4.4.17
-docker.mongodb.5.0.version=5.0.13
-docker.mongodb.6.0.version=6.0.2
+docker.mongodb.4.0.version=4.0.28
+docker.mongodb.4.4.version=4.4.12
+docker.mongodb.5.0.version=5.0.6
 
 # Supported versions of Redis
 docker.redis.6.version=6.2.6
 
 # Supported versions of Cassandra
-docker.cassandra.3.version=3.11.14
+docker.cassandra.3.version=3.11.12
 
 # Docker environment settings
 docker.java.inside.basic=-v $HOME:/tmp/jenkins-home

pom.xml

@@ -5,7 +5,7 @@
 
 	<groupId>org.springframework.data</groupId>
 	<artifactId>spring-data-mongodb-parent</artifactId>
-	<version>4.0.0-RC2</version>
+	<version>3.3.7</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>3.0.0-RC2</version>
+		<version>2.6.7</version>
 	</parent>
 
 	<modules>
@@ -26,8 +26,8 @@
 	<properties>
 		<project.type>multi</project.type>
 		<dist.id>spring-data-mongodb</dist.id>
-		<springdata.commons>3.0.0-RC2</springdata.commons>
-		<mongo>4.8.0-beta0</mongo>
+		<springdata.commons>2.6.7</springdata.commons>
+		<mongo>4.4.2</mongo>
 		<mongo.reactivestreams>${mongo}</mongo.reactivestreams>
 		<jmh.version>1.19</jmh.version>
 	</properties>
@@ -145,11 +145,8 @@
 
 	<repositories>
 		<repository>
-			<id>spring-libs-milestone</id>
-			<url>https://repo.spring.io/libs-milestone</url>
-			<snapshots>
-				<enabled>true</enabled>
-			</snapshots>
+			<id>spring-libs-release</id>
+			<url>https://repo.spring.io/libs-release</url>
 		</repository>
 		<repository>
 			<id>sonatype-libs-snapshot</id>

spring-data-mongodb-benchmarks/pom.xml

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

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

@@ -322,7 +322,7 @@ public class AbstractMicrobenchmark {
 		try {
 			ResultsWriter.forUri(uri).write(results);
 		} catch (Exception e) {
-			System.err.println(String.format("Cannot save benchmark results to '%s'; Error was %s", uri, e));
+			System.err.println(String.format("Cannot save benchmark results to '%s'. Error was %s.", uri, e));
 		}
 	}
 }

spring-data-mongodb-distribution/pom.xml

@@ -1,7 +1,6 @@
 <?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
 
 	<modelVersion>4.0.0</modelVersion>
 
@@ -15,18 +14,13 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>4.0.0-RC2</version>
+		<version>3.3.7</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 
 	<properties>
 		<project.root>${basedir}/..</project.root>
 		<dist.key>SDMONGO</dist.key>
-
-		<!-- Observability -->
-		<micrometer-docs-generator.inputPath>${maven.multiModuleProjectDirectory}/spring-data-mongodb/</micrometer-docs-generator.inputPath>
-		<micrometer-docs-generator.inclusionPattern>.*</micrometer-docs-generator.inclusionPattern>
-		<micrometer-docs-generator.outputPath>${maven.multiModuleProjectDirectory}/target/</micrometer-docs-generator.outputPath>
 	</properties>
 
 	<build>
@@ -35,43 +29,12 @@
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-assembly-plugin</artifactId>
 			</plugin>
-			<plugin>
-				<groupId>org.codehaus.mojo</groupId>
-				<artifactId>exec-maven-plugin</artifactId>
-				<executions>
-					<execution>
-						<id>generate-docs</id>
-						<phase>generate-resources</phase>
-						<goals>
-							<goal>java</goal>
-						</goals>
-						<configuration>
-							<mainClass>io.micrometer.docs.DocsGeneratorCommand</mainClass>
-							<includePluginDependencies>true</includePluginDependencies>
-							<arguments>
-								<argument>${micrometer-docs-generator.inputPath}</argument>
-								<argument>${micrometer-docs-generator.inclusionPattern}</argument>
-								<argument>${micrometer-docs-generator.outputPath}</argument>
-							</arguments>
-						</configuration>
-					</execution>
-				</executions>
-				<dependencies>
-					<dependency>
-						<groupId>io.micrometer</groupId>
-						<artifactId>micrometer-docs-generator</artifactId>
-						<version>${micrometer-docs-generator}</version>
-						<type>jar</type>
-					</dependency>
-				</dependencies>
-			</plugin>
 			<plugin>
 				<groupId>org.asciidoctor</groupId>
 				<artifactId>asciidoctor-maven-plugin</artifactId>
 				<configuration>
 					<attributes>
-						<mongo-reactivestreams>${mongo.reactivestreams}
-						</mongo-reactivestreams>
+						<mongo-reactivestreams>${mongo.reactivestreams}</mongo-reactivestreams>
 						<reactor>${reactor}</reactor>
 					</attributes>
 				</configuration>
@@ -80,15 +43,4 @@
 
 	</build>
 
-	<pluginRepositories>
-		<pluginRepository>
-			<id>spring-plugins-release</id>
-			<url>https://repo.spring.io/plugins-release</url>
-		</pluginRepository>
-		<pluginRepository>
-			<id>spring-plugins-snapshot</id>
-			<url>https://repo.spring.io/libs-snapshot</url>
-		</pluginRepository>
-	</pluginRepositories>
-
 </project>

spring-data-mongodb/pom.xml

@@ -1,7 +1,5 @@
 <?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
 
 	<modelVersion>4.0.0</modelVersion>
 
@@ -13,7 +11,7 @@
 	<parent>
 		<groupId>org.springframework.data</groupId>
 		<artifactId>spring-data-mongodb-parent</artifactId>
-		<version>4.0.0-RC2</version>
+		<version>3.3.7</version>
 		<relativePath>../pom.xml</relativePath>
 	</parent>
 
@@ -124,6 +122,27 @@
 			<optional>true</optional>
 		</dependency>
 
+		<dependency>
+			<groupId>io.reactivex</groupId>
+			<artifactId>rxjava</artifactId>
+			<version>${rxjava}</version>
+			<optional>true</optional>
+		</dependency>
+
+		<dependency>
+			<groupId>io.reactivex</groupId>
+			<artifactId>rxjava-reactive-streams</artifactId>
+			<version>${rxjava-reactive-streams}</version>
+			<optional>true</optional>
+		</dependency>
+
+		<dependency>
+			<groupId>io.reactivex.rxjava2</groupId>
+			<artifactId>rxjava</artifactId>
+			<version>${rxjava2}</version>
+			<optional>true</optional>
+		</dependency>
+
 		<dependency>
 			<groupId>io.reactivex.rxjava3</groupId>
 			<artifactId>rxjava</artifactId>
@@ -133,6 +152,12 @@
 
 		<!-- CDI -->
 		<!-- Dependency order required to build against CDI 1.0 and test with CDI 2.0 -->
+		<dependency>
+			<groupId>org.apache.geronimo.specs</groupId>
+			<artifactId>geronimo-jcdi_2.0_spec</artifactId>
+			<version>1.0.1</version>
+			<scope>test</scope>
+		</dependency>
 
 		<dependency>
 			<groupId>javax.interceptor</groupId>
@@ -142,48 +167,31 @@
 		</dependency>
 
 		<dependency>
-			<groupId>jakarta.enterprise</groupId>
-			<artifactId>jakarta.enterprise.cdi-api</artifactId>
+			<groupId>javax.enterprise</groupId>
+			<artifactId>cdi-api</artifactId>
 			<version>${cdi}</version>
 			<scope>provided</scope>
 			<optional>true</optional>
 		</dependency>
 
 		<dependency>
-			<groupId>jakarta.annotation</groupId>
-			<artifactId>jakarta.annotation-api</artifactId>
-			<version>${jakarta-annotation-api}</version>
+			<groupId>javax.annotation</groupId>
+			<artifactId>javax.annotation-api</artifactId>
+			<version>${javax-annotation-api}</version>
 			<scope>test</scope>
 		</dependency>
 
 		<dependency>
 			<groupId>org.apache.openwebbeans</groupId>
 			<artifactId>openwebbeans-se</artifactId>
-			<classifier>jakarta</classifier>
-			<version>${webbeans}</version>
-			<scope>test</scope>
-		</dependency>
-
-		<dependency>
-			<groupId>org.apache.openwebbeans</groupId>
-			<artifactId>openwebbeans-spi</artifactId>
-			<classifier>jakarta</classifier>
-			<version>${webbeans}</version>
-			<scope>test</scope>
-		</dependency>
-
-		<dependency>
-			<groupId>org.apache.openwebbeans</groupId>
-			<artifactId>openwebbeans-impl</artifactId>
-			<classifier>jakarta</classifier>
 			<version>${webbeans}</version>
 			<scope>test</scope>
 		</dependency>
 
 		<!-- JSR 303 Validation -->
 		<dependency>
-			<groupId>jakarta.validation</groupId>
-			<artifactId>jakarta.validation-api</artifactId>
+			<groupId>javax.validation</groupId>
+			<artifactId>validation-api</artifactId>
 			<version>${validation}</version>
 			<optional>true</optional>
 		</dependency>
@@ -196,37 +204,30 @@
 		</dependency>
 
 		<dependency>
-			<groupId>io.micrometer</groupId>
-			<artifactId>micrometer-observation</artifactId>
-			<optional>true</optional>
-		</dependency>
-
-		<dependency>
-			<groupId>io.micrometer</groupId>
-			<artifactId>micrometer-tracing</artifactId>
-			<optional>true</optional>
-		</dependency>
-
-		<dependency>
-			<groupId>org.hibernate.validator</groupId>
+			<groupId>org.hibernate</groupId>
 			<artifactId>hibernate-validator</artifactId>
-			<version>7.0.1.Final</version>
+			<version>5.4.3.Final</version>
 			<scope>test</scope>
 		</dependency>
 
 		<dependency>
-			<groupId>jakarta.el</groupId>
-			<artifactId>jakarta.el-api</artifactId>
-			<version>4.0.0</version>
-			<scope>provided</scope>
-			<optional>true</optional>
+			<groupId>org.glassfish</groupId>
+			<artifactId>javax.el</artifactId>
+			<version>3.0.1-b11</version>
+			<scope>test</scope>
 		</dependency>
 
 		<dependency>
-			<groupId>org.glassfish</groupId>
-			<artifactId>jakarta.el</artifactId>
-			<version>4.0.2</version>
-			<scope>provided</scope>
+			<groupId>joda-time</groupId>
+			<artifactId>joda-time</artifactId>
+			<version>${jodatime}</version>
+			<scope>test</scope>
+		</dependency>
+
+		<dependency>
+			<groupId>org.threeten</groupId>
+			<artifactId>threetenbp</artifactId>
+			<version>${threetenbp}</version>
 			<optional>true</optional>
 		</dependency>
 
@@ -236,6 +237,13 @@
 			<optional>true</optional>
 		</dependency>
 
+		<dependency>
+			<groupId>org.slf4j</groupId>
+			<artifactId>jul-to-slf4j</artifactId>
+			<version>${slf4j}</version>
+			<scope>test</scope>
+		</dependency>
+
 		<dependency>
 			<groupId>nl.jqno.equalsverifier</groupId>
 			<artifactId>equalsverifier</artifactId>
@@ -271,9 +279,9 @@
 		</dependency>
 
 		<dependency>
-			<groupId>jakarta.transaction</groupId>
-			<artifactId>jakarta.transaction-api</artifactId>
-			<version>2.0.0</version>
+			<groupId>javax.transaction</groupId>
+			<artifactId>jta</artifactId>
+			<version>1.1</version>
 			<scope>test</scope>
 		</dependency>
 
@@ -304,34 +312,11 @@
 
 		<dependency>
 			<groupId>io.mockk</groupId>
-			<artifactId>mockk-jvm</artifactId>
+			<artifactId>mockk</artifactId>
 			<version>${mockk}</version>
 			<scope>test</scope>
 		</dependency>
 
-		<dependency>
-			<groupId>io.micrometer</groupId>
-			<artifactId>micrometer-test</artifactId>
-			<scope>test</scope>
-			<exclusions>
-				<exclusion>
-					<groupId>com.github.tomakehurst</groupId>
-					<artifactId>wiremock-jre8-standalone</artifactId>
-				</exclusion>
-			</exclusions>
-		</dependency>
-		<dependency>
-			<groupId>io.micrometer</groupId>
-			<artifactId>micrometer-tracing-test</artifactId>
-			<scope>test</scope>
-		</dependency>
-
-		<dependency>
-			<groupId>io.micrometer</groupId>
-			<artifactId>micrometer-tracing-integration-test</artifactId>
-			<scope>test</scope>
-		</dependency>
-
 		<!-- jMolecules -->
 
 		<dependency>
@@ -365,11 +350,8 @@
 							<goal>test-process</goal>
 						</goals>
 						<configuration>
-							<outputDirectory>target/generated-test-sources
-							</outputDirectory>
-							<processor>
-								org.springframework.data.mongodb.repository.support.MongoAnnotationProcessor
-							</processor>
+							<outputDirectory>target/generated-test-sources</outputDirectory>
+							<processor>org.springframework.data.mongodb.repository.support.MongoAnnotationProcessor</processor>
 						</configuration>
 					</execution>
 				</executions>
@@ -389,9 +371,7 @@
 						<exclude>**/ReactivePerformanceTests.java</exclude>
 					</excludes>
 					<systemPropertyVariables>
-						<java.util.logging.config.file>
-							src/test/resources/logging.properties
-						</java.util.logging.config.file>
+						<java.util.logging.config.file>src/test/resources/logging.properties</java.util.logging.config.file>
 						<reactor.trace.cancel>true</reactor.trace.cancel>
 					</systemPropertyVariables>
 				</configuration>

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

@@ -103,11 +103,19 @@ public class BindableMongoExpression implements MongoExpression {
 		return new BindableMongoExpression(expressionString, codecRegistryProvider, args);
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.MongoExpression#toDocument()
+	 */
 	@Override
 	public Document toDocument() {
 		return target.get();
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see java.lang.Object#toString()
+	 */
 	@Override
 	public String toString() {
 		return "BindableMongoExpression{" + "expressionString='" + expressionString + '\'' + ", args="

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

@@ -62,7 +62,7 @@ public interface CodecRegistryProvider {
 	 */
 	default <T> Optional<Codec<T>> getCodecFor(Class<T> type) {
 
-		Assert.notNull(type, "Type must not be null");
+		Assert.notNull(type, "Type must not be null!");
 
 		try {
 			return Optional.of(getCodecRegistry().get(type));

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

@@ -102,7 +102,7 @@ public class MongoDatabaseUtils {
 	private static MongoDatabase doGetMongoDatabase(@Nullable String dbName, MongoDatabaseFactory factory,
 			SessionSynchronization sessionSynchronization) {
 
-		Assert.notNull(factory, "Factory must not be null");
+		Assert.notNull(factory, "Factory must not be null!");
 
 		if (sessionSynchronization == SessionSynchronization.NEVER
 				|| !TransactionSynchronizationManager.isSynchronizationActive()) {
@@ -193,11 +193,19 @@ public class MongoDatabaseUtils {
 			this.resourceHolder = resourceHolder;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.transaction.support.ResourceHolderSynchronization#shouldReleaseBeforeCompletion()
+		 */
 		@Override
 		protected boolean shouldReleaseBeforeCompletion() {
 			return false;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.transaction.support.ResourceHolderSynchronization#processResourceAfterCommit(java.lang.Object)
+		 */
 		@Override
 		protected void processResourceAfterCommit(MongoResourceHolder resourceHolder) {
 
@@ -206,6 +214,10 @@ public class MongoDatabaseUtils {
 			}
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.transaction.support.ResourceHolderSynchronization#afterCompletion(int)
+		 */
 		@Override
 		public void afterCompletion(int status) {
 
@@ -216,6 +228,10 @@ public class MongoDatabaseUtils {
 			super.afterCompletion(status);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.transaction.support.ResourceHolderSynchronization#releaseResource(java.lang.Object, java.lang.Object)
+		 */
 		@Override
 		protected void releaseResource(MongoResourceHolder resourceHolder, Object resourceKey) {
 

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

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2011-2022 the original author 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
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb;
+
+import org.springframework.dao.DataAccessException;
+
+import com.mongodb.client.MongoDatabase;
+
+/**
+ * Interface for factories creating {@link MongoDatabase} instances.
+ *
+ * @author Mark Pollack
+ * @author Thomas Darimont
+ * @author Christoph Strobl
+ * @deprecated since 3.0, use {@link MongoDatabaseFactory} instead.
+ */
+@Deprecated
+public interface MongoDbFactory extends MongoDatabaseFactory {
+
+	/**
+	 * Creates a default {@link MongoDatabase} instance.
+	 *
+	 * @return never {@literal null}.
+	 * @throws DataAccessException
+	 * @deprecated since 3.0. Use {@link #getMongoDatabase()} instead.
+	 */
+	@Deprecated
+	default MongoDatabase getDb() throws DataAccessException {
+		return getMongoDatabase();
+	}
+
+	/**
+	 * Obtain a {@link MongoDatabase} instance to access the database with the given name.
+	 *
+	 * @param dbName must not be {@literal null} or empty.
+	 * @return never {@literal null}.
+	 * @throws DataAccessException
+	 * @deprecated since 3.0. Use {@link #getMongoDatabase(String)} instead.
+	 */
+	@Deprecated
+	default MongoDatabase getDb(String dbName) throws DataAccessException {
+		return getMongoDatabase(dbName);
+	}
+}

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

@@ -1,81 +0,0 @@
-/*
- * Copyright 2022 the original author 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
- *
- *      https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.springframework.data.mongodb;
-
-import java.util.Arrays;
-import java.util.function.Consumer;
-
-import org.springframework.data.domain.ManagedTypes;
-
-/**
- * @author Christoph Strobl
- * @since 4.0
- */
-public final class MongoManagedTypes implements ManagedTypes {
-
-	private final ManagedTypes delegate;
-
-	private MongoManagedTypes(ManagedTypes types) {
-		this.delegate = types;
-	}
-
-	/**
-	 * Wraps an existing {@link ManagedTypes} object with {@link MongoManagedTypes}.
-	 *
-	 * @param managedTypes
-	 * @return
-	 */
-	public static MongoManagedTypes from(ManagedTypes managedTypes) {
-		return new MongoManagedTypes(managedTypes);
-	}
-
-	/**
-	 * Factory method used to construct {@link MongoManagedTypes} from the given array of {@link Class types}.
-	 *
-	 * @param types array of {@link Class types} used to initialize the {@link ManagedTypes}; must not be {@literal null}.
-	 * @return new instance of {@link MongoManagedTypes} initialized from {@link Class types}.
-	 */
-	public static MongoManagedTypes from(Class<?>... types) {
-		return fromIterable(Arrays.asList(types));
-	}
-
-	/**
-	 * Factory method used to construct {@link MongoManagedTypes} from the given, required {@link Iterable} of
-	 * {@link Class types}.
-	 *
-	 * @param types {@link Iterable} of {@link Class types} used to initialize the {@link ManagedTypes}; must not be
-	 *          {@literal null}.
-	 * @return new instance of {@link MongoManagedTypes} initialized the given, required {@link Iterable} of {@link Class
-	 *         types}.
-	 */
-	public static MongoManagedTypes fromIterable(Iterable<? extends Class<?>> types) {
-		return from(ManagedTypes.fromIterable(types));
-	}
-
-	/**
-	 * Factory method to return an empty {@link MongoManagedTypes} object.
-	 *
-	 * @return an empty {@link MongoManagedTypes} object.
-	 */
-	public static MongoManagedTypes empty() {
-		return from(ManagedTypes.empty());
-	}
-
-	@Override
-	public void forEach(Consumer<Class<?>> action) {
-		delegate.forEach(action);
-	}
-}

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

@@ -68,7 +68,7 @@ class MongoResourceHolder extends ResourceHolderSupport {
 		ClientSession session = getSession();
 
 		if (session == null) {
-			throw new IllegalStateException("No session available");
+			throw new IllegalStateException("No session available!");
 		}
 
 		return session;

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

@@ -100,12 +100,16 @@ public class MongoTransactionManager extends AbstractPlatformTransactionManager
 	 */
 	public MongoTransactionManager(MongoDatabaseFactory dbFactory, @Nullable TransactionOptions options) {
 
-		Assert.notNull(dbFactory, "DbFactory must not be null");
+		Assert.notNull(dbFactory, "DbFactory must not be null!");
 
 		this.dbFactory = dbFactory;
 		this.options = options;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * org.springframework.transaction.support.AbstractPlatformTransactionManager#doGetTransaction()
+	 */
 	@Override
 	protected Object doGetTransaction() throws TransactionException {
 
@@ -114,11 +118,19 @@ public class MongoTransactionManager extends AbstractPlatformTransactionManager
 		return new MongoTransactionObject(resourceHolder);
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * org.springframework.transaction.support.AbstractPlatformTransactionManager#isExistingTransaction(java.lang.Object)
+	 */
 	@Override
 	protected boolean isExistingTransaction(Object transaction) throws TransactionException {
 		return extractMongoTransaction(transaction).hasResourceHolder();
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * org.springframework.transaction.support.AbstractPlatformTransactionManager#doBegin(java.lang.Object, org.springframework.transaction.TransactionDefinition)
+	 */
 	@Override
 	protected void doBegin(Object transaction, TransactionDefinition definition) throws TransactionException {
 
@@ -148,6 +160,10 @@ public class MongoTransactionManager extends AbstractPlatformTransactionManager
 		TransactionSynchronizationManager.bindResource(getRequiredDbFactory(), resourceHolder);
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * org.springframework.transaction.support.AbstractPlatformTransactionManager#doSuspend(java.lang.Object)
+	 */
 	@Override
 	protected Object doSuspend(Object transaction) throws TransactionException {
 
@@ -157,11 +173,19 @@ public class MongoTransactionManager extends AbstractPlatformTransactionManager
 		return TransactionSynchronizationManager.unbindResource(getRequiredDbFactory());
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * org.springframework.transaction.support.AbstractPlatformTransactionManager#doResume(java.lang.Object, java.lang.Object)
+	 */
 	@Override
 	protected void doResume(@Nullable Object transaction, Object suspendedResources) {
 		TransactionSynchronizationManager.bindResource(getRequiredDbFactory(), suspendedResources);
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * org.springframework.transaction.support.AbstractPlatformTransactionManager#doCommit(org.springframework.transaction.support.DefaultTransactionStatus)
+	 */
 	@Override
 	protected final void doCommit(DefaultTransactionStatus status) throws TransactionException {
 
@@ -212,6 +236,10 @@ public class MongoTransactionManager extends AbstractPlatformTransactionManager
 		transactionObject.commitTransaction();
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * org.springframework.transaction.support.AbstractPlatformTransactionManager#doRollback(org.springframework.transaction.support.DefaultTransactionStatus)
+	 */
 	@Override
 	protected void doRollback(DefaultTransactionStatus status) throws TransactionException {
 
@@ -231,6 +259,10 @@ public class MongoTransactionManager extends AbstractPlatformTransactionManager
 		}
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * org.springframework.transaction.support.AbstractPlatformTransactionManager#doSetRollbackOnly(org.springframework.transaction.support.DefaultTransactionStatus)
+	 */
 	@Override
 	protected void doSetRollbackOnly(DefaultTransactionStatus status) throws TransactionException {
 
@@ -238,6 +270,10 @@ public class MongoTransactionManager extends AbstractPlatformTransactionManager
 		transactionObject.getRequiredResourceHolder().setRollbackOnly();
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * org.springframework.transaction.support.AbstractPlatformTransactionManager#doCleanupAfterCompletion(java.lang.Object)
+	 */
 	@Override
 	protected void doCleanupAfterCompletion(Object transaction) {
 
@@ -266,7 +302,7 @@ public class MongoTransactionManager extends AbstractPlatformTransactionManager
 	 */
 	public void setDbFactory(MongoDatabaseFactory dbFactory) {
 
-		Assert.notNull(dbFactory, "DbFactory must not be null");
+		Assert.notNull(dbFactory, "DbFactory must not be null!");
 		this.dbFactory = dbFactory;
 	}
 
@@ -289,11 +325,19 @@ public class MongoTransactionManager extends AbstractPlatformTransactionManager
 		return dbFactory;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.transaction.support.ResourceTransactionManager#getResourceFactory()
+	 */
 	@Override
 	public MongoDatabaseFactory getResourceFactory() {
 		return getRequiredDbFactory();
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
+	 */
 	@Override
 	public void afterPropertiesSet() {
 		getRequiredDbFactory();
@@ -315,7 +359,7 @@ public class MongoTransactionManager extends AbstractPlatformTransactionManager
 	private MongoDatabaseFactory getRequiredDbFactory() {
 
 		Assert.state(dbFactory != null,
-				"MongoTransactionManager operates upon a MongoDbFactory; Did you forget to provide one; It's required");
+				"MongoTransactionManager operates upon a MongoDbFactory. Did you forget to provide one? It's required.");
 
 		return dbFactory;
 	}
@@ -450,22 +494,30 @@ public class MongoTransactionManager extends AbstractPlatformTransactionManager
 
 		private MongoResourceHolder getRequiredResourceHolder() {
 
-			Assert.state(resourceHolder != null, "MongoResourceHolder is required but not present; o_O");
+			Assert.state(resourceHolder != null, "MongoResourceHolder is required but not present. o_O");
 			return resourceHolder;
 		}
 
 		private ClientSession getRequiredSession() {
 
 			ClientSession session = getSession();
-			Assert.state(session != null, "A Session is required but it turned out to be null");
+			Assert.state(session != null, "A Session is required but it turned out to be null.");
 			return session;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see  org.springframework.transaction.support.SmartTransactionObject#isRollbackOnly()
+		 */
 		@Override
 		public boolean isRollbackOnly() {
 			return this.resourceHolder != null && this.resourceHolder.isRollbackOnly();
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see  org.springframework.transaction.support.SmartTransactionObject#flush()
+		 */
 		@Override
 		public void flush() {
 			TransactionSynchronizationUtils.triggerFlush();

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

@@ -136,7 +136,7 @@ public class ReactiveMongoDatabaseUtils {
 	private static Mono<MongoDatabase> doGetMongoDatabase(@Nullable String dbName, ReactiveMongoDatabaseFactory factory,
 			SessionSynchronization sessionSynchronization) {
 
-		Assert.notNull(factory, "DatabaseFactory must not be null");
+		Assert.notNull(factory, "DatabaseFactory must not be null!");
 
 		if (sessionSynchronization == SessionSynchronization.NEVER) {
 			return getMongoDatabaseOrDefault(dbName, factory);
@@ -214,11 +214,19 @@ public class ReactiveMongoDatabaseUtils {
 			this.resourceHolder = resourceHolder;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.transaction.reactive.ReactiveResourceSynchronization#shouldReleaseBeforeCompletion()
+		 */
 		@Override
 		protected boolean shouldReleaseBeforeCompletion() {
 			return false;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.transaction.reactive.ReactiveResourceSynchronization#processResourceAfterCommit(java.lang.Object)
+		 */
 		@Override
 		protected Mono<Void> processResourceAfterCommit(ReactiveMongoResourceHolder resourceHolder) {
 
@@ -229,6 +237,10 @@ public class ReactiveMongoDatabaseUtils {
 			return Mono.empty();
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.transaction.reactive.ReactiveResourceSynchronization#afterCompletion(int)
+		 */
 		@Override
 		public Mono<Void> afterCompletion(int status) {
 
@@ -244,6 +256,10 @@ public class ReactiveMongoDatabaseUtils {
 			});
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.transaction.reactive.ReactiveResourceSynchronization#releaseResource(java.lang.Object, java.lang.Object)
+		 */
 		@Override
 		protected Mono<Void> releaseResource(ReactiveMongoResourceHolder resourceHolder, Object resourceKey) {
 

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

@@ -104,12 +104,16 @@ public class ReactiveMongoTransactionManager extends AbstractReactiveTransaction
 	public ReactiveMongoTransactionManager(ReactiveMongoDatabaseFactory databaseFactory,
 			@Nullable TransactionOptions options) {
 
-		Assert.notNull(databaseFactory, "DatabaseFactory must not be null");
+		Assert.notNull(databaseFactory, "DatabaseFactory must not be null!");
 
 		this.databaseFactory = databaseFactory;
 		this.options = options;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.transaction.reactive.AbstractReactiveTransactionManager#doGetTransaction(org.springframework.transaction.reactive.TransactionSynchronizationManager)
+	 */
 	@Override
 	protected Object doGetTransaction(TransactionSynchronizationManager synchronizationManager)
 			throws TransactionException {
@@ -119,11 +123,19 @@ public class ReactiveMongoTransactionManager extends AbstractReactiveTransaction
 		return new ReactiveMongoTransactionObject(resourceHolder);
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.transaction.reactive.AbstractReactiveTransactionManager#isExistingTransaction(java.lang.Object)
+	 */
 	@Override
 	protected boolean isExistingTransaction(Object transaction) throws TransactionException {
 		return extractMongoTransaction(transaction).hasResourceHolder();
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.transaction.reactive.AbstractReactiveTransactionManager#doBegin(org.springframework.transaction.reactive.TransactionSynchronizationManager, java.lang.Object, org.springframework.transaction.TransactionDefinition)
+	 */
 	@Override
 	protected Mono<Void> doBegin(TransactionSynchronizationManager synchronizationManager, Object transaction,
 			TransactionDefinition definition) throws TransactionException {
@@ -163,6 +175,10 @@ public class ReactiveMongoTransactionManager extends AbstractReactiveTransaction
 		});
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.transaction.reactive.AbstractReactiveTransactionManager#doSuspend(org.springframework.transaction.reactive.TransactionSynchronizationManager, java.lang.Object)
+	 */
 	@Override
 	protected Mono<Object> doSuspend(TransactionSynchronizationManager synchronizationManager, Object transaction)
 			throws TransactionException {
@@ -176,6 +192,10 @@ public class ReactiveMongoTransactionManager extends AbstractReactiveTransaction
 		});
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.transaction.reactive.AbstractReactiveTransactionManager#doResume(org.springframework.transaction.reactive.TransactionSynchronizationManager, java.lang.Object, java.lang.Object)
+	 */
 	@Override
 	protected Mono<Void> doResume(TransactionSynchronizationManager synchronizationManager, @Nullable Object transaction,
 			Object suspendedResources) {
@@ -183,6 +203,10 @@ public class ReactiveMongoTransactionManager extends AbstractReactiveTransaction
 				.fromRunnable(() -> synchronizationManager.bindResource(getRequiredDatabaseFactory(), suspendedResources));
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.transaction.reactive.AbstractReactiveTransactionManager#doCommit(org.springframework.transaction.reactive.TransactionSynchronizationManager, org.springframework.transaction.reactive.GenericReactiveTransaction)
+	 */
 	@Override
 	protected final Mono<Void> doCommit(TransactionSynchronizationManager synchronizationManager,
 			GenericReactiveTransaction status) throws TransactionException {
@@ -219,6 +243,10 @@ public class ReactiveMongoTransactionManager extends AbstractReactiveTransaction
 		return transactionObject.commitTransaction();
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.transaction.reactive.AbstractReactiveTransactionManager#doRollback(org.springframework.transaction.reactive.TransactionSynchronizationManager, org.springframework.transaction.reactive.GenericReactiveTransaction)
+	 */
 	@Override
 	protected Mono<Void> doRollback(TransactionSynchronizationManager synchronizationManager,
 			GenericReactiveTransaction status) {
@@ -240,6 +268,10 @@ public class ReactiveMongoTransactionManager extends AbstractReactiveTransaction
 		});
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.transaction.reactive.AbstractReactiveTransactionManager#doSetRollbackOnly(org.springframework.transaction.reactive.TransactionSynchronizationManager, org.springframework.transaction.reactive.GenericReactiveTransaction)
+	 */
 	@Override
 	protected Mono<Void> doSetRollbackOnly(TransactionSynchronizationManager synchronizationManager,
 			GenericReactiveTransaction status) throws TransactionException {
@@ -250,6 +282,10 @@ public class ReactiveMongoTransactionManager extends AbstractReactiveTransaction
 		});
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.transaction.reactive.AbstractReactiveTransactionManager#doCleanupAfterCompletion(org.springframework.transaction.reactive.TransactionSynchronizationManager, java.lang.Object)
+	 */
 	@Override
 	protected Mono<Void> doCleanupAfterCompletion(TransactionSynchronizationManager synchronizationManager,
 			Object transaction) {
@@ -281,7 +317,7 @@ public class ReactiveMongoTransactionManager extends AbstractReactiveTransaction
 	 */
 	public void setDatabaseFactory(ReactiveMongoDatabaseFactory databaseFactory) {
 
-		Assert.notNull(databaseFactory, "DatabaseFactory must not be null");
+		Assert.notNull(databaseFactory, "DatabaseFactory must not be null!");
 		this.databaseFactory = databaseFactory;
 	}
 
@@ -304,6 +340,10 @@ public class ReactiveMongoTransactionManager extends AbstractReactiveTransaction
 		return databaseFactory;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet()
+	 */
 	@Override
 	public void afterPropertiesSet() {
 		getRequiredDatabaseFactory();
@@ -323,7 +363,7 @@ public class ReactiveMongoTransactionManager extends AbstractReactiveTransaction
 	private ReactiveMongoDatabaseFactory getRequiredDatabaseFactory() {
 
 		Assert.state(databaseFactory != null,
-				"ReactiveMongoTransactionManager operates upon a ReactiveMongoDatabaseFactory; Did you forget to provide one; It's required");
+				"ReactiveMongoTransactionManager operates upon a ReactiveMongoDatabaseFactory. Did you forget to provide one? It's required.");
 
 		return databaseFactory;
 	}
@@ -458,22 +498,30 @@ public class ReactiveMongoTransactionManager extends AbstractReactiveTransaction
 
 		private ReactiveMongoResourceHolder getRequiredResourceHolder() {
 
-			Assert.state(resourceHolder != null, "ReactiveMongoResourceHolder is required but not present; o_O");
+			Assert.state(resourceHolder != null, "ReactiveMongoResourceHolder is required but not present. o_O");
 			return resourceHolder;
 		}
 
 		private ClientSession getRequiredSession() {
 
 			ClientSession session = getSession();
-			Assert.state(session != null, "A Session is required but it turned out to be null");
+			Assert.state(session != null, "A Session is required but it turned out to be null.");
 			return session;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.transaction.support.SmartTransactionObject#isRollbackOnly()
+		 */
 		@Override
 		public boolean isRollbackOnly() {
 			return this.resourceHolder != null && this.resourceHolder.isRollbackOnly();
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.transaction.support.SmartTransactionObject#flush()
+		 */
 		@Override
 		public void flush() {
 			throw new UnsupportedOperationException("flush() not supported");

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

@@ -76,13 +76,13 @@ public class SessionAwareMethodInterceptor<D, C> implements MethodInterceptor {
 			Class<D> databaseType, ClientSessionOperator<D> databaseDecorator, Class<C> collectionType,
 			ClientSessionOperator<C> collectionDecorator) {
 
-		Assert.notNull(session, "ClientSession must not be null");
-		Assert.notNull(target, "Target must not be null");
-		Assert.notNull(sessionType, "SessionType must not be null");
-		Assert.notNull(databaseType, "Database type must not be null");
-		Assert.notNull(databaseDecorator, "Database ClientSessionOperator must not be null");
-		Assert.notNull(collectionType, "Collection type must not be null");
-		Assert.notNull(collectionDecorator, "Collection ClientSessionOperator must not be null");
+		Assert.notNull(session, "ClientSession must not be null!");
+		Assert.notNull(target, "Target must not be null!");
+		Assert.notNull(sessionType, "SessionType must not be null!");
+		Assert.notNull(databaseType, "Database type must not be null!");
+		Assert.notNull(databaseDecorator, "Database ClientSessionOperator must not be null!");
+		Assert.notNull(collectionType, "Collection type must not be null!");
+		Assert.notNull(collectionDecorator, "Collection ClientSessionOperator must not be null!");
 
 		this.session = session;
 		this.target = target;
@@ -95,6 +95,10 @@ public class SessionAwareMethodInterceptor<D, C> implements MethodInterceptor {
 		this.sessionType = sessionType;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.aopalliance.intercept.MethodInterceptor(org.aopalliance.intercept.MethodInvocation)
+	 */
 	@Nullable
 	@Override
 	public Object invoke(MethodInvocation methodInvocation) throws Throwable {

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

@@ -15,8 +15,8 @@
  */
 package org.springframework.data.mongodb;
 
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.data.util.Version;
 import org.springframework.util.StringUtils;
 
@@ -31,7 +31,7 @@ import com.mongodb.MongoDriverInformation;
  */
 public class SpringDataMongoDB {
 
-	private static final Log LOGGER = LogFactory.getLog(SpringDataMongoDB.class);
+	private static final Logger LOGGER = LoggerFactory.getLogger(SpringDataMongoDB.class);
 
 	private static final Version FALLBACK_VERSION = new Version(3);
 	private static final MongoDriverInformation DRIVER_INFORMATION = MongoDriverInformation
@@ -68,7 +68,7 @@ public class SpringDataMongoDB {
 		try {
 			return Version.parse(versionString);
 		} catch (Exception e) {
-			LOGGER.debug(String.format("Cannot read Spring Data MongoDB version '%s'.", versionString));
+			LOGGER.debug("Cannot read Spring Data MongoDB version '{}'.", versionString);
 		}
 
 		return FALLBACK_VERSION;

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/aot/LazyLoadingProxyAotProcessor.java

@@ -1,110 +0,0 @@
-/*
- * Copyright 2022 the original author 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
- *
- *      https://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.aot;
-
-import java.lang.annotation.Annotation;
-import java.lang.reflect.Field;
-import java.util.ArrayList;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Set;
-
-import org.springframework.aot.generate.GenerationContext;
-import org.springframework.aot.hint.MemberCategory;
-import org.springframework.aot.hint.TypeReference;
-import org.springframework.core.ResolvableType;
-import org.springframework.core.annotation.AnnotatedElementUtils;
-import org.springframework.core.annotation.MergedAnnotations;
-import org.springframework.data.annotation.Reference;
-import org.springframework.data.mongodb.core.convert.LazyLoadingProxyFactory;
-import org.springframework.data.mongodb.core.convert.LazyLoadingProxyFactory.LazyLoadingInterceptor;
-import org.springframework.data.mongodb.core.mapping.DBRef;
-import org.springframework.data.mongodb.core.mapping.DocumentReference;
-import org.springframework.data.util.TypeUtils;
-
-/**
- * @author Christoph Strobl
- * @since 4.0
- */
-public class LazyLoadingProxyAotProcessor {
-
-	private boolean generalLazyLoadingProxyContributed = false;
-
-	public void registerLazyLoadingProxyIfNeeded(Class<?> type, GenerationContext generationContext) {
-
-		Set<Field> refFields = getFieldsWithAnnotationPresent(type, Reference.class);
-		if (refFields.isEmpty()) {
-			return;
-		}
-
-		refFields.stream() //
-				.filter(LazyLoadingProxyAotProcessor::isLazyLoading) //
-				.forEach(field -> {
-
-					if (!generalLazyLoadingProxyContributed) {
-						generationContext.getRuntimeHints().proxies().registerJdkProxy(
-								TypeReference.of(org.springframework.data.mongodb.core.convert.LazyLoadingProxy.class),
-								TypeReference.of(org.springframework.aop.SpringProxy.class),
-								TypeReference.of(org.springframework.aop.framework.Advised.class),
-								TypeReference.of(org.springframework.core.DecoratingProxy.class));
-						generalLazyLoadingProxyContributed = true;
-					}
-
-					if (field.getType().isInterface()) {
-
-						List<Class<?>> interfaces = new ArrayList<>(
-								TypeUtils.resolveTypesInSignature(ResolvableType.forField(field, type)));
-
-						interfaces.add(0, org.springframework.data.mongodb.core.convert.LazyLoadingProxy.class);
-						interfaces.add(org.springframework.aop.SpringProxy.class);
-						interfaces.add(org.springframework.aop.framework.Advised.class);
-						interfaces.add(org.springframework.core.DecoratingProxy.class);
-
-						generationContext.getRuntimeHints().proxies().registerJdkProxy(interfaces.toArray(Class[]::new));
-					} else {
-
-						Class<?> proxyClass = LazyLoadingProxyFactory.resolveProxyType(field.getType(),
-								() -> LazyLoadingInterceptor.none());
-
-						// see: spring-projects/spring-framework/issues/29309
-						generationContext.getRuntimeHints().reflection().registerType(proxyClass,
-								MemberCategory.INVOKE_DECLARED_CONSTRUCTORS, MemberCategory.INVOKE_DECLARED_METHODS, MemberCategory.DECLARED_FIELDS);
-					}
-				});
-	}
-
-	private static boolean isLazyLoading(Field field) {
-		if (AnnotatedElementUtils.isAnnotated(field, DBRef.class)) {
-			return AnnotatedElementUtils.findMergedAnnotation(field, DBRef.class).lazy();
-		}
-		if (AnnotatedElementUtils.isAnnotated(field, DocumentReference.class)) {
-			return AnnotatedElementUtils.findMergedAnnotation(field, DocumentReference.class).lazy();
-		}
-		return false;
-	}
-
-	private static Set<Field> getFieldsWithAnnotationPresent(Class<?> type, Class<? extends Annotation> annotation) {
-
-		Set<Field> fields = new LinkedHashSet<>();
-		for (Field field : type.getDeclaredFields()) {
-			if (MergedAnnotations.from(field).get(annotation).isPresent()) {
-				fields.add(field);
-			}
-		}
-		return fields;
-	}
-
-}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/aot/MongoAotPredicates.java

@@ -1,45 +0,0 @@
-/*
- * Copyright 2022 the original author 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
- *
- *      https://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.aot;
-
-import java.util.function.Predicate;
-
-import org.springframework.data.mongodb.core.mapping.MongoSimpleTypes;
-import org.springframework.data.util.ReactiveWrappers;
-import org.springframework.data.util.ReactiveWrappers.ReactiveLibrary;
-import org.springframework.data.util.TypeUtils;
-import org.springframework.lang.Nullable;
-import org.springframework.util.ClassUtils;
-
-/**
- * @author Christoph Strobl
- * @since 4.0
- */
-public class MongoAotPredicates {
-
-	public static final Predicate<Class<?>> IS_SIMPLE_TYPE = (type) ->  MongoSimpleTypes.HOLDER.isSimpleType(type) || TypeUtils.type(type).isPartOf("org.bson");
-	public static final Predicate<ReactiveLibrary> IS_REACTIVE_LIBARARY_AVAILABLE = (lib) -> ReactiveWrappers.isAvailable(lib);
-	public static final Predicate<ClassLoader> IS_SYNC_CLIENT_PRESENT = (classLoader) -> ClassUtils.isPresent("com.mongodb.client.MongoClient", classLoader);
-
-	public static boolean isReactorPresent() {
-		return IS_REACTIVE_LIBARARY_AVAILABLE.test(ReactiveWrappers.ReactiveLibrary.PROJECT_REACTOR);
-	}
-
-	public static boolean isSyncClientPresent(@Nullable ClassLoader classLoader) {
-		return IS_SYNC_CLIENT_PRESENT.test(classLoader);
-	}
-
-}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/aot/MongoManagedTypesBeanRegistrationAotProcessor.java

@@ -1,56 +0,0 @@
-/*
- * Copyright 2022 the original author 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
- *
- *      https://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.aot;
-
-import org.springframework.aot.generate.GenerationContext;
-import org.springframework.core.ResolvableType;
-import org.springframework.data.aot.ManagedTypesBeanRegistrationAotProcessor;
-import org.springframework.data.mongodb.MongoManagedTypes;
-import org.springframework.lang.Nullable;
-import org.springframework.util.ClassUtils;
-
-/**
- * @author Christoph Strobl
- * @since 2022/06
- */
-class MongoManagedTypesBeanRegistrationAotProcessor extends ManagedTypesBeanRegistrationAotProcessor {
-
-	private final LazyLoadingProxyAotProcessor lazyLoadingProxyAotProcessor = new LazyLoadingProxyAotProcessor();
-
-	public MongoManagedTypesBeanRegistrationAotProcessor() {
-		setModuleIdentifier("mongo");
-	}
-
-	@Override
-	protected boolean isMatch(@Nullable Class<?> beanType, @Nullable String beanName) {
-		return isMongoManagedTypes(beanType) || super.isMatch(beanType, beanName);
-	}
-
-	protected boolean isMongoManagedTypes(@Nullable Class<?> beanType) {
-		return beanType != null && ClassUtils.isAssignable(MongoManagedTypes.class, beanType);
-	}
-
-	@Override
-	protected void contributeType(ResolvableType type, GenerationContext generationContext) {
-
-		if (MongoAotPredicates.IS_SIMPLE_TYPE.test(type.toClass())) {
-			return;
-		}
-
-		super.contributeType(type, generationContext);
-		lazyLoadingProxyAotProcessor.registerLazyLoadingProxyIfNeeded(type.toClass(), generationContext);
-	}
-}

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/aot/MongoRuntimeHints.java

@@ -1,81 +0,0 @@
-/*
- * Copyright 2022 the original author 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
- *
- *      https://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.aot;
-
-import static org.springframework.data.mongodb.aot.MongoAotPredicates.*;
-
-import java.util.Arrays;
-
-import org.springframework.aot.hint.MemberCategory;
-import org.springframework.aot.hint.RuntimeHints;
-import org.springframework.aot.hint.RuntimeHintsRegistrar;
-import org.springframework.aot.hint.TypeReference;
-import org.springframework.data.mongodb.core.mapping.event.AfterConvertCallback;
-import org.springframework.data.mongodb.core.mapping.event.AfterSaveCallback;
-import org.springframework.data.mongodb.core.mapping.event.BeforeConvertCallback;
-import org.springframework.data.mongodb.core.mapping.event.BeforeSaveCallback;
-import org.springframework.data.mongodb.core.mapping.event.ReactiveAfterConvertCallback;
-import org.springframework.data.mongodb.core.mapping.event.ReactiveAfterSaveCallback;
-import org.springframework.data.mongodb.core.mapping.event.ReactiveBeforeConvertCallback;
-import org.springframework.data.mongodb.core.mapping.event.ReactiveBeforeSaveCallback;
-import org.springframework.lang.Nullable;
-import org.springframework.util.ClassUtils;
-
-/**
- * {@link RuntimeHintsRegistrar} for repository types and entity callbacks.
- *
- * @author Christoph Strobl
- * @author Mark Paluch
- * @since 4.0
- */
-class MongoRuntimeHints implements RuntimeHintsRegistrar {
-
-	@Override
-	public void registerHints(RuntimeHints hints, @Nullable ClassLoader classLoader) {
-
-		hints.reflection().registerTypes(
-				Arrays.asList(TypeReference.of(BeforeConvertCallback.class), TypeReference.of(BeforeSaveCallback.class),
-						TypeReference.of(AfterConvertCallback.class), TypeReference.of(AfterSaveCallback.class)),
-				builder -> builder.withMembers(MemberCategory.INVOKE_DECLARED_CONSTRUCTORS,
-						MemberCategory.INVOKE_PUBLIC_METHODS));
-
-		registerTransactionProxyHints(hints, classLoader);
-
-		if (isReactorPresent()) {
-
-			hints.reflection()
-					.registerTypes(Arrays.asList(TypeReference.of(ReactiveBeforeConvertCallback.class),
-							TypeReference.of(ReactiveBeforeSaveCallback.class), TypeReference.of(ReactiveAfterConvertCallback.class),
-							TypeReference.of(ReactiveAfterSaveCallback.class)),
-							builder -> builder.withMembers(MemberCategory.INVOKE_DECLARED_CONSTRUCTORS,
-									MemberCategory.INVOKE_PUBLIC_METHODS));
-
-		}
-	}
-
-	private static void registerTransactionProxyHints(RuntimeHints hints, @Nullable ClassLoader classLoader) {
-
-		if (MongoAotPredicates.isSyncClientPresent(classLoader) && ClassUtils.isPresent("org.springframework.aop.SpringProxy", classLoader)) {
-
-			hints.proxies().registerJdkProxy(TypeReference.of("com.mongodb.client.MongoDatabase"),
-					TypeReference.of("org.springframework.aop.SpringProxy"),
-					TypeReference.of("org.springframework.core.DecoratingProxy"));
-			hints.proxies().registerJdkProxy(TypeReference.of("com.mongodb.client.MongoCollection"),
-					TypeReference.of("org.springframework.aop.SpringProxy"),
-					TypeReference.of("org.springframework.core.DecoratingProxy"));
-		}
-	}
-}

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

@@ -25,7 +25,9 @@ import org.springframework.data.mongodb.core.convert.DbRefResolver;
 import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver;
 import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
 import org.springframework.data.mongodb.core.convert.MongoCustomConversions;
+import org.springframework.data.mongodb.core.mapping.Document;
 import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
+import org.springframework.lang.Nullable;
 
 import com.mongodb.MongoClientSettings;
 import com.mongodb.MongoClientSettings.Builder;
@@ -78,12 +80,30 @@ public abstract class AbstractMongoClientConfiguration extends MongoConfiguratio
 		return new SimpleMongoClientDatabaseFactory(mongoClient(), getDatabaseName());
 	}
 
+	/**
+	 * Return the base package to scan for mapped {@link Document}s. Will return the package name of the configuration
+	 * class' (the concrete class, not this one here) by default. So if you have a {@code com.acme.AppConfig} extending
+	 * {@link AbstractMongoClientConfiguration} the base package will be considered {@code com.acme} unless the method is
+	 * overridden to implement alternate behavior.
+	 *
+	 * @return the base package to scan for mapped {@link Document} classes or {@literal null} to not enable scanning for
+	 *         entities.
+	 * @deprecated use {@link #getMappingBasePackages()} instead.
+	 */
+	@Deprecated
+	@Nullable
+	protected String getMappingBasePackage() {
+
+		Package mappingBasePackage = getClass().getPackage();
+		return mappingBasePackage == null ? null : mappingBasePackage.getName();
+	}
+
 	/**
 	 * Creates a {@link MappingMongoConverter} using the configured {@link #mongoDbFactory()} and
-	 * {@link #mongoMappingContext(MongoCustomConversions, org.springframework.data.mongodb.MongoManagedTypes)}. Will get {@link #customConversions()} applied.
+	 * {@link #mongoMappingContext(MongoCustomConversions)}. Will get {@link #customConversions()} applied.
 	 *
 	 * @see #customConversions()
-	 * @see #mongoMappingContext(MongoCustomConversions, org.springframework.data.mongodb.MongoManagedTypes)
+	 * @see #mongoMappingContext(MongoCustomConversions)
 	 * @see #mongoDbFactory()
 	 */
 	@Bean

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

@@ -84,10 +84,10 @@ public abstract class AbstractReactiveMongoConfiguration extends MongoConfigurat
 
 	/**
 	 * Creates a {@link MappingMongoConverter} using the configured {@link #reactiveMongoDbFactory()} and
-	 * {@link #mongoMappingContext(MongoCustomConversions, org.springframework.data.mongodb.MongoManagedTypes)}. Will get {@link #customConversions()} applied.
+	 * {@link #mongoMappingContext(MongoCustomConversions)}. Will get {@link #customConversions()} applied.
 	 *
 	 * @see #customConversions()
-	 * @see #mongoMappingContext(MongoCustomConversions, org.springframework.data.mongodb.MongoManagedTypes)
+	 * @see #mongoMappingContext(MongoCustomConversions)
 	 * @see #reactiveMongoDbFactory()
 	 * @return never {@literal null}.
 	 */

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

@@ -30,6 +30,10 @@ import com.mongodb.ConnectionString;
  */
 public class ConnectionStringPropertyEditor extends PropertyEditorSupport {
 
+	/*
+	 * (non-Javadoc)
+	 * @see java.beans.PropertyEditorSupport#setAsText(java.lang.String)
+	 */
 	@Override
 	public void setAsText(@Nullable String connectionString) {
 

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

@@ -34,6 +34,10 @@ import org.w3c.dom.Element;
  */
 class GridFsTemplateParser extends AbstractBeanDefinitionParser {
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.xml.AbstractBeanDefinitionParser#resolveId(org.w3c.dom.Element, org.springframework.beans.factory.support.AbstractBeanDefinition, org.springframework.beans.factory.xml.ParserContext)
+	 */
 	@Override
 	protected String resolveId(Element element, AbstractBeanDefinition definition, ParserContext parserContext)
 			throws BeanDefinitionStoreException {
@@ -42,6 +46,10 @@ class GridFsTemplateParser extends AbstractBeanDefinitionParser {
 		return StringUtils.hasText(id) ? id : BeanNames.GRID_FS_TEMPLATE_BEAN_NAME;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.xml.AbstractBeanDefinitionParser#parseInternal(org.w3c.dom.Element, org.springframework.beans.factory.xml.ParserContext)
+	 */
 	@Override
 	protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
 

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

@@ -80,7 +80,7 @@ import org.w3c.dom.Element;
 public class MappingMongoConverterParser implements BeanDefinitionParser {
 
 	private static final String BASE_PACKAGE = "base-package";
-	private static final boolean JSR_303_PRESENT = ClassUtils.isPresent("jakarta.validation.Validator",
+	private static final boolean JSR_303_PRESENT = ClassUtils.isPresent("javax.validation.Validator",
 			MappingMongoConverterParser.class.getClassLoader());
 
 	/* (non-Javadoc)
@@ -253,7 +253,7 @@ public class MappingMongoConverterParser implements BeanDefinitionParser {
 				&& Boolean.parseBoolean(abbreviateFieldNames);
 
 		if (fieldNamingStrategyReferenced && abbreviationActivated) {
-			context.error("Field name abbreviation cannot be activated if a field-naming-strategy-ref is configured",
+			context.error("Field name abbreviation cannot be activated if a field-naming-strategy-ref is configured!",
 					element);
 			return;
 		}
@@ -374,6 +374,10 @@ public class MappingMongoConverterParser implements BeanDefinitionParser {
 			this.delegates = new HashSet<>(Arrays.asList(filters));
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.core.type.filter.TypeFilter#match(org.springframework.core.type.classreading.MetadataReader, org.springframework.core.type.classreading.MetadataReaderFactory)
+		 */
 		public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
 				throws IOException {
 

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

@@ -47,16 +47,28 @@ public class MongoAuditingBeanDefinitionParser extends AbstractSingleBeanDefinit
 	private static boolean PROJECT_REACTOR_AVAILABLE = ClassUtils.isPresent("reactor.core.publisher.Mono",
 			MongoAuditingRegistrar.class.getClassLoader());
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser#getBeanClass(org.w3c.dom.Element)
+	 */
 	@Override
 	protected Class<?> getBeanClass(Element element) {
 		return AuditingEntityCallback.class;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.xml.AbstractBeanDefinitionParser#shouldGenerateId()
+	 */
 	@Override
 	protected boolean shouldGenerateId() {
 		return true;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser#doParse(org.w3c.dom.Element, org.springframework.beans.factory.xml.ParserContext, org.springframework.beans.factory.support.BeanDefinitionBuilder)
+	 */
 	@Override
 	protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
 

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

@@ -18,10 +18,11 @@ package org.springframework.data.mongodb.config;
 import java.lang.annotation.Annotation;
 
 import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.support.AbstractBeanDefinition;
 import org.springframework.beans.factory.support.BeanDefinitionBuilder;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
-import org.springframework.core.Ordered;
+import org.springframework.core.type.AnnotationMetadata;
 import org.springframework.data.auditing.IsNewAwareAuditingHandler;
 import org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport;
 import org.springframework.data.auditing.config.AuditingConfiguration;
@@ -35,42 +36,68 @@ import org.springframework.util.Assert;
  * @author Thomas Darimont
  * @author Oliver Gierke
  * @author Mark Paluch
- * @author Christoph Strobl
  */
-class MongoAuditingRegistrar extends AuditingBeanDefinitionRegistrarSupport implements Ordered {
+class MongoAuditingRegistrar extends AuditingBeanDefinitionRegistrarSupport {
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport#getAnnotation()
+	 */
 	@Override
 	protected Class<? extends Annotation> getAnnotation() {
 		return EnableMongoAuditing.class;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport#getAuditingHandlerBeanName()
+	 */
 	@Override
 	protected String getAuditingHandlerBeanName() {
 		return "mongoAuditingHandler";
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport#registerBeanDefinitions(org.springframework.core.type.AnnotationMetadata, org.springframework.beans.factory.support.BeanDefinitionRegistry)
+	 */
 	@Override
-	protected void postProcess(BeanDefinitionBuilder builder, AuditingConfiguration configuration,
-			BeanDefinitionRegistry registry) {
+	public void registerBeanDefinitions(AnnotationMetadata annotationMetadata, BeanDefinitionRegistry registry) {
 
-		builder.setFactoryMethod("from").addConstructorArgReference("mongoMappingContext");
+		Assert.notNull(annotationMetadata, "AnnotationMetadata must not be null!");
+		Assert.notNull(registry, "BeanDefinitionRegistry must not be null!");
+
+		super.registerBeanDefinitions(annotationMetadata, registry);
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport#getAuditHandlerBeanDefinitionBuilder(org.springframework.data.auditing.config.AuditingConfiguration)
+	 */
 	@Override
 	protected BeanDefinitionBuilder getAuditHandlerBeanDefinitionBuilder(AuditingConfiguration configuration) {
 
-		Assert.notNull(configuration, "AuditingConfiguration must not be null");
+		Assert.notNull(configuration, "AuditingConfiguration must not be null!");
 
-		return configureDefaultAuditHandlerAttributes(configuration,
-				BeanDefinitionBuilder.rootBeanDefinition(IsNewAwareAuditingHandler.class));
+		BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(IsNewAwareAuditingHandler.class);
+
+		BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(PersistentEntitiesFactoryBean.class);
+		definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
+
+		builder.addConstructorArgValue(definition.getBeanDefinition());
+		return configureDefaultAuditHandlerAttributes(configuration, builder);
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport#registerAuditListener(org.springframework.beans.factory.config.BeanDefinition, org.springframework.beans.factory.support.BeanDefinitionRegistry)
+	 */
 	@Override
 	protected void registerAuditListenerBeanDefinition(BeanDefinition auditingHandlerDefinition,
 			BeanDefinitionRegistry registry) {
 
-		Assert.notNull(auditingHandlerDefinition, "BeanDefinition must not be null");
-		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
+		Assert.notNull(auditingHandlerDefinition, "BeanDefinition must not be null!");
+		Assert.notNull(registry, "BeanDefinitionRegistry must not be null!");
 
 		BeanDefinitionBuilder listenerBeanDefinitionBuilder = BeanDefinitionBuilder
 				.rootBeanDefinition(AuditingEntityCallback.class);
@@ -81,8 +108,4 @@ class MongoAuditingRegistrar extends AuditingBeanDefinitionRegistrarSupport impl
 				AuditingEntityCallback.class.getName(), registry);
 	}
 
-	@Override
-	public int getOrder() {
-		return Ordered.LOWEST_PRECEDENCE;
-	}
 }

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

@@ -35,6 +35,10 @@ import org.w3c.dom.Element;
  */
 public class MongoClientParser implements BeanDefinitionParser {
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.xml.BeanDefinitionParser#parse(org.w3c.dom.Element, org.springframework.beans.factory.xml.ParserContext)
+	 */
 	public BeanDefinition parse(Element element, ParserContext parserContext) {
 
 		Object source = parserContext.extractSource(element);

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

@@ -30,7 +30,6 @@ import org.springframework.data.convert.CustomConversions;
 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.MongoManagedTypes;
 import org.springframework.data.mongodb.core.convert.MongoCustomConversions;
 import org.springframework.data.mongodb.core.convert.MongoCustomConversions.MongoConverterConfigurationAdapter;
 import org.springframework.data.mongodb.core.mapping.Document;
@@ -77,13 +76,14 @@ public abstract class MongoConfigurationSupport {
 	 *
 	 * @see #getMappingBasePackages()
 	 * @return
+	 * @throws ClassNotFoundException
 	 */
 	@Bean
-	public MongoMappingContext mongoMappingContext(MongoCustomConversions customConversions,
-			MongoManagedTypes mongoManagedTypes) {
+	public MongoMappingContext mongoMappingContext(MongoCustomConversions customConversions)
+			throws ClassNotFoundException {
 
 		MongoMappingContext mappingContext = new MongoMappingContext();
-		mappingContext.setManagedTypes(mongoManagedTypes);
+		mappingContext.setInitialEntitySet(getInitialEntitySet());
 		mappingContext.setSimpleTypeHolder(customConversions.getSimpleTypeHolder());
 		mappingContext.setFieldNamingStrategy(fieldNamingStrategy());
 		mappingContext.setAutoIndexCreation(autoIndexCreation());
@@ -91,16 +91,6 @@ public abstract class MongoConfigurationSupport {
 		return mappingContext;
 	}
 
-	/**
-	 * @return new instance of {@link MongoManagedTypes}.
-	 * @throws ClassNotFoundException
-	 * @since 4.0
-	 */
-	@Bean
-	public MongoManagedTypes mongoManagedTypes() throws ClassNotFoundException {
-		return MongoManagedTypes.fromIterable(getInitialEntitySet());
-	}
-
 	/**
 	 * Register custom {@link Converter}s in a {@link CustomConversions} object if required. These
 	 * {@link CustomConversions} will be registered with the

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

@@ -51,6 +51,10 @@ public class MongoCredentialPropertyEditor extends PropertyEditorSupport {
 	private static final String OPTIONS_DELIMITER = "?";
 	private static final String OPTION_VALUE_DELIMITER = "&";
 
+	/*
+	 * (non-Javadoc)
+	 * @see java.beans.PropertyEditorSupport#setAsText(java.lang.String)
+	 */
 	@Override
 	public void setAsText(@Nullable String text) throws IllegalArgumentException {
 
@@ -117,7 +121,7 @@ public class MongoCredentialPropertyEditor extends PropertyEditorSupport {
 								userNameAndPassword[1].toCharArray()));
 					} else {
 						throw new IllegalArgumentException(
-								String.format("Cannot create MongoCredentials for unknown auth mechanism '%s'", authMechanism));
+								String.format("Cannot create MongoCredentials for unknown auth mechanism '%s'!", authMechanism));
 					}
 				}
 			} else {
@@ -194,7 +198,7 @@ public class MongoCredentialPropertyEditor extends PropertyEditorSupport {
 			String[] optionArgs = option.split("=");
 
 			if (optionArgs.length == 1) {
-				throw new IllegalArgumentException(String.format("Query parameter '%s' has no value", optionArgs[0]));
+				throw new IllegalArgumentException(String.format("Query parameter '%s' has no value!", optionArgs[0]));
 			}
 
 			properties.put(optionArgs[0], optionArgs[1]);
@@ -209,21 +213,21 @@ public class MongoCredentialPropertyEditor extends PropertyEditorSupport {
 
 		if (source.length != 2) {
 			throw new IllegalArgumentException(
-					"Credentials need to specify username and password like in 'username:password@database'");
+					"Credentials need to specify username and password like in 'username:password@database'!");
 		}
 	}
 
 	private static void verifyDatabasePresent(String source) {
 
 		if (!StringUtils.hasText(source)) {
-			throw new IllegalArgumentException("Credentials need to specify database like in 'username:password@database'");
+			throw new IllegalArgumentException("Credentials need to specify database like in 'username:password@database'!");
 		}
 	}
 
 	private static void verifyUserNamePresent(String[] source) {
 
 		if (source.length == 0 || !StringUtils.hasText(source[0])) {
-			throw new IllegalArgumentException("Credentials need to specify username");
+			throw new IllegalArgumentException("Credentials need to specify username!");
 		}
 	}
 
@@ -231,7 +235,7 @@ public class MongoCredentialPropertyEditor extends PropertyEditorSupport {
 		try {
 			return URLDecoder.decode(it, "UTF-8");
 		} catch (UnsupportedEncodingException e) {
-			throw new IllegalArgumentException("o_O UTF-8 not supported", e);
+			throw new IllegalArgumentException("o_O UTF-8 not supported!", e);
 		}
 	}
 }

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

@@ -62,6 +62,10 @@ public class MongoDbFactoryParser extends AbstractBeanDefinitionParser {
 		MONGO_URI_ALLOWED_ADDITIONAL_ATTRIBUTES = Collections.unmodifiableSet(mongoUriAllowedAdditionalAttributes);
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.xml.AbstractBeanDefinitionParser#resolveId(org.w3c.dom.Element, org.springframework.beans.factory.support.AbstractBeanDefinition, org.springframework.beans.factory.xml.ParserContext)
+	 */
 	@Override
 	protected String resolveId(Element element, AbstractBeanDefinition definition, ParserContext parserContext)
 			throws BeanDefinitionStoreException {
@@ -70,6 +74,10 @@ public class MongoDbFactoryParser extends AbstractBeanDefinitionParser {
 		return StringUtils.hasText(id) ? id : BeanNames.DB_FACTORY_BEAN_NAME;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.xml.AbstractBeanDefinitionParser#parseInternal(org.w3c.dom.Element, org.springframework.beans.factory.xml.ParserContext)
+	 */
 	@Override
 	protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
 
@@ -163,7 +171,7 @@ public class MongoDbFactoryParser extends AbstractBeanDefinitionParser {
 
 		if (element.getAttributes().getLength() > allowedAttributesCount) {
 
-			parserContext.getReaderContext().error("Configure either MongoDB " + type + " or details individually",
+			parserContext.getReaderContext().error("Configure either MongoDB " + type + " or details individually!",
 					parserContext.extractSource(element));
 		}
 

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

@@ -26,6 +26,10 @@ import org.springframework.beans.factory.xml.NamespaceHandlerSupport;
  */
 public class MongoNamespaceHandler extends NamespaceHandlerSupport {
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.xml.NamespaceHandler#init()
+	 */
 	public void init() {
 
 		registerBeanDefinitionParser("mapping-converter", new MappingMongoConverterParser());

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

@@ -40,6 +40,7 @@ import org.w3c.dom.Element;
  * @author Christoph Strobl
  * @author Mark Paluch
  */
+@SuppressWarnings("deprecation")
 abstract class MongoParsingUtils {
 
 	private MongoParsingUtils() {}

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

@@ -39,6 +39,10 @@ import org.w3c.dom.Element;
  */
 class MongoTemplateParser extends AbstractBeanDefinitionParser {
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.xml.AbstractBeanDefinitionParser#resolveId(org.w3c.dom.Element, org.springframework.beans.factory.support.AbstractBeanDefinition, org.springframework.beans.factory.xml.ParserContext)
+	 */
 	@Override
 	protected String resolveId(Element element, AbstractBeanDefinition definition, ParserContext parserContext)
 			throws BeanDefinitionStoreException {
@@ -47,6 +51,10 @@ class MongoTemplateParser extends AbstractBeanDefinitionParser {
 		return StringUtils.hasText(id) ? id : BeanNames.MONGO_TEMPLATE_BEAN_NAME;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.xml.AbstractBeanDefinitionParser#parseInternal(org.w3c.dom.Element, org.springframework.beans.factory.xml.ParserContext)
+	 */
 	@Override
 	protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
 

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

@@ -41,11 +41,19 @@ public class PersistentEntitiesFactoryBean implements FactoryBean<PersistentEnti
 		this.converter = converter;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.FactoryBean#getObject()
+	 */
 	@Override
 	public PersistentEntities getObject() {
 		return PersistentEntities.of(converter.getMappingContext());
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.FactoryBean#getObjectType()
+	 */
 	@Override
 	public Class<?> getObjectType() {
 		return PersistentEntities.class;

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

@@ -18,9 +18,11 @@ package org.springframework.data.mongodb.config;
 import java.lang.annotation.Annotation;
 
 import org.springframework.beans.factory.config.BeanDefinition;
+import org.springframework.beans.factory.support.AbstractBeanDefinition;
 import org.springframework.beans.factory.support.BeanDefinitionBuilder;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.context.annotation.ImportBeanDefinitionRegistrar;
+import org.springframework.core.type.AnnotationMetadata;
 import org.springframework.data.auditing.ReactiveIsNewAwareAuditingHandler;
 import org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport;
 import org.springframework.data.auditing.config.AuditingConfiguration;
@@ -32,42 +34,56 @@ import org.springframework.util.Assert;
  * {@link ImportBeanDefinitionRegistrar} to enable {@link EnableReactiveMongoAuditing} annotation.
  *
  * @author Mark Paluch
- * @author Christoph Strobl
  * @since 3.1
  */
 class ReactiveMongoAuditingRegistrar extends AuditingBeanDefinitionRegistrarSupport {
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport#getAnnotation()
+	 */
 	@Override
 	protected Class<? extends Annotation> getAnnotation() {
 		return EnableReactiveMongoAuditing.class;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport#getAuditingHandlerBeanName()
+	 */
 	@Override
 	protected String getAuditingHandlerBeanName() {
 		return "reactiveMongoAuditingHandler";
 	}
 
-	@Override
-	protected void postProcess(BeanDefinitionBuilder builder, AuditingConfiguration configuration,
-			BeanDefinitionRegistry registry) {
-		builder.setFactoryMethod("from").addConstructorArgReference("mongoMappingContext");
-	}
-
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport#getAuditHandlerBeanDefinitionBuilder(org.springframework.data.auditing.config.AuditingConfiguration)
+	 */
 	@Override
 	protected BeanDefinitionBuilder getAuditHandlerBeanDefinitionBuilder(AuditingConfiguration configuration) {
 
-		Assert.notNull(configuration, "AuditingConfiguration must not be null");
+		Assert.notNull(configuration, "AuditingConfiguration must not be null!");
 
-		return configureDefaultAuditHandlerAttributes(configuration,
-				BeanDefinitionBuilder.rootBeanDefinition(ReactiveIsNewAwareAuditingHandler.class));
+		BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(ReactiveIsNewAwareAuditingHandler.class);
+
+		BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(PersistentEntitiesFactoryBean.class);
+		definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_CONSTRUCTOR);
+
+		builder.addConstructorArgValue(definition.getBeanDefinition());
+		return configureDefaultAuditHandlerAttributes(configuration, builder);
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.auditing.config.AuditingBeanDefinitionRegistrarSupport#registerAuditListener(org.springframework.beans.factory.config.BeanDefinition, org.springframework.beans.factory.support.BeanDefinitionRegistry)
+	 */
 	@Override
 	protected void registerAuditListenerBeanDefinition(BeanDefinition auditingHandlerDefinition,
 			BeanDefinitionRegistry registry) {
 
-		Assert.notNull(auditingHandlerDefinition, "BeanDefinition must not be null");
-		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
+		Assert.notNull(auditingHandlerDefinition, "BeanDefinition must not be null!");
+		Assert.notNull(registry, "BeanDefinitionRegistry must not be null!");
 
 		BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(ReactiveAuditingEntityCallback.class);
 

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

@@ -32,6 +32,10 @@ import com.mongodb.ReadConcernLevel;
  */
 public class ReadConcernPropertyEditor extends PropertyEditorSupport {
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.xml.BeanDefinitionParser#parse(org.w3c.dom.Element, org.springframework.beans.factory.xml.ParserContext)
+	 */
 	@Override
 	public void setAsText(@Nullable String readConcernString) {
 

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

@@ -29,6 +29,10 @@ import com.mongodb.ReadPreference;
  */
 public class ReadPreferencePropertyEditor extends PropertyEditorSupport {
 
+	/*
+	 * (non-Javadoc)
+	 * @see java.beans.PropertyEditorSupport#setAsText(java.lang.String)
+	 */
 	@Override
 	public void setAsText(@Nullable String readPreferenceString) throws IllegalArgumentException {
 

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

@@ -21,8 +21,8 @@ import java.net.UnknownHostException;
 import java.util.HashSet;
 import java.util.Set;
 
-import org.apache.commons.logging.Log;
-import org.apache.commons.logging.LogFactory;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
@@ -43,9 +43,13 @@ public class ServerAddressPropertyEditor extends PropertyEditorSupport {
 	 * A port is a number without a leading 0 at the end of the address that is proceeded by just a single :.
 	 */
 	private static final String HOST_PORT_SPLIT_PATTERN = "(?<!:):(?=[123456789]\\d*$)";
-	private static final String COULD_NOT_PARSE_ADDRESS_MESSAGE = "Could not parse address %s '%s'; Check your replica set configuration";
-	private static final Log LOG = LogFactory.getLog(ServerAddressPropertyEditor.class);
+	private static final String COULD_NOT_PARSE_ADDRESS_MESSAGE = "Could not parse address {} '{}'. Check your replica set configuration!";
+	private static final Logger LOG = LoggerFactory.getLogger(ServerAddressPropertyEditor.class);
 
+	/*
+	 * (non-Javadoc)
+	 * @see java.beans.PropertyEditorSupport#setAsText(java.lang.String)
+	 */
 	@Override
 	public void setAsText(@Nullable String replicaSetString) {
 
@@ -68,7 +72,7 @@ public class ServerAddressPropertyEditor extends PropertyEditorSupport {
 
 		if (serverAddresses.isEmpty()) {
 			throw new IllegalArgumentException(
-					"Could not resolve at least one server of the replica set configuration; Validate your config");
+					"Could not resolve at least one server of the replica set configuration! Validate your config!");
 		}
 
 		setValue(serverAddresses.toArray(new ServerAddress[serverAddresses.size()]));
@@ -84,18 +88,14 @@ public class ServerAddressPropertyEditor extends PropertyEditorSupport {
 	private ServerAddress parseServerAddress(String source) {
 
 		if (!StringUtils.hasText(source)) {
-			if(LOG.isWarnEnabled()) {
-				LOG.warn(String.format(COULD_NOT_PARSE_ADDRESS_MESSAGE, "source", source));
-			}
+			LOG.warn(COULD_NOT_PARSE_ADDRESS_MESSAGE, "source", source);
 			return null;
 		}
 
 		String[] hostAndPort = extractHostAddressAndPort(source.trim());
 
 		if (hostAndPort.length > 2) {
-			if(LOG.isWarnEnabled()) {
-				LOG.warn(String.format(COULD_NOT_PARSE_ADDRESS_MESSAGE, "source", source));
-			}
+			LOG.warn(COULD_NOT_PARSE_ADDRESS_MESSAGE, "source", source);
 			return null;
 		}
 
@@ -105,13 +105,9 @@ public class ServerAddressPropertyEditor extends PropertyEditorSupport {
 
 			return port == null ? new ServerAddress(hostAddress) : new ServerAddress(hostAddress, port);
 		} catch (UnknownHostException e) {
-			if(LOG.isWarnEnabled()) {
-				LOG.warn(String.format(COULD_NOT_PARSE_ADDRESS_MESSAGE, "host", hostAndPort[0]));
-			}
+			LOG.warn(COULD_NOT_PARSE_ADDRESS_MESSAGE, "host", hostAndPort[0]);
 		} catch (NumberFormatException e) {
-			if(LOG.isWarnEnabled()) {
-				LOG.warn(String.format(COULD_NOT_PARSE_ADDRESS_MESSAGE, "port", hostAndPort[1]));
-			}
+			LOG.warn(COULD_NOT_PARSE_ADDRESS_MESSAGE, "port", hostAndPort[1]);
 		}
 
 		return null;
@@ -125,7 +121,7 @@ public class ServerAddressPropertyEditor extends PropertyEditorSupport {
 	 */
 	private String[] extractHostAddressAndPort(String addressAndPortSource) {
 
-		Assert.notNull(addressAndPortSource, "Address and port source must not be null");
+		Assert.notNull(addressAndPortSource, "Address and port source must not be null!");
 
 		String[] hostAndPort = addressAndPortSource.split(HOST_PORT_SPLIT_PATTERN);
 		String hostAddress = hostAndPort[0];

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

@@ -26,6 +26,10 @@ import com.mongodb.WriteConcern;
  */
 public class StringToWriteConcernConverter implements Converter<String, WriteConcern> {
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.core.convert.converter.Converter#convert(java.lang.Object)
+	 */
 	public WriteConcern convert(String source) {
 
 		WriteConcern writeConcern = WriteConcern.valueOf(source);

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

@@ -29,6 +29,10 @@ import org.springframework.util.StringUtils;
  */
 public class UUidRepresentationPropertyEditor extends PropertyEditorSupport {
 
+	/*
+	 * (non-Javadoc)
+	 * @see java.beans.PropertyEditorSupport#setAsText(java.lang.String)
+	 */
 	@Override
 	public void setAsText(@Nullable String value) {
 

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

@@ -15,6 +15,8 @@
  */
 package org.springframework.data.mongodb.core;
 
+import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.Optional;
 import java.util.stream.Collectors;
@@ -22,16 +24,22 @@ import java.util.stream.Collectors;
 import org.bson.Document;
 import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.data.mongodb.core.aggregation.Aggregation;
+import org.springframework.data.mongodb.core.aggregation.AggregationOperation;
 import org.springframework.data.mongodb.core.aggregation.AggregationOperationContext;
+import org.springframework.data.mongodb.core.aggregation.AggregationOptions;
 import org.springframework.data.mongodb.core.aggregation.AggregationOptions.DomainTypeMapping;
+import org.springframework.data.mongodb.core.aggregation.CountOperation;
 import org.springframework.data.mongodb.core.aggregation.RelaxedTypeBasedAggregationOperationContext;
 import org.springframework.data.mongodb.core.aggregation.TypeBasedAggregationOperationContext;
 import org.springframework.data.mongodb.core.aggregation.TypedAggregation;
 import org.springframework.data.mongodb.core.convert.QueryMapper;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
+import org.springframework.data.mongodb.core.query.CriteriaDefinition;
+import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.data.util.Lazy;
 import org.springframework.lang.Nullable;
+import org.springframework.util.Assert;
 import org.springframework.util.ObjectUtils;
 
 /**

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

@@ -24,14 +24,10 @@ import org.springframework.data.util.Pair;
 import com.mongodb.bulk.BulkWriteResult;
 
 /**
- * Bulk operations for insert/update/remove actions on a collection. Bulk operations are available since MongoDB 2.6 and
- * make use of low level bulk commands on the protocol level. This interface defines a fluent API to add multiple single
- * operations or list of similar operations in sequence which can then eventually be executed by calling
+ * Bulk operations for insert/update/remove actions on a collection. These bulks operation are available since MongoDB
+ * 2.6 and make use of low level bulk commands on the protocol level. This interface defines a fluent API to add
+ * multiple single operations or list of similar operations in sequence which can then eventually be executed by calling
  * {@link #execute()}.
- * <p>
- * Bulk operations are issued as one batch that pulls together all insert, update, and delete operations. Operations
- * that require individual operation results such as optimistic locking (using {@code @Version}) are not supported and
- * the version field remains not populated.
  *
  * @author Tobias Trelle
  * @author Oliver Gierke

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

@@ -36,29 +36,21 @@ import com.mongodb.client.model.changestream.OperationType;
  *
  * @author Christoph Strobl
  * @author Mark Paluch
- * @author Myroslav Kosinskyi
  * @since 2.1
  */
 public class ChangeStreamEvent<T> {
 
 	@SuppressWarnings("rawtypes") //
-	private static final AtomicReferenceFieldUpdater<ChangeStreamEvent, Object> CONVERTED_FULL_DOCUMENT_UPDATER = AtomicReferenceFieldUpdater
-			.newUpdater(ChangeStreamEvent.class, Object.class, "convertedFullDocument");
-
-	@SuppressWarnings("rawtypes") //
-	private static final AtomicReferenceFieldUpdater<ChangeStreamEvent, Object> CONVERTED_FULL_DOCUMENT_BEFORE_CHANGE_UPDATER = AtomicReferenceFieldUpdater
-			.newUpdater(ChangeStreamEvent.class, Object.class, "convertedFullDocumentBeforeChange");
+	private static final AtomicReferenceFieldUpdater<ChangeStreamEvent, Object> CONVERTED_UPDATER = AtomicReferenceFieldUpdater
+			.newUpdater(ChangeStreamEvent.class, Object.class, "converted");
 
 	private final @Nullable ChangeStreamDocument<Document> raw;
 
 	private final Class<T> targetType;
 	private final MongoConverter converter;
 
-	// accessed through CONVERTED_FULL_DOCUMENT_UPDATER.
-	private volatile @Nullable T convertedFullDocument;
-
-	// accessed through CONVERTED_FULL_DOCUMENT_BEFORE_CHANGE_UPDATER.
-	private volatile @Nullable T convertedFullDocumentBeforeChange;
+	// accessed through CONVERTED_UPDATER.
+	private volatile @Nullable T converted;
 
 	/**
 	 * @param raw can be {@literal null}.
@@ -155,43 +147,27 @@ public class ChangeStreamEvent<T> {
 	@Nullable
 	public T getBody() {
 
-		if (raw == null || raw.getFullDocument() == null) {
+		if (raw == null) {
 			return null;
 		}
 
-		return getConvertedFullDocument(raw.getFullDocument());
-	}
+		Document fullDocument = raw.getFullDocument();
 
-	/**
-	 * Get the potentially converted {@link ChangeStreamDocument#getFullDocumentBeforeChange() document} before being changed.
-	 *
-	 * @return {@literal null} when {@link #getRaw()} or {@link ChangeStreamDocument#getFullDocumentBeforeChange()} is
-	 *         {@literal null}.
-	 * @since 4.0
-	 */
-	@Nullable
-	public T getBodyBeforeChange() {
-
-		if (raw == null || raw.getFullDocumentBeforeChange() == null) {
-			return null;
+		if (fullDocument == null) {
+			return targetType.cast(fullDocument);
 		}
 
-		return getConvertedFullDocumentBeforeChange(raw.getFullDocumentBeforeChange());
+		return getConverted(fullDocument);
 	}
 
 	@SuppressWarnings("unchecked")
-	private T getConvertedFullDocumentBeforeChange(Document fullDocument) {
-		return (T) doGetConverted(fullDocument, CONVERTED_FULL_DOCUMENT_BEFORE_CHANGE_UPDATER);
+	private T getConverted(Document fullDocument) {
+		return (T) doGetConverted(fullDocument);
 	}
 
-	@SuppressWarnings("unchecked")
-	private T getConvertedFullDocument(Document fullDocument) {
-		return (T) doGetConverted(fullDocument, CONVERTED_FULL_DOCUMENT_UPDATER);
-	}
+	private Object doGetConverted(Document fullDocument) {
 
-	private Object doGetConverted(Document fullDocument, AtomicReferenceFieldUpdater<ChangeStreamEvent, Object> updater) {
-
-		Object result = updater.get(this);
+		Object result = CONVERTED_UPDATER.get(this);
 
 		if (result != null) {
 			return result;
@@ -200,19 +176,23 @@ public class ChangeStreamEvent<T> {
 		if (ClassUtils.isAssignable(Document.class, fullDocument.getClass())) {
 
 			result = converter.read(targetType, fullDocument);
-			return updater.compareAndSet(this, null, result) ? result : updater.get(this);
+			return CONVERTED_UPDATER.compareAndSet(this, null, result) ? result : CONVERTED_UPDATER.get(this);
 		}
 
 		if (converter.getConversionService().canConvert(fullDocument.getClass(), targetType)) {
 
 			result = converter.getConversionService().convert(fullDocument, targetType);
-			return updater.compareAndSet(this, null, result) ? result : updater.get(this);
+			return CONVERTED_UPDATER.compareAndSet(this, null, result) ? result : CONVERTED_UPDATER.get(this);
 		}
 
 		throw new IllegalArgumentException(
 				String.format("No converter found capable of converting %s to %s", fullDocument.getClass(), targetType));
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see java.lang.Object#toString()
+	 */
 	@Override
 	public String toString() {
 		return "ChangeStreamEvent {" + "raw=" + raw + ", targetType=" + targetType + '}';

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

@@ -32,7 +32,6 @@ import org.springframework.util.ObjectUtils;
 
 import com.mongodb.client.model.changestream.ChangeStreamDocument;
 import com.mongodb.client.model.changestream.FullDocument;
-import com.mongodb.client.model.changestream.FullDocumentBeforeChange;
 
 /**
  * Options applicable to MongoDB <a href="https://docs.mongodb.com/manual/changeStreams/">Change Streams</a>. Intended
@@ -41,7 +40,6 @@ import com.mongodb.client.model.changestream.FullDocumentBeforeChange;
  *
  * @author Christoph Strobl
  * @author Mark Paluch
- * @author Myroslav Kosinskyi
  * @since 2.1
  */
 public class ChangeStreamOptions {
@@ -49,7 +47,6 @@ public class ChangeStreamOptions {
 	private @Nullable Object filter;
 	private @Nullable BsonValue resumeToken;
 	private @Nullable FullDocument fullDocumentLookup;
-	private @Nullable FullDocumentBeforeChange fullDocumentBeforeChangeLookup;
 	private @Nullable Collation collation;
 	private @Nullable Object resumeTimestamp;
 	private Resume resume = Resume.UNDEFINED;
@@ -77,14 +74,6 @@ public class ChangeStreamOptions {
 		return Optional.ofNullable(fullDocumentLookup);
 	}
 
-	/**
-	 * @return {@link Optional#empty()} if not set.
-	 * @since 4.0
-	 */
-	public Optional<FullDocumentBeforeChange> getFullDocumentBeforeChangeLookup() {
-		return Optional.ofNullable(fullDocumentBeforeChangeLookup);
-	}
-
 	/**
 	 * @return {@link Optional#empty()} if not set.
 	 */
@@ -159,7 +148,7 @@ public class ChangeStreamOptions {
 		}
 
 		throw new IllegalArgumentException(
-				"o_O that should actually not happen; The timestamp should be an Instant or a BsonTimestamp but was "
+				"o_O that should actually not happen. The timestamp should be an Instant or a BsonTimestamp but was "
 						+ ObjectUtils.nullSafeClassName(timestamp));
 	}
 
@@ -181,9 +170,6 @@ public class ChangeStreamOptions {
 		if (!ObjectUtils.nullSafeEquals(this.fullDocumentLookup, that.fullDocumentLookup)) {
 			return false;
 		}
-		if (!ObjectUtils.nullSafeEquals(this.fullDocumentBeforeChangeLookup, that.fullDocumentBeforeChangeLookup)) {
-			return false;
-		}
 		if (!ObjectUtils.nullSafeEquals(this.collation, that.collation)) {
 			return false;
 		}
@@ -198,7 +184,6 @@ public class ChangeStreamOptions {
 		int result = ObjectUtils.nullSafeHashCode(filter);
 		result = 31 * result + ObjectUtils.nullSafeHashCode(resumeToken);
 		result = 31 * result + ObjectUtils.nullSafeHashCode(fullDocumentLookup);
-		result = 31 * result + ObjectUtils.nullSafeHashCode(fullDocumentBeforeChangeLookup);
 		result = 31 * result + ObjectUtils.nullSafeHashCode(collation);
 		result = 31 * result + ObjectUtils.nullSafeHashCode(resumeTimestamp);
 		result = 31 * result + ObjectUtils.nullSafeHashCode(resume);
@@ -235,7 +220,6 @@ public class ChangeStreamOptions {
 		private @Nullable Object filter;
 		private @Nullable BsonValue resumeToken;
 		private @Nullable FullDocument fullDocumentLookup;
-		private @Nullable FullDocumentBeforeChange fullDocumentBeforeChangeLookup;
 		private @Nullable Collation collation;
 		private @Nullable Object resumeTimestamp;
 		private Resume resume = Resume.UNDEFINED;
@@ -250,7 +234,7 @@ public class ChangeStreamOptions {
 		 */
 		public ChangeStreamOptionsBuilder collation(Collation collation) {
 
-			Assert.notNull(collation, "Collation must not be null nor empty");
+			Assert.notNull(collation, "Collation must not be null nor empty!");
 
 			this.collation = collation;
 			return this;
@@ -274,7 +258,7 @@ public class ChangeStreamOptions {
 		 */
 		public ChangeStreamOptionsBuilder filter(Aggregation filter) {
 
-			Assert.notNull(filter, "Filter must not be null");
+			Assert.notNull(filter, "Filter must not be null!");
 
 			this.filter = filter;
 			return this;
@@ -303,7 +287,7 @@ public class ChangeStreamOptions {
 		 */
 		public ChangeStreamOptionsBuilder resumeToken(BsonValue resumeToken) {
 
-			Assert.notNull(resumeToken, "ResumeToken must not be null");
+			Assert.notNull(resumeToken, "ResumeToken must not be null!");
 
 			this.resumeToken = resumeToken;
 
@@ -332,38 +316,12 @@ public class ChangeStreamOptions {
 		 */
 		public ChangeStreamOptionsBuilder fullDocumentLookup(FullDocument lookup) {
 
-			Assert.notNull(lookup, "Lookup must not be null");
+			Assert.notNull(lookup, "Lookup must not be null!");
 
 			this.fullDocumentLookup = lookup;
 			return this;
 		}
 
-		/**
-		 * Set the {@link FullDocumentBeforeChange} lookup to use.
-		 *
-		 * @param lookup must not be {@literal null}.
-		 * @return this.
-		 * @since 4.0
-		 */
-		public ChangeStreamOptionsBuilder fullDocumentBeforeChangeLookup(FullDocumentBeforeChange lookup) {
-
-			Assert.notNull(lookup, "Lookup must not be null");
-
-			this.fullDocumentBeforeChangeLookup = lookup;
-			return this;
-		}
-
-		/**
-		 * Return the full document before being changed if it is available.
-		 *
-		 * @return this.
-		 * @since 4.0
-		 * @see #fullDocumentBeforeChangeLookup(FullDocumentBeforeChange) 
-		 */
-		public ChangeStreamOptionsBuilder returnFullDocumentBeforeChange() {
-			return fullDocumentBeforeChangeLookup(FullDocumentBeforeChange.WHEN_AVAILABLE);
-		}
-
 		/**
 		 * Set the cluster time to resume from.
 		 *
@@ -372,7 +330,7 @@ public class ChangeStreamOptions {
 		 */
 		public ChangeStreamOptionsBuilder resumeAt(Instant resumeTimestamp) {
 
-			Assert.notNull(resumeTimestamp, "ResumeTimestamp must not be null");
+			Assert.notNull(resumeTimestamp, "ResumeTimestamp must not be null!");
 
 			this.resumeTimestamp = resumeTimestamp;
 			return this;
@@ -387,7 +345,7 @@ public class ChangeStreamOptions {
 		 */
 		public ChangeStreamOptionsBuilder resumeAt(BsonTimestamp resumeTimestamp) {
 
-			Assert.notNull(resumeTimestamp, "ResumeTimestamp must not be null");
+			Assert.notNull(resumeTimestamp, "ResumeTimestamp must not be null!");
 
 			this.resumeTimestamp = resumeTimestamp;
 			return this;
@@ -433,7 +391,6 @@ public class ChangeStreamOptions {
 			options.filter = this.filter;
 			options.resumeToken = this.resumeToken;
 			options.fullDocumentLookup = this.fullDocumentLookup;
-			options.fullDocumentBeforeChangeLookup = this.fullDocumentBeforeChangeLookup;
 			options.collation = this.collation;
 			options.resumeTimestamp = this.resumeTimestamp;
 			options.resume = this.resume;

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

@@ -46,11 +46,24 @@ public class CollectionOptions {
 	private @Nullable Collation collation;
 	private ValidationOptions validationOptions;
 	private @Nullable TimeSeriesOptions timeSeriesOptions;
-	private @Nullable CollectionChangeStreamOptions changeStreamOptions;
+
+	/**
+	 * Constructs a new <code>CollectionOptions</code> instance.
+	 *
+	 * @param size the collection size in bytes, this data space is preallocated. Can be {@literal null}.
+	 * @param maxDocuments the maximum number of documents in the collection. Can be {@literal null}.
+	 * @param capped true to created a "capped" collection (fixed size with auto-FIFO behavior based on insertion order),
+	 *          false otherwise. Can be {@literal null}.
+	 * @deprecated since 2.0 please use {@link CollectionOptions#empty()} as entry point.
+	 */
+	@Deprecated
+	public CollectionOptions(@Nullable Long size, @Nullable Long maxDocuments, @Nullable Boolean capped) {
+		this(size, maxDocuments, capped, null, ValidationOptions.none(), null);
+	}
 
 	private CollectionOptions(@Nullable Long size, @Nullable Long maxDocuments, @Nullable Boolean capped,
 			@Nullable Collation collation, ValidationOptions validationOptions,
-			@Nullable TimeSeriesOptions timeSeriesOptions, @Nullable CollectionChangeStreamOptions changeStreamOptions) {
+			@Nullable TimeSeriesOptions timeSeriesOptions) {
 
 		this.maxDocuments = maxDocuments;
 		this.size = size;
@@ -58,7 +71,6 @@ public class CollectionOptions {
 		this.collation = collation;
 		this.validationOptions = validationOptions;
 		this.timeSeriesOptions = timeSeriesOptions;
-		this.changeStreamOptions = changeStreamOptions;
 	}
 
 	/**
@@ -70,9 +82,9 @@ public class CollectionOptions {
 	 */
 	public static CollectionOptions just(Collation collation) {
 
-		Assert.notNull(collation, "Collation must not be null");
+		Assert.notNull(collation, "Collation must not be null!");
 
-		return new CollectionOptions(null, null, null, collation, ValidationOptions.none(), null, null);
+		return new CollectionOptions(null, null, null, collation, ValidationOptions.none(), null);
 	}
 
 	/**
@@ -82,7 +94,7 @@ public class CollectionOptions {
 	 * @since 2.0
 	 */
 	public static CollectionOptions empty() {
-		return new CollectionOptions(null, null, null, null, ValidationOptions.none(), null, null);
+		return new CollectionOptions(null, null, null, null, ValidationOptions.none(), null);
 	}
 
 	/**
@@ -99,18 +111,6 @@ public class CollectionOptions {
 		return empty().timeSeries(TimeSeriesOptions.timeSeries(timeField));
 	}
 
-	/**
-	 * Quick way to set up {@link CollectionOptions} for emitting (pre & post) change events.
-	 *
-	 * @return new instance of {@link CollectionOptions}.
-	 * @see #changeStream(CollectionChangeStreamOptions)
-	 * @see CollectionChangeStreamOptions#preAndPostImages(boolean) 
-	 * @since 4.0
-	 */
-	public static CollectionOptions emitChangedRevisions() {
-		return empty().changeStream(CollectionChangeStreamOptions.preAndPostImages(true));
-	}
-
 	/**
 	 * Create new {@link CollectionOptions} with already given settings and capped set to {@literal true}. <br />
 	 * <strong>NOTE</strong> Using capped collections requires defining {@link #size(long)}.
@@ -119,7 +119,7 @@ public class CollectionOptions {
 	 * @since 2.0
 	 */
 	public CollectionOptions capped() {
-		return new CollectionOptions(size, maxDocuments, true, collation, validationOptions, timeSeriesOptions, changeStreamOptions);
+		return new CollectionOptions(size, maxDocuments, true, collation, validationOptions, null);
 	}
 
 	/**
@@ -130,7 +130,7 @@ public class CollectionOptions {
 	 * @since 2.0
 	 */
 	public CollectionOptions maxDocuments(long maxDocuments) {
-		return new CollectionOptions(size, maxDocuments, capped, collation, validationOptions, timeSeriesOptions, changeStreamOptions);
+		return new CollectionOptions(size, maxDocuments, capped, collation, validationOptions, timeSeriesOptions);
 	}
 
 	/**
@@ -141,7 +141,7 @@ public class CollectionOptions {
 	 * @since 2.0
 	 */
 	public CollectionOptions size(long size) {
-		return new CollectionOptions(size, maxDocuments, capped, collation, validationOptions, timeSeriesOptions, changeStreamOptions);
+		return new CollectionOptions(size, maxDocuments, capped, collation, validationOptions, timeSeriesOptions);
 	}
 
 	/**
@@ -152,7 +152,7 @@ public class CollectionOptions {
 	 * @since 2.0
 	 */
 	public CollectionOptions collation(@Nullable Collation collation) {
-		return new CollectionOptions(size, maxDocuments, capped, collation, validationOptions, timeSeriesOptions, changeStreamOptions);
+		return new CollectionOptions(size, maxDocuments, capped, collation, validationOptions, timeSeriesOptions);
 	}
 
 	/**
@@ -244,7 +244,7 @@ public class CollectionOptions {
 	 */
 	public CollectionOptions schemaValidationLevel(ValidationLevel validationLevel) {
 
-		Assert.notNull(validationLevel, "ValidationLevel must not be null");
+		Assert.notNull(validationLevel, "ValidationLevel must not be null!");
 		return validation(validationOptions.validationLevel(validationLevel));
 	}
 
@@ -258,7 +258,7 @@ public class CollectionOptions {
 	 */
 	public CollectionOptions schemaValidationAction(ValidationAction validationAction) {
 
-		Assert.notNull(validationAction, "ValidationAction must not be null");
+		Assert.notNull(validationAction, "ValidationAction must not be null!");
 		return validation(validationOptions.validationAction(validationAction));
 	}
 
@@ -271,8 +271,8 @@ public class CollectionOptions {
 	 */
 	public CollectionOptions validation(ValidationOptions validationOptions) {
 
-		Assert.notNull(validationOptions, "ValidationOptions must not be null");
-		return new CollectionOptions(size, maxDocuments, capped, collation, validationOptions, timeSeriesOptions, changeStreamOptions);
+		Assert.notNull(validationOptions, "ValidationOptions must not be null!");
+		return new CollectionOptions(size, maxDocuments, capped, collation, validationOptions, timeSeriesOptions);
 	}
 
 	/**
@@ -284,21 +284,8 @@ public class CollectionOptions {
 	 */
 	public CollectionOptions timeSeries(TimeSeriesOptions timeSeriesOptions) {
 
-		Assert.notNull(timeSeriesOptions, "TimeSeriesOptions must not be null");
-		return new CollectionOptions(size, maxDocuments, capped, collation, validationOptions, timeSeriesOptions, changeStreamOptions);
-	}
-
-	/**
-	 * Create new {@link CollectionOptions} with the given {@link TimeSeriesOptions}.
-	 *
-	 * @param changeStreamOptions must not be {@literal null}.
-	 * @return new instance of {@link CollectionOptions}.
-	 * @since 3.3
-	 */
-	public CollectionOptions changeStream(CollectionChangeStreamOptions changeStreamOptions) {
-
-		Assert.notNull(changeStreamOptions, "ChangeStreamOptions must not be null");
-		return new CollectionOptions(size, maxDocuments, capped, collation, validationOptions, timeSeriesOptions, changeStreamOptions);
+		Assert.notNull(timeSeriesOptions, "TimeSeriesOptions must not be null!");
+		return new CollectionOptions(size, maxDocuments, capped, collation, validationOptions, timeSeriesOptions);
 	}
 
 	/**
@@ -359,16 +346,6 @@ public class CollectionOptions {
 		return Optional.ofNullable(timeSeriesOptions);
 	}
 
-	/**
-	 * Get the {@link CollectionChangeStreamOptions} if available.
-	 *
-	 * @return {@link Optional#empty()} if not specified.
-	 * @since 4.0
-	 */
-	public Optional<CollectionChangeStreamOptions> getChangeStreamOptions() {
-		return Optional.ofNullable(changeStreamOptions);
-	}
-
 	/**
 	 * Encapsulation of ValidationOptions options.
 	 *
@@ -465,34 +442,6 @@ public class CollectionOptions {
 		}
 	}
 
-	/**
-	 * Encapsulation of options applied to define collections change stream behaviour.
-	 *
-	 * @author Christoph Strobl
-	 * @since 4.0
-	 */
-	public static class CollectionChangeStreamOptions {
-
-		private final boolean preAndPostImages;
-
-		private CollectionChangeStreamOptions(boolean emitChangedRevisions) {
-			this.preAndPostImages = emitChangedRevisions;
-		}
-
-		/**
-		 * Output the version of a document before and after changes (the document pre- and post-images).
-		 *
-		 * @return new instance of {@link CollectionChangeStreamOptions}.
-		 */
-		public static CollectionChangeStreamOptions preAndPostImages(boolean emitChangedRevisions) {
-			return new CollectionChangeStreamOptions(true);
-		}
-
-		public boolean getPreAndPostImages() {
-			return preAndPostImages;
-		}
-	}
-
 	/**
 	 * Options applicable to Time Series collections.
 	 *
@@ -511,7 +460,7 @@ public class CollectionOptions {
 
 		private TimeSeriesOptions(String timeField, @Nullable String metaField, GranularityDefinition granularity) {
 
-			Assert.hasText(timeField, "Time field must not be empty or null");
+			Assert.hasText(timeField, "Time field must not be empty or null!");
 
 			this.timeField = timeField;
 			this.metaField = metaField;

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

@@ -23,8 +23,8 @@ import java.util.List;
 import java.util.Map;
 
 import org.bson.Document;
+
 import org.springframework.data.geo.Point;
-import org.springframework.data.mongodb.core.query.MetricConversion;
 import org.springframework.lang.Nullable;
 import org.springframework.util.ObjectUtils;
 
@@ -38,7 +38,7 @@ import org.springframework.util.ObjectUtils;
  */
 class CountQuery {
 
-	private final Document source;
+	private Document source;
 
 	private CountQuery(Document source) {
 		this.source = source;
@@ -101,7 +101,7 @@ class CountQuery {
 		}
 
 		if (valueToInspect instanceof Collection) {
-			return requiresRewrite((Collection<?>) valueToInspect);
+			return requiresRewrite((Collection) valueToInspect);
 		}
 
 		return false;
@@ -157,14 +157,12 @@ class CountQuery {
 	 * @param $and potentially existing {@code $and} condition.
 	 * @return the rewritten query {@link Document}.
 	 */
-	@SuppressWarnings("unchecked")
 	private static Document createGeoWithin(String key, Document source, @Nullable Object $and) {
 
 		boolean spheric = source.containsKey("$nearSphere");
 		Object $near = spheric ? source.get("$nearSphere") : source.get("$near");
 
-		Number maxDistance = getMaxDistance(source, $near, spheric);
-
+		Number maxDistance = source.containsKey("$maxDistance") ? (Number) source.get("$maxDistance") : Double.MAX_VALUE;
 		List<Object> $centerMax = Arrays.asList(toCenterCoordinates($near), maxDistance);
 		Document $geoWithinMax = new Document("$geoWithin",
 				new Document(spheric ? "$centerSphere" : "$center", $centerMax));
@@ -182,12 +180,12 @@ class CountQuery {
 
 		if ($and != null) {
 			if ($and instanceof Collection) {
-				Collection<Document> andElements = (Collection<Document>) $and;
+				Collection andElements = (Collection) $and;
 				criteria = new ArrayList<>(andElements.size() + 2);
 				criteria.addAll(andElements);
 			} else {
 				throw new IllegalArgumentException(
-						"Cannot rewrite query as it contains an '$and' element that is not a Collection: Offending element: "
+						"Cannot rewrite query as it contains an '$and' element that is not a Collection!: Offending element: "
 								+ $and);
 			}
 		} else {
@@ -196,33 +194,9 @@ class CountQuery {
 
 		criteria.add(new Document("$nor", Collections.singletonList(new Document(key, $geoWithinMin))));
 		criteria.add(new Document(key, $geoWithinMax));
-
 		return new Document("$and", criteria);
 	}
 
-	private static Number getMaxDistance(Document source, Object $near, boolean spheric) {
-
-		Number maxDistance = Double.MAX_VALUE;
-
-		if (source.containsKey("$maxDistance")) { // legacy coordinate pair
-			return (Number) source.get("$maxDistance");
-		}
-
-		if ($near instanceof Document nearDoc) {
-
-			if (nearDoc.containsKey("$maxDistance")) {
-
-				maxDistance = (Number) nearDoc.get("$maxDistance");
-				// geojson is in Meters but we need radians x/(6378.1*1000)
-				if (spheric && nearDoc.containsKey("$geometry")) {
-					maxDistance = MetricConversion.metersToRadians(maxDistance.doubleValue());
-				}
-			}
-		}
-
-		return maxDistance;
-	}
-
 	private static boolean containsNear(Document source) {
 		return source.containsKey("$near") || source.containsKey("$nearSphere");
 	}
@@ -246,16 +220,10 @@ class CountQuery {
 			return Arrays.asList(((Point) value).getX(), ((Point) value).getY());
 		}
 
-		if (value instanceof Document document) {
+		if (value instanceof Document && ((Document) value).containsKey("x")) {
 
-			if (document.containsKey("x")) {
-				return Arrays.asList(document.get("x"), document.get("y"));
-			}
-
-			if (document.containsKey("$geometry")) {
-				Document geoJsonPoint = document.get("$geometry", Document.class);
-				return geoJsonPoint.get("coordinates");
-			}
+			Document point = (Document) value;
+			return Arrays.asList(point.get("x"), point.get("y"));
 		}
 
 		return value;

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

@@ -61,8 +61,8 @@ public interface CursorPreparer extends ReadPreferenceAware {
 	default FindIterable<Document> initiateFind(MongoCollection<Document> collection,
 			Function<MongoCollection<Document>, FindIterable<Document>> find) {
 
-		Assert.notNull(collection, "Collection must not be null");
-		Assert.notNull(find, "Find function must not be null");
+		Assert.notNull(collection, "Collection must not be null!");
+		Assert.notNull(find, "Find function must not be null!");
 
 		if (hasReadPreference()) {
 			collection = collection.withReadPreference(getReadPreference());

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

@@ -90,9 +90,9 @@ class DefaultBulkOperations implements BulkOperations {
 	DefaultBulkOperations(MongoOperations mongoOperations, String collectionName,
 			BulkOperationContext bulkOperationContext) {
 
-		Assert.notNull(mongoOperations, "MongoOperations must not be null");
-		Assert.hasText(collectionName, "CollectionName must not be null nor empty");
-		Assert.notNull(bulkOperationContext, "BulkOperationContext must not be null");
+		Assert.notNull(mongoOperations, "MongoOperations must not be null!");
+		Assert.hasText(collectionName, "CollectionName must not be null nor empty!");
+		Assert.notNull(bulkOperationContext, "BulkOperationContext must not be null!");
 
 		this.mongoOperations = mongoOperations;
 		this.collectionName = collectionName;
@@ -109,10 +109,14 @@ class DefaultBulkOperations implements BulkOperations {
 		this.defaultWriteConcern = defaultWriteConcern;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.BulkOperations#insert(java.lang.Object)
+	 */
 	@Override
 	public BulkOperations insert(Object document) {
 
-		Assert.notNull(document, "Document must not be null");
+		Assert.notNull(document, "Document must not be null!");
 
 		maybeEmitEvent(new BeforeConvertEvent<>(document, collectionName));
 		Object source = maybeInvokeBeforeConvertCallback(document);
@@ -121,30 +125,42 @@ class DefaultBulkOperations implements BulkOperations {
 		return this;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.BulkOperations#insert(java.util.List)
+	 */
 	@Override
 	public BulkOperations insert(List<? extends Object> documents) {
 
-		Assert.notNull(documents, "Documents must not be null");
+		Assert.notNull(documents, "Documents must not be null!");
 
 		documents.forEach(this::insert);
 
 		return this;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.BulkOperations#updateOne(org.springframework.data.mongodb.core.query.Query, org.springframework.data.mongodb.core.query.Update)
+	 */
 	@Override
 	@SuppressWarnings("unchecked")
 	public BulkOperations updateOne(Query query, Update update) {
 
-		Assert.notNull(query, "Query must not be null");
-		Assert.notNull(update, "Update must not be null");
+		Assert.notNull(query, "Query must not be null!");
+		Assert.notNull(update, "Update must not be null!");
 
 		return updateOne(Collections.singletonList(Pair.of(query, update)));
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.BulkOperations#updateOne(java.util.List)
+	 */
 	@Override
 	public BulkOperations updateOne(List<Pair<Query, Update>> updates) {
 
-		Assert.notNull(updates, "Updates must not be null");
+		Assert.notNull(updates, "Updates must not be null!");
 
 		for (Pair<Query, Update> update : updates) {
 			update(update.getFirst(), update.getSecond(), false, false);
@@ -153,20 +169,28 @@ class DefaultBulkOperations implements BulkOperations {
 		return this;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.BulkOperations#updateMulti(org.springframework.data.mongodb.core.query.Query, org.springframework.data.mongodb.core.query.Update)
+	 */
 	@Override
 	@SuppressWarnings("unchecked")
 	public BulkOperations updateMulti(Query query, Update update) {
 
-		Assert.notNull(query, "Query must not be null");
-		Assert.notNull(update, "Update must not be null");
+		Assert.notNull(query, "Query must not be null!");
+		Assert.notNull(update, "Update must not be null!");
 
 		return updateMulti(Collections.singletonList(Pair.of(query, update)));
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.BulkOperations#updateMulti(java.util.List)
+	 */
 	@Override
 	public BulkOperations updateMulti(List<Pair<Query, Update>> updates) {
 
-		Assert.notNull(updates, "Updates must not be null");
+		Assert.notNull(updates, "Updates must not be null!");
 
 		for (Pair<Query, Update> update : updates) {
 			update(update.getFirst(), update.getSecond(), false, true);
@@ -175,11 +199,19 @@ class DefaultBulkOperations implements BulkOperations {
 		return this;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.BulkOperations#upsert(org.springframework.data.mongodb.core.query.Query, org.springframework.data.mongodb.core.query.Update)
+	 */
 	@Override
 	public BulkOperations upsert(Query query, Update update) {
 		return update(query, update, true, true);
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.BulkOperations#upsert(java.util.List)
+	 */
 	@Override
 	public BulkOperations upsert(List<Pair<Query, Update>> updates) {
 
@@ -190,10 +222,14 @@ class DefaultBulkOperations implements BulkOperations {
 		return this;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.BulkOperations#remove(org.springframework.data.mongodb.core.query.Query)
+	 */
 	@Override
 	public BulkOperations remove(Query query) {
 
-		Assert.notNull(query, "Query must not be null");
+		Assert.notNull(query, "Query must not be null!");
 
 		DeleteOptions deleteOptions = new DeleteOptions();
 		query.getCollation().map(Collation::toMongoCollation).ifPresent(deleteOptions::collation);
@@ -203,10 +239,14 @@ class DefaultBulkOperations implements BulkOperations {
 		return this;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.BulkOperations#remove(java.util.List)
+	 */
 	@Override
 	public BulkOperations remove(List<Query> removes) {
 
-		Assert.notNull(removes, "Removals must not be null");
+		Assert.notNull(removes, "Removals must not be null!");
 
 		for (Query query : removes) {
 			remove(query);
@@ -215,12 +255,16 @@ class DefaultBulkOperations implements BulkOperations {
 		return this;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.BulkOperations#replaceOne(org.springframework.data.mongodb.core.query.Query, java.lang.Object, org.springframework.data.mongodb.core.FindAndReplaceOptions)
+	 */
 	@Override
 	public BulkOperations replaceOne(Query query, Object replacement, FindAndReplaceOptions options) {
 
-		Assert.notNull(query, "Query must not be null");
-		Assert.notNull(replacement, "Replacement must not be null");
-		Assert.notNull(options, "Options must not be null");
+		Assert.notNull(query, "Query must not be null!");
+		Assert.notNull(replacement, "Replacement must not be null!");
+		Assert.notNull(options, "Options must not be null!");
 
 		ReplaceOptions replaceOptions = new ReplaceOptions();
 		replaceOptions.upsert(options.isUpsert());
@@ -234,6 +278,10 @@ class DefaultBulkOperations implements BulkOperations {
 		return this;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.BulkOperations#executeBulk()
+	 */
 	@Override
 	public com.mongodb.bulk.BulkWriteResult execute() {
 
@@ -241,7 +289,7 @@ class DefaultBulkOperations implements BulkOperations {
 
 			com.mongodb.bulk.BulkWriteResult result = mongoOperations.execute(collectionName, this::bulkWriteTo);
 
-			Assert.state(result != null, "Result must not be null");
+			Assert.state(result != null, "Result must not be null.");
 
 			models.forEach(this::maybeEmitAfterSaveEvent);
 			models.forEach(this::maybeInvokeAfterSaveCallback);
@@ -308,8 +356,8 @@ class DefaultBulkOperations implements BulkOperations {
 	 */
 	private BulkOperations update(Query query, Update update, boolean upsert, boolean multi) {
 
-		Assert.notNull(query, "Query must not be null");
-		Assert.notNull(update, "Update must not be null");
+		Assert.notNull(query, "Query must not be null!");
+		Assert.notNull(update, "Update must not be null!");
 
 		UpdateOptions options = computeUpdateOptions(query, update, upsert);
 
@@ -470,7 +518,7 @@ class DefaultBulkOperations implements BulkOperations {
 				return options.ordered(false);
 		}
 
-		throw new IllegalStateException("BulkMode was null");
+		throw new IllegalStateException("BulkMode was null!");
 	}
 
 	/**

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

@@ -83,9 +83,9 @@ public class DefaultIndexOperations implements IndexOperations {
 	public DefaultIndexOperations(MongoDatabaseFactory mongoDbFactory, String collectionName, QueryMapper queryMapper,
 			@Nullable Class<?> type) {
 
-		Assert.notNull(mongoDbFactory, "MongoDbFactory must not be null");
-		Assert.notNull(collectionName, "Collection name can not be null");
-		Assert.notNull(queryMapper, "QueryMapper must not be null");
+		Assert.notNull(mongoDbFactory, "MongoDbFactory must not be null!");
+		Assert.notNull(collectionName, "Collection name can not be null!");
+		Assert.notNull(queryMapper, "QueryMapper must not be null!");
 
 		this.collectionName = collectionName;
 		this.mapper = queryMapper;
@@ -103,8 +103,8 @@ public class DefaultIndexOperations implements IndexOperations {
 	 */
 	public DefaultIndexOperations(MongoOperations mongoOperations, String collectionName, @Nullable Class<?> type) {
 
-		Assert.notNull(mongoOperations, "MongoOperations must not be null");
-		Assert.hasText(collectionName, "Collection name must not be null or empty");
+		Assert.notNull(mongoOperations, "MongoOperations must not be null!");
+		Assert.hasText(collectionName, "Collection name must not be null or empty!");
 
 		this.mongoOperations = mongoOperations;
 		this.mapper = new QueryMapper(mongoOperations.getConverter());
@@ -112,6 +112,10 @@ public class DefaultIndexOperations implements IndexOperations {
 		this.type = type;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.index.IndexOperations#ensureIndex(org.springframework.data.mongodb.core.index.IndexDefinition)
+	 */
 	public String ensureIndex(final IndexDefinition indexDefinition) {
 
 		return execute(collection -> {
@@ -146,6 +150,10 @@ public class DefaultIndexOperations implements IndexOperations {
 		return null;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.index.IndexOperations#dropIndex(java.lang.String)
+	 */
 	public void dropIndex(final String name) {
 
 		execute(collection -> {
@@ -155,10 +163,18 @@ public class DefaultIndexOperations implements IndexOperations {
 
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.index.IndexOperations#dropAllIndexes()
+	 */
 	public void dropAllIndexes() {
 		dropIndex("*");
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.index.IndexOperations#getIndexInfo()
+	 */
 	public List<IndexInfo> getIndexInfo() {
 
 		return execute(new CollectionCallback<List<IndexInfo>>() {
@@ -190,7 +206,7 @@ public class DefaultIndexOperations implements IndexOperations {
 	@Nullable
 	public <T> T execute(CollectionCallback<T> callback) {
 
-		Assert.notNull(callback, "CollectionCallback must not be null");
+		Assert.notNull(callback, "CollectionCallback must not be null!");
 
 		if (type != null) {
 			return mongoOperations.execute(type, callback);

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

@@ -42,6 +42,10 @@ class DefaultIndexOperationsProvider implements IndexOperationsProvider {
 		this.mapper = mapper;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.index.IndexOperationsProvider#reactiveIndexOps(java.lang.String)
+	 */
 	@Override
 	public IndexOperations indexOps(String collectionName, Class<?> type) {
 		return new DefaultIndexOperations(mongoDbFactory, collectionName, mapper, type);

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

@@ -76,9 +76,9 @@ public class DefaultReactiveIndexOperations implements ReactiveIndexOperations {
 	private DefaultReactiveIndexOperations(ReactiveMongoOperations mongoOperations, String collectionName,
 			QueryMapper queryMapper, Optional<Class<?>> type) {
 
-		Assert.notNull(mongoOperations, "ReactiveMongoOperations must not be null");
-		Assert.notNull(collectionName, "Collection must not be null");
-		Assert.notNull(queryMapper, "QueryMapper must not be null");
+		Assert.notNull(mongoOperations, "ReactiveMongoOperations must not be null!");
+		Assert.notNull(collectionName, "Collection must not be null!");
+		Assert.notNull(queryMapper, "QueryMapper must not be null!");
 
 		this.mongoOperations = mongoOperations;
 		this.collectionName = collectionName;
@@ -86,6 +86,10 @@ public class DefaultReactiveIndexOperations implements ReactiveIndexOperations {
 		this.type = type;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.index.ReactiveIndexOperations#ensureIndex(org.springframework.data.mongodb.core.index.IndexDefinition)
+	 */
 	public Mono<String> ensureIndex(final IndexDefinition indexDefinition) {
 
 		return mongoOperations.execute(collectionName, collection -> {
@@ -115,14 +119,26 @@ public class DefaultReactiveIndexOperations implements ReactiveIndexOperations {
 				.orElse(null);
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.index.ReactiveIndexOperations#dropIndex(java.lang.String)
+	 */
 	public Mono<Void> dropIndex(final String name) {
 		return mongoOperations.execute(collectionName, collection -> collection.dropIndex(name)).then();
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.index.ReactiveIndexOperations#dropAllIndexes()
+	 */
 	public Mono<Void> dropAllIndexes() {
 		return dropIndex("*");
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.index.ReactiveIndexOperations#getIndexInfo()
+	 */
 	public Flux<IndexInfo> getIndexInfo() {
 
 		return mongoOperations.execute(collectionName, collection -> collection.listIndexes(Document.class)) //

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

@@ -31,6 +31,7 @@ import org.bson.types.ObjectId;
 import org.springframework.dao.DataAccessException;
 import org.springframework.data.mongodb.core.script.ExecutableMongoScript;
 import org.springframework.data.mongodb.core.script.NamedMongoScript;
+import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.CollectionUtils;
 import org.springframework.util.ObjectUtils;
@@ -64,29 +65,41 @@ class DefaultScriptOperations implements ScriptOperations {
 	 */
 	public DefaultScriptOperations(MongoOperations mongoOperations) {
 
-		Assert.notNull(mongoOperations, "MongoOperations must not be null");
+		Assert.notNull(mongoOperations, "MongoOperations must not be null!");
 
 		this.mongoOperations = mongoOperations;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ScriptOperations#register(org.springframework.data.mongodb.core.script.ExecutableMongoScript)
+	 */
 	@Override
 	public NamedMongoScript register(ExecutableMongoScript script) {
 		return register(new NamedMongoScript(generateScriptName(), script));
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ScriptOperations#register(org.springframework.data.mongodb.core.script.NamedMongoScript)
+	 */
 	@Override
 	public NamedMongoScript register(NamedMongoScript script) {
 
-		Assert.notNull(script, "Script must not be null");
+		Assert.notNull(script, "Script must not be null!");
 
 		mongoOperations.save(script, SCRIPT_COLLECTION_NAME);
 		return script;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ScriptOperations#execute(org.springframework.data.mongodb.core.script.ExecutableMongoScript, java.lang.Object[])
+	 */
 	@Override
 	public Object execute(final ExecutableMongoScript script, final Object... args) {
 
-		Assert.notNull(script, "Script must not be null");
+		Assert.notNull(script, "Script must not be null!");
 
 		return mongoOperations.execute(new DbCallback<Object>() {
 
@@ -102,10 +115,14 @@ class DefaultScriptOperations implements ScriptOperations {
 		});
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ScriptOperations#call(java.lang.String, java.lang.Object[])
+	 */
 	@Override
 	public Object call(final String scriptName, final Object... args) {
 
-		Assert.hasText(scriptName, "ScriptName must not be null or empty");
+		Assert.hasText(scriptName, "ScriptName must not be null or empty!");
 
 		return mongoOperations.execute(new DbCallback<Object>() {
 
@@ -118,14 +135,22 @@ class DefaultScriptOperations implements ScriptOperations {
 		});
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ScriptOperations#exists(java.lang.String)
+	 */
 	@Override
 	public boolean exists(String scriptName) {
 
-		Assert.hasText(scriptName, "ScriptName must not be null or empty");
+		Assert.hasText(scriptName, "ScriptName must not be null or empty!");
 
 		return mongoOperations.exists(query(where("_id").is(scriptName)), NamedMongoScript.class, SCRIPT_COLLECTION_NAME);
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ScriptOperations#getScriptNames()
+	 */
 	@Override
 	public Set<String> getScriptNames() {
 

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

@@ -1,60 +0,0 @@
-/*
- * Copyright 2022 the original author 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
- *
- *      https://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.context.ApplicationEventPublisher;
-import org.springframework.lang.Nullable;
-
-/**
- * Delegate class to encapsulate lifecycle event configuration and publishing.
- *
- * @author Mark Paluch
- * @since 4.0
- * @see ApplicationEventPublisher
- */
-class EntityLifecycleEventDelegate {
-
-	private @Nullable ApplicationEventPublisher publisher;
-	private boolean eventsEnabled = true;
-
-	public void setPublisher(@Nullable ApplicationEventPublisher publisher) {
-		this.publisher = publisher;
-	}
-
-	public boolean isEventsEnabled() {
-		return eventsEnabled;
-	}
-
-	public void setEventsEnabled(boolean eventsEnabled) {
-		this.eventsEnabled = eventsEnabled;
-	}
-
-	/**
-	 * Publish an application event if event publishing is enabled.
-	 *
-	 * @param event the application event.
-	 */
-	public void publishEvent(Object event) {
-
-		if (canPublishEvent()) {
-			publisher.publishEvent(event);
-		}
-	}
-
-	private boolean canPublishEvent() {
-		return publisher != null && eventsEnabled;
-	}
-}

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

@@ -23,7 +23,6 @@ import java.util.Optional;
 import org.bson.Document;
 import org.springframework.core.convert.ConversionService;
 import org.springframework.dao.InvalidDataAccessApiUsageException;
-import org.springframework.data.convert.CustomConversions;
 import org.springframework.data.mapping.IdentifierAccessor;
 import org.springframework.data.mapping.MappingException;
 import org.springframework.data.mapping.PersistentEntity;
@@ -31,10 +30,7 @@ import org.springframework.data.mapping.PersistentPropertyAccessor;
 import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.data.mapping.model.ConvertingPropertyAccessor;
 import org.springframework.data.mongodb.core.CollectionOptions.TimeSeriesOptions;
-import org.springframework.data.mongodb.core.convert.MongoConverter;
-import org.springframework.data.mongodb.core.convert.MongoJsonSchemaMapper;
 import org.springframework.data.mongodb.core.convert.MongoWriter;
-import org.springframework.data.mongodb.core.convert.QueryMapper;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
 import org.springframework.data.mongodb.core.mapping.MongoSimpleTypes;
@@ -43,11 +39,6 @@ import org.springframework.data.mongodb.core.query.Collation;
 import org.springframework.data.mongodb.core.query.Criteria;
 import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.data.mongodb.core.timeseries.Granularity;
-import org.springframework.data.mongodb.core.validation.Validator;
-import org.springframework.data.projection.EntityProjection;
-import org.springframework.data.projection.EntityProjectionIntrospector;
-import org.springframework.data.projection.ProjectionFactory;
-import org.springframework.data.util.Optionals;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
@@ -56,11 +47,6 @@ import org.springframework.util.MultiValueMap;
 import org.springframework.util.ObjectUtils;
 import org.springframework.util.StringUtils;
 
-import com.mongodb.client.model.ChangeStreamPreAndPostImagesOptions;
-import com.mongodb.client.model.CreateCollectionOptions;
-import com.mongodb.client.model.TimeSeriesGranularity;
-import com.mongodb.client.model.ValidationOptions;
-
 /**
  * Common operations performed on an entity in the context of it's mapping metadata.
  *
@@ -76,31 +62,9 @@ class EntityOperations {
 	private static final String ID_FIELD = "_id";
 
 	private final MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> context;
-	private final QueryMapper queryMapper;
 
-	private final EntityProjectionIntrospector introspector;
-
-	private final MongoJsonSchemaMapper schemaMapper;
-
-	EntityOperations(MongoConverter converter) {
-		this(converter, new QueryMapper(converter));
-	}
-
-	EntityOperations(MongoConverter converter, QueryMapper queryMapper) {
-		this(converter, converter.getMappingContext(), converter.getCustomConversions(), converter.getProjectionFactory(),
-				queryMapper);
-	}
-
-	EntityOperations(MongoConverter converter,
-			MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> context,
-			CustomConversions conversions, ProjectionFactory projectionFactory, QueryMapper queryMapper) {
+	EntityOperations(MappingContext<? extends MongoPersistentEntity<?>, MongoPersistentProperty> context) {
 		this.context = context;
-		this.queryMapper = queryMapper;
-		this.introspector = EntityProjectionIntrospector.create(projectionFactory,
-				EntityProjectionIntrospector.ProjectionPredicate.typeHierarchy()
-						.and(((target, underlyingType) -> !conversions.isSimpleType(target))),
-				context);
-		this.schemaMapper = new MongoJsonSchemaMapper(converter);
 	}
 
 	/**
@@ -112,7 +76,7 @@ class EntityOperations {
 	@SuppressWarnings({ "unchecked", "rawtypes" })
 	<T> Entity<T> forEntity(T entity) {
 
-		Assert.notNull(entity, "Bean must not be null");
+		Assert.notNull(entity, "Bean must not be null!");
 
 		if (entity instanceof String) {
 			return new UnmappedEntity(parse(entity.toString()));
@@ -135,8 +99,8 @@ class EntityOperations {
 	@SuppressWarnings({ "unchecked", "rawtypes" })
 	<T> AdaptibleEntity<T> forEntity(T entity, ConversionService conversionService) {
 
-		Assert.notNull(entity, "Bean must not be null");
-		Assert.notNull(conversionService, "ConversionService must not be null");
+		Assert.notNull(entity, "Bean must not be null!");
+		Assert.notNull(conversionService, "ConversionService must not be null!");
 
 		if (entity instanceof String) {
 			return new UnmappedEntity(parse(entity.toString()));
@@ -171,7 +135,7 @@ class EntityOperations {
 
 		if (entityClass == null) {
 			throw new InvalidDataAccessApiUsageException(
-					"No class parameter provided, entity collection can't be determined");
+					"No class parameter provided, entity collection can't be determined!");
 		}
 
 		MongoPersistentEntity<?> persistentEntity = context.getPersistentEntity(entityClass);
@@ -208,7 +172,7 @@ class EntityOperations {
 	 */
 	public String getIdPropertyName(Class<?> type) {
 
-		Assert.notNull(type, "Type must not be null");
+		Assert.notNull(type, "Type must not be null!");
 
 		MongoPersistentEntity<?> persistentEntity = context.getPersistentEntity(type);
 
@@ -247,12 +211,12 @@ class EntityOperations {
 		try {
 			return Document.parse(source);
 		} catch (org.bson.json.JsonParseException o_O) {
-			throw new MappingException("Could not parse given String to save into a JSON document", o_O);
+			throw new MappingException("Could not parse given String to save into a JSON document!", o_O);
 		} catch (RuntimeException o_O) {
 
 			// legacy 3.x exception
 			if (ClassUtils.matchesTypeName(o_O.getClass(), "JSONParseException")) {
-				throw new MappingException("Could not parse given String to save into a JSON document", o_O);
+				throw new MappingException("Could not parse given String to save into a JSON document!", o_O);
 			}
 			throw o_O;
 		}
@@ -272,92 +236,6 @@ class EntityOperations {
 		return UntypedOperations.instance();
 	}
 
-	/**
-	 * Introspect the given {@link Class result type} in the context of the {@link Class entity type} whether the returned
-	 * type is a projection and what property paths are participating in the projection.
-	 *
-	 * @param resultType the type to project on. Must not be {@literal null}.
-	 * @param entityType the source domain type. Must not be {@literal null}.
-	 * @return the introspection result.
-	 * @since 3.4
-	 * @see EntityProjectionIntrospector#introspect(Class, Class)
-	 */
-	public <M, D> EntityProjection<M, D> introspectProjection(Class<M> resultType, Class<D> entityType) {
-		return introspector.introspect(resultType, entityType);
-	}
-
-	/**
-	 * Convert {@link CollectionOptions} to {@link CreateCollectionOptions} using {@link Class entityType} to obtain
-	 * mapping metadata.
-	 *
-	 * @param collectionOptions
-	 * @param entityType
-	 * @return
-	 * @since 3.4
-	 */
-	public CreateCollectionOptions convertToCreateCollectionOptions(@Nullable CollectionOptions collectionOptions,
-			Class<?> entityType) {
-
-		Optional<Collation> collation = Optionals.firstNonEmpty(
-				() -> Optional.ofNullable(collectionOptions).flatMap(CollectionOptions::getCollation),
-				() -> forType(entityType).getCollation());//
-
-		CreateCollectionOptions result = new CreateCollectionOptions();
-		collation.map(Collation::toMongoCollation).ifPresent(result::collation);
-
-		if (collectionOptions == null) {
-			return result;
-		}
-
-		collectionOptions.getCapped().ifPresent(result::capped);
-		collectionOptions.getSize().ifPresent(result::sizeInBytes);
-		collectionOptions.getMaxDocuments().ifPresent(result::maxDocuments);
-		collectionOptions.getCollation().map(Collation::toMongoCollation).ifPresent(result::collation);
-
-		collectionOptions.getValidationOptions().ifPresent(it -> {
-
-			ValidationOptions validationOptions = new ValidationOptions();
-
-			it.getValidationAction().ifPresent(validationOptions::validationAction);
-			it.getValidationLevel().ifPresent(validationOptions::validationLevel);
-
-			it.getValidator().ifPresent(val -> validationOptions.validator(getMappedValidator(val, entityType)));
-
-			result.validationOptions(validationOptions);
-		});
-
-		collectionOptions.getTimeSeriesOptions().map(forType(entityType)::mapTimeSeriesOptions).ifPresent(it -> {
-
-			com.mongodb.client.model.TimeSeriesOptions options = new com.mongodb.client.model.TimeSeriesOptions(
-					it.getTimeField());
-
-			if (StringUtils.hasText(it.getMetaField())) {
-				options.metaField(it.getMetaField());
-			}
-			if (!Granularity.DEFAULT.equals(it.getGranularity())) {
-				options.granularity(TimeSeriesGranularity.valueOf(it.getGranularity().name().toUpperCase()));
-			}
-
-			result.timeSeriesOptions(options);
-		});
-
-		collectionOptions.getChangeStreamOptions().ifPresent(it -> result
-				.changeStreamPreAndPostImagesOptions(new ChangeStreamPreAndPostImagesOptions(it.getPreAndPostImages())));
-
-		return result;
-	}
-
-	private Document getMappedValidator(Validator validator, Class<?> domainType) {
-
-		Document validationRules = validator.toDocument();
-
-		if (validationRules.containsKey("$jsonSchema")) {
-			return schemaMapper.mapSchema(validationRules, domainType);
-		}
-
-		return queryMapper.getMappedObject(validationRules, context.getPersistentEntity(domainType));
-	}
-
 	/**
 	 * A representation of information about an entity.
 	 *
@@ -502,21 +380,37 @@ class EntityOperations {
 			this.map = map;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#getIdPropertyName()
+		 */
 		@Override
 		public String getIdFieldName() {
 			return ID_FIELD;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#getId()
+		 */
 		@Override
 		public Object getId() {
 			return map.get(ID_FIELD);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#getByIdQuery()
+		 */
 		@Override
 		public Query getByIdQuery() {
 			return Query.query(Criteria.where(ID_FIELD).is(map.get(ID_FIELD)));
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.MutablePersistableSource#populateIdIfNecessary(java.lang.Object)
+		 */
 		@Nullable
 		@Override
 		public T populateIdIfNecessary(@Nullable Object id) {
@@ -526,11 +420,19 @@ class EntityOperations {
 			return map;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#getQueryForVersion()
+		 */
 		@Override
 		public Query getQueryForVersion() {
-			throw new MappingException("Cannot query for version on plain Documents");
+			throw new MappingException("Cannot query for version on plain Documents!");
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#toMappedDocument(org.springframework.data.mongodb.core.convert.MongoWriter)
+		 */
 		@Override
 		public MappedDocument toMappedDocument(MongoWriter<? super T> writer) {
 			return MappedDocument.of(map instanceof Document //
@@ -538,27 +440,47 @@ class EntityOperations {
 					: new Document(map));
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.MutablePersistableSource#initializeVersionProperty()
+		 */
 		@Override
 		public T initializeVersionProperty() {
 			return map;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.MutablePersistableSource#getVersion()
+		 */
 		@Override
 		@Nullable
 		public Number getVersion() {
 			return null;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.MutablePersistableSource#incrementVersion()
+		 */
 		@Override
 		public T incrementVersion() {
 			return map;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#getBean()
+		 */
 		@Override
 		public T getBean() {
 			return map;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.Entity#isNew()
+		 */
 		@Override
 		public boolean isNew() {
 			return map.get(ID_FIELD) != null;
@@ -571,6 +493,10 @@ class EntityOperations {
 			super(map);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#toMappedDocument(org.springframework.data.mongodb.core.convert.MongoWriter)
+		 */
 		@Override
 		@SuppressWarnings("unchecked")
 		public MappedDocument toMappedDocument(MongoWriter<? super T> writer) {
@@ -610,21 +536,33 @@ class EntityOperations {
 			return new MappedEntity<>(entity, identifierAccessor, propertyAccessor);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#getIdPropertyName()
+		 */
 		@Override
 		public String getIdFieldName() {
 			return entity.getRequiredIdProperty().getFieldName();
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#getId()
+		 */
 		@Override
 		public Object getId() {
 			return idAccessor.getRequiredIdentifier();
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#getByIdQuery()
+		 */
 		@Override
 		public Query getByIdQuery() {
 
 			if (!entity.hasIdProperty()) {
-				throw new MappingException("No id property found for object of type " + entity.getType());
+				throw new MappingException("No id property found for object of type " + entity.getType() + "!");
 			}
 
 			MongoPersistentProperty idProperty = entity.getRequiredIdProperty();
@@ -632,6 +570,10 @@ class EntityOperations {
 			return Query.query(Criteria.where(idProperty.getName()).is(getId()));
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#getQueryForVersion(java.lang.Object)
+		 */
 		@Override
 		public Query getQueryForVersion() {
 
@@ -642,6 +584,10 @@ class EntityOperations {
 					.and(versionProperty.getName()).is(getVersion()));
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#toMappedDocument(org.springframework.data.mongodb.core.convert.MongoWriter)
+		 */
 		@Override
 		public MappedDocument toMappedDocument(MongoWriter<? super T> writer) {
 
@@ -657,6 +603,10 @@ class EntityOperations {
 			return MappedDocument.of(document);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.Entity#assertUpdateableIdIfNotSet()
+		 */
 		public void assertUpdateableIdIfNotSet() {
 
 			if (!entity.hasIdProperty()) {
@@ -672,27 +622,43 @@ class EntityOperations {
 
 			if (!MongoSimpleTypes.AUTOGENERATED_ID_TYPES.contains(property.getType())) {
 				throw new InvalidDataAccessApiUsageException(
-						String.format("Cannot autogenerate id of type %s for entity of type %s", property.getType().getName(),
+						String.format("Cannot autogenerate id of type %s for entity of type %s!", property.getType().getName(),
 								entity.getType().getName()));
 			}
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#isVersionedEntity()
+		 */
 		@Override
 		public boolean isVersionedEntity() {
 			return entity.hasVersionProperty();
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#getVersion()
+		 */
 		@Override
 		@Nullable
 		public Object getVersion() {
 			return propertyAccessor.getProperty(entity.getRequiredVersionProperty());
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#getBean()
+		 */
 		@Override
 		public T getBean() {
 			return propertyAccessor.getBean();
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.Entity#isNew()
+		 */
 		@Override
 		public boolean isNew() {
 			return entity.isNew(propertyAccessor.getBean());
@@ -727,6 +693,10 @@ class EntityOperations {
 					new ConvertingPropertyAccessor<>(propertyAccessor, conversionService));
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.AdaptibleEntity#populateIdIfNecessary(java.lang.Object)
+		 */
 		@Nullable
 		@Override
 		public T populateIdIfNecessary(@Nullable Object id) {
@@ -748,6 +718,10 @@ class EntityOperations {
 			return propertyAccessor.getBean();
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.MappedEntity#getVersion()
+		 */
 		@Override
 		@Nullable
 		public Number getVersion() {
@@ -757,6 +731,10 @@ class EntityOperations {
 			return propertyAccessor.getProperty(versionProperty, Number.class);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.AdaptibleEntity#initializeVersionProperty()
+		 */
 		@Override
 		public T initializeVersionProperty() {
 
@@ -771,6 +749,10 @@ class EntityOperations {
 			return propertyAccessor.getBean();
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.AdaptibleEntity#incrementVersion()
+		 */
 		@Override
 		public T incrementVersion() {
 
@@ -842,11 +824,19 @@ class EntityOperations {
 			return (TypedOperations) INSTANCE;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.TypedOperations#getCollation()
+		 */
 		@Override
 		public Optional<Collation> getCollation() {
 			return Optional.empty();
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.TypedOperations#getCollation(org.springframework.data.mongodb.core.query.Query)
+		 */
 		@Override
 		public Optional<Collation> getCollation(Query query) {
 
@@ -881,11 +871,19 @@ class EntityOperations {
 			this.entity = entity;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.TypedOperations#getCollation()
+		 */
 		@Override
 		public Optional<Collation> getCollation() {
 			return Optional.ofNullable(entity.getCollation());
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.EntityOperations.TypedOperations#getCollation(org.springframework.data.mongodb.core.query.Query)
+		 */
 		@Override
 		public Optional<Collation> getCollation(Query query) {
 

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

@@ -15,10 +15,9 @@
  */
 package org.springframework.data.mongodb.core;
 
-import java.util.stream.Stream;
-
 import org.springframework.data.mongodb.core.aggregation.Aggregation;
 import org.springframework.data.mongodb.core.aggregation.AggregationResults;
+import org.springframework.data.util.CloseableIterator;
 
 /**
  * {@link ExecutableAggregationOperation} allows creation and execution of MongoDB aggregation operations in a fluent
@@ -89,12 +88,12 @@ public interface ExecutableAggregationOperation {
 
 		/**
 		 * Apply pipeline operations as specified and stream all matching elements. <br />
-		 * Returns a {@link Stream} that wraps the Mongo DB {@link com.mongodb.client.FindIterable}
+		 * Returns a {@link CloseableIterator} that wraps the a Mongo DB {@link com.mongodb.client.FindIterable}
 		 *
-		 * @return the result {@link Stream}, containing mapped objects, needing to be closed once fully processed (e.g.
-		 *         through a try-with-resources clause).
+		 * @return a {@link CloseableIterator} that wraps the a Mongo DB {@link com.mongodb.client.FindIterable} that needs to be closed.
+		 *         Never {@literal null}.
 		 */
-		Stream<T> stream();
+		CloseableIterator<T> stream();
 	}
 
 	/**

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

@@ -15,11 +15,10 @@
  */
 package org.springframework.data.mongodb.core;
 
-import java.util.stream.Stream;
-
 import org.springframework.data.mongodb.core.aggregation.Aggregation;
 import org.springframework.data.mongodb.core.aggregation.AggregationResults;
 import org.springframework.data.mongodb.core.aggregation.TypedAggregation;
+import org.springframework.data.util.CloseableIterator;
 import org.springframework.util.Assert;
 import org.springframework.util.StringUtils;
 
@@ -38,10 +37,14 @@ class ExecutableAggregationOperationSupport implements ExecutableAggregationOper
 		this.template = template;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ExecutableAggregationOperation#aggregateAndReturn(java.lang.Class)
+	 */
 	@Override
 	public <T> ExecutableAggregation<T> aggregateAndReturn(Class<T> domainType) {
 
-		Assert.notNull(domainType, "DomainType must not be null");
+		Assert.notNull(domainType, "DomainType must not be null!");
 
 		return new ExecutableAggregationSupport<>(template, domainType, null, null);
 	}
@@ -66,29 +69,45 @@ class ExecutableAggregationOperationSupport implements ExecutableAggregationOper
 			this.collection = collection;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableAggregationOperation.AggregationWithCollection#inCollection(java.lang.String)
+		 */
 		@Override
 		public AggregationWithAggregation<T> inCollection(String collection) {
 
-			Assert.hasText(collection, "Collection must not be null nor empty");
+			Assert.hasText(collection, "Collection must not be null nor empty!");
 
 			return new ExecutableAggregationSupport<>(template, domainType, aggregation, collection);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableAggregationOperation.AggregationWithAggregation#by(org.springframework.data.mongodb.core.aggregation.Aggregation)
+		 */
 		@Override
 		public TerminatingAggregation<T> by(Aggregation aggregation) {
 
-			Assert.notNull(aggregation, "Aggregation must not be null");
+			Assert.notNull(aggregation, "Aggregation must not be null!");
 
 			return new ExecutableAggregationSupport<>(template, domainType, aggregation, collection);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableAggregationOperation.TerminatingAggregation#all()
+		 */
 		@Override
 		public AggregationResults<T> all() {
 			return template.aggregate(aggregation, getCollectionName(aggregation), domainType);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableAggregationOperation.TerminatingAggregation#stream()
+		 */
 		@Override
-		public Stream<T> stream() {
+		public CloseableIterator<T> stream() {
 			return template.aggregateStream(aggregation, getCollectionName(aggregation), domainType);
 		}
 

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

@@ -118,8 +118,8 @@ public interface ExecutableFindOperation {
 		/**
 		 * Stream all matching elements.
 		 *
-		 * @return the result {@link Stream}, containing mapped objects, needing to be closed once fully processed (e.g.
-		 *         through a try-with-resources clause).
+		 * @return a {@link Stream} that wraps the a Mongo DB {@link com.mongodb.client.FindIterable} that needs to be closed. Never
+		 *         {@literal null}.
 		 */
 		Stream<T> stream();
 

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

@@ -20,11 +20,12 @@ import java.util.Optional;
 import java.util.stream.Stream;
 
 import org.bson.Document;
-
 import org.springframework.dao.IncorrectResultSizeDataAccessException;
 import org.springframework.data.mongodb.core.query.NearQuery;
 import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.data.mongodb.core.query.SerializationUtils;
+import org.springframework.data.util.CloseableIterator;
+import org.springframework.data.util.StreamUtils;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.ObjectUtils;
@@ -50,10 +51,14 @@ class ExecutableFindOperationSupport implements ExecutableFindOperation {
 		this.template = template;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ExecutableFindOperation#query(java.lang.Class)
+	 */
 	@Override
 	public <T> ExecutableFind<T> query(Class<T> domainType) {
 
-		Assert.notNull(domainType, "DomainType must not be null");
+		Assert.notNull(domainType, "DomainType must not be null!");
 
 		return new ExecutableFindSupport<>(template, domainType, domainType, null, ALL_QUERY);
 	}
@@ -69,11 +74,11 @@ class ExecutableFindOperationSupport implements ExecutableFindOperation {
 		private final MongoTemplate template;
 		private final Class<?> domainType;
 		private final Class<T> returnType;
-		private final @Nullable String collection;
+		@Nullable private final String collection;
 		private final Query query;
 
 		ExecutableFindSupport(MongoTemplate template, Class<?> domainType, Class<T> returnType,
-				@Nullable String collection, Query query) {
+				String collection, Query query) {
 			this.template = template;
 			this.domainType = domainType;
 			this.returnType = returnType;
@@ -81,30 +86,46 @@ class ExecutableFindOperationSupport implements ExecutableFindOperation {
 			this.query = query;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.FindWithCollection#inCollection(java.lang.String)
+		 */
 		@Override
 		public FindWithProjection<T> inCollection(String collection) {
 
-			Assert.hasText(collection, "Collection name must not be null nor empty");
+			Assert.hasText(collection, "Collection name must not be null nor empty!");
 
 			return new ExecutableFindSupport<>(template, domainType, returnType, collection, query);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.FindWithProjection#as(Class)
+		 */
 		@Override
 		public <T1> FindWithQuery<T1> as(Class<T1> returnType) {
 
-			Assert.notNull(returnType, "ReturnType must not be null");
+			Assert.notNull(returnType, "ReturnType must not be null!");
 
 			return new ExecutableFindSupport<>(template, domainType, returnType, collection, query);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.FindWithQuery#matching(org.springframework.data.mongodb.core.query.Query)
+		 */
 		@Override
 		public TerminatingFind<T> matching(Query query) {
 
-			Assert.notNull(query, "Query must not be null");
+			Assert.notNull(query, "Query must not be null!");
 
 			return new ExecutableFindSupport<>(template, domainType, returnType, collection, query);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.TerminatingFind#oneValue()
+		 */
 		@Override
 		public T oneValue() {
 
@@ -115,12 +136,16 @@ class ExecutableFindOperationSupport implements ExecutableFindOperation {
 			}
 
 			if (result.size() > 1) {
-				throw new IncorrectResultSizeDataAccessException("Query " + asString() + " returned non unique result", 1);
+				throw new IncorrectResultSizeDataAccessException("Query " + asString() + " returned non unique result.", 1);
 			}
 
 			return result.iterator().next();
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.TerminatingFind#firstValue()
+		 */
 		@Override
 		public T firstValue() {
 
@@ -129,36 +154,60 @@ class ExecutableFindOperationSupport implements ExecutableFindOperation {
 			return ObjectUtils.isEmpty(result) ? null : result.iterator().next();
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.TerminatingFind#all()
+		 */
 		@Override
 		public List<T> all() {
 			return doFind(null);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.TerminatingFind#stream()
+		 */
 		@Override
 		public Stream<T> stream() {
-			return doStream();
+			return StreamUtils.createStreamFromIterator(doStream());
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.FindWithQuery#near(org.springframework.data.mongodb.core.query.NearQuery)
+		 */
 		@Override
 		public TerminatingFindNear<T> near(NearQuery nearQuery) {
 			return () -> template.geoNear(nearQuery, domainType, getCollectionName(), returnType);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.TerminatingFind#count()
+		 */
 		@Override
 		public long count() {
 			return template.count(query, domainType, getCollectionName());
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.TerminatingFind#exists()
+		 */
 		@Override
 		public boolean exists() {
 			return template.exists(query, domainType, getCollectionName());
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.FindDistinct#distinct(java.lang.String)
+		 */
 		@SuppressWarnings("unchecked")
 		@Override
 		public TerminatingDistinct<Object> distinct(String field) {
 
-			Assert.notNull(field, "Field must not be null");
+			Assert.notNull(field, "Field must not be null!");
 
 			return new DistinctOperationSupport(this, field);
 		}
@@ -178,7 +227,7 @@ class ExecutableFindOperationSupport implements ExecutableFindOperation {
 					returnType == domainType ? (Class<T>) Object.class : returnType);
 		}
 
-		private Stream<T> doStream() {
+		private CloseableIterator<T> doStream() {
 			return template.doStream(query, domainType, getCollectionName(), returnType);
 		}
 
@@ -208,6 +257,10 @@ class ExecutableFindOperationSupport implements ExecutableFindOperation {
 			this.delegate = delegate;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.CursorPreparer#prepare(com.mongodb.clientFindIterable)
+		 */
 		@Override
 		public FindIterable<Document> prepare(FindIterable<Document> iterable) {
 
@@ -242,23 +295,35 @@ class ExecutableFindOperationSupport implements ExecutableFindOperation {
 			this.field = field;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.DistinctWithProjection#as(java.lang.Class)
+		 */
 		@Override
 		@SuppressWarnings("unchecked")
 		public <R> TerminatingDistinct<R> as(Class<R> resultType) {
 
-			Assert.notNull(resultType, "ResultType must not be null");
+			Assert.notNull(resultType, "ResultType must not be null!");
 
 			return new DistinctOperationSupport<>((ExecutableFindSupport) delegate.as(resultType), field);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.DistinctWithQuery#matching(org.springframework.data.mongodb.core.query.Query)
+		 */
 		@Override
 		public TerminatingDistinct<T> matching(Query query) {
 
-			Assert.notNull(query, "Query must not be null");
+			Assert.notNull(query, "Query must not be null!");
 
 			return new DistinctOperationSupport<>((ExecutableFindSupport<T>) delegate.matching(query), field);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableFindOperation.TerminatingDistinct#all()
+		 */
 		@Override
 		public List<T> all() {
 			return delegate.doFindDistinct(field);

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

@@ -40,10 +40,14 @@ class ExecutableInsertOperationSupport implements ExecutableInsertOperation {
 		this.template = template;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.coreExecutableInsertOperation#insert(java.lan.Class)
+	 */
 	@Override
 	public <T> ExecutableInsert<T> insert(Class<T> domainType) {
 
-		Assert.notNull(domainType, "DomainType must not be null");
+		Assert.notNull(domainType, "DomainType must not be null!");
 
 		return new ExecutableInsertSupport<>(template, domainType, null, null);
 	}
@@ -67,43 +71,63 @@ class ExecutableInsertOperationSupport implements ExecutableInsertOperation {
 			this.bulkMode = bulkMode;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableInsertOperation.TerminatingInsert#insert(java.lang.Class)
+		 */
 		@Override
 		public T one(T object) {
 
-			Assert.notNull(object, "Object must not be null");
+			Assert.notNull(object, "Object must not be null!");
 
 			return template.insert(object, getCollectionName());
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableInsertOperation.TerminatingInsert#all(java.util.Collection)
+		 */
 		@Override
 		public Collection<T> all(Collection<? extends T> objects) {
 
-			Assert.notNull(objects, "Objects must not be null");
+			Assert.notNull(objects, "Objects must not be null!");
 
 			return template.insert(objects, getCollectionName());
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableInsertOperation.TerminatingBulkInsert#bulk(java.util.Collection)
+		 */
 		@Override
 		public BulkWriteResult bulk(Collection<? extends T> objects) {
 
-			Assert.notNull(objects, "Objects must not be null");
+			Assert.notNull(objects, "Objects must not be null!");
 
 			return template.bulkOps(bulkMode != null ? bulkMode : BulkMode.ORDERED, domainType, getCollectionName())
 					.insert(new ArrayList<>(objects)).execute();
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableInsertOperation.InsertWithCollection#inCollection(java.lang.String)
+		 */
 		@Override
 		public InsertWithBulkMode<T> inCollection(String collection) {
 
-			Assert.hasText(collection, "Collection must not be null nor empty");
+			Assert.hasText(collection, "Collection must not be null nor empty.");
 
 			return new ExecutableInsertSupport<>(template, domainType, collection, bulkMode);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableInsertOperation.InsertWithBulkMode#withBulkMode(org.springframework.data.mongodb.core.BulkMode)
+		 */
 		@Override
 		public TerminatingBulkInsert<T> withBulkMode(BulkMode bulkMode) {
 
-			Assert.notNull(bulkMode, "BulkMode must not be null");
+			Assert.notNull(bulkMode, "BulkMode must not be null!");
 
 			return new ExecutableInsertSupport<>(template, domainType, collection, bulkMode);
 		}

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

@@ -187,9 +187,7 @@ public interface ExecutableMapReduceOperation {
 	 *
 	 * @author Christoph Strobl
 	 * @since 2.1
-	 * @deprecated since 4.0 in favor of {@link org.springframework.data.mongodb.core.aggregation}.
 	 */
-	@Deprecated
 	interface MapReduceWithOptions<T> {
 
 		/**

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

@@ -37,7 +37,7 @@ class ExecutableMapReduceOperationSupport implements ExecutableMapReduceOperatio
 
 	ExecutableMapReduceOperationSupport(MongoTemplate template) {
 
-		Assert.notNull(template, "Template must not be null");
+		Assert.notNull(template, "Template must not be null!");
 		this.template = template;
 	}
 
@@ -48,7 +48,7 @@ class ExecutableMapReduceOperationSupport implements ExecutableMapReduceOperatio
 	@Override
 	public <T> ExecutableMapReduceSupport<T> mapReduce(Class<T> domainType) {
 
-		Assert.notNull(domainType, "DomainType must not be null");
+		Assert.notNull(domainType, "DomainType must not be null!");
 
 		return new ExecutableMapReduceSupport<>(template, domainType, domainType, null, ALL_QUERY, null, null, null);
 	}
@@ -101,7 +101,7 @@ class ExecutableMapReduceOperationSupport implements ExecutableMapReduceOperatio
 		@Override
 		public MapReduceWithProjection<T> inCollection(String collection) {
 
-			Assert.hasText(collection, "Collection name must not be null nor empty");
+			Assert.hasText(collection, "Collection name must not be null nor empty!");
 
 			return new ExecutableMapReduceSupport<>(template, domainType, returnType, collection, query, mapFunction,
 					reduceFunction, options);
@@ -114,7 +114,7 @@ class ExecutableMapReduceOperationSupport implements ExecutableMapReduceOperatio
 		@Override
 		public TerminatingMapReduce<T> matching(Query query) {
 
-			Assert.notNull(query, "Query must not be null");
+			Assert.notNull(query, "Query must not be null!");
 
 			return new ExecutableMapReduceSupport<>(template, domainType, returnType, collection, query, mapFunction,
 					reduceFunction, options);
@@ -127,7 +127,7 @@ class ExecutableMapReduceOperationSupport implements ExecutableMapReduceOperatio
 		@Override
 		public <R> MapReduceWithQuery<R> as(Class<R> resultType) {
 
-			Assert.notNull(resultType, "ResultType must not be null");
+			Assert.notNull(resultType, "ResultType must not be null!");
 
 			return new ExecutableMapReduceSupport<>(template, domainType, resultType, collection, query, mapFunction,
 					reduceFunction, options);
@@ -140,7 +140,7 @@ class ExecutableMapReduceOperationSupport implements ExecutableMapReduceOperatio
 		@Override
 		public ExecutableMapReduce<T> with(MapReduceOptions options) {
 
-			Assert.notNull(options, "Options must not be null Please consider empty MapReduceOptions#options() instead");
+			Assert.notNull(options, "Options must not be null! Please consider empty MapReduceOptions#options() instead.");
 
 			return new ExecutableMapReduceSupport<>(template, domainType, returnType, collection, query, mapFunction,
 					reduceFunction, options);
@@ -153,7 +153,7 @@ class ExecutableMapReduceOperationSupport implements ExecutableMapReduceOperatio
 		@Override
 		public MapReduceWithReduceFunction<T> map(String mapFunction) {
 
-			Assert.hasText(mapFunction, "MapFunction name must not be null nor empty");
+			Assert.hasText(mapFunction, "MapFunction name must not be null nor empty!");
 
 			return new ExecutableMapReduceSupport<>(template, domainType, returnType, collection, query, mapFunction,
 					reduceFunction, options);
@@ -166,7 +166,7 @@ class ExecutableMapReduceOperationSupport implements ExecutableMapReduceOperatio
 		@Override
 		public ExecutableMapReduce<T> reduce(String reduceFunction) {
 
-			Assert.hasText(reduceFunction, "ReduceFunction name must not be null nor empty");
+			Assert.hasText(reduceFunction, "ReduceFunction name must not be null nor empty!");
 
 			return new ExecutableMapReduceSupport<>(template, domainType, returnType, collection, query, mapFunction,
 					reduceFunction, options);

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

@@ -41,10 +41,14 @@ class ExecutableRemoveOperationSupport implements ExecutableRemoveOperation {
 		this.tempate = tempate;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ExecutableRemoveOperation#remove(java.lang.Class)
+	 */
 	@Override
 	public <T> ExecutableRemove<T> remove(Class<T> domainType) {
 
-		Assert.notNull(domainType, "DomainType must not be null");
+		Assert.notNull(domainType, "DomainType must not be null!");
 
 		return new ExecutableRemoveSupport<>(tempate, domainType, ALL_QUERY, null);
 	}
@@ -67,32 +71,52 @@ class ExecutableRemoveOperationSupport implements ExecutableRemoveOperation {
 			this.collection = collection;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableRemoveOperation.RemoveWithCollection#inCollection(java.lang.String)
+		 */
 		@Override
 		public RemoveWithQuery<T> inCollection(String collection) {
 
-			Assert.hasText(collection, "Collection must not be null nor empty");
+			Assert.hasText(collection, "Collection must not be null nor empty!");
 
 			return new ExecutableRemoveSupport<>(template, domainType, query, collection);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableRemoveOperation.RemoveWithQuery#matching(org.springframework.data.mongodb.core.query.Query)
+		 */
 		@Override
 		public TerminatingRemove<T> matching(Query query) {
 
-			Assert.notNull(query, "Query must not be null");
+			Assert.notNull(query, "Query must not be null!");
 
 			return new ExecutableRemoveSupport<>(template, domainType, query, collection);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableRemoveOperation.TerminatingRemove#all()
+		 */
 		@Override
 		public DeleteResult all() {
 			return template.doRemove(getCollectionName(), query, domainType, true);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableRemoveOperation.TerminatingRemove#one()
+		 */
 		@Override
 		public DeleteResult one() {
 			return template.doRemove(getCollectionName(), query, domainType, false);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableRemoveOperation.TerminatingRemove#findAndRemove()
+		 */
 		@Override
 		public List<T> findAndRemove() {
 

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

@@ -40,10 +40,14 @@ class ExecutableUpdateOperationSupport implements ExecutableUpdateOperation {
 		this.template = template;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ExecutableUpdateOperation#update(java.lang.Class)
+	 */
 	@Override
 	public <T> ExecutableUpdate<T> update(Class<T> domainType) {
 
-		Assert.notNull(domainType, "DomainType must not be null");
+		Assert.notNull(domainType, "DomainType must not be null!");
 
 		return new ExecutableUpdateSupport<>(template, domainType, ALL_QUERY, null, null, null, null, null, domainType);
 	}
@@ -81,84 +85,128 @@ class ExecutableUpdateOperationSupport implements ExecutableUpdateOperation {
 			this.targetType = targetType;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableUpdateOperation.UpdateWithUpdate#apply(org.springframework.data.mongodb.core.query.UpdateDefinition)
+		 */
 		@Override
 		public TerminatingUpdate<T> apply(UpdateDefinition update) {
 
-			Assert.notNull(update, "Update must not be null");
+			Assert.notNull(update, "Update must not be null!");
 
 			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
 					findAndReplaceOptions, replacement, targetType);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableUpdateOperation.UpdateWithCollection#inCollection(java.lang.String)
+		 */
 		@Override
 		public UpdateWithQuery<T> inCollection(String collection) {
 
-			Assert.hasText(collection, "Collection must not be null nor empty");
+			Assert.hasText(collection, "Collection must not be null nor empty!");
 
 			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
 					findAndReplaceOptions, replacement, targetType);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableUpdateOperation.FindAndModifyWithOptions#withOptions(org.springframework.data.mongodb.core.FindAndModifyOptions)
+		 */
 		@Override
 		public TerminatingFindAndModify<T> withOptions(FindAndModifyOptions options) {
 
-			Assert.notNull(options, "Options must not be null");
+			Assert.notNull(options, "Options must not be null!");
 
 			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, options,
 					findAndReplaceOptions, replacement, targetType);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableUpdateOperation.UpdateWithUpdate#replaceWith(Object)
+		 */
 		@Override
 		public FindAndReplaceWithProjection<T> replaceWith(T replacement) {
 
-			Assert.notNull(replacement, "Replacement must not be null");
+			Assert.notNull(replacement, "Replacement must not be null!");
 
 			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
 					findAndReplaceOptions, replacement, targetType);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableUpdateOperation.FindAndReplaceWithOptions#withOptions(org.springframework.data.mongodb.core.FindAndReplaceOptions)
+		 */
 		@Override
 		public FindAndReplaceWithProjection<T> withOptions(FindAndReplaceOptions options) {
 
-			Assert.notNull(options, "Options must not be null");
+			Assert.notNull(options, "Options must not be null!");
 
 			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
 					options, replacement, targetType);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveUpdateOperation.UpdateWithQuery#matching(org.springframework.data.mongodb.core.query.Query)
+		 */
 		@Override
 		public UpdateWithUpdate<T> matching(Query query) {
 
-			Assert.notNull(query, "Query must not be null");
+			Assert.notNull(query, "Query must not be null!");
 
 			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
 					findAndReplaceOptions, replacement, targetType);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveUpdateOperation.FindAndReplaceWithProjection#as(java.lang.Class)
+		 */
 		@Override
 		public <R> FindAndReplaceWithOptions<R> as(Class<R> resultType) {
 
-			Assert.notNull(resultType, "ResultType must not be null");
+			Assert.notNull(resultType, "ResultType must not be null!");
 
 			return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, findAndModifyOptions,
 					findAndReplaceOptions, replacement, resultType);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableUpdateOperation.TerminatingUpdate#all()
+		 */
 		@Override
 		public UpdateResult all() {
 			return doUpdate(true, false);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableUpdateOperation.TerminatingUpdate#first()
+		 */
 		@Override
 		public UpdateResult first() {
 			return doUpdate(false, false);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableUpdateOperation.TerminatingUpdate#upsert()
+		 */
 		@Override
 		public UpdateResult upsert() {
 			return doUpdate(true, true);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableUpdateOperation.TerminatingFindAndModify#findAndModifyValue()
+		 */
 		@Override
 		public @Nullable T findAndModifyValue() {
 
@@ -167,6 +215,10 @@ class ExecutableUpdateOperationSupport implements ExecutableUpdateOperation {
 					getCollectionName());
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ExecutableUpdateOperation.TerminatingFindAndReplace#findAndReplaceValue()
+		 */
 		@Override
 		public @Nullable T findAndReplaceValue() {
 

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

@@ -35,7 +35,7 @@ public class FindAndModifyOptions {
 
 	private static final FindAndModifyOptions NONE = new FindAndModifyOptions() {
 
-		private static final String ERROR_MSG = "FindAndModifyOptions.none() cannot be changed; Please use FindAndModifyOptions.options() instead";
+		private static final String ERROR_MSG = "FindAndModifyOptions.none() cannot be changed. Please use FindAndModifyOptions.options() instead.";
 
 		@Override
 		public FindAndModifyOptions returnNew(boolean returnNew) {

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

@@ -38,7 +38,7 @@ public class FindAndReplaceOptions {
 
 	private static final FindAndReplaceOptions NONE = new FindAndReplaceOptions() {
 
-		private static final String ERROR_MSG = "FindAndReplaceOptions.none() cannot be changed; Please use FindAndReplaceOptions.options() instead";
+		private static final String ERROR_MSG = "FindAndReplaceOptions.none() cannot be changed. Please use FindAndReplaceOptions.options() instead.";
 
 		@Override
 		public FindAndReplaceOptions returnNew() {

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

@@ -61,8 +61,8 @@ public interface FindPublisherPreparer extends ReadPreferenceAware {
 	default FindPublisher<Document> initiateFind(MongoCollection<Document> collection,
 			Function<MongoCollection<Document>, FindPublisher<Document>> find) {
 
-		Assert.notNull(collection, "Collection must not be null");
-		Assert.notNull(find, "Find function must not be null");
+		Assert.notNull(collection, "Collection must not be null!");
+		Assert.notNull(find, "Find function must not be null!");
 
 		if (hasReadPreference()) {
 			collection = collection.withReadPreference(getReadPreference());

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

@@ -39,7 +39,7 @@ class GeoCommandStatistics {
 	 */
 	private GeoCommandStatistics(Document source) {
 
-		Assert.notNull(source, "Source document must not be null");
+		Assert.notNull(source, "Source document must not be null!");
 		this.source = source;
 	}
 
@@ -51,7 +51,7 @@ class GeoCommandStatistics {
 	 */
 	public static GeoCommandStatistics from(Document commandResult) {
 
-		Assert.notNull(commandResult, "Command result must not be null");
+		Assert.notNull(commandResult, "Command result must not be null!");
 
 		Object stats = commandResult.get("stats");
 		return stats == null ? NONE : new GeoCommandStatistics((Document) stats);

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

@@ -97,16 +97,6 @@ public class MappedDocument {
 		return this.document;
 	}
 
-	/**
-	 * Updates the documents {@link #ID_FIELD}.
-	 *
-	 * @param value the {@literal _id} value to set.
-	 * @since 3.4.3
-	 */
-	public void updateId(Object value) {
-		document.put(ID_FIELD, value);
-	}
-
 	/**
 	 * An {@link UpdateDefinition} that indicates that the {@link #getUpdateObject() update object} has already been
 	 * mapped to the specific domain type.
@@ -122,31 +112,55 @@ public class MappedDocument {
 			this.delegate = delegate;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.query.UpdateDefinition#getUpdateObject()
+		 */
 		@Override
 		public Document getUpdateObject() {
 			return delegate.getUpdateObject();
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.query.UpdateDefinition#modifies(java.lang.String)
+		 */
 		@Override
 		public boolean modifies(String key) {
 			return delegate.modifies(key);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.query.UpdateDefinition#inc(java.lang.String)
+		 */
 		@Override
 		public void inc(String version) {
 			delegate.inc(version);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.query.UpdateDefinition#isIsolated()
+		 */
 		@Override
 		public Boolean isIsolated() {
 			return delegate.isIsolated();
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.query.UpdateDefinition#getArrayFilters()
+		 */
 		@Override
 		public List<ArrayFilter> getArrayFilters() {
 			return delegate.getArrayFilters();
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.query.UpdateDefinition#hasArrayFilters()
+		 */
 		@Override
 		public boolean hasArrayFilters() {
 			return delegate.hasArrayFilters();

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

@@ -24,6 +24,7 @@ import java.util.function.Predicate;
 import java.util.stream.Collectors;
 
 import org.bson.Document;
+
 import org.springframework.data.mapping.PersistentProperty;
 import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.data.mongodb.core.convert.MongoConverter;
@@ -40,11 +41,10 @@ import org.springframework.data.mongodb.core.schema.JsonSchemaProperty;
 import org.springframework.data.mongodb.core.schema.MongoJsonSchema;
 import org.springframework.data.mongodb.core.schema.MongoJsonSchema.MongoJsonSchemaBuilder;
 import org.springframework.data.mongodb.core.schema.TypedJsonSchemaObject;
-import org.springframework.data.util.TypeInformation;
+import org.springframework.data.util.ClassTypeInformation;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.CollectionUtils;
-import org.springframework.util.LinkedMultiValueMap;
 import org.springframework.util.ObjectUtils;
 import org.springframework.util.StringUtils;
 
@@ -62,7 +62,6 @@ class MappingMongoJsonSchemaCreator implements MongoJsonSchemaCreator {
 	private final MongoConverter converter;
 	private final MappingContext<MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext;
 	private final Predicate<JsonSchemaPropertyContext> filter;
-	private final LinkedMultiValueMap<String, Class<?>> mergeProperties;
 
 	/**
 	 * Create a new instance of {@link MappingMongoJsonSchemaCreator}.
@@ -73,48 +72,29 @@ class MappingMongoJsonSchemaCreator implements MongoJsonSchemaCreator {
 	MappingMongoJsonSchemaCreator(MongoConverter converter) {
 
 		this(converter, (MappingContext<MongoPersistentEntity<?>, MongoPersistentProperty>) converter.getMappingContext(),
-				(property) -> true, new LinkedMultiValueMap<>());
+				(property) -> true);
 	}
 
 	@SuppressWarnings("unchecked")
 	MappingMongoJsonSchemaCreator(MongoConverter converter,
 			MappingContext<MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext,
-			Predicate<JsonSchemaPropertyContext> filter, LinkedMultiValueMap<String, Class<?>> mergeProperties) {
+			Predicate<JsonSchemaPropertyContext> filter) {
 
-		Assert.notNull(converter, "Converter must not be null");
+		Assert.notNull(converter, "Converter must not be null!");
 		this.converter = converter;
 		this.mappingContext = mappingContext;
 		this.filter = filter;
-		this.mergeProperties = mergeProperties;
 	}
 
 	@Override
 	public MongoJsonSchemaCreator filter(Predicate<JsonSchemaPropertyContext> filter) {
-		return new MappingMongoJsonSchemaCreator(converter, mappingContext, filter, mergeProperties);
+		return new MappingMongoJsonSchemaCreator(converter, mappingContext, filter);
 	}
 
-	@Override
-	public PropertySpecifier property(String path) {
-		return types -> withTypesFor(path, types);
-	}
-
-	/**
-	 * Specify additional types to be considered wehen rendering the schema for the given path.
-	 *
-	 * @param path path the path using {@literal dot '.'} notation.
-	 * @param types must not be {@literal null}.
-	 * @return new instance of {@link MongoJsonSchemaCreator}.
-	 * @since 3.4
+	/*
+	 * (non-Javadoc)
+	 * org.springframework.data.mongodb.core.MongoJsonSchemaCreator#createSchemaFor(java.lang.Class)
 	 */
-	public MongoJsonSchemaCreator withTypesFor(String path, Class<?>... types) {
-
-		LinkedMultiValueMap<String, Class<?>> clone = mergeProperties.clone();
-		for (Class<?> type : types) {
-			clone.add(path, type);
-		}
-		return new MappingMongoJsonSchemaCreator(converter, mappingContext, filter, clone);
-	}
-
 	@Override
 	public MongoJsonSchema createSchemaFor(Class<?> type) {
 
@@ -155,12 +135,9 @@ class MappingMongoJsonSchemaCreator implements MongoJsonSchemaCreator {
 
 			List<MongoPersistentProperty> currentPath = new ArrayList<>(path);
 
-			String stringPath = currentPath.stream().map(PersistentProperty::getName).collect(Collectors.joining("."));
-			stringPath = StringUtils.hasText(stringPath) ? (stringPath + "." + nested.getName()) : nested.getName();
-			if (!filter.test(new PropertyContext(stringPath, nested))) {
-				if (!mergeProperties.containsKey(stringPath)) {
-					continue;
-				}
+			if (!filter.test(new PropertyContext(
+					currentPath.stream().map(PersistentProperty::getName).collect(Collectors.joining(".")), nested))) {
+				continue;
 			}
 
 			if (path.contains(nested)) { // cycle guard
@@ -178,34 +155,14 @@ class MappingMongoJsonSchemaCreator implements MongoJsonSchemaCreator {
 
 	private JsonSchemaProperty computeSchemaForProperty(List<MongoPersistentProperty> path) {
 
-		String stringPath = path.stream().map(MongoPersistentProperty::getName).collect(Collectors.joining("."));
 		MongoPersistentProperty property = CollectionUtils.lastElement(path);
 
 		boolean required = isRequiredProperty(property);
 		Class<?> rawTargetType = computeTargetType(property); // target type before conversion
 		Class<?> targetType = converter.getTypeMapper().getWriteTargetTypeFor(rawTargetType); // conversion target type
 
-		if (!isCollection(property) && ObjectUtils.nullSafeEquals(rawTargetType, targetType)) {
-			if (property.isEntity() || mergeProperties.containsKey(stringPath)) {
-				List<JsonSchemaProperty> targetProperties = new ArrayList<>();
-
-				if (property.isEntity()) {
-					targetProperties.add(createObjectSchemaPropertyForEntity(path, property, required));
-				}
-				if (mergeProperties.containsKey(stringPath)) {
-					for (Class<?> theType : mergeProperties.get(stringPath)) {
-
-						ObjectJsonSchemaProperty target = JsonSchemaProperty.object(property.getName());
-						List<JsonSchemaProperty> nestedProperties = computePropertiesForEntity(path,
-								mappingContext.getRequiredPersistentEntity(theType));
-
-						targetProperties.add(createPotentiallyRequiredSchemaProperty(
-								target.properties(nestedProperties.toArray(new JsonSchemaProperty[0])), required));
-					}
-				}
-				return targetProperties.size() == 1 ? targetProperties.iterator().next()
-						: JsonSchemaProperty.merged(targetProperties);
-			}
+		if (!isCollection(property) && property.isEntity() && ObjectUtils.nullSafeEquals(rawTargetType, targetType)) {
+			return createObjectSchemaPropertyForEntity(path, property, required);
 		}
 
 		String fieldName = computePropertyFieldName(property);
@@ -267,7 +224,7 @@ class MappingMongoJsonSchemaCreator implements MongoJsonSchemaCreator {
 	}
 
 	private boolean isSpecificType(MongoPersistentProperty property) {
-		return !TypeInformation.OBJECT.equals(property.getTypeInformation().getActualType());
+		return !ClassTypeInformation.OBJECT.equals(property.getTypeInformation().getActualType());
 	}
 
 	private JsonSchemaProperty applyEncryptionDataIfNecessary(MongoPersistentProperty property,

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

@@ -57,8 +57,8 @@ public class MongoAction {
 	public MongoAction(@Nullable WriteConcern defaultWriteConcern, MongoActionOperation mongoActionOperation,
 			String collectionName, @Nullable Class<?> entityType, @Nullable Document document, @Nullable Document query) {
 
-		Assert.hasText(collectionName, "Collection name must not be null or empty");
-		Assert.notNull(mongoActionOperation, "MongoActionOperation must not be null");
+		Assert.hasText(collectionName, "Collection name must not be null or empty!");
+		Assert.notNull(mongoActionOperation, "MongoActionOperation must not be null!");
 
 		this.defaultWriteConcern = defaultWriteConcern;
 		this.mongoActionOperation = mongoActionOperation;

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

@@ -42,20 +42,29 @@ public class MongoAdmin implements MongoAdminOperations {
 	 */
 	public MongoAdmin(MongoClient client) {
 
-		Assert.notNull(client, "Client must not be null");
+		Assert.notNull(client, "Client must not be null!");
 		this.mongoClient = client;
 	}
 
+	/* (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.core.MongoAdminOperations#dropDatabase(java.lang.String)
+	 */
 	@ManagedOperation
 	public void dropDatabase(String databaseName) {
 		getDB(databaseName).drop();
 	}
 
+	/* (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.core.MongoAdminOperations#createDatabase(java.lang.String)
+	 */
 	@ManagedOperation
 	public void createDatabase(String databaseName) {
 		getDB(databaseName);
 	}
 
+	/* (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.core.MongoAdminOperations#getDatabaseStats(java.lang.String)
+	 */
 	@ManagedOperation
 	public String getDatabaseStats(String databaseName) {
 		return getDB(databaseName).runCommand(new Document("dbStats", 1).append("scale", 1024)).toJson();

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

@@ -119,15 +119,27 @@ public class MongoClientFactoryBean extends AbstractFactoryBean<MongoClient> imp
 		this.exceptionTranslator = exceptionTranslator == null ? DEFAULT_EXCEPTION_TRANSLATOR : exceptionTranslator;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.FactoryBean#getObjectType()
+	 */
 	public Class<? extends MongoClient> getObjectType() {
 		return MongoClient.class;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.dao.support.PersistenceExceptionTranslator#translateExceptionIfPossible(java.lang.RuntimeException)
+	 */
 	@Nullable
 	public DataAccessException translateExceptionIfPossible(RuntimeException ex) {
 		return exceptionTranslator.translateExceptionIfPossible(ex);
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.config.AbstractFactoryBean#createInstance()
+	 */
 	@Override
 	protected MongoClient createInstance() throws Exception {
 		return createMongoClient(computeClientSetting());
@@ -146,7 +158,7 @@ public class MongoClientFactoryBean extends AbstractFactoryBean<MongoClient> imp
 	protected MongoClientSettings computeClientSetting() {
 
 		if (connectionString != null && (StringUtils.hasText(host) || port != null)) {
-			throw new IllegalStateException("ConnectionString and host/port configuration exclude one another");
+			throw new IllegalStateException("ConnectionString and host/port configuration exclude one another!");
 		}
 
 		ConnectionString connectionString = this.connectionString != null ? this.connectionString
@@ -324,6 +336,10 @@ public class MongoClientFactoryBean extends AbstractFactoryBean<MongoClient> imp
 		return !fromConnectionStringIsDefault ? fromConnectionString : defaultValue;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.config.AbstractFactoryBean#destroyInstance(java.lang.Object)
+	 */
 	@Override
 	protected void destroyInstance(@Nullable MongoClient instance) throws Exception {
 
@@ -337,11 +353,6 @@ public class MongoClientFactoryBean extends AbstractFactoryBean<MongoClient> imp
 	}
 
 	private String getOrDefault(Object value, String defaultValue) {
-
-		if(value == null) {
-			return defaultValue;
-		}
-		String sValue = value.toString();
-		return StringUtils.hasText(sValue) ? sValue : defaultValue;
+		return !StringUtils.isEmpty(value) ? value.toString() : defaultValue;
 	}
 }

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

@@ -44,8 +44,8 @@ public class MongoDataIntegrityViolationException extends DataIntegrityViolation
 
 		super(message);
 
-		Assert.notNull(writeResult, "WriteResult must not be null");
-		Assert.notNull(actionOperation, "MongoActionOperation must not be null");
+		Assert.notNull(writeResult, "WriteResult must not be null!");
+		Assert.notNull(actionOperation, "MongoActionOperation must not be null!");
 
 		this.writeResult = writeResult;
 		this.actionOperation = actionOperation;

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

@@ -64,10 +64,10 @@ public abstract class MongoDatabaseFactorySupport<C> implements MongoDatabaseFac
 	protected MongoDatabaseFactorySupport(C mongoClient, String databaseName, boolean mongoInstanceCreated,
 			PersistenceExceptionTranslator exceptionTranslator) {
 
-		Assert.notNull(mongoClient, "MongoClient must not be null");
-		Assert.hasText(databaseName, "Database name must not be empty");
+		Assert.notNull(mongoClient, "MongoClient must not be null!");
+		Assert.hasText(databaseName, "Database name must not be empty!");
 		Assert.isTrue(databaseName.matches("[^/\\\\.$\"\\s]+"),
-				"Database name must not contain slashes, dots, spaces, quotes, or dollar signs");
+				"Database name must not contain slashes, dots, spaces, quotes, or dollar signs!");
 
 		this.mongoClient = mongoClient;
 		this.databaseName = databaseName;
@@ -84,14 +84,22 @@ public abstract class MongoDatabaseFactorySupport<C> implements MongoDatabaseFac
 		this.writeConcern = writeConcern;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.MongoDbFactory#getMongoDatabase()
+	 */
 	public MongoDatabase getMongoDatabase() throws DataAccessException {
 		return getMongoDatabase(getDefaultDatabaseName());
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.MongoDbFactory#getMongoDatabase(java.lang.String)
+	 */
 	@Override
 	public MongoDatabase getMongoDatabase(String dbName) throws DataAccessException {
 
-		Assert.hasText(dbName, "Database name must not be empty");
+		Assert.hasText(dbName, "Database name must not be empty!");
 
 		MongoDatabase db = doGetMongoDatabase(dbName);
 
@@ -110,16 +118,28 @@ public abstract class MongoDatabaseFactorySupport<C> implements MongoDatabaseFac
 	 */
 	protected abstract MongoDatabase doGetMongoDatabase(String dbName);
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.beans.factory.DisposableBean#destroy()
+	 */
 	public void destroy() throws Exception {
 		if (mongoInstanceCreated) {
 			closeClient();
 		}
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.MongoDbFactory#getExceptionTranslator()
+	 */
 	public PersistenceExceptionTranslator getExceptionTranslator() {
 		return this.exceptionTranslator;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.MongoDbFactory#withSession(com.mongodb.session.Session)
+	 */
 	public MongoDatabaseFactory withSession(ClientSession session) {
 		return new MongoDatabaseFactorySupport.ClientSessionBoundMongoDbFactory(session, this);
 	}
@@ -160,31 +180,55 @@ public abstract class MongoDatabaseFactorySupport<C> implements MongoDatabaseFac
 			this.delegate = delegate;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.MongoDbFactory#getMongoDatabase()
+		 */
 		@Override
 		public MongoDatabase getMongoDatabase() throws DataAccessException {
 			return proxyMongoDatabase(delegate.getMongoDatabase());
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.MongoDbFactory#getMongoDatabase(java.lang.String)
+		 */
 		@Override
 		public MongoDatabase getMongoDatabase(String dbName) throws DataAccessException {
 			return proxyMongoDatabase(delegate.getMongoDatabase(dbName));
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.MongoDbFactory#getExceptionTranslator()
+		 */
 		@Override
 		public PersistenceExceptionTranslator getExceptionTranslator() {
 			return delegate.getExceptionTranslator();
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.MongoDbFactory#getSession(com.mongodb.ClientSessionOptions)
+		 */
 		@Override
 		public ClientSession getSession(ClientSessionOptions options) {
 			return delegate.getSession(options);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.MongoDbFactory#withSession(com.mongodb.session.ClientSession)
+		 */
 		@Override
 		public MongoDatabaseFactory withSession(ClientSession session) {
 			return delegate.withSession(session);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.MongoDbFactory#isTransactionActive()
+		 */
 		@Override
 		public boolean isTransactionActive() {
 			return session != null && session.hasActiveTransaction();

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

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2018-2022 the original author 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
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core;
+
+import org.springframework.dao.support.PersistenceExceptionTranslator;
+
+/**
+ * Common base class for usage with both {@link com.mongodb.client.MongoClients} defining common properties such as
+ * database name and exception translator.
+ * <br />
+ * Not intended to be used directly.
+ *
+ * @author Christoph Strobl
+ * @author Mark Paluch
+ * @param <C> Client type.
+ * @since 2.1
+ * @see SimpleMongoClientDatabaseFactory
+ * @deprecated since 3.0, use {@link MongoDatabaseFactorySupport} instead.
+ */
+@Deprecated
+public abstract class MongoDbFactorySupport<C> extends MongoDatabaseFactorySupport<C> {
+
+	/**
+	 * Create a new {@link MongoDbFactorySupport} object given {@code mongoClient}, {@code databaseName},
+	 * {@code mongoInstanceCreated} and {@link PersistenceExceptionTranslator}.
+	 *
+	 * @param mongoClient must not be {@literal null}.
+	 * @param databaseName must not be {@literal null} or empty.
+	 * @param mongoInstanceCreated {@literal true} if the client instance was created by a subclass of
+	 *          {@link MongoDbFactorySupport} to close the client on {@link #destroy()}.
+	 * @param exceptionTranslator must not be {@literal null}.
+	 */
+	protected MongoDbFactorySupport(C mongoClient, String databaseName, boolean mongoInstanceCreated,
+			PersistenceExceptionTranslator exceptionTranslator) {
+		super(mongoClient, databaseName, mongoInstanceCreated, exceptionTranslator);
+	}
+}

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

@@ -88,6 +88,10 @@ public class MongoEncryptionSettingsFactoryBean implements FactoryBean<AutoEncry
 		this.schemaMap = schemaMap;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see  org.springframework.beans.factory.FactoryBean#getObject()
+	 */
 	@Override
 	public AutoEncryptionSettings getObject() {
 
@@ -105,6 +109,10 @@ public class MongoEncryptionSettingsFactoryBean implements FactoryBean<AutoEncry
 		return source != null ? source : Collections.emptyMap();
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see  org.springframework.beans.factory.FactoryBean#getObjectType()
+	 */
 	@Override
 	public Class<?> getObjectType() {
 		return AutoEncryptionSettings.class;

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

@@ -68,6 +68,10 @@ public class MongoExceptionTranslator implements PersistenceExceptionTranslator
 	private static final Set<String> DATA_INTEGRITY_EXCEPTIONS = new HashSet<>(
 			Arrays.asList("WriteConcernException", "MongoWriteException", "MongoBulkWriteException"));
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.dao.support.PersistenceExceptionTranslator#translateExceptionIfPossible(java.lang.RuntimeException)
+	 */
 	@Nullable
 	public DataAccessException translateExceptionIfPossible(RuntimeException ex) {
 

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

@@ -15,7 +15,6 @@
  */
 package org.springframework.data.mongodb.core;
 
-import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;
 import java.util.function.Predicate;
@@ -63,6 +62,7 @@ import org.springframework.util.Assert;
  * {@link org.springframework.data.annotation.Id _id} properties using types that can be converted into
  * {@link org.bson.types.ObjectId} like {@link String} will be mapped to {@code type : 'object'} unless there is more
  * specific information available via the {@link org.springframework.data.mongodb.core.mapping.MongoId} annotation.
+
  * {@link Encrypted} properties will contain {@literal encrypt} information.
  *
  * @author Christoph Strobl
@@ -78,20 +78,6 @@ public interface MongoJsonSchemaCreator {
 	 */
 	MongoJsonSchema createSchemaFor(Class<?> type);
 
-	/**
-	 * Create a merged {@link MongoJsonSchema} out of the individual schemas of the given types by merging their
-	 * properties into one large {@link MongoJsonSchema schema}.
-	 *
-	 * @param types must not be {@literal null} nor contain {@literal null}.
-	 * @return new instance of {@link MongoJsonSchema}.
-	 * @since 3.4
-	 */
-	default MongoJsonSchema mergedSchemaFor(Class<?>... types) {
-
-		MongoJsonSchema[] schemas = Arrays.stream(types).map(this::createSchemaFor).toArray(MongoJsonSchema[]::new);
-		return MongoJsonSchema.merge(schemas);
-	}
-
 	/**
 	 * Filter matching {@link JsonSchemaProperty properties}.
 	 *
@@ -101,39 +87,30 @@ public interface MongoJsonSchemaCreator {
 	 */
 	MongoJsonSchemaCreator filter(Predicate<JsonSchemaPropertyContext> filter);
 
-	/**
-	 * Entry point to specify additional behavior for a given path.
-	 *
-	 * @param path the path using {@literal dot '.'} notation.
-	 * @return new instance of {@link PropertySpecifier}.
-	 * @since 3.4
-	 */
-	PropertySpecifier property(String path);
-
 	/**
 	 * The context in which a specific {@link #getProperty()} is encountered during schema creation.
-	 *
+	 * 
 	 * @since 3.3
 	 */
 	interface JsonSchemaPropertyContext {
 
 		/**
 		 * The path to a given field/property in dot notation.
-		 *
+		 * 
 		 * @return never {@literal null}.
 		 */
 		String getPath();
 
 		/**
 		 * The current property.
-		 *
+		 * 
 		 * @return never {@literal null}.
 		 */
 		MongoPersistentProperty getProperty();
 
 		/**
 		 * Obtain the {@link MongoPersistentEntity} for a given property.
-		 *
+		 * 
 		 * @param property must not be {@literal null}.
 		 * @param <T>
 		 * @return {@literal null} if the property is not an entity. It is nevertheless recommend to check
@@ -192,7 +169,7 @@ public interface MongoJsonSchemaCreator {
 	 */
 	static MongoJsonSchemaCreator create(MongoConverter mongoConverter) {
 
-		Assert.notNull(mongoConverter, "MongoConverter must not be null");
+		Assert.notNull(mongoConverter, "MongoConverter must not be null!");
 		return new MappingMongoJsonSchemaCreator(mongoConverter);
 	}
 
@@ -232,19 +209,4 @@ public interface MongoJsonSchemaCreator {
 
 		return create(converter);
 	}
-
-	/**
-	 * @author Christoph Strobl
-	 * @since 3.4
-	 */
-	interface PropertySpecifier {
-
-		/**
-		 * Set additional type parameters for polymorphic ones.
-		 *
-		 * @param types must not be {@literal null}.
-		 * @return the source
-		 */
-		MongoJsonSchemaCreator withTypes(Class<?>... types);
-	}
 }

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

@@ -20,21 +20,20 @@ import java.util.List;
 import java.util.Set;
 import java.util.function.Consumer;
 import java.util.function.Supplier;
-import java.util.stream.Stream;
 
 import org.bson.Document;
 import org.springframework.data.geo.GeoResults;
 import org.springframework.data.mongodb.core.BulkOperations.BulkMode;
 import org.springframework.data.mongodb.core.aggregation.Aggregation;
-import org.springframework.data.mongodb.core.aggregation.AggregationOperation;
 import org.springframework.data.mongodb.core.aggregation.AggregationOptions;
-import org.springframework.data.mongodb.core.aggregation.AggregationPipeline;
 import org.springframework.data.mongodb.core.aggregation.AggregationResults;
 import org.springframework.data.mongodb.core.aggregation.AggregationUpdate;
 import org.springframework.data.mongodb.core.aggregation.TypedAggregation;
 import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
 import org.springframework.data.mongodb.core.convert.MongoConverter;
 import org.springframework.data.mongodb.core.index.IndexOperations;
+import org.springframework.data.mongodb.core.mapreduce.GroupBy;
+import org.springframework.data.mongodb.core.mapreduce.GroupByResults;
 import org.springframework.data.mongodb.core.mapreduce.MapReduceOptions;
 import org.springframework.data.mongodb.core.mapreduce.MapReduceResults;
 import org.springframework.data.mongodb.core.query.BasicQuery;
@@ -43,6 +42,7 @@ import org.springframework.data.mongodb.core.query.NearQuery;
 import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.data.mongodb.core.query.Update;
 import org.springframework.data.mongodb.core.query.UpdateDefinition;
+import org.springframework.data.util.CloseableIterator;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
@@ -57,7 +57,8 @@ import com.mongodb.client.result.UpdateResult;
 /**
  * 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). <br />
+ * proxy).
+ * <br />
  * <strong>NOTE:</strong> Some operations cannot be executed within a MongoDB transaction. Please refer to the MongoDB
  * specific documentation to learn more about <a href="https://docs.mongodb.com/manual/core/transactions/">Multi
  * Document Transactions</a>.
@@ -84,7 +85,7 @@ public interface MongoOperations extends FluentMongoOperations {
 	String getCollectionName(Class<?> entityClass);
 
 	/**
-	 * Execute a MongoDB command expressed as a JSON string. Parsing is delegated to {@link Document#parse(String)} to
+	 * Execute the a MongoDB command expressed as a JSON string. Parsing is delegated to {@link Document#parse(String)} to
 	 * obtain the {@link Document} holding the actual command. Any errors that result from executing this command will be
 	 * converted into Spring's DAO exception hierarchy.
 	 *
@@ -124,7 +125,8 @@ public interface MongoOperations extends FluentMongoOperations {
 	void executeQuery(Query query, String collectionName, DocumentCallbackHandler dch);
 
 	/**
-	 * Executes a {@link DbCallback} translating any exceptions as necessary. <br />
+	 * Executes a {@link DbCallback} translating any exceptions as necessary.
+	 * <br />
 	 * Allows for returning a result object, that is a domain object or a collection of domain objects.
 	 *
 	 * @param action callback object that specifies the MongoDB actions to perform on the passed in DB instance. Must not
@@ -136,7 +138,8 @@ public interface MongoOperations extends FluentMongoOperations {
 	<T> T execute(DbCallback<T> action);
 
 	/**
-	 * Executes the given {@link CollectionCallback} on the entity collection of the specified class. <br />
+	 * Executes the given {@link CollectionCallback} on the entity collection of the specified class.
+	 * <br />
 	 * 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. Must not be {@literal null}.
@@ -148,7 +151,8 @@ public interface MongoOperations extends FluentMongoOperations {
 	<T> T execute(Class<?> entityClass, CollectionCallback<T> action);
 
 	/**
-	 * Executes the given {@link CollectionCallback} on the collection of the given name. <br />
+	 * Executes the given {@link CollectionCallback} on the collection of the given name.
+	 * <br />
 	 * Allows for returning a result object, that is a domain object or a collection of domain objects.
 	 *
 	 * @param collectionName the name of the collection that specifies which {@link MongoCollection} instance will be
@@ -172,7 +176,8 @@ public interface MongoOperations extends FluentMongoOperations {
 
 	/**
 	 * Obtain a {@link ClientSession session} bound instance of {@link SessionScoped} binding the {@link ClientSession}
-	 * provided by the given {@link Supplier} to each and every command issued against MongoDB. <br />
+	 * provided by the given {@link Supplier} to each and every command issued against MongoDB.
+	 * <br />
 	 * <strong>Note:</strong> It is up to the caller to manage the {@link ClientSession} lifecycle. Use the
 	 * {@link SessionScoped#execute(SessionCallback, Consumer)} hook to potentially close the {@link ClientSession}.
 	 *
@@ -181,7 +186,7 @@ public interface MongoOperations extends FluentMongoOperations {
 	 */
 	default SessionScoped withSession(Supplier<ClientSession> sessionProvider) {
 
-		Assert.notNull(sessionProvider, "SessionProvider must not be null");
+		Assert.notNull(sessionProvider, "SessionProvider must not be null!");
 
 		return new SessionScoped() {
 
@@ -207,7 +212,8 @@ public interface MongoOperations extends FluentMongoOperations {
 	}
 
 	/**
-	 * Obtain a {@link ClientSession} bound instance of {@link MongoOperations}. <br />
+	 * Obtain a {@link ClientSession} bound instance of {@link MongoOperations}.
+	 * <br />
 	 * <strong>Note:</strong> It is up to the caller to manage the {@link ClientSession} lifecycle.
 	 *
 	 * @param session must not be {@literal null}.
@@ -220,34 +226,34 @@ public interface MongoOperations extends FluentMongoOperations {
 	 * Executes the given {@link Query} on the entity collection of the specified {@code entityType} backed by a Mongo DB
 	 * {@link com.mongodb.client.FindIterable}.
 	 * <p>
-	 * Returns a {@link String} that wraps the Mongo DB {@link com.mongodb.client.FindIterable} that needs to be closed.
+	 * Returns a {@link CloseableIterator} that wraps the a Mongo DB {@link com.mongodb.client.FindIterable} that needs to
+	 * be closed.
 	 *
 	 * @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 entityType must not be {@literal null}.
 	 * @param <T> element return type
-	 * @return the result {@link Stream}, containing mapped objects, needing to be closed once fully processed (e.g.
-	 *         through a try-with-resources clause).
+	 * @return will never be {@literal null}.
 	 * @since 1.7
 	 */
-	<T> Stream<T> stream(Query query, Class<T> entityType);
+	<T> CloseableIterator<T> stream(Query query, Class<T> entityType);
 
 	/**
 	 * Executes the given {@link Query} on the entity collection of the specified {@code entityType} and collection backed
 	 * by a Mongo DB {@link com.mongodb.client.FindIterable}.
 	 * <p>
-	 * Returns a {@link Stream} that wraps the Mongo DB {@link com.mongodb.client.FindIterable} that needs to be closed.
+	 * Returns a {@link CloseableIterator} that wraps the a Mongo DB {@link com.mongodb.client.FindIterable} that needs to
+	 * be closed.
 	 *
 	 * @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 entityType must not be {@literal null}.
 	 * @param collectionName must not be {@literal null} or empty.
 	 * @param <T> element return type
-	 * @return the result {@link Stream}, containing mapped objects, needing to be closed once fully processed (e.g.
-	 *         through a try-with-resources clause).
+	 * @return will never be {@literal null}.
 	 * @since 1.10
 	 */
-	<T> Stream<T> stream(Query query, Class<T> entityType, String collectionName);
+	<T> CloseableIterator<T> stream(Query query, Class<T> entityType, String collectionName);
 
 	/**
 	 * Create an uncapped collection with a name based on the provided entity class.
@@ -283,56 +289,6 @@ public interface MongoOperations extends FluentMongoOperations {
 	 */
 	MongoCollection<Document> createCollection(String collectionName, @Nullable CollectionOptions collectionOptions);
 
-	/**
-	 * Create a view with the provided name. The view content is defined by the {@link AggregationOperation pipeline
-	 * stages} on another collection or view identified by the given {@link #getCollectionName(Class) source type}.
-	 *
-	 * @param name the name of the view to create.
-	 * @param source the type defining the views source collection.
-	 * @param stages the {@link AggregationOperation aggregation pipeline stages} defining the view content.
-	 * @since 4.0
-	 */
-	default MongoCollection<Document> createView(String name, Class<?> source, AggregationOperation... stages) {
-		return createView(name, source, AggregationPipeline.of(stages));
-	}
-
-	/**
-	 * Create a view with the provided name. The view content is defined by the {@link AggregationPipeline pipeline} on
-	 * another collection or view identified by the given {@link #getCollectionName(Class) source type}.
-	 *
-	 * @param name the name of the view to create.
-	 * @param source the type defining the views source collection.
-	 * @param pipeline the {@link AggregationPipeline} defining the view content.
-	 * @since 4.0
-	 */
-	default MongoCollection<Document> createView(String name, Class<?> source, AggregationPipeline pipeline) {
-		return createView(name, source, pipeline, null);
-	}
-
-	/**
-	 * Create a view with the provided name. The view content is defined by the {@link AggregationPipeline pipeline} on
-	 * another collection or view identified by the given {@link #getCollectionName(Class) source type}.
-	 *
-	 * @param name the name of the view to create.
-	 * @param source the type defining the views source collection.
-	 * @param pipeline the {@link AggregationPipeline} defining the view content.
-	 * @param options additional settings to apply when creating the view. Can be {@literal null}.
-	 * @since 4.0
-	 */
-	MongoCollection<Document> createView(String name, Class<?> source, AggregationPipeline pipeline, @Nullable ViewOptions options);
-
-	/**
-	 * Create a view with the provided name. The view content is defined by the {@link AggregationPipeline pipeline} on
-	 * another collection or view identified by the given source.
-	 *
-	 * @param name the name of the view to create.
-	 * @param source the name of the collection or view defining the to be created views source.
-	 * @param pipeline the {@link AggregationPipeline} defining the view content.
-	 * @param options additional settings to apply when creating the view. Can be {@literal null}.
-	 * @since 4.0
-	 */
-	MongoCollection<Document> createView(String name, String source, AggregationPipeline pipeline, @Nullable ViewOptions options);
-
 	/**
 	 * A set of collection names.
 	 *
@@ -344,7 +300,8 @@ public interface MongoOperations extends FluentMongoOperations {
 	 * Get a {@link MongoCollection} by its name. The returned collection may not exists yet (except in local memory) and
 	 * is created on first interaction with the server. Collections can be explicitly created via
 	 * {@link #createCollection(Class)}. Please make sure to check if the collection {@link #collectionExists(Class)
-	 * exists} first. <br />
+	 * exists} first.
+	 * <br />
 	 * Translate any exceptions as necessary.
 	 *
 	 * @param collectionName name of the collection. Must not be {@literal null}.
@@ -353,7 +310,8 @@ public interface MongoOperations extends FluentMongoOperations {
 	MongoCollection<Document> getCollection(String collectionName);
 
 	/**
-	 * Check to see if a collection with a name indicated by the entity class exists. <br />
+	 * Check to see if a collection with a name indicated by the entity class exists.
+	 * <br />
 	 * Translate any exceptions as necessary.
 	 *
 	 * @param entityClass class that determines the name of the collection. Must not be {@literal null}.
@@ -362,7 +320,8 @@ public interface MongoOperations extends FluentMongoOperations {
 	<T> boolean collectionExists(Class<T> entityClass);
 
 	/**
-	 * Check to see if a collection with a given name exists. <br />
+	 * Check to see if a collection with a given name exists.
+	 * <br />
 	 * Translate any exceptions as necessary.
 	 *
 	 * @param collectionName name of the collection. Must not be {@literal null}.
@@ -371,7 +330,8 @@ public interface MongoOperations extends FluentMongoOperations {
 	boolean collectionExists(String collectionName);
 
 	/**
-	 * Drop the collection with the name indicated by the entity class. <br />
+	 * Drop the collection with the name indicated by the entity class.
+	 * <br />
 	 * Translate any exceptions as necessary.
 	 *
 	 * @param entityClass class that determines the collection to drop/delete. Must not be {@literal null}.
@@ -379,7 +339,8 @@ public interface MongoOperations extends FluentMongoOperations {
 	<T> void dropCollection(Class<T> entityClass);
 
 	/**
-	 * Drop the collection with the given name. <br />
+	 * Drop the collection with the given name.
+	 * <br />
 	 * Translate any exceptions as necessary.
 	 *
 	 * @param collectionName name of the collection to drop/delete.
@@ -442,9 +403,11 @@ public interface MongoOperations extends FluentMongoOperations {
 	BulkOperations bulkOps(BulkMode mode, @Nullable Class<?> entityType, String collectionName);
 
 	/**
-	 * Query for a list of objects of type T from the collection used by the entity class. <br />
+	 * Query for a list of objects of type T from the collection used by the entity class.
+	 * <br />
 	 * The object is converted from the MongoDB native representation using an instance of {@see MongoConverter}. Unless
-	 * configured otherwise, an instance of {@link MappingMongoConverter} will be used. <br />
+	 * configured otherwise, an instance of {@link MappingMongoConverter} will be used.
+	 * <br />
 	 * 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.
 	 *
@@ -454,9 +417,11 @@ public interface MongoOperations extends FluentMongoOperations {
 	<T> List<T> findAll(Class<T> entityClass);
 
 	/**
-	 * Query for a list of objects of type T from the specified collection. <br />
+	 * Query for a list of objects of type T from the specified collection.
+	 * <br />
 	 * The object is converted from the MongoDB native representation using an instance of {@see MongoConverter}. Unless
-	 * configured otherwise, an instance of {@link MappingMongoConverter} will be used. <br />
+	 * configured otherwise, an instance of {@link MappingMongoConverter} will be used.
+	 * <br />
 	 * 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.
 	 *
@@ -466,6 +431,43 @@ public interface MongoOperations extends FluentMongoOperations {
 	 */
 	<T> List<T> findAll(Class<T> entityClass, String collectionName);
 
+	/**
+	 * 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 inputCollectionName the collection where the group operation will read from
+	 * @param groupBy the conditions under which the group operation will be performed, e.g. keys, initial document,
+	 *          reduce function.
+	 * @param entityClass The parametrized type of the returned list
+	 * @return The results of the group operation
+	 * @deprecated since 2.2. The {@code group} command has been removed in MongoDB Server 4.2.0. <br />
+	 *             Please use {@link #aggregate(TypedAggregation, String, Class) } with a
+	 *             {@link org.springframework.data.mongodb.core.aggregation.GroupOperation} instead.
+	 */
+	@Deprecated
+	<T> GroupByResults<T> group(String inputCollectionName, GroupBy groupBy, Class<T> entityClass);
+
+	/**
+	 * 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
+	 * @param groupBy the conditions under which the group operation will be performed, e.g. keys, initial document,
+	 *          reduce function.
+	 * @param entityClass The parametrized type of the returned list
+	 * @return The results of the group operation
+	 * @deprecated since 2.2. The {@code group} command has been removed in MongoDB Server 4.2.0. <br />
+	 *             Please use {@link #aggregate(TypedAggregation, String, Class) } with a
+	 *             {@link org.springframework.data.mongodb.core.aggregation.GroupOperation} and
+	 *             {@link org.springframework.data.mongodb.core.aggregation.MatchOperation} instead.
+	 */
+	@Deprecated
+	<T> GroupByResults<T> group(@Nullable Criteria criteria, String inputCollectionName, GroupBy groupBy,
+			Class<T> entityClass);
+
 	/**
 	 * 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.
@@ -520,9 +522,9 @@ public interface MongoOperations extends FluentMongoOperations {
 	/**
 	 * Execute an aggregation operation backed by a Mongo DB {@link com.mongodb.client.AggregateIterable}.
 	 * <p>
-	 * Returns a {@link Stream} that wraps the Mongo DB {@link com.mongodb.client.AggregateIterable} that needs to be
-	 * closed. The raw results will be mapped to the given entity class. The name of the inputCollection is derived from
-	 * the inputType of the aggregation.
+	 * Returns a {@link CloseableIterator} that wraps the a Mongo DB {@link com.mongodb.client.AggregateIterable} that
+	 * needs to be closed. The raw results will be mapped to the given entity class. The name of the inputCollection is
+	 * derived from the inputType of the aggregation.
 	 * <p>
 	 * Aggregation streaming can't be used with {@link AggregationOptions#isExplain() aggregation explain}. Enabling
 	 * explanation mode will throw an {@link IllegalArgumentException}.
@@ -531,37 +533,35 @@ public interface MongoOperations extends FluentMongoOperations {
 	 *          {@literal null}.
 	 * @param collectionName The name of the input collection to use for the aggreation.
 	 * @param outputType The parametrized type of the returned list, must not be {@literal null}.
-	 * @return the result {@link Stream}, containing mapped objects, needing to be closed once fully processed (e.g.
-	 *         through a try-with-resources clause).
+	 * @return The results of the aggregation operation.
 	 * @since 2.0
 	 */
-	<O> Stream<O> aggregateStream(TypedAggregation<?> aggregation, String collectionName, Class<O> outputType);
+	<O> CloseableIterator<O> aggregateStream(TypedAggregation<?> aggregation, String collectionName, Class<O> outputType);
 
 	/**
 	 * Execute an aggregation operation backed by a Mongo DB {@link com.mongodb.client.AggregateIterable}.
-	 * <p>
-	 * Returns a {@link Stream} that wraps the Mongo DB {@link com.mongodb.client.AggregateIterable} that needs to be
-	 * closed. The raw results will be mapped to the given entity class and are returned as stream. The name of the
-	 * inputCollection is derived from the inputType of the aggregation.
-	 * <p>
+	 * <br />
+	 * Returns a {@link CloseableIterator} that wraps the a Mongo DB {@link com.mongodb.client.AggregateIterable} that
+	 * needs to be closed. The raw results will be mapped to the given entity class and are returned as stream. The name
+	 * of the inputCollection is derived from the inputType of the aggregation.
+	 * <br />
 	 * Aggregation streaming can't be used with {@link AggregationOptions#isExplain() aggregation explain}. Enabling
 	 * explanation mode will throw an {@link IllegalArgumentException}.
 	 *
 	 * @param aggregation The {@link TypedAggregation} specification holding the aggregation operations, must not be
 	 *          {@literal null}.
 	 * @param outputType The parametrized type of the returned list, must not be {@literal null}.
-	 * @return the result {@link Stream}, containing mapped objects, needing to be closed once fully processed (e.g.
-	 *         through a try-with-resources clause).
+	 * @return The results of the aggregation operation.
 	 * @since 2.0
 	 */
-	<O> Stream<O> aggregateStream(TypedAggregation<?> aggregation, Class<O> outputType);
+	<O> CloseableIterator<O> aggregateStream(TypedAggregation<?> aggregation, Class<O> outputType);
 
 	/**
 	 * Execute an aggregation operation backed by a Mongo DB {@link com.mongodb.client.AggregateIterable}.
-	 * <p>
-	 * Returns a {@link Stream} that wraps the Mongo DB {@link com.mongodb.client.AggregateIterable} that needs to be
-	 * closed. The raw results will be mapped to the given entity class.
-	 * <p>
+	 * <br />
+	 * Returns a {@link CloseableIterator} that wraps the a Mongo DB {@link com.mongodb.client.AggregateIterable} that
+	 * needs to be closed. The raw results will be mapped to the given entity class.
+	 * <br />
 	 * Aggregation streaming can't be used with {@link AggregationOptions#isExplain() aggregation explain}. Enabling
 	 * explanation mode will throw an {@link IllegalArgumentException}.
 	 *
@@ -570,18 +570,17 @@ public interface MongoOperations extends FluentMongoOperations {
 	 * @param inputType the inputType where the aggregation operation will read from, must not be {@literal null} or
 	 *          empty.
 	 * @param outputType The parametrized type of the returned list, must not be {@literal null}.
-	 * @return the result {@link Stream}, containing mapped objects, needing to be closed once fully processed (e.g.
-	 *         through a try-with-resources clause).
+	 * @return The results of the aggregation operation.
 	 * @since 2.0
 	 */
-	<O> Stream<O> aggregateStream(Aggregation aggregation, Class<?> inputType, Class<O> outputType);
+	<O> CloseableIterator<O> aggregateStream(Aggregation aggregation, Class<?> inputType, Class<O> outputType);
 
 	/**
 	 * Execute an aggregation operation backed by a Mongo DB {@link com.mongodb.client.AggregateIterable}.
-	 * <p>
-	 * Returns a {@link Stream} that wraps the Mongo DB {@link com.mongodb.client.AggregateIterable} that needs to be
-	 * closed. The raw results will be mapped to the given entity class.
-	 * <p>
+	 * <br />
+	 * Returns a {@link CloseableIterator} that wraps the a Mongo DB {@link com.mongodb.client.AggregateIterable} that
+	 * needs to be closed. The raw results will be mapped to the given entity class.
+	 * <br />
 	 * Aggregation streaming can't be used with {@link AggregationOptions#isExplain() aggregation explain}. Enabling
 	 * explanation mode will throw an {@link IllegalArgumentException}.
 	 *
@@ -590,11 +589,10 @@ public interface MongoOperations extends FluentMongoOperations {
 	 * @param collectionName the collection where the aggregation operation will read from, must not be {@literal null} or
 	 *          empty.
 	 * @param outputType The parametrized type of the returned list, must not be {@literal null}.
-	 * @return the result {@link Stream}, containing mapped objects, needing to be closed once fully processed (e.g.
-	 *         through a try-with-resources clause).
+	 * @return The results of the aggregation operation.
 	 * @since 2.0
 	 */
-	<O> Stream<O> aggregateStream(Aggregation aggregation, String collectionName, Class<O> outputType);
+	<O> CloseableIterator<O> aggregateStream(Aggregation aggregation, String collectionName, Class<O> outputType);
 
 	/**
 	 * Execute a map-reduce operation. The map-reduce operation will be formed with an output type of INLINE
@@ -604,9 +602,7 @@ public interface MongoOperations extends FluentMongoOperations {
 	 * @param reduceFunction The JavaScript reduce function
 	 * @param entityClass The parametrized type of the returned list. Must not be {@literal null}.
 	 * @return The results of the map reduce operation
-	 * @deprecated since 3.4 in favor of {@link #aggregate(TypedAggregation, Class)}.
 	 */
-	@Deprecated
 	<T> MapReduceResults<T> mapReduce(String inputCollectionName, String mapFunction, String reduceFunction,
 			Class<T> entityClass);
 
@@ -619,9 +615,7 @@ public interface MongoOperations extends FluentMongoOperations {
 	 * @param mapReduceOptions Options that specify detailed map-reduce behavior.
 	 * @param entityClass The parametrized type of the returned list. Must not be {@literal null}.
 	 * @return The results of the map reduce operation
-	 * @deprecated since 3.4 in favor of {@link #aggregate(TypedAggregation, Class)}.
 	 */
-	@Deprecated
 	<T> MapReduceResults<T> mapReduce(String inputCollectionName, String mapFunction, String reduceFunction,
 			@Nullable MapReduceOptions mapReduceOptions, Class<T> entityClass);
 
@@ -635,9 +629,7 @@ public interface MongoOperations extends FluentMongoOperations {
 	 * @param reduceFunction The JavaScript reduce function
 	 * @param entityClass The parametrized type of the returned list. Must not be {@literal null}.
 	 * @return The results of the map reduce operation
-	 * @deprecated since 3.4 in favor of {@link #aggregate(TypedAggregation, Class)}.
 	 */
-	@Deprecated
 	<T> MapReduceResults<T> mapReduce(Query query, String inputCollectionName, String mapFunction, String reduceFunction,
 			Class<T> entityClass);
 
@@ -651,9 +643,7 @@ public interface MongoOperations extends FluentMongoOperations {
 	 * @param mapReduceOptions Options that specify detailed map-reduce behavior
 	 * @param entityClass The parametrized type of the returned list. Must not be {@literal null}.
 	 * @return The results of the map reduce operation
-	 * @deprecated since 3.4 in favor of {@link #aggregate(TypedAggregation, Class)}.
 	 */
-	@Deprecated
 	<T> MapReduceResults<T> mapReduce(Query query, String inputCollectionName, String mapFunction, String reduceFunction,
 			@Nullable MapReduceOptions mapReduceOptions, Class<T> entityClass);
 
@@ -712,9 +702,11 @@ public interface MongoOperations extends FluentMongoOperations {
 
 	/**
 	 * Map the results of an ad-hoc query on the collection for the entity class to a single instance of an object of the
-	 * specified type. <br />
+	 * specified type.
+	 * <br />
 	 * The object is converted from the MongoDB native representation using an instance of {@see MongoConverter}. Unless
-	 * configured otherwise, an instance of {@link MappingMongoConverter} will be used. <br />
+	 * configured otherwise, an instance of {@link MappingMongoConverter} will be used.
+	 * <br />
 	 * The query is specified as a {@link Query} which can be created either using the {@link BasicQuery} or the more
 	 * feature rich {@link Query}.
 	 *
@@ -728,9 +720,11 @@ public interface MongoOperations extends FluentMongoOperations {
 
 	/**
 	 * Map the results of an ad-hoc query on the specified collection to a single instance of an object of the specified
-	 * type. <br />
+	 * type.
+	 * <br />
 	 * The object is converted from the MongoDB native representation using an instance of {@see MongoConverter}. Unless
-	 * configured otherwise, an instance of {@link MappingMongoConverter} will be used. <br />
+	 * configured otherwise, an instance of {@link MappingMongoConverter} will be used.
+	 * <br />
 	 * The query is specified as a {@link Query} which can be created either using the {@link BasicQuery} or the more
 	 * feature rich {@link Query}.
 	 *
@@ -774,9 +768,11 @@ public interface MongoOperations extends FluentMongoOperations {
 	boolean exists(Query query, @Nullable Class<?> entityClass, String collectionName);
 
 	/**
-	 * Map the results of an ad-hoc query on the collection for the entity class to a List of the specified type. <br />
+	 * Map the results of an ad-hoc query on the collection for the entity class to a List of the specified type.
+	 * <br />
 	 * The object is converted from the MongoDB native representation using an instance of {@see MongoConverter}. Unless
-	 * configured otherwise, an instance of {@link MappingMongoConverter} will be used. <br />
+	 * configured otherwise, an instance of {@link MappingMongoConverter} will be used.
+	 * <br />
 	 * The query is specified as a {@link Query} which can be created either using the {@link BasicQuery} or the more
 	 * feature rich {@link Query}.
 	 *
@@ -788,9 +784,11 @@ public interface MongoOperations extends FluentMongoOperations {
 	<T> List<T> find(Query query, Class<T> entityClass);
 
 	/**
-	 * Map the results of an ad-hoc query on the specified collection to a List of the specified type. <br />
+	 * Map the results of an ad-hoc query on the specified collection to a List of the specified type.
+	 * <br />
 	 * The object is converted from the MongoDB native representation using an instance of {@see MongoConverter}. Unless
-	 * configured otherwise, an instance of {@link MappingMongoConverter} will be used. <br />
+	 * configured otherwise, an instance of {@link MappingMongoConverter} will be used.
+	 * <br />
 	 * The query is specified as a {@link Query} which can be created either using the {@link BasicQuery} or the more
 	 * feature rich {@link Query}.
 	 *
@@ -1042,7 +1040,7 @@ public interface MongoOperations extends FluentMongoOperations {
 	@Nullable
 	default <T> T findAndReplace(Query query, T replacement, FindAndReplaceOptions options, String collectionName) {
 
-		Assert.notNull(replacement, "Replacement must not be null");
+		Assert.notNull(replacement, "Replacement must not be null!");
 		return findAndReplace(query, replacement, options, (Class<T>) ClassUtils.getUserClass(replacement), collectionName);
 	}
 
@@ -1128,8 +1126,10 @@ public interface MongoOperations extends FluentMongoOperations {
 	/**
 	 * Map the results of an ad-hoc query on the collection for the entity type to a single instance of an object of the
 	 * specified type. The first document that matches the query is returned and also removed from the collection in the
-	 * database. <br />
-	 * The object is converted from the MongoDB native representation using an instance of {@see MongoConverter}. <br />
+	 * database.
+	 * <br />
+	 * The object is converted from the MongoDB native representation using an instance of {@see MongoConverter}.
+	 * <br />
 	 * The query is specified as a {@link Query} which can be created either using the {@link BasicQuery} or the more
 	 * feature rich {@link Query}.
 	 *
@@ -1146,7 +1146,8 @@ public interface MongoOperations extends FluentMongoOperations {
 	 * type. The first document that matches the query is returned and also removed from the collection in the database.
 	 * <br />
 	 * The object is converted from the MongoDB native representation using an instance of {@see MongoConverter}. Unless
-	 * configured otherwise, an instance of {@link MappingMongoConverter} will be used. <br />
+	 * configured otherwise, an instance of {@link MappingMongoConverter} will be used.
+	 * <br />
 	 * The query is specified as a {@link Query} which can be created either using the {@link BasicQuery} or the more
 	 * feature rich {@link Query}.
 	 *
@@ -1165,100 +1166,8 @@ public interface MongoOperations extends FluentMongoOperations {
 	 * <strong>NOTE:</strong> Query {@link Query#getSkip() offset} and {@link Query#getLimit() limit} can have direct
 	 * influence on the resulting number of documents found as those values are passed on to the server and potentially
 	 * limit the range and order within which the server performs the count operation. Use an {@literal unpaged} query to
-	 * count all matches. <br />
-	 * This method may choose to use {@link #estimatedCount(Class)} for empty queries instead of running an
-	 * {@link com.mongodb.client.MongoCollection#countDocuments(org.bson.conversions.Bson, com.mongodb.client.model.CountOptions)
-	 * aggregation execution} which may have an impact on performance.
-	 *
-	 * @param query the {@link Query} class that specifies the criteria used to find documents. Must not be
-	 *          {@literal null}.
-	 * @param entityClass class that determines the collection to use. Must not be {@literal null}.
-	 * @return the count of matching documents.
-	 * @throws org.springframework.data.mapping.MappingException if the collection name cannot be
-	 * 	  {@link #getCollectionName(Class) derived} from the given type.
-	 * @see #exactCount(Query, Class)
-	 * @see #estimatedCount(Class)
-	 */
-	long count(Query query, Class<?> entityClass);
-
-	/**
-	 * 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. Use {@link #count(Query, Class, String)} to get full type specific support. <br />
-	 * <strong>NOTE:</strong> Query {@link Query#getSkip() offset} and {@link Query#getLimit() limit} can have direct
-	 * influence on the resulting number of documents found as those values are passed on to the server and potentially
-	 * limit the range and order within which the server performs the count operation. Use an {@literal unpaged} query to
-	 * count all matches. <br />
-	 * This method may choose to use {@link #estimatedCount(Class)} for empty queries instead of running an
-	 * {@link com.mongodb.client.MongoCollection#countDocuments(org.bson.conversions.Bson, com.mongodb.client.model.CountOptions)
-	 * aggregation execution} which may have an impact on performance.
-	 *
-	 * @param query the {@link Query} class that specifies the criteria used to find documents.
-	 * @param collectionName must not be {@literal null} or empty.
-	 * @return the count of matching documents.
-	 * @see #count(Query, Class, String)
-	 * @see #exactCount(Query, String)
-	 * @see #estimatedCount(String)
-	 */
-	long count(Query query, String collectionName);
-
-	/**
-	 * 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}. <br />
-	 * <strong>NOTE:</strong> Query {@link Query#getSkip() offset} and {@link Query#getLimit() limit} can have direct
-	 * influence on the resulting number of documents found as those values are passed on to the server and potentially
-	 * limit the range and order within which the server performs the count operation. Use an {@literal unpaged} query to
-	 * count all matches. <br />
-	 * This method may choose to use {@link #estimatedCount(Class)} for empty queries instead of running an
-	 * {@link com.mongodb.client.MongoCollection#countDocuments(org.bson.conversions.Bson, com.mongodb.client.model.CountOptions)
-	 * aggregation execution} which may have an impact on performance.
-	 *
-	 * @param query the {@link Query} class that specifies the criteria used to find documents. Must not be
-	 *          {@literal null}.
-	 * @param entityClass the parametrized type. Can be {@literal null}.
-	 * @param collectionName must not be {@literal null} or empty.
-	 * @return the count of matching documents.
-	 * @see #count(Query, Class, String)
-	 * @see #estimatedCount(String)
-	 */
-	long count(Query query, @Nullable Class<?> entityClass, String collectionName);
-
-	/**
-	 * Estimate the number of documents, in the collection {@link #getCollectionName(Class) identified by the given type},
-	 * based on collection statistics. <br />
-	 * Please make sure to read the MongoDB reference documentation about limitations on eg. sharded cluster or inside
-	 * transactions.
-	 *
-	 * @param entityClass must not be {@literal null}.
-	 * @return the estimated number of documents.
-	 * @throws org.springframework.data.mapping.MappingException if the collection name cannot be
-	 *           {@link #getCollectionName(Class) derived} from the given type.
-	 * @since 3.1
-	 */
-	default long estimatedCount(Class<?> entityClass) {
-
-		Assert.notNull(entityClass, "Entity class must not be null");
-		return estimatedCount(getCollectionName(entityClass));
-	}
-
-	/**
-	 * Estimate the number of documents in the given collection based on collection statistics. <br />
-	 * Please make sure to read the MongoDB reference documentation about limitations on eg. sharded cluster or inside
-	 * transactions.
-	 *
-	 * @param collectionName must not be {@literal null}.
-	 * @return the estimated number of documents.
-	 * @since 3.1
-	 */
-	long estimatedCount(String collectionName);
-
-	/**
-	 * Returns the number of documents for the given {@link Query} by querying the collection of the given entity class.
+	 * count all matches.
 	 * <br />
-	 * <strong>NOTE:</strong> Query {@link Query#getSkip() offset} and {@link Query#getLimit() limit} can have direct
-	 * influence on the resulting number of documents found as those values are passed on to the server and potentially
-	 * limit the range and order within which the server performs the count operation. Use an {@literal unpaged} query to
-	 * count all matches. <br />
 	 * This method uses an
 	 * {@link com.mongodb.client.MongoCollection#countDocuments(org.bson.conversions.Bson, com.mongodb.client.model.CountOptions)
 	 * aggregation execution} even for empty {@link Query queries} which may have an impact on performance, but guarantees
@@ -1270,12 +1179,9 @@ public interface MongoOperations extends FluentMongoOperations {
 	 * @param entityClass class that determines the collection to use. Must not be {@literal null}.
 	 * @return the count of matching documents.
 	 * @throws org.springframework.data.mapping.MappingException if the collection name cannot be
-	 *           {@link #getCollectionName(Class) derived} from the given type.
-	 * @since 3.4
+	 * 	  {@link #getCollectionName(Class) derived} from the given type.
 	 */
-	default long exactCount(Query query, Class<?> entityClass) {
-		return exactCount(query, entityClass, getCollectionName(entityClass));
-	}
+	long count(Query query, Class<?> entityClass);
 
 	/**
 	 * Returns the number of documents for the given {@link Query} querying the given collection. The given {@link Query}
@@ -1284,7 +1190,8 @@ public interface MongoOperations extends FluentMongoOperations {
 	 * <strong>NOTE:</strong> Query {@link Query#getSkip() offset} and {@link Query#getLimit() limit} can have direct
 	 * influence on the resulting number of documents found as those values are passed on to the server and potentially
 	 * limit the range and order within which the server performs the count operation. Use an {@literal unpaged} query to
-	 * count all matches. <br />
+	 * count all matches.
+	 * <br />
 	 * This method uses an
 	 * {@link com.mongodb.client.MongoCollection#countDocuments(org.bson.conversions.Bson, com.mongodb.client.model.CountOptions)
 	 * aggregation execution} even for empty {@link Query queries} which may have an impact on performance, but guarantees
@@ -1295,19 +1202,48 @@ public interface MongoOperations extends FluentMongoOperations {
 	 * @param collectionName must not be {@literal null} or empty.
 	 * @return the count of matching documents.
 	 * @see #count(Query, Class, String)
-	 * @since 3.4
 	 */
-	default long exactCount(Query query, String collectionName) {
-		return exactCount(query, null, collectionName);
+	long count(Query query, String collectionName);
+
+	/**
+	 * Estimate the number of documents, in the collection {@link #getCollectionName(Class) identified by the given type},
+	 * based on collection statistics.
+	 * <br />
+	 * Please make sure to read the MongoDB reference documentation about limitations on eg. sharded cluster or inside
+	 * transactions.
+	 *
+	 * @param entityClass must not be {@literal null}.
+	 * @return the estimated number of documents.
+	 * @throws org.springframework.data.mapping.MappingException if the collection name cannot be
+	 *           {@link #getCollectionName(Class) derived} from the given type.
+	 * @since 3.1
+	 */
+	default long estimatedCount(Class<?> entityClass) {
+
+		Assert.notNull(entityClass, "Entity class must not be null!");
+		return estimatedCount(getCollectionName(entityClass));
 	}
 
+	/**
+	 * Estimate the number of documents in the given collection based on collection statistics.
+	 * <br />
+	 * Please make sure to read the MongoDB reference documentation about limitations on eg. sharded cluster or inside
+	 * transactions.
+	 *
+	 * @param collectionName must not be {@literal null}.
+	 * @return the estimated number of documents.
+	 * @since 3.1
+	 */
+	long estimatedCount(String collectionName);
+
 	/**
 	 * 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}. <br />
 	 * <strong>NOTE:</strong> Query {@link Query#getSkip() offset} and {@link Query#getLimit() limit} can have direct
 	 * influence on the resulting number of documents found as those values are passed on to the server and potentially
 	 * limit the range and order within which the server performs the count operation. Use an {@literal unpaged} query to
-	 * count all matches. <br />
+	 * count all matches.
+	 * <br />
 	 * This method uses an
 	 * {@link com.mongodb.client.MongoCollection#countDocuments(org.bson.conversions.Bson, com.mongodb.client.model.CountOptions)
 	 * aggregation execution} even for empty {@link Query queries} which may have an impact on performance, but guarantees
@@ -1319,19 +1255,20 @@ public interface MongoOperations extends FluentMongoOperations {
 	 * @param entityClass the parametrized type. Can be {@literal null}.
 	 * @param collectionName must not be {@literal null} or empty.
 	 * @return the count of matching documents.
-	 * @since 3.4
 	 */
-	long exactCount(Query query, @Nullable Class<?> entityClass, String collectionName);
+	long count(Query query, @Nullable Class<?> entityClass, String collectionName);
 
 	/**
-	 * Insert the object into the collection for the entity type of the object to save. <br />
-	 * The object is converted to the MongoDB native representation using an instance of {@see MongoConverter}. <br />
-	 * If your object has an {@literal Id} property which holds a {@literal null} value, it will be set with the generated
-	 * Id from MongoDB. If your Id property is a String then MongoDB ObjectId will be used to populate that string.
-	 * Otherwise, the conversion from ObjectId to your property type will be handled by Spring's BeanWrapper class that
-	 * leverages Type Conversion API. See
+	 * Insert the object into the collection for the entity type of the object to save.
+	 * <br />
+	 * The object is converted to the MongoDB native representation using an instance of {@see MongoConverter}.
+	 * <br />
+	 * If your object has an "Id' property, it will be set with the generated Id from MongoDB. If your Id property is a
+	 * String then MongoDB ObjectId will be used to populate that string. Otherwise, the conversion from ObjectId to your
+	 * property type will be handled by Spring's BeanWrapper class that leverages Type Conversion API. See
 	 * <a href="https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#validation" > Spring's
-	 * Type Conversion"</a> for more details. <br />
+	 * Type Conversion"</a> for more details.
+	 * <br />
 	 * Insert is used to initially store the object into the database. To update an existing object use the save method.
 	 * <br />
 	 * The {@code objectToSave} must not be collection-like.
@@ -1345,9 +1282,11 @@ public interface MongoOperations extends FluentMongoOperations {
 	<T> T insert(T objectToSave);
 
 	/**
-	 * Insert the object into the specified collection. <br />
+	 * Insert the object into the specified collection.
+	 * <br />
 	 * The object is converted to the MongoDB native representation using an instance of {@see MongoConverter}. Unless
-	 * configured otherwise, an instance of {@link MappingMongoConverter} will be used. <br />
+	 * configured otherwise, an instance of {@link MappingMongoConverter} will be used.
+	 * <br />
 	 * Insert is used to initially store the object into the database. To update an existing object use the save method.
 	 * <br />
 	 * The {@code objectToSave} must not be collection-like.
@@ -1392,14 +1331,17 @@ public interface MongoOperations extends FluentMongoOperations {
 
 	/**
 	 * Save the object to the collection for the entity type of the object to save. This will perform an insert if the
-	 * object is not already present, that is an 'upsert'. <br />
+	 * object is not already present, that is an 'upsert'.
+	 * <br />
 	 * The object is converted to the MongoDB native representation using an instance of {@see MongoConverter}. Unless
-	 * configured otherwise, an instance of {@link MappingMongoConverter} will be used. <br />
+	 * configured otherwise, an instance of {@link MappingMongoConverter} will be used.
+	 * <br />
 	 * If your object has an "Id' property, it will be set with the generated Id from MongoDB. If your Id property is a
 	 * String then MongoDB ObjectId will be used to populate that string. Otherwise, the conversion from ObjectId to your
 	 * property type will be handled by Spring's BeanWrapper class that leverages Type Conversion API. See
 	 * <a href="https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#validation" > Spring's
-	 * Type Conversion"</a> for more details. <br />
+	 * Type Conversion"</a> for more details.
+	 * <br />
 	 * The {@code objectToSave} must not be collection-like.
 	 *
 	 * @param objectToSave the object to store in the collection. Must not be {@literal null}.
@@ -1412,14 +1354,16 @@ public interface MongoOperations extends FluentMongoOperations {
 
 	/**
 	 * Save the object to the specified collection. This will perform an insert if the object is not already present, that
-	 * is an 'upsert'. <br />
+	 * is an 'upsert'.
+	 * <br />
 	 * The object is converted to the MongoDB native representation using an instance of {@see MongoConverter}. Unless
-	 * configured otherwise, an instance of {@link MappingMongoConverter} will be used. <br />
+	 * configured otherwise, an instance of {@link MappingMongoConverter} will be used.
+	 * <br />
 	 * If your object has an "Id' property, it will be set with the generated Id from MongoDB. If your Id property is a
 	 * String then MongoDB ObjectId will be used to populate that string. Otherwise, the conversion from ObjectId to your
-	 * property type will be handled by Spring's BeanWrapper class that leverages Type Conversion API. See
-	 * <a href="https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#validation">Spring's Type
-	 * Conversion</a> for more details. <br />
+	 * property type will be handled by Spring's BeanWrapper class that leverages Type Conversion API.
+	 * See <a href="https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#validation">Spring's Type Conversion</a> for more details.
+	 * <br />
 	 * The {@code objectToSave} must not be collection-like.
 	 *
 	 * @param objectToSave the object to store in the collection. Must not be {@literal null}.
@@ -1623,7 +1567,7 @@ public interface MongoOperations extends FluentMongoOperations {
 	DeleteResult remove(Object object, String collectionName);
 
 	/**
-	 * Remove all documents that match the provided query document criteria from the collection used to store the
+	 * 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 the query document that specifies the criteria used to remove a record.
@@ -1636,7 +1580,7 @@ public interface MongoOperations extends FluentMongoOperations {
 	DeleteResult remove(Query query, Class<?> entityClass);
 
 	/**
-	 * Remove all documents that match the provided query document criteria from the collection used to store the
+	 * 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 the query document that specifies the criteria used to remove a record.
@@ -1686,9 +1630,9 @@ public interface MongoOperations extends FluentMongoOperations {
 	<T> List<T> findAllAndRemove(Query query, Class<T> entityClass);
 
 	/**
-	 * Returns and removes all documents that match the provided query document criteria from 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.
+	 * 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 the query document that specifies the criteria used to find and remove documents.
 	 * @param entityClass class of the pojo to be operated on.

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

@@ -16,19 +16,18 @@
 package org.springframework.data.mongodb.core;
 
 import org.bson.Document;
-
+import org.springframework.data.mapping.SimplePropertyHandler;
 import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
-import org.springframework.data.mongodb.core.mapping.PersistentPropertyTranslator;
-import org.springframework.data.projection.EntityProjection;
-import org.springframework.data.util.Predicates;
+import org.springframework.data.projection.ProjectionFactory;
+import org.springframework.data.projection.ProjectionInformation;
+import org.springframework.util.ClassUtils;
 
 /**
  * Common operations performed on properties of an entity like extracting fields information for projection creation.
  *
  * @author Christoph Strobl
- * @author Mark Paluch
  * @since 2.1
  */
 class PropertyOperations {
@@ -41,37 +40,37 @@ class PropertyOperations {
 
 	/**
 	 * For cases where {@code fields} is {@link Document#isEmpty() empty} include only fields that are required for
-	 * creating the projection (target) type if the {@code EntityProjection} is a {@literal DTO projection} or a
+	 * creating the projection (target) type if the {@code targetType} is a {@literal DTO projection} or a
 	 * {@literal closed interface projection}.
 	 *
-	 * @param projection must not be {@literal null}.
+	 * @param projectionFactory must not be {@literal null}.
 	 * @param fields must not be {@literal null}.
+	 * @param domainType must not be {@literal null}.
+	 * @param targetType must not be {@literal null}.
 	 * @return {@link Document} with fields to be included.
 	 */
-	Document computeMappedFieldsForProjection(EntityProjection<?, ?> projection,
-			Document fields) {
+	Document computeFieldsForProjection(ProjectionFactory projectionFactory, Document fields, Class<?> domainType,
+			Class<?> targetType) {
 
-		if (!projection.isClosedProjection()) {
+		if (!fields.isEmpty() || ClassUtils.isAssignable(domainType, targetType)) {
 			return fields;
 		}
 
 		Document projectedFields = new Document();
 
-		if (projection.getMappedType().getType().isInterface()) {
-			projection.forEach(it -> {
-				projectedFields.put(it.getPropertyPath().getSegment(), 1);
-			});
+		if (targetType.isInterface()) {
+
+			ProjectionInformation projectionInformation = projectionFactory.getProjectionInformation(targetType);
+
+			if (projectionInformation.isClosed()) {
+				projectionInformation.getInputProperties().forEach(it -> projectedFields.append(it.getName(), 1));
+			}
 		} else {
 
-			// DTO projections use merged metadata between domain type and result type
-			PersistentPropertyTranslator translator = PersistentPropertyTranslator.create(
-					mappingContext.getRequiredPersistentEntity(projection.getDomainType()),
-					Predicates.negate(MongoPersistentProperty::hasExplicitFieldName));
-
-			MongoPersistentEntity<?> persistentEntity = mappingContext
-					.getRequiredPersistentEntity(projection.getMappedType());
-			for (MongoPersistentProperty property : persistentEntity) {
-				projectedFields.put(translator.translate(property).getFieldName(), 1);
+			MongoPersistentEntity<?> entity = mappingContext.getPersistentEntity(targetType);
+			if (entity != null) {
+				entity.doWithProperties(
+						(SimplePropertyHandler) persistentProperty -> projectedFields.append(persistentProperty.getName(), 1));
 			}
 		}
 

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

@@ -28,7 +28,6 @@ import java.util.stream.Collectors;
 import org.bson.BsonValue;
 import org.bson.Document;
 import org.bson.codecs.Codec;
-import org.bson.types.ObjectId;
 import org.springframework.data.mapping.PropertyPath;
 import org.springframework.data.mapping.PropertyReferenceException;
 import org.springframework.data.mapping.context.MappingContext;
@@ -46,7 +45,6 @@ import org.springframework.data.mongodb.core.aggregation.TypeBasedAggregationOpe
 import org.springframework.data.mongodb.core.aggregation.TypedAggregation;
 import org.springframework.data.mongodb.core.convert.QueryMapper;
 import org.springframework.data.mongodb.core.convert.UpdateMapper;
-import org.springframework.data.mongodb.core.mapping.MongoId;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
 import org.springframework.data.mongodb.core.mapping.ShardKey;
@@ -56,10 +54,11 @@ import org.springframework.data.mongodb.core.query.Query;
 import org.springframework.data.mongodb.core.query.UpdateDefinition;
 import org.springframework.data.mongodb.core.query.UpdateDefinition.ArrayFilter;
 import org.springframework.data.mongodb.util.BsonUtils;
-import org.springframework.data.projection.EntityProjection;
+import org.springframework.data.projection.ProjectionFactory;
 import org.springframework.data.util.Lazy;
 import org.springframework.lang.Nullable;
 import org.springframework.util.ClassUtils;
+import org.springframework.util.ObjectUtils;
 import org.springframework.util.StringUtils;
 
 import com.mongodb.client.model.CountOptions;
@@ -108,14 +107,6 @@ class QueryOperations {
 		this.aggregationUtil = new AggregationUtil(queryMapper, mappingContext);
 	}
 
-	InsertContext createInsertContext(Document source) {
-		return createInsertContext(MappedDocument.of(source));
-	}
-
-	InsertContext createInsertContext(MappedDocument mappedDocument) {
-		return new InsertContext(mappedDocument);
-	}
-
 	/**
 	 * Create a new {@link QueryContext} instance.
 	 *
@@ -236,57 +227,6 @@ class QueryOperations {
 		return new AggregationDefinition(aggregation, aggregationOperationContext);
 	}
 
-	/**
-	 * {@link InsertContext} encapsulates common tasks required to interact with {@link Document} to be inserted.
-	 *
-	 * @since 3.4.3
-	 */
-	class InsertContext {
-
-		private final MappedDocument source;
-
-		private InsertContext(MappedDocument source) {
-			this.source = source;
-		}
-
-		/**
-		 * Prepare the {@literal _id} field. May generate a new {@literal id} value and convert it to the id properties
-		 * {@link MongoPersistentProperty#getFieldType() target type}.
-		 *
-		 * @param type must not be {@literal null}.
-		 * @param <T>
-		 * @return the {@link MappedDocument} containing the changes.
-		 * @see #prepareId(MongoPersistentEntity)
-		 */
-		<T> MappedDocument prepareId(Class<T> type) {
-			return prepareId(mappingContext.getPersistentEntity(type));
-		}
-
-		/**
-		 * Prepare the {@literal _id} field. May generate a new {@literal id} value and convert it to the id properties
-		 * {@link MongoPersistentProperty#getFieldType() target type}.
-		 *
-		 * @param entity can be {@literal null}.
-		 * @param <T>
-		 * @return the {@link MappedDocument} containing the changes.
-		 */
-		<T> MappedDocument prepareId(@Nullable MongoPersistentEntity<T> entity) {
-
-			if (entity == null || source.hasId()) {
-				return source;
-			}
-
-			MongoPersistentProperty idProperty = entity.getIdProperty();
-			if (idProperty != null
-					&& (idProperty.hasExplicitWriteTarget() || idProperty.isAnnotationPresent(MongoId.class))) {
-				if (!ClassUtils.isAssignable(ObjectId.class, idProperty.getFieldType())) {
-					source.updateId(queryMapper.convertId(new ObjectId(), idProperty.getFieldType()));
-				}
-			}
-			return source;
-		}
-	}
-
 	/**
 	 * {@link QueryContext} encapsulates common tasks required to convert a {@link Query} into its MongoDB document
 	 * representation, mapping field names, as well as determining and applying {@link Collation collations}.
@@ -348,58 +288,45 @@ class QueryOperations {
 			return queryMapper.getMappedObject(getQueryObject(), entity);
 		}
 
-		Document getMappedFields(@Nullable MongoPersistentEntity<?> entity, EntityProjection<?, ?> projection) {
+		Document getMappedFields(@Nullable MongoPersistentEntity<?> entity, Class<?> targetType,
+				ProjectionFactory projectionFactory) {
 
-			Document fields = evaluateFields(entity);
+			Document fields = new Document();
 
-			if (entity == null) {
-				return fields;
-			}
-
-			Document mappedFields;
-			if (!fields.isEmpty()) {
-				mappedFields = queryMapper.getMappedFields(fields, entity);
-			} else {
-				mappedFields = propertyOperations.computeMappedFieldsForProjection(projection, fields);
-				mappedFields = queryMapper.addMetaAttributes(mappedFields, entity);
-			}
-
-			if (entity.hasTextScoreProperty() && mappedFields.containsKey(entity.getTextScoreProperty().getFieldName())
-					&& !query.getQueryObject().containsKey("$text")) {
-				mappedFields.remove(entity.getTextScoreProperty().getFieldName());
-			}
-
-			if (mappedFields.isEmpty()) {
-				return BsonUtils.EMPTY_DOCUMENT;
-			}
-
-			return mappedFields;
-		}
-
-		private Document evaluateFields(@Nullable MongoPersistentEntity<?> entity) {
-
-			Document fields = query.getFieldsObject();
-
-			if (fields.isEmpty()) {
-				return BsonUtils.EMPTY_DOCUMENT;
-			}
-
-			Document evaluated = new Document();
-
-			for (Entry<String, Object> entry : fields.entrySet()) {
+			for (Entry<String, Object> entry : query.getFieldsObject().entrySet()) {
 
 				if (entry.getValue() instanceof MongoExpression) {
 
 					AggregationOperationContext ctx = entity == null ? Aggregation.DEFAULT_CONTEXT
 							: new RelaxedTypeBasedAggregationOperationContext(entity.getType(), mappingContext, queryMapper);
 
-					evaluated.put(entry.getKey(), AggregationExpression.from((MongoExpression) entry.getValue()).toDocument(ctx));
+					fields.put(entry.getKey(), AggregationExpression.from((MongoExpression) entry.getValue()).toDocument(ctx));
 				} else {
-					evaluated.put(entry.getKey(), entry.getValue());
+					fields.put(entry.getKey(), entry.getValue());
 				}
 			}
 
-			return evaluated;
+			Document mappedFields = fields;
+
+			if (entity == null) {
+				return mappedFields;
+			}
+
+			Document projectedFields = propertyOperations.computeFieldsForProjection(projectionFactory, fields,
+					entity.getType(), targetType);
+
+			if (ObjectUtils.nullSafeEquals(fields, projectedFields)) {
+				mappedFields = queryMapper.getMappedFields(projectedFields, entity);
+			} else {
+				mappedFields = queryMapper.getMappedFields(projectedFields,
+						mappingContext.getRequiredPersistentEntity(targetType));
+			}
+
+			if (entity.hasTextScoreProperty() && !query.getQueryObject().containsKey("$text")) {
+				mappedFields.remove(entity.getTextScoreProperty().getFieldName());
+			}
+
+			return mappedFields;
 		}
 
 		/**
@@ -461,7 +388,8 @@ class QueryOperations {
 		}
 
 		@Override
-		Document getMappedFields(@Nullable MongoPersistentEntity<?> entity, EntityProjection<?, ?> projection) {
+		Document getMappedFields(@Nullable MongoPersistentEntity<?> entity, Class<?> targetType,
+				ProjectionFactory projectionFactory) {
 			return getMappedFields(entity);
 		}
 

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

@@ -41,15 +41,19 @@ class ReactiveAggregationOperationSupport implements ReactiveAggregationOperatio
 	 */
 	ReactiveAggregationOperationSupport(ReactiveMongoTemplate template) {
 
-		Assert.notNull(template, "Template must not be null");
+		Assert.notNull(template, "Template must not be null!");
 
 		this.template = template;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ReactiveAggregationOperation#aggregateAndReturn(java.lang.Class)
+	 */
 	@Override
 	public <T> ReactiveAggregation<T> aggregateAndReturn(Class<T> domainType) {
 
-		Assert.notNull(domainType, "DomainType must not be null");
+		Assert.notNull(domainType, "DomainType must not be null!");
 
 		return new ReactiveAggregationSupport<>(template, domainType, null, null);
 	}
@@ -71,22 +75,34 @@ class ReactiveAggregationOperationSupport implements ReactiveAggregationOperatio
 			this.collection = collection;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveAggregationOperation.AggregationOperationWithCollection#inCollection(java.lang.String)
+		 */
 		@Override
 		public AggregationOperationWithAggregation<T> inCollection(String collection) {
 
-			Assert.hasText(collection, "Collection must not be null nor empty");
+			Assert.hasText(collection, "Collection must not be null nor empty!");
 
 			return new ReactiveAggregationSupport<>(template, domainType, aggregation, collection);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveAggregationOperation.AggregationOperationWithAggregation#by(org.springframework.data.mongodb.core.Aggregation)
+		 */
 		@Override
 		public TerminatingAggregationOperation<T> by(Aggregation aggregation) {
 
-			Assert.notNull(aggregation, "Aggregation must not be null");
+			Assert.notNull(aggregation, "Aggregation must not be null!");
 
 			return new ReactiveAggregationSupport<>(template, domainType, aggregation, collection);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveAggregationOperation.TerminatingAggregationOperation#all()
+		 */
 		@Override
 		public Flux<T> all() {
 			return template.aggregate(aggregation, getCollectionName(aggregation), domainType);

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

@@ -46,10 +46,14 @@ class ReactiveChangeStreamOperationSupport implements ReactiveChangeStreamOperat
 		this.template = template;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ReactiveChangeStreamOperation#changeStream(java.lang.Class)
+	 */
 	@Override
 	public <T> ReactiveChangeStream<T> changeStream(Class<T> domainType) {
 
-		Assert.notNull(domainType, "DomainType must not be null");
+		Assert.notNull(domainType, "DomainType must not be null!");
 		return new ReactiveChangeStreamSupport<>(template, domainType, domainType, null, null);
 	}
 
@@ -72,22 +76,34 @@ class ReactiveChangeStreamOperationSupport implements ReactiveChangeStreamOperat
 			this.options = options;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveChangeStreamOperation.ChangeStreamWithCollection#watchCollection(java.lang.String)
+		 */
 		@Override
 		public ChangeStreamWithFilterAndProjection<T> watchCollection(String collection) {
 
-			Assert.hasText(collection, "Collection name must not be null nor empty");
+			Assert.hasText(collection, "Collection name must not be null nor empty!");
 
 			return new ReactiveChangeStreamSupport<>(template, domainType, returnType, collection, options);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveChangeStreamOperation.ChangeStreamWithCollection#watchCollection(java.lang.Class)
+		 */
 		@Override
 		public ChangeStreamWithFilterAndProjection<T> watchCollection(Class<?> entityClass) {
 
-			Assert.notNull(entityClass, "Collection type not be null");
+			Assert.notNull(entityClass, "Collection type not be null!");
 
 			return watchCollection(template.getCollectionName(entityClass));
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveChangeStreamOperation.ResumingChangeStream#resumeAt(java.lang.Object)
+		 */
 		@Override
 		public TerminatingChangeStream<T> resumeAt(Object token) {
 
@@ -101,6 +117,10 @@ class ReactiveChangeStreamOperationSupport implements ReactiveChangeStreamOperat
 			});
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveChangeStreamOperation.ResumingChangeStream#resumeAfter(java.lang.Object)
+		 */
 		@Override
 		public TerminatingChangeStream<T> resumeAfter(Object token) {
 
@@ -109,6 +129,10 @@ class ReactiveChangeStreamOperationSupport implements ReactiveChangeStreamOperat
 			return withOptions(builder -> builder.resumeAfter((BsonValue) token));
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveChangeStreamOperation.ResumingChangeStream#startAfter(java.lang.Object)
+		 */
 		@Override
 		public TerminatingChangeStream<T> startAfter(Object token) {
 
@@ -117,6 +141,10 @@ class ReactiveChangeStreamOperationSupport implements ReactiveChangeStreamOperat
 			return withOptions(builder -> builder.startAfter((BsonValue) token));
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveChangeStreamOperation.ChangeStreamWithOptions#withOptions(java.util.function.Consumer)
+		 */
 		@Override
 		public ReactiveChangeStreamSupport<T> withOptions(Consumer<ChangeStreamOptionsBuilder> optionsConsumer) {
 
@@ -126,19 +154,31 @@ class ReactiveChangeStreamOperationSupport implements ReactiveChangeStreamOperat
 			return new ReactiveChangeStreamSupport<>(template, domainType, returnType, collection, builder.build());
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveChangeStreamOperation.ChangeStreamWithProjection#as(java.lang.Class)
+		 */
 		@Override
 		public <R> ChangeStreamWithFilterAndProjection<R> as(Class<R> resultType) {
 
-			Assert.notNull(resultType, "ResultType must not be null");
+			Assert.notNull(resultType, "ResultType must not be null!");
 
 			return new ReactiveChangeStreamSupport<>(template, domainType, resultType, collection, options);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveChangeStreamOperation.ChangeStreamWithFilter#filter(org.springframework.data.mongodb.core.aggregation.Aggregation)
+		 */
 		@Override
 		public ChangeStreamWithFilterAndProjection<T> filter(Aggregation filter) {
 			return withOptions(builder -> builder.filter(filter));
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveChangeStreamOperation.ChangeStreamWithFilter#filter(org.springframework.data.mongodb.core.query.CriteriaDefinition)
+		 */
 		@Override
 		public ChangeStreamWithFilterAndProjection<T> filter(CriteriaDefinition by) {
 
@@ -148,6 +188,10 @@ class ReactiveChangeStreamOperationSupport implements ReactiveChangeStreamOperat
 			return filter(aggregation);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveChangeStreamOperation.TerminatingChangeStream#listen()
+		 */
 		@Override
 		public Flux<ChangeStreamEvent<T>> listen() {
 			return template.changeStream(collection, options != null ? options : ChangeStreamOptions.empty(), returnType);

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

@@ -44,10 +44,14 @@ class ReactiveFindOperationSupport implements ReactiveFindOperation {
 		this.template = template;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ReactiveFindOperation#query(java.lang.Class)
+	 */
 	@Override
 	public <T> ReactiveFind<T> query(Class<T> domainType) {
 
-		Assert.notNull(domainType, "DomainType must not be null");
+		Assert.notNull(domainType, "DomainType must not be null!");
 
 		return new ReactiveFindSupport<>(template, domainType, domainType, null, ALL_QUERY);
 	}
@@ -77,30 +81,46 @@ class ReactiveFindOperationSupport implements ReactiveFindOperation {
 			this.query = query;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.FindWithCollection#inCollection(java.lang.String)
+		 */
 		@Override
 		public FindWithProjection<T> inCollection(String collection) {
 
-			Assert.hasText(collection, "Collection name must not be null nor empty");
+			Assert.hasText(collection, "Collection name must not be null nor empty!");
 
 			return new ReactiveFindSupport<>(template, domainType, returnType, collection, query);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.FindWithProjection#as(java.lang.Class)
+		 */
 		@Override
 		public <T1> FindWithQuery<T1> as(Class<T1> returnType) {
 
-			Assert.notNull(returnType, "ReturnType must not be null");
+			Assert.notNull(returnType, "ReturnType must not be null!");
 
 			return new ReactiveFindSupport<>(template, domainType, returnType, collection, query);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.FindWithQuery#matching(org.springframework.data.mongodb.core.query.Query)
+		 */
 		@Override
 		public TerminatingFind<T> matching(Query query) {
 
-			Assert.notNull(query, "Query must not be null");
+			Assert.notNull(query, "Query must not be null!");
 
 			return new ReactiveFindSupport<>(template, domainType, returnType, collection, query);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.TerminatingFind#first()
+		 */
 		@Override
 		public Mono<T> first() {
 
@@ -110,6 +130,10 @@ class ReactiveFindOperationSupport implements ReactiveFindOperation {
 			return result.next();
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.TerminatingFind#one()
+		 */
 		@Override
 		public Mono<T> one() {
 
@@ -124,42 +148,66 @@ class ReactiveFindOperationSupport implements ReactiveFindOperation {
 
 				if (it.size() > 1) {
 					return Mono.error(
-							new IncorrectResultSizeDataAccessException("Query " + asString() + " returned non unique result", 1));
+							new IncorrectResultSizeDataAccessException("Query " + asString() + " returned non unique result.", 1));
 				}
 
 				return Mono.just(it.get(0));
 			});
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.TerminatingFind#all()
+		 */
 		@Override
 		public Flux<T> all() {
 			return doFind(null);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.TerminatingFind#tail()
+		 */
 		@Override
 		public Flux<T> tail() {
 			return doFind(template.new TailingQueryFindPublisherPreparer(query, domainType));
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.FindWithQuery#near(org.springframework.data.mongodb.core.query.NearQuery)
+		 */
 		@Override
 		public TerminatingFindNear<T> near(NearQuery nearQuery) {
 			return () -> template.geoNear(nearQuery, domainType, getCollectionName(), returnType);
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.TerminatingFind#count()
+		 */
 		@Override
 		public Mono<Long> count() {
 			return template.count(query, domainType, getCollectionName());
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.TerminatingFind#exists()
+		 */
 		@Override
 		public Mono<Boolean> exists() {
 			return template.exists(query, domainType, getCollectionName());
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.FindDistinct#distinct(java.lang.String)
+		 */
 		@Override
 		public TerminatingDistinct<Object> distinct(String field) {
 
-			Assert.notNull(field, "Field must not be null");
+			Assert.notNull(field, "Field must not be null!");
 
 			return new DistinctOperationSupport<>(this, field);
 		}
@@ -207,23 +255,35 @@ class ReactiveFindOperationSupport implements ReactiveFindOperation {
 				this.field = field;
 			}
 
+			/*
+			 * (non-Javadoc)
+			 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.DistinctWithProjection#as(java.lang.Class)
+			 */
 			@Override
 			public <R> TerminatingDistinct<R> as(Class<R> resultType) {
 
-				Assert.notNull(resultType, "ResultType must not be null");
+				Assert.notNull(resultType, "ResultType must not be null!");
 
 				return new DistinctOperationSupport<>((ReactiveFindSupport) delegate.as(resultType), field);
 			}
 
+			/*
+			 * (non-Javadoc)
+			 * @see org.springframework.data.mongodb.core.ReactiveFindOperation.DistinctWithQuery#matching(org.springframework.data.mongodb.core.query.Query)
+			 */
 			@Override
 			@SuppressWarnings("unchecked")
 			public TerminatingDistinct<T> matching(Query query) {
 
-				Assert.notNull(query, "Query must not be null");
+				Assert.notNull(query, "Query must not be null!");
 
 				return new DistinctOperationSupport<>((ReactiveFindSupport<T>) delegate.matching(query), field);
 			}
 
+			/*
+			 * (non-Javadoc)
+			 * @see org.springframework.data.mongodb.core..ReactiveFindOperation.TerminatingDistinct#all()
+			 */
 			@Override
 			public Flux<T> all() {
 				return delegate.doFindDistinct(field);

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

@@ -38,10 +38,14 @@ class ReactiveInsertOperationSupport implements ReactiveInsertOperation {
 		this.template = template;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.ReactiveInsertOperation#insert(java.lang.Class)
+	 */
 	@Override
 	public <T> ReactiveInsert<T> insert(Class<T> domainType) {
 
-		Assert.notNull(domainType, "DomainType must not be null");
+		Assert.notNull(domainType, "DomainType must not be null!");
 
 		return new ReactiveInsertSupport<>(template, domainType, null);
 	}
@@ -59,26 +63,38 @@ class ReactiveInsertOperationSupport implements ReactiveInsertOperation {
 			this.collection = collection;
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveInsertOperation.TerminatingInsert#one(java.lang.Object)
+		 */
 		@Override
 		public Mono<T> one(T object) {
 
-			Assert.notNull(object, "Object must not be null");
+			Assert.notNull(object, "Object must not be null!");
 
 			return template.insert(object, getCollectionName());
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveInsertOperation.TerminatingInsert#all(java.util.Collection)
+		 */
 		@Override
 		public Flux<T> all(Collection<? extends T> objects) {
 
-			Assert.notNull(objects, "Objects must not be null");
+			Assert.notNull(objects, "Objects must not be null!");
 
 			return template.insert(objects, getCollectionName());
 		}
 
+		/*
+		 * (non-Javadoc)
+		 * @see org.springframework.data.mongodb.core.ReactiveInsertOperation.InsertWithCollection#inCollection(java.lang.String)
+		 */
 		@Override
 		public ReactiveInsert<T> inCollection(String collection) {
 
-			Assert.hasText(collection, "Collection must not be null nor empty");
+			Assert.hasText(collection, "Collection must not be null nor empty.");
 
 			return new ReactiveInsertSupport<>(template, domainType, collection);
 		}

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

@@ -46,7 +46,7 @@ class ReactiveMapReduceOperationSupport implements ReactiveMapReduceOperation {
 	@Override
 	public <T> ReactiveMapReduceSupport<T> mapReduce(Class<T> domainType) {
 
-		Assert.notNull(domainType, "DomainType must not be null");
+		Assert.notNull(domainType, "DomainType must not be null!");
 
 		return new ReactiveMapReduceSupport<>(template, domainType, domainType, null, ALL_QUERY, null, null, null);
 	}
@@ -100,7 +100,7 @@ class ReactiveMapReduceOperationSupport implements ReactiveMapReduceOperation {
 		@Override
 		public MapReduceWithProjection<T> inCollection(String collection) {
 
-			Assert.hasText(collection, "Collection name must not be null nor empty");
+			Assert.hasText(collection, "Collection name must not be null nor empty!");
 
 			return new ReactiveMapReduceSupport<>(template, domainType, returnType, collection, query, mapFunction,
 					reduceFunction, options);
@@ -113,7 +113,7 @@ class ReactiveMapReduceOperationSupport implements ReactiveMapReduceOperation {
 		@Override
 		public TerminatingMapReduce<T> matching(Query query) {
 
-			Assert.notNull(query, "Query must not be null");
+			Assert.notNull(query, "Query must not be null!");
 
 			return new ReactiveMapReduceSupport<>(template, domainType, returnType, collection, query, mapFunction,
 					reduceFunction, options);
@@ -126,7 +126,7 @@ class ReactiveMapReduceOperationSupport implements ReactiveMapReduceOperation {
 		@Override
 		public <R> MapReduceWithQuery<R> as(Class<R> resultType) {
 
-			Assert.notNull(resultType, "ResultType must not be null");
+			Assert.notNull(resultType, "ResultType must not be null!");
 
 			return new ReactiveMapReduceSupport<>(template, domainType, resultType, collection, query, mapFunction,
 					reduceFunction, options);
@@ -139,7 +139,7 @@ class ReactiveMapReduceOperationSupport implements ReactiveMapReduceOperation {
 		@Override
 		public ReactiveMapReduce<T> with(MapReduceOptions options) {
 
-			Assert.notNull(options, "Options must not be null Please consider empty MapReduceOptions#options() instead");
+			Assert.notNull(options, "Options must not be null! Please consider empty MapReduceOptions#options() instead.");
 
 			return new ReactiveMapReduceSupport<>(template, domainType, returnType, collection, query, mapFunction,
 					reduceFunction, options);
@@ -152,7 +152,7 @@ class ReactiveMapReduceOperationSupport implements ReactiveMapReduceOperation {
 		@Override
 		public MapReduceWithReduceFunction<T> map(String mapFunction) {
 
-			Assert.hasText(mapFunction, "MapFunction name must not be null nor empty");
+			Assert.hasText(mapFunction, "MapFunction name must not be null nor empty!");
 
 			return new ReactiveMapReduceSupport<>(template, domainType, returnType, collection, query, mapFunction,
 					reduceFunction, options);
@@ -165,7 +165,7 @@ class ReactiveMapReduceOperationSupport implements ReactiveMapReduceOperation {
 		@Override
 		public ReactiveMapReduce<T> reduce(String reduceFunction) {
 
-			Assert.hasText(reduceFunction, "ReduceFunction name must not be null nor empty");
+			Assert.hasText(reduceFunction, "ReduceFunction name must not be null nor empty!");
 
 			return new ReactiveMapReduceSupport<>(template, domainType, returnType, collection, query, mapFunction,
 					reduceFunction, options);

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

@@ -115,7 +115,7 @@ public class ReactiveMongoClientFactoryBean extends AbstractFactoryBean<MongoCli
 		}
 
 		throw new IllegalStateException(
-				"Cannot create MongoClients; One of the following is required: mongoClientSettings, connectionString or host/port");
+				"Cannot create MongoClients. One of the following is required: mongoClientSettings, connectionString or host/port");
 	}
 
 	@Override

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2022 the original author or authors.
+ * Copyright 2016-2022 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,21 +13,19 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.springframework.data.mongodb.observability;
+package org.springframework.data.mongodb.core;
 
-import io.micrometer.observation.Observation;
-import io.micrometer.observation.ObservationConvention;
+import com.mongodb.MongoClientSettings;
 
 /**
- * {@link ObservationConvention} for {@link MongoHandlerContext}.
+ * A factory bean for construction of a {@link MongoClientSettings} instance to be used with the async MongoDB driver.
  *
- * @author Greg Turnquist
- * @since 4
+ * @author Mark Paluch
+ * @author Christoph Strobl
+ * @since 2.0
+ * @deprecated since 3.0 - Use {@link MongoClientSettingsFactoryBean} instead.
  */
-public interface MongoHandlerObservationConvention extends ObservationConvention<MongoHandlerContext> {
+@Deprecated
+public class ReactiveMongoClientSettingsFactoryBean extends MongoClientSettingsFactoryBean {
 
-	@Override
-	default boolean supportsContext(Observation.Context context) {
-		return context instanceof MongoHandlerContext;
-	}
 }