From b407963344264a7677224a23b59b7f97191b5b07 Mon Sep 17 00:00:00 2001 From: Christoph Strobl Date: Mon, 18 Apr 2016 13:52:13 +0200 Subject: [PATCH] =?UTF-8?q?DATAMONGO-1416=20-=20Get=20rid=20of=20the=20war?= =?UTF-8?q?nings=20for=20Atomic=E2=80=A6=20type=20conversions.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit We now use explicit converters instead of a ConverterFactory. This reduces noise in log when registering converters. Original pull request: #362. --- .../mongodb/core/convert/MongoConverters.java | 69 ++++++++++++++++++- .../convert/MongoConvertersUnitTests.java | 39 +++++++++++ 2 files changed, 107 insertions(+), 1 deletion(-) diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/MongoConverters.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/MongoConverters.java index f11403edb..4f1377f40 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/MongoConverters.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/MongoConverters.java @@ -81,7 +81,10 @@ abstract class MongoConverters { converters.add(DBObjectToNamedMongoScriptCoverter.INSTANCE); converters.add(CurrencyToStringConverter.INSTANCE); converters.add(StringToCurrencyConverter.INSTANCE); - converters.add(NumberToNumberConverterFactory.INSTANCE); + converters.add(AtomicIntegerToIntegerConverter.INSTANCE); + converters.add(AtomicLongToLongConverter.INSTANCE); + converters.add(LongToAtomicLongConverter.INSTANCE); + converters.add(IntegerToAtomicIntegerConverter.INSTANCE); return converters; } @@ -374,4 +377,68 @@ abstract class MongoConverters { } } } + + /** + * {@link ConverterFactory} implementation converting {@link AtomicLong} into {@link Long}. + * + * @author Christoph Strobl + * @since 1.10 + */ + @WritingConverter + public static enum AtomicLongToLongConverter implements Converter { + INSTANCE; + + @Override + public Long convert(AtomicLong source) { + return NumberUtils.convertNumberToTargetClass(source, Long.class); + } + } + + /** + * {@link ConverterFactory} implementation converting {@link AtomicInteger} into {@link Integer}. + * + * @author Christoph Strobl + * @since 1.10 + */ + @WritingConverter + public static enum AtomicIntegerToIntegerConverter implements Converter { + INSTANCE; + + @Override + public Integer convert(AtomicInteger source) { + return NumberUtils.convertNumberToTargetClass(source, Integer.class); + } + } + + /** + * {@link ConverterFactory} implementation converting {@link Long} into {@link AtomicLong}. + * + * @author Christoph Strobl + * @since 1.10 + */ + @ReadingConverter + public static enum LongToAtomicLongConverter implements Converter { + INSTANCE; + + @Override + public AtomicLong convert(Long source) { + return source != null ? new AtomicLong(source) : null; + } + } + + /** + * {@link ConverterFactory} implementation converting {@link Integer} into {@link AtomicInteger}. + * + * @author Christoph Strobl + * @since 1.10 + */ + @ReadingConverter + public static enum IntegerToAtomicIntegerConverter implements Converter { + INSTANCE; + + @Override + public AtomicInteger convert(Integer source) { + return source != null ? new AtomicInteger(source) : null; + } + } } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/MongoConvertersUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/MongoConvertersUnitTests.java index 053c7bce4..acd22c6da 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/MongoConvertersUnitTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/convert/MongoConvertersUnitTests.java @@ -20,15 +20,22 @@ import static org.junit.Assert.*; import java.math.BigDecimal; import java.util.Currency; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicLong; +import org.hamcrest.core.IsInstanceOf; import org.junit.Test; import org.springframework.data.geo.Box; import org.springframework.data.geo.Circle; import org.springframework.data.geo.Point; import org.springframework.data.geo.Polygon; import org.springframework.data.geo.Shape; +import org.springframework.data.mongodb.core.convert.MongoConverters.AtomicIntegerToIntegerConverter; +import org.springframework.data.mongodb.core.convert.MongoConverters.AtomicLongToLongConverter; import org.springframework.data.mongodb.core.convert.MongoConverters.BigDecimalToStringConverter; import org.springframework.data.mongodb.core.convert.MongoConverters.CurrencyToStringConverter; +import org.springframework.data.mongodb.core.convert.MongoConverters.IntegerToAtomicIntegerConverter; +import org.springframework.data.mongodb.core.convert.MongoConverters.LongToAtomicLongConverter; import org.springframework.data.mongodb.core.convert.MongoConverters.StringToBigDecimalConverter; import org.springframework.data.mongodb.core.convert.MongoConverters.StringToCurrencyConverter; import org.springframework.data.mongodb.core.geo.Sphere; @@ -140,4 +147,36 @@ public class MongoConvertersUnitTests { public void convertsStringToCurrencyCorrectly() { assertThat(StringToCurrencyConverter.INSTANCE.convert("USD"), is(Currency.getInstance("USD"))); } + + /** + * @see DATAMONGO-1416 + */ + @Test + public void convertsAtomicLongToLongCorrectly() { + assertThat(AtomicLongToLongConverter.INSTANCE.convert(new AtomicLong(100L)), is(100L)); + } + + /** + * @see DATAMONGO-1416 + */ + @Test + public void convertsAtomicIntegerToIntegerCorrectly() { + assertThat(AtomicIntegerToIntegerConverter.INSTANCE.convert(new AtomicInteger(100)), is(100)); + } + + /** + * @see DATAMONGO-1416 + */ + @Test + public void convertsLongToAtomicLongCorrectly() { + assertThat(LongToAtomicLongConverter.INSTANCE.convert(100L), IsInstanceOf.instanceOf(AtomicLong.class)); + } + + /** + * @see DATAMONGO-1416 + */ + @Test + public void convertsIntegerToAtomicIntegerCorrectly() { + assertThat(IntegerToAtomicIntegerConverter.INSTANCE.convert(100), IsInstanceOf.instanceOf(AtomicInteger.class)); + } }