Polishing.

Refine updateOne/updateMulti signatures to accept UpdateDefinition in the generic signature. Use pattern variables and records where applicable. Resolve code duplicates.

See #3872
Original pull request: #4344

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

@@ -29,6 +29,15 @@ import com.mongodb.bulk.BulkWriteResult;
  * 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()}.
+ *
+ * <pre class="code">
+ * MongoTemplate template = …;
+ *
+ * template.bulkOps(BulkMode.UNORDERED, Person.class)
+ * 				.insert(newPerson)
+ * 				.updateOne(where("firstname").is("Joe"), Update.update("lastname", "Doe"))
+ * 				.execute();
+ * </pre>
  * <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
@@ -96,7 +105,7 @@ public interface BulkOperations {
 	 * @param updates Update operations to perform.
 	 * @return the current {@link BulkOperations} instance with the update added, will never be {@literal null}.
 	 */
-	BulkOperations updateOne(List<Pair<Query, Update>> updates);
+	BulkOperations updateOne(List<Pair<Query, UpdateDefinition>> updates);
 
 	/**
 	 * Add a single update to the bulk operation. For the update request, all matching documents are updated.
@@ -125,7 +134,7 @@ public interface BulkOperations {
 	 * @param updates Update operations to perform.
 	 * @return the current {@link BulkOperations} instance with the update added, will never be {@literal null}.
 	 */
-	BulkOperations updateMulti(List<Pair<Query, Update>> updates);
+	BulkOperations updateMulti(List<Pair<Query, UpdateDefinition>> updates);
 
 	/**
 	 * Add a single upsert to the bulk operation. An upsert is an update if the set of matching documents is not empty,
@@ -180,7 +189,7 @@ public interface BulkOperations {
 	 *
 	 * @param query Update criteria.
 	 * @param replacement the replacement document. Must not be {@literal null}.
-	 * @return the current {@link BulkOperations} instance with the replace added, will never be {@literal null}.
+	 * @return the current {@link BulkOperations} instance with the replacement added, will never be {@literal null}.
 	 * @since 2.2
 	 */
 	default BulkOperations replaceOne(Query query, Object replacement) {
@@ -193,7 +202,7 @@ public interface BulkOperations {
 	 * @param query Update criteria.
 	 * @param replacement the replacement document. Must not be {@literal null}.
 	 * @param options the {@link FindAndModifyOptions} holding additional information. Must not be {@literal null}.
-	 * @return the current {@link BulkOperations} instance with the replace added, will never be {@literal null}.
+	 * @return the current {@link BulkOperations} instance with the replacement added, will never be {@literal null}.
 	 * @since 2.2
 	 */
 	BulkOperations replaceOne(Query query, Object replacement, FindAndReplaceOptions options);

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

@@ -22,9 +22,11 @@ import java.util.stream.Collectors;
 
 import org.bson.Document;
 import org.bson.conversions.Bson;
+import org.springframework.context.ApplicationEvent;
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.dao.DataIntegrityViolationException;
 import org.springframework.data.mapping.PersistentEntity;
+import org.springframework.data.mapping.callback.EntityCallback;
 import org.springframework.data.mapping.callback.EntityCallbacks;
 import org.springframework.data.mongodb.BulkOperationException;
 import org.springframework.data.mongodb.core.aggregation.AggregationOperationContext;
@@ -48,7 +50,6 @@ import org.springframework.data.mongodb.core.query.UpdateDefinition.ArrayFilter;
 import org.springframework.data.util.Pair;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
-import org.springframework.util.ObjectUtils;
 
 import com.mongodb.MongoBulkWriteException;
 import com.mongodb.WriteConcern;
@@ -78,7 +79,6 @@ class DefaultBulkOperations implements BulkOperations {
 	private final List<SourceAwareWriteModelHolder> models = new ArrayList<>();
 
 	private @Nullable WriteConcern defaultWriteConcern;
-
 	private BulkWriteOptions bulkOptions;
 
 	/**
@@ -100,7 +100,7 @@ class DefaultBulkOperations implements BulkOperations {
 		this.mongoOperations = mongoOperations;
 		this.collectionName = collectionName;
 		this.bulkOperationContext = bulkOperationContext;
-		this.bulkOptions = getBulkWriteOptions(bulkOperationContext.getBulkMode());
+		this.bulkOptions = getBulkWriteOptions(bulkOperationContext.bulkMode());
 	}
 
 	/**
@@ -145,11 +145,11 @@ class DefaultBulkOperations implements BulkOperations {
 	}
 
 	@Override
-	public BulkOperations updateOne(List<Pair<Query, Update>> updates) {
+	public BulkOperations updateOne(List<Pair<Query, UpdateDefinition>> updates) {
 
 		Assert.notNull(updates, "Updates must not be null");
 
-		for (Pair<Query, Update> update : updates) {
+		for (Pair<Query, UpdateDefinition> update : updates) {
 			update(update.getFirst(), update.getSecond(), false, false);
 		}
 
@@ -169,11 +169,11 @@ class DefaultBulkOperations implements BulkOperations {
 	}
 
 	@Override
-	public BulkOperations updateMulti(List<Pair<Query, Update>> updates) {
+	public BulkOperations updateMulti(List<Pair<Query, UpdateDefinition>> updates) {
 
 		Assert.notNull(updates, "Updates must not be null");
 
-		for (Pair<Query, Update> update : updates) {
+		for (Pair<Query, UpdateDefinition> update : updates) {
 			update(update.getFirst(), update.getSecond(), false, true);
 		}
 
@@ -253,7 +253,7 @@ class DefaultBulkOperations implements BulkOperations {
 
 			return result;
 		} finally {
-			this.bulkOptions = getBulkWriteOptions(bulkOperationContext.getBulkMode());
+			this.bulkOptions = getBulkWriteOptions(bulkOperationContext.bulkMode());
 		}
 	}
 
@@ -272,9 +272,8 @@ class DefaultBulkOperations implements BulkOperations {
 					bulkOptions);
 		} catch (RuntimeException ex) {
 
-			if (ex instanceof MongoBulkWriteException) {
+			if (ex instanceof MongoBulkWriteException mongoBulkWriteException) {
 
-				MongoBulkWriteException mongoBulkWriteException = (MongoBulkWriteException) ex;
 				if (mongoBulkWriteException.getWriteConcernError() != null) {
 					throw new DataIntegrityViolationException(ex.getMessage(), ex);
 				}
@@ -289,17 +288,17 @@ class DefaultBulkOperations implements BulkOperations {
 
 		maybeEmitBeforeSaveEvent(it);
 
-		if (it.getModel() instanceof InsertOneModel) {
+		if (it.model() instanceof InsertOneModel) {
 
-			Document target = ((InsertOneModel<Document>) it.getModel()).getDocument();
-			maybeInvokeBeforeSaveCallback(it.getSource(), target);
-		} else if (it.getModel() instanceof ReplaceOneModel) {
+			Document target = ((InsertOneModel<Document>) it.model()).getDocument();
+			maybeInvokeBeforeSaveCallback(it.source(), target);
+		} else if (it.model() instanceof ReplaceOneModel) {
 
-			Document target = ((ReplaceOneModel<Document>) it.getModel()).getReplacement();
-			maybeInvokeBeforeSaveCallback(it.getSource(), target);
+			Document target = ((ReplaceOneModel<Document>) it.model()).getReplacement();
+			maybeInvokeBeforeSaveCallback(it.source(), target);
 		}
 
-		return mapWriteModel(it.getSource(), it.getModel());
+		return mapWriteModel(it.source(), it.model());
 	}
 
 	/**
@@ -329,9 +328,8 @@ class DefaultBulkOperations implements BulkOperations {
 
 	private WriteModel<Document> mapWriteModel(Object source, WriteModel<Document> writeModel) {
 
-		if (writeModel instanceof UpdateOneModel) {
+		if (writeModel instanceof UpdateOneModel<Document> model) {
 
-			UpdateOneModel<Document> model = (UpdateOneModel<Document>) writeModel;
 			if (source instanceof AggregationUpdate aggregationUpdate) {
 
 				List<Document> pipeline = mapUpdatePipeline(aggregationUpdate);
@@ -342,9 +340,8 @@ class DefaultBulkOperations implements BulkOperations {
 					model.getOptions());
 		}
 
-		if (writeModel instanceof UpdateManyModel) {
+		if (writeModel instanceof UpdateManyModel<Document> model) {
 
-			UpdateManyModel<Document> model = (UpdateManyModel<Document>) writeModel;
 			if (source instanceof AggregationUpdate aggregationUpdate) {
 
 				List<Document> pipeline = mapUpdatePipeline(aggregationUpdate);
@@ -355,17 +352,11 @@ class DefaultBulkOperations implements BulkOperations {
 					model.getOptions());
 		}
 
-		if (writeModel instanceof DeleteOneModel) {
-
-			DeleteOneModel<Document> model = (DeleteOneModel<Document>) writeModel;
-
+		if (writeModel instanceof DeleteOneModel<Document> model) {
 			return new DeleteOneModel<>(getMappedQuery(model.getFilter()), model.getOptions());
 		}
 
-		if (writeModel instanceof DeleteManyModel) {
-
-			DeleteManyModel<Document> model = (DeleteManyModel<Document>) writeModel;
-
+		if (writeModel instanceof DeleteManyModel<Document> model) {
 			return new DeleteManyModel<>(getMappedQuery(model.getFilter()), model.getOptions());
 		}
 
@@ -373,24 +364,23 @@ class DefaultBulkOperations implements BulkOperations {
 	}
 
 	private List<Document> mapUpdatePipeline(AggregationUpdate source) {
-		Class<?> type = bulkOperationContext.getEntity().isPresent()
-				? bulkOperationContext.getEntity().map(PersistentEntity::getType).get()
+
+		Class<?> type = bulkOperationContext.entity().isPresent()
+				? bulkOperationContext.entity().map(PersistentEntity::getType).get()
 				: Object.class;
 		AggregationOperationContext context = new RelaxedTypeBasedAggregationOperationContext(type,
-				bulkOperationContext.getUpdateMapper().getMappingContext(), bulkOperationContext.getQueryMapper());
+				bulkOperationContext.updateMapper().getMappingContext(), bulkOperationContext.queryMapper());
 
-		List<Document> pipeline = new AggregationUtil(bulkOperationContext.getQueryMapper(),
-				bulkOperationContext.getQueryMapper().getMappingContext()).createPipeline(source,
-						context);
-		return pipeline;
+		return new AggregationUtil(bulkOperationContext.queryMapper(),
+				bulkOperationContext.queryMapper().getMappingContext()).createPipeline(source, context);
 	}
 
 	private Bson getMappedUpdate(Bson update) {
-		return bulkOperationContext.getUpdateMapper().getMappedObject(update, bulkOperationContext.getEntity());
+		return bulkOperationContext.updateMapper().getMappedObject(update, bulkOperationContext.entity());
 	}
 
 	private Bson getMappedQuery(Bson query) {
-		return bulkOperationContext.getQueryMapper().getMappedObject(query, bulkOperationContext.getEntity());
+		return bulkOperationContext.queryMapper().getMappedObject(query, bulkOperationContext.entity());
 	}
 
 	private Document getMappedObject(Object source) {
@@ -411,80 +401,57 @@ class DefaultBulkOperations implements BulkOperations {
 
 	private void maybeEmitBeforeSaveEvent(SourceAwareWriteModelHolder holder) {
 
-		if (holder.getModel() instanceof InsertOneModel) {
+		if (holder.model() instanceof InsertOneModel) {
 
-			Document target = ((InsertOneModel<Document>) holder.getModel()).getDocument();
-			maybeEmitEvent(new BeforeSaveEvent<>(holder.getSource(), target, collectionName));
-		} else if (holder.getModel() instanceof ReplaceOneModel) {
+			Document target = ((InsertOneModel<Document>) holder.model()).getDocument();
+			maybeEmitEvent(new BeforeSaveEvent<>(holder.source(), target, collectionName));
+		} else if (holder.model() instanceof ReplaceOneModel) {
 
-			Document target = ((ReplaceOneModel<Document>) holder.getModel()).getReplacement();
-			maybeEmitEvent(new BeforeSaveEvent<>(holder.getSource(), target, collectionName));
+			Document target = ((ReplaceOneModel<Document>) holder.model()).getReplacement();
+			maybeEmitEvent(new BeforeSaveEvent<>(holder.source(), target, collectionName));
 		}
 	}
 
 	private void maybeEmitAfterSaveEvent(SourceAwareWriteModelHolder holder) {
 
-		if (holder.getModel() instanceof InsertOneModel) {
+		if (holder.model() instanceof InsertOneModel) {
 
-			Document target = ((InsertOneModel<Document>) holder.getModel()).getDocument();
-			maybeEmitEvent(new AfterSaveEvent<>(holder.getSource(), target, collectionName));
-		} else if (holder.getModel() instanceof ReplaceOneModel) {
+			Document target = ((InsertOneModel<Document>) holder.model()).getDocument();
+			maybeEmitEvent(new AfterSaveEvent<>(holder.source(), target, collectionName));
+		} else if (holder.model() instanceof ReplaceOneModel) {
 
-			Document target = ((ReplaceOneModel<Document>) holder.getModel()).getReplacement();
-			maybeEmitEvent(new AfterSaveEvent<>(holder.getSource(), target, collectionName));
+			Document target = ((ReplaceOneModel<Document>) holder.model()).getReplacement();
+			maybeEmitEvent(new AfterSaveEvent<>(holder.source(), target, collectionName));
 		}
 	}
 
 	private void maybeInvokeAfterSaveCallback(SourceAwareWriteModelHolder holder) {
 
-		if (holder.getModel() instanceof InsertOneModel) {
+		if (holder.model() instanceof InsertOneModel) {
 
-			Document target = ((InsertOneModel<Document>) holder.getModel()).getDocument();
-			maybeInvokeAfterSaveCallback(holder.getSource(), target);
-		} else if (holder.getModel() instanceof ReplaceOneModel) {
+			Document target = ((InsertOneModel<Document>) holder.model()).getDocument();
+			maybeInvokeAfterSaveCallback(holder.source(), target);
+		} else if (holder.model() instanceof ReplaceOneModel) {
 
-			Document target = ((ReplaceOneModel<Document>) holder.getModel()).getReplacement();
-			maybeInvokeAfterSaveCallback(holder.getSource(), target);
+			Document target = ((ReplaceOneModel<Document>) holder.model()).getReplacement();
+			maybeInvokeAfterSaveCallback(holder.source(), target);
 		}
 	}
 
-	private <E extends MongoMappingEvent<T>, T> E maybeEmitEvent(E event) {
-
-		if (bulkOperationContext.getEventPublisher() == null) {
-			return event;
-		}
-
-		bulkOperationContext.getEventPublisher().publishEvent(event);
-		return event;
+	private void maybeEmitEvent(MongoMappingEvent<?> event) {
+		bulkOperationContext.publishEvent(event);
 	}
 
 	private Object maybeInvokeBeforeConvertCallback(Object value) {
-
-		if (bulkOperationContext.getEntityCallbacks() == null) {
-			return value;
-		}
-
-		return bulkOperationContext.getEntityCallbacks().callback(BeforeConvertCallback.class, value, collectionName);
+		return bulkOperationContext.callback(BeforeConvertCallback.class, value, collectionName);
 	}
 
 	private Object maybeInvokeBeforeSaveCallback(Object value, Document mappedDocument) {
-
-		if (bulkOperationContext.getEntityCallbacks() == null) {
-			return value;
-		}
-
-		return bulkOperationContext.getEntityCallbacks().callback(BeforeSaveCallback.class, value, mappedDocument,
-				collectionName);
+		return bulkOperationContext.callback(BeforeSaveCallback.class, value, mappedDocument, collectionName);
 	}
 
 	private Object maybeInvokeAfterSaveCallback(Object value, Document mappedDocument) {
-
-		if (bulkOperationContext.getEntityCallbacks() == null) {
-			return value;
-		}
-
-		return bulkOperationContext.getEntityCallbacks().callback(AfterSaveCallback.class, value, mappedDocument,
-				collectionName);
+		return bulkOperationContext.callback(AfterSaveCallback.class, value, mappedDocument, collectionName);
 	}
 
 	private static BulkWriteOptions getBulkWriteOptions(BulkMode bulkMode) {
@@ -525,152 +492,62 @@ class DefaultBulkOperations implements BulkOperations {
 	}
 
 	/**
-	 * {@link BulkOperationContext} holds information about
-	 * {@link org.springframework.data.mongodb.core.BulkOperations.BulkMode} the entity in use as well as references to
+	 * {@link BulkOperationContext} holds information about {@link BulkMode} the entity in use as well as references to
 	 * {@link QueryMapper} and {@link UpdateMapper}.
 	 *
 	 * @author Christoph Strobl
 	 * @since 2.0
 	 */
-	static final class BulkOperationContext {
-
-		private final BulkMode bulkMode;
-		private final Optional<? extends MongoPersistentEntity<?>> entity;
-		private final QueryMapper queryMapper;
-		private final UpdateMapper updateMapper;
-		private final ApplicationEventPublisher eventPublisher;
-		private final EntityCallbacks entityCallbacks;
-
-		BulkOperationContext(BulkOperations.BulkMode bulkMode, Optional<? extends MongoPersistentEntity<?>> entity,
-				QueryMapper queryMapper, UpdateMapper updateMapper, ApplicationEventPublisher eventPublisher,
-				EntityCallbacks entityCallbacks) {
-
-			this.bulkMode = bulkMode;
-			this.entity = entity;
-			this.queryMapper = queryMapper;
-			this.updateMapper = updateMapper;
-			this.eventPublisher = eventPublisher;
-			this.entityCallbacks = entityCallbacks;
-		}
+	record BulkOperationContext(BulkMode bulkMode, Optional<? extends MongoPersistentEntity<?>> entity,
+			QueryMapper queryMapper, UpdateMapper updateMapper, @Nullable ApplicationEventPublisher eventPublisher,
+			@Nullable EntityCallbacks entityCallbacks) {
 
-		public BulkMode getBulkMode() {
-			return this.bulkMode;
+		public boolean skipEventPublishing() {
+			return eventPublisher == null;
 		}
 
-		public Optional<? extends MongoPersistentEntity<?>> getEntity() {
-			return this.entity;
+		public boolean skipEntityCallbacks() {
+			return entityCallbacks == null;
 		}
 
-		public QueryMapper getQueryMapper() {
-			return this.queryMapper;
-		}
-
-		public UpdateMapper getUpdateMapper() {
-			return this.updateMapper;
-		}
+		@SuppressWarnings("rawtypes")
+		public <T> T callback(Class<? extends EntityCallback> callbackType, T entity, String collectionName) {
 
-		public ApplicationEventPublisher getEventPublisher() {
-			return this.eventPublisher;
-		}
+			if (skipEntityCallbacks()) {
+				return entity;
+			}
 
-		public EntityCallbacks getEntityCallbacks() {
-			return this.entityCallbacks;
+			return entityCallbacks.callback(callbackType, entity, collectionName);
 		}
 
-		@Override
-		public boolean equals(@Nullable Object o) {
-			if (this == o)
-				return true;
-			if (o == null || getClass() != o.getClass())
-				return false;
-
-			BulkOperationContext that = (BulkOperationContext) o;
+		@SuppressWarnings("rawtypes")
+		public <T> T callback(Class<? extends EntityCallback> callbackType, T entity, Document document,
+				String collectionName) {
 
-			if (bulkMode != that.bulkMode)
-				return false;
-			if (!ObjectUtils.nullSafeEquals(this.entity, that.entity)) {
-				return false;
+			if (skipEntityCallbacks()) {
+				return entity;
 			}
-			if (!ObjectUtils.nullSafeEquals(this.queryMapper, that.queryMapper)) {
-				return false;
-			}
-			if (!ObjectUtils.nullSafeEquals(this.updateMapper, that.updateMapper)) {
-				return false;
-			}
-			if (!ObjectUtils.nullSafeEquals(this.eventPublisher, that.eventPublisher)) {
-				return false;
-			}
-			return ObjectUtils.nullSafeEquals(this.entityCallbacks, that.entityCallbacks);
-		}
 
-		@Override
-		public int hashCode() {
-			int result = bulkMode != null ? bulkMode.hashCode() : 0;
-			result = 31 * result + ObjectUtils.nullSafeHashCode(entity);
-			result = 31 * result + ObjectUtils.nullSafeHashCode(queryMapper);
-			result = 31 * result + ObjectUtils.nullSafeHashCode(updateMapper);
-			result = 31 * result + ObjectUtils.nullSafeHashCode(eventPublisher);
-			result = 31 * result + ObjectUtils.nullSafeHashCode(entityCallbacks);
-			return result;
+			return entityCallbacks.callback(callbackType, entity, document, collectionName);
 		}
 
-		public String toString() {
-			return "DefaultBulkOperations.BulkOperationContext(bulkMode=" + this.getBulkMode() + ", entity="
-					+ this.getEntity() + ", queryMapper=" + this.getQueryMapper() + ", updateMapper=" + this.getUpdateMapper()
-					+ ", eventPublisher=" + this.getEventPublisher() + ", entityCallbacks=" + this.getEntityCallbacks() + ")";
+		public void publishEvent(ApplicationEvent event) {
+
+			if (skipEventPublishing()) {
+				return;
+			}
+
+			eventPublisher.publishEvent(event);
 		}
 	}
 
 	/**
 	 * Value object chaining together an actual source with its {@link WriteModel} representation.
 	 *
-	 * @since 2.2
 	 * @author Christoph Strobl
+	 * @since 2.2
 	 */
-	private static final class SourceAwareWriteModelHolder {
-
-		private final Object source;
-		private final WriteModel<Document> model;
-
-		SourceAwareWriteModelHolder(Object source, WriteModel<Document> model) {
-
-			this.source = source;
-			this.model = model;
-		}
+	record SourceAwareWriteModelHolder(Object source, WriteModel<Document> model) {
 
-		public Object getSource() {
-			return this.source;
-		}
-
-		public WriteModel<Document> getModel() {
-			return this.model;
-		}
-
-		@Override
-		public boolean equals(@Nullable Object o) {
-			if (this == o)
-				return true;
-			if (o == null || getClass() != o.getClass())
-				return false;
-
-			SourceAwareWriteModelHolder that = (SourceAwareWriteModelHolder) o;
-
-			if (!ObjectUtils.nullSafeEquals(this.source, that.source)) {
-				return false;
-			}
-			return ObjectUtils.nullSafeEquals(this.model, that.model);
-		}
-
-		@Override
-		public int hashCode() {
-			int result = ObjectUtils.nullSafeHashCode(model);
-			result = 31 * result + ObjectUtils.nullSafeHashCode(source);
-			return result;
-		}
-
-		public String toString() {
-			return "DefaultBulkOperations.SourceAwareWriteModelHolder(source=" + this.getSource() + ", model="
-					+ this.getModel() + ")";
-		}
 	}
 }

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

@@ -74,7 +74,16 @@ import org.springframework.data.mongodb.core.aggregation.AggregationOptions.Buil
 import org.springframework.data.mongodb.core.aggregation.AggregationPipeline;
 import org.springframework.data.mongodb.core.aggregation.AggregationResults;
 import org.springframework.data.mongodb.core.aggregation.TypedAggregation;
-import org.springframework.data.mongodb.core.convert.*;
+import org.springframework.data.mongodb.core.convert.DbRefResolver;
+import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver;
+import org.springframework.data.mongodb.core.convert.JsonSchemaMapper;
+import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
+import org.springframework.data.mongodb.core.convert.MongoConverter;
+import org.springframework.data.mongodb.core.convert.MongoCustomConversions;
+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.convert.UpdateMapper;
 import org.springframework.data.mongodb.core.index.IndexOperations;
 import org.springframework.data.mongodb.core.index.IndexOperationsProvider;
 import org.springframework.data.mongodb.core.index.MongoMappingEventPublisher;
@@ -110,7 +119,16 @@ import com.mongodb.ClientSessionOptions;
 import com.mongodb.MongoException;
 import com.mongodb.ReadPreference;
 import com.mongodb.WriteConcern;
-import com.mongodb.client.*;
+import com.mongodb.client.AggregateIterable;
+import com.mongodb.client.ClientSession;
+import com.mongodb.client.DistinctIterable;
+import com.mongodb.client.FindIterable;
+import com.mongodb.client.MapReduceIterable;
+import com.mongodb.client.MongoClient;
+import com.mongodb.client.MongoCollection;
+import com.mongodb.client.MongoCursor;
+import com.mongodb.client.MongoDatabase;
+import com.mongodb.client.MongoIterable;
 import com.mongodb.client.model.*;
 import com.mongodb.client.result.DeleteResult;
 import com.mongodb.client.result.UpdateResult;
@@ -750,8 +768,8 @@ public class MongoTemplate
 	}
 
 	@Override
-	public BulkOperations bulkOps(BulkMode bulkMode, String collectionName) {
-		return bulkOps(bulkMode, null, collectionName);
+	public BulkOperations bulkOps(BulkMode mode, String collectionName) {
+		return bulkOps(mode, null, collectionName);
 	}
 
 	@Override
@@ -871,7 +889,7 @@ public class MongoTemplate
 		Assert.notNull(targetClass, "Target type must not be null");
 
 		EntityProjection<T, ?> projection = operations.introspectProjection(targetClass, sourceClass);
-		ProjectingReadCallback<?,T> callback = new ProjectingReadCallback<>(mongoConverter, projection, collectionName);
+		ProjectingReadCallback<?, T> callback = new ProjectingReadCallback<>(mongoConverter, projection, collectionName);
 		int limit = query.isLimited() ? query.getLimit() + 1 : Integer.MAX_VALUE;
 
 		if (query.hasKeyset()) {

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/DefaultBulkOperationsIntegrationTests.java

@@ -23,7 +23,6 @@ import java.util.List;
 import java.util.Optional;
 import java.util.stream.Stream;
 
-import com.mongodb.bulk.BulkWriteResult;
 import org.bson.Document;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -49,6 +48,7 @@ import org.springframework.data.util.Pair;
 
 import com.mongodb.MongoBulkWriteException;
 import com.mongodb.WriteConcern;
+import com.mongodb.bulk.BulkWriteResult;
 import com.mongodb.client.MongoCollection;
 
 /**
@@ -295,7 +295,7 @@ public class DefaultBulkOperationsIntegrationTests {
 	public void mixedBulkOrderedWithList() {
 
 		List<BaseDoc> inserts = Arrays.asList(newDoc("1", "v1"), newDoc("2", "v2"), newDoc("3", "v2"));
-		List<Pair<Query, Update>> updates = Arrays.asList(Pair.of(where("value", "v2"), set("value", "v3")));
+		List<Pair<Query, UpdateDefinition>> updates = Arrays.asList(Pair.of(where("value", "v2"), set("value", "v3")));
 		List<Query> removes = Arrays.asList(where("_id", "1"));
 
 		com.mongodb.bulk.BulkWriteResult result = createBulkOps(BulkMode.ORDERED, BaseDoc.class).insert(inserts)
@@ -329,7 +329,7 @@ public class DefaultBulkOperationsIntegrationTests {
 
 		insertSomeDocuments();
 
-		List<Pair<Query, Update>> updates = new ArrayList<Pair<Query, Update>>();
+		List<Pair<Query, UpdateDefinition>> updates = new ArrayList<>();
 		updates.add(Pair.of(where("value", "value1"), set("value", "value3")));
 		updates.add(Pair.of(where("value", "value2"), set("value", "value4")));