Polishing.

Register BigDecimal and BigInteger as simple types to allow explicitly typed writes and register converters in the ConversionService directly to avoid forcing a specific type.

Revert BigDecimalRepresentation list change to use only one representation.

In a sense, we're aligning with MongoDB's driver behavior that BigDecimal now maps by default to Decimal128, while BigInteger requires explicit configuration.

Original Pull Request: #5051

Author: mp911de

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

@@ -1376,6 +1376,7 @@ private void writeSimpleInternal(@Nullable Object value, Bson bson, MongoPersist
 
 		if (typeHint != null && Object.class != typeHint) {
 
+			// TODO this is weird and leads to double-conversion in some cases, e.g. BigDecimal -> Decimal128 -> BigDecimal
 			if (conversionService.canConvert(value.getClass(), typeHint)) {
 				value = doConvert(value, typeHint);
 			}

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

@@ -110,9 +110,9 @@ static Collection<Object> getDateToUtcConverters() {
 	 * @return
 	 * @since 5.0
 	 */
-	static Collection<Object> getBigNumberDecimal128Converters() {
+	static Collection<Converter<?, ?>> getBigNumberDecimal128Converters() {
 
-		List<Object> converters = new ArrayList<>(3);
+		List<Converter<?, ?>> converters = new ArrayList<>(3);
 
 		converters.add(BigDecimalToDecimal128Converter.INSTANCE);
 		converters.add(Decimal128ToBigDecimalConverter.INSTANCE);
@@ -127,9 +127,9 @@ static Collection<Object> getBigNumberDecimal128Converters() {
 	 * @return
 	 * @since 5.0
 	 */
-	static Collection<Object> getBigNumberStringConverters() {
+	static Collection<Converter<?, ?>> getBigNumberStringConverters() {
 
-		List<Object> converters = new ArrayList<>(4);
+		List<Converter<?, ?>> converters = new ArrayList<>(2);
 
 		converters.add(BigDecimalToStringConverter.INSTANCE);
 		converters.add(BigIntegerToStringConverter.INSTANCE);
@@ -228,6 +228,7 @@ public ObjectId convert(BigInteger source) {
 		}
 	}
 
+	@WritingConverter
 	enum BigDecimalToStringConverter implements Converter<BigDecimal, String> {
 		INSTANCE;
 
@@ -239,6 +240,7 @@ public String convert(BigDecimal source) {
 	/**
 	 * @since 2.2
 	 */
+	@WritingConverter
 	enum BigDecimalToDecimal128Converter implements Converter<BigDecimal, Decimal128> {
 		INSTANCE;
 
@@ -250,6 +252,7 @@ public Decimal128 convert(BigDecimal source) {
 	/**
 	 * @since 5.0
 	 */
+	@WritingConverter
 	enum BigIntegerToDecimal128Converter implements Converter<BigInteger, Decimal128> {
 		INSTANCE;
 
@@ -258,6 +261,7 @@ public Decimal128 convert(BigInteger source) {
 		}
 	}
 
+	@ReadingConverter
 	enum StringToBigDecimalConverter implements Converter<String, BigDecimal> {
 		INSTANCE;
 
@@ -269,6 +273,7 @@ enum StringToBigDecimalConverter implements Converter<String, BigDecimal> {
 	/**
 	 * @since 2.2
 	 */
+	@ReadingConverter
 	enum Decimal128ToBigDecimalConverter implements Converter<Decimal128, BigDecimal> {
 		INSTANCE;
 

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

@@ -30,13 +30,16 @@
 import java.util.Locale;
 import java.util.Set;
 import java.util.function.Consumer;
+import java.util.function.Predicate;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.jspecify.annotations.Nullable;
+
 import org.springframework.core.convert.TypeDescriptor;
 import org.springframework.core.convert.converter.Converter;
 import org.springframework.core.convert.converter.ConverterFactory;
+import org.springframework.core.convert.converter.ConverterRegistry;
 import org.springframework.core.convert.converter.GenericConverter;
 import org.springframework.data.convert.ConverterBuilder;
 import org.springframework.data.convert.PropertyValueConversions;
@@ -78,6 +81,12 @@ public class MongoCustomConversions extends org.springframework.data.convert.Cus
 		STORE_CONVERTERS = Collections.unmodifiableList(converters);
 	}
 
+	/**
+	 * Converters to be registered with the {@code ConversionService} but hidden from CustomConversions to avoid
+	 * converter-based type hinting.
+	 */
+	private final List<Converter<?, ?>> fallbackConversionServiceConverters = new ArrayList<>();
+
 	/**
 	 * Creates an empty {@link MongoCustomConversions} object.
 	 */
@@ -101,7 +110,12 @@ public MongoCustomConversions(List<?> converters) {
 	 * @since 2.3
 	 */
 	protected MongoCustomConversions(MongoConverterConfigurationAdapter conversionConfiguration) {
-		super(conversionConfiguration.createConverterConfiguration());
+		this(conversionConfiguration.createConverterConfiguration());
+	}
+
+	private MongoCustomConversions(MongoConverterConfiguration converterConfiguration) {
+		super(converterConfiguration);
+		this.fallbackConversionServiceConverters.addAll(converterConfiguration.fallbackConversionServiceConverters);
 	}
 
 	/**
@@ -120,6 +134,12 @@ public static MongoCustomConversions create(Consumer<MongoConverterConfiguration
 		return new MongoCustomConversions(adapter);
 	}
 
+	@Override
+	public void registerConvertersIn(ConverterRegistry conversionService) {
+		this.fallbackConversionServiceConverters.forEach(conversionService::addConverter);
+		super.registerConvertersIn(conversionService);
+	}
+
 	@WritingConverter
 	private enum CustomToStringConverter implements GenericConverter {
 
@@ -155,7 +175,7 @@ public static class MongoConverterConfigurationAdapter {
 				LocalDateTime.class);
 
 		private boolean useNativeDriverJavaTimeCodecs = false;
-		private BigDecimalRepresentation @Nullable [] bigDecimals;
+		private @Nullable BigDecimalRepresentation bigDecimals;
 		private final List<Object> customConverters = new ArrayList<>();
 
 		private final PropertyValueConversions internalValueConversion = PropertyValueConversions.simple(it -> {});
@@ -312,14 +332,14 @@ public MongoConverterConfigurationAdapter useSpringDataJavaTimeCodecs() {
 		 * Configures the representation to for {@link java.math.BigDecimal} and {@link java.math.BigInteger} values in
 		 * MongoDB. Defaults to {@link BigDecimalRepresentation#DECIMAL128}.
 		 *
-		 * @param representations ordered list of representations to use (first one is default)
+		 * @param representation the representation to use.
 		 * @return this.
 		 * @since 4.5
 		 */
-		public MongoConverterConfigurationAdapter bigDecimal(BigDecimalRepresentation... representations) {
+		public MongoConverterConfigurationAdapter bigDecimal(BigDecimalRepresentation representation) {
 
-			Assert.notEmpty(representations, "BigDecimalDataType must not be null");
-			this.bigDecimals = representations;
+			Assert.notNull(representation, "BigDecimalDataType must not be null");
+			this.bigDecimals = representation;
 			return this;
 		}
 
@@ -365,27 +385,32 @@ PropertyValueConversions valueConversions() {
 			return this.propertyValueConversions;
 		}
 
-		ConverterConfiguration createConverterConfiguration() {
+		MongoConverterConfiguration createConverterConfiguration() {
 
 			if (hasDefaultPropertyValueConversions()
 					&& propertyValueConversions instanceof SimplePropertyValueConversions svc) {
 				svc.init();
 			}
 
 			List<Object> storeConverters = new ArrayList<>(STORE_CONVERTERS.size() + 10);
-
-			if (bigDecimals != null) {
-				for (BigDecimalRepresentation representation : bigDecimals) {
-					switch (representation) {
-						case STRING -> storeConverters.addAll(MongoConverters.getBigNumberStringConverters());
-						case DECIMAL128 -> storeConverters.addAll(MongoConverters.getBigNumberDecimal128Converters());
-					}
+			List<Converter<?, ?>> fallbackConversionServiceConverters = new ArrayList<>(5);
+			fallbackConversionServiceConverters.addAll(MongoConverters.getBigNumberStringConverters());
+			fallbackConversionServiceConverters.addAll(MongoConverters.getBigNumberDecimal128Converters());
+
+			if (bigDecimals == null) {
+				if (LOGGER.isInfoEnabled()) {
+					LOGGER.info(
+							"No BigDecimal/BigInteger representation set. Choose 'BigDecimalRepresentation.DECIMAL128' or 'BigDecimalRepresentation.String' to store values in desired format.");
+				}
+			} else {
+				switch (bigDecimals) {
+					case STRING -> storeConverters.addAll(MongoConverters.getBigNumberStringConverters());
+					case DECIMAL128 -> storeConverters.addAll(MongoConverters.getBigNumberDecimal128Converters());
 				}
-			} else if (LOGGER.isInfoEnabled()) {
-				LOGGER.info(
-						"No BigDecimal/BigInteger representation set. Choose [DECIMAL128] and/or [String] to store values in desired format.");
 			}
 
+			fallbackConversionServiceConverters.removeAll(storeConverters);
+
 			if (useNativeDriverJavaTimeCodecs) {
 
 				/*
@@ -397,7 +422,8 @@ ConverterConfiguration createConverterConfiguration() {
 				StoreConversions storeConversions = StoreConversions
 						.of(new SimpleTypeHolder(JAVA_DRIVER_TIME_SIMPLE_TYPES, MongoSimpleTypes.HOLDER), storeConverters);
 
-				return new ConverterConfiguration(storeConversions, this.customConverters, convertiblePair -> {
+				return new MongoConverterConfiguration(storeConversions, fallbackConversionServiceConverters,
+						this.customConverters, convertiblePair -> {
 
 					// Avoid default registrations
 
@@ -408,8 +434,10 @@ ConverterConfiguration createConverterConfiguration() {
 			}
 
 			storeConverters.addAll(STORE_CONVERTERS);
-			return new ConverterConfiguration(StoreConversions.of(MongoSimpleTypes.createSimpleTypeHolder(), storeConverters),
-					this.customConverters, convertiblePair -> true, this.propertyValueConversions);
+			return new MongoConverterConfiguration(
+					StoreConversions.of(MongoSimpleTypes.createSimpleTypeHolder(), storeConverters),
+					fallbackConversionServiceConverters, this.customConverters, convertiblePair -> true,
+					this.propertyValueConversions);
 		}
 
 		private boolean hasDefaultPropertyValueConversions() {
@@ -418,6 +446,19 @@ private boolean hasDefaultPropertyValueConversions() {
 
 	}
 
+	static class MongoConverterConfiguration extends ConverterConfiguration {
+
+		private final List<Converter<?, ?>> fallbackConversionServiceConverters;
+
+		public MongoConverterConfiguration(StoreConversions storeConversions,
+				List<Converter<?, ?>> fallbackConversionServiceConverters, List<?> userConverters,
+				Predicate<GenericConverter.ConvertiblePair> converterRegistrationFilter,
+				@Nullable PropertyValueConversions propertyValueConversions) {
+			super(storeConversions, userConverters, converterRegistrationFilter, propertyValueConversions);
+			this.fallbackConversionServiceConverters = fallbackConversionServiceConverters;
+		}
+	}
+
 	/**
 	 * Strategy to represent {@link java.math.BigDecimal} and {@link java.math.BigInteger} values in MongoDB.
 	 *

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

@@ -15,6 +15,7 @@
  */
 package org.springframework.data.mongodb.core.mapping;
 
+import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.time.Instant;
 import java.util.Set;
@@ -60,7 +61,7 @@ public abstract class MongoSimpleTypes {
 			BsonDocument.class, BsonDouble.class, BsonInt32.class, BsonInt64.class, BsonJavaScript.class,
 			BsonJavaScriptWithScope.class, BsonObjectId.class, BsonRegularExpression.class, BsonString.class,
 			BsonTimestamp.class, Geometry.class, GeometryCollection.class, LineString.class, MultiLineString.class,
-			MultiPoint.class, MultiPolygon.class, Point.class, Polygon.class);
+			MultiPoint.class, MultiPolygon.class, Point.class, Polygon.class, BigInteger.class, BigDecimal.class);
 
 	public static final SimpleTypeHolder HOLDER = createSimpleTypeHolder();