Introduce `SessionSynchronization.NEVER` to disable transactional participation.

SessionSynchronization.NEVER bypasses all transactional integration in cases where applications do not want to make use of transactions so that transaction inspection overhead is avoided.

Original Pull Request: #3809

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

@@ -104,7 +104,8 @@ public class MongoDatabaseUtils {
 
 		Assert.notNull(factory, "Factory must not be null!");
 
-		if (!TransactionSynchronizationManager.isSynchronizationActive()) {
+		if (sessionSynchronization == SessionSynchronization.NEVER
+				|| !TransactionSynchronizationManager.isSynchronizationActive()) {
 			return StringUtils.hasText(dbName) ? factory.getMongoDatabase(dbName) : factory.getMongoDatabase();
 		}
 

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

@@ -138,6 +138,10 @@ public class ReactiveMongoDatabaseUtils {
 
 		Assert.notNull(factory, "DatabaseFactory must not be null!");
 
+		if (sessionSynchronization == SessionSynchronization.NEVER) {
+			return getMongoDatabaseOrDefault(dbName, factory);
+		}
+
 		return TransactionSynchronizationManager.forCurrentTransaction()
 				.filter(TransactionSynchronizationManager::isSynchronizationActive) //
 				.flatMap(synchronizationManager -> {

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

@@ -15,13 +15,20 @@
  */
 package org.springframework.data.mongodb;
 
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.ReactiveMongoTemplate;
+
 /**
- * {@link SessionSynchronization} is used along with {@link org.springframework.data.mongodb.core.MongoTemplate} to
- * define in which type of transactions to participate if any.
+ * {@link SessionSynchronization} is used along with {@code MongoTemplate} to define in which type of transactions to
+ * participate if any.
  *
  * @author Christoph Strobl
  * @author Mark Paluch
  * @since 2.1
+ * @see MongoTemplate#setSessionSynchronization(SessionSynchronization)
+ * @see MongoDatabaseUtils#getDatabase(MongoDatabaseFactory, SessionSynchronization)
+ * @see ReactiveMongoTemplate#setSessionSynchronization(SessionSynchronization)
+ * @see ReactiveMongoDatabaseUtils#getDatabase(ReactiveMongoDatabaseFactory, SessionSynchronization)
  */
 public enum SessionSynchronization {
 
@@ -34,5 +41,12 @@ public enum SessionSynchronization {
 	/**
 	 * Synchronize with native MongoDB transactions initiated via {@link MongoTransactionManager}.
 	 */
-	ON_ACTUAL_TRANSACTION;
+	ON_ACTUAL_TRANSACTION,
+
+	/**
+	 * Do not participate in ongoing transactions.
+	 *
+	 * @since 3.2.5
+	 */
+	NEVER;
 }

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/MongoDatabaseUtilsUnitTests.java

@@ -109,6 +109,30 @@ class MongoDatabaseUtilsUnitTests {
 		verify(dbFactory, never()).withSession(any(ClientSession.class));
 	}
 
+	@Test // GH-3760
+	void shouldJustReturnDatabaseIfSessionSynchronizationDisabled() throws Exception {
+
+		when(dbFactory.getMongoDatabase()).thenReturn(db);
+
+		JtaTransactionManager txManager = new JtaTransactionManager(userTransaction);
+		TransactionTemplate txTemplate = new TransactionTemplate(txManager);
+
+		txTemplate.execute(new TransactionCallbackWithoutResult() {
+
+			@Override
+			protected void doInTransactionWithoutResult(TransactionStatus transactionStatus) {
+
+				MongoDatabaseUtils.getDatabase(dbFactory, SessionSynchronization.NEVER);
+
+				assertThat(TransactionSynchronizationManager.hasResource(dbFactory)).isFalse();
+			}
+		});
+
+		verify(userTransaction).getStatus();
+		verifyNoMoreInteractions(userTransaction);
+		verifyNoInteractions(session);
+	}
+
 	@Test // DATAMONGO-1920
 	void shouldParticipateInOngoingJtaTransactionWithCommitWhenSessionSychronizationIsAny() throws Exception {
 

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/ReactiveMongoDatabaseUtilsUnitTests.java

@@ -88,6 +88,20 @@ class ReactiveMongoDatabaseUtilsUnitTests {
 		}).as(StepVerifier::create).expectNext(true).verifyComplete();
 	}
 
+	@Test // GH-3760
+	void shouldJustReturnDatabaseIfSessionSynchronizationDisabled() {
+
+		when(databaseFactory.getMongoDatabase()).thenReturn(Mono.just(db));
+
+		ReactiveMongoDatabaseUtils.getDatabase(databaseFactory, SessionSynchronization.NEVER) //
+				.as(StepVerifier::create) //
+				.expectNextCount(1) //
+				.verifyComplete();
+
+		verify(databaseFactory, never()).getSession(any());
+		verify(databaseFactory, never()).withSession(any(ClientSession.class));
+	}
+
 	@Test // DATAMONGO-2265
 	void shouldNotStartSessionWhenNoTransactionOngoing() {